triton::backend::traccc::ModelState Class Reference

Inheritance diagram for triton::backend::traccc::ModelState:

Collaboration diagram for triton::backend::traccc::ModelState:

Public Member Functions
virtual	~ModelState ()=default
const std::string &	InputCellsTensorName () const
TRITONSERVER_DataType	InputCellsTensorDataType () const
const std::vector< int64_t > &	InputCellsTensorNonBatchShape () const
size_t	TotalInstanceCount () const
TRITONSERVER_Error *	ValidateModelConfig ()

Static Public Member Functions
static TRITONSERVER_Error *	Create (TRITONBACKEND_Model *triton_model, ModelState **state)

Public Attributes
int64_t	cellFeatures

Private Member Functions
	ModelState (TRITONBACKEND_Model *triton_model)
	Also possible problems in this function!

Private Attributes
std::string	m_inputCellsName
TRITONSERVER_DataType	m_inputCellsDatatype
std::vector< int64_t >	m_inputCellsNbShape
size_t	m_totalInstanceCount = 1

Detailed Description

Definition at line 179 of file TracccTritonBackend.cxx.

Constructor & Destructor Documentation

~ModelState()

virtual triton::backend::traccc::ModelState::~ModelState ( )

virtualdefault

ModelState()

triton::backend::traccc::ModelState::ModelState ( TRITONBACKEND_Model * triton_model )

private

Also possible problems in this function!

Definition at line 228 of file TracccTritonBackend.cxx.

    : BackendModel(triton_model)
{
  // Validate that the model's configuration matches what is supported
  // by this backend.
  THROW_IF_BACKEND_MODEL_ERROR(ValidateModelConfig());
}

Member Function Documentation

Create()

TRITONSERVER_Error * triton::backend::traccc::ModelState::Create ( TRITONBACKEND_Model * triton_model, ModelState ** state )

static

Definition at line 237 of file TracccTritonBackend.cxx.

{
  try {
    *state = new ModelState(triton_model);
  }
  catch (const BackendModelException& ex) {
    RETURN_ERROR_IF_TRUE(
        ex.err_ == nullptr, TRITONSERVER_ERROR_INTERNAL,
        std::string("unexpected nullptr in BackendModelException"));
    RETURN_IF_ERROR(ex.err_);
  }
 
  return nullptr;  // success
}

InputCellsTensorDataType()

TRITONSERVER_DataType triton::backend::traccc::ModelState::InputCellsTensorDataType ( ) const

inline

Definition at line 189 of file TracccTritonBackend.cxx.

{ return m_inputCellsDatatype; }

InputCellsTensorName()

const std::string & triton::backend::traccc::ModelState::InputCellsTensorName ( ) const

inline

Definition at line 186 of file TracccTritonBackend.cxx.

{ return m_inputCellsName; }

InputCellsTensorNonBatchShape()

const std::vector< int64_t > & triton::backend::traccc::ModelState::InputCellsTensorNonBatchShape ( ) const

inline

Definition at line 202 of file TracccTritonBackend.cxx.

    {
        return m_inputCellsNbShape;
    }

TotalInstanceCount()

size_t triton::backend::traccc::ModelState::TotalInstanceCount ( ) const

inline

Definition at line 207 of file TracccTritonBackend.cxx.

{ return m_totalInstanceCount; }

ValidateModelConfig()

TRITONSERVER_Error * triton::backend::traccc::ModelState::ValidateModelConfig

(

)

Definition at line 253 of file TracccTritonBackend.cxx.

{
    // If verbose logging is enabled, dump the model's configuration as
    // JSON into the console output.
    if (TRITONSERVER_LogIsEnabled(TRITONSERVER_LOG_VERBOSE)) {
    common::TritonJson::WriteBuffer buffer;
    RETURN_IF_ERROR(ModelConfig().PrettyWrite(&buffer));
    LOG_MESSAGE(
        TRITONSERVER_LOG_VERBOSE,
        (std::string("model configuration:\n") + buffer.Contents()).c_str());
    }
 
    // ModelConfig is the model configuration as a TritonJson
    // object. Use the TritonJson utilities to parse the JSON and
    // determine if the configuration is supported by this backend.
    common::TritonJson::Value inputs, outputs;
    RETURN_IF_ERROR(ModelConfig().MemberAsArray("input", &inputs));
    RETURN_IF_ERROR(ModelConfig().MemberAsArray("output", &outputs));
 
    // The model must have exactly the 2 inputs (CELLS, EVENT_IOV) and the 4
    // outputs the client reads back
    RETURN_ERROR_IF_FALSE(
        inputs.ArraySize() == 2, TRITONSERVER_ERROR_INVALID_ARG,
        std::string("model configuration must have 2 inputs"));
    RETURN_ERROR_IF_FALSE(
        outputs.ArraySize() == outputNames.size(), TRITONSERVER_ERROR_INVALID_ARG,
        std::string("model configuration must have ") +
            std::to_string(outputNames.size()) + " outputs");
 
    // CELLS comes first; EVENT_IOV is looked up by its fixed name, and
    // Triton checks its type and shape against this configuration
    common::TritonJson::Value input_cells;
    RETURN_IF_ERROR(inputs.IndexAsObject(0, &input_cells));
 
    // Record the input name in the model state.
    const char *input_cells_name;
    size_t input_cells_len;
    RETURN_IF_ERROR(input_cells.MemberAsString("name", &input_cells_name, &input_cells_len));
    // MemberAsString hands back a pointer into the parsed JSON plus its
    // length; that buffer is not guaranteed to be NUL-terminated, so the
    // length must be used. Building the name with the const char* overload
    // instead can append trailing garbage, which then makes
    // TRITONBACKEND_RequestInput fail to find the tensor at execute time.
    m_inputCellsName = std::string(input_cells_name, input_cells_len);
 
    LOG_MESSAGE(TRITONSERVER_LOG_INFO,
                (std::string("'traccc' backend: input tensor is '") +
                 m_inputCellsName + "' (" +
                 std::to_string(m_inputCellsName.size()) + " chars)").c_str());
 
    std::string input_cells_dtype;
    RETURN_IF_ERROR(input_cells.MemberAsString("data_type", &input_cells_dtype));
    m_inputCellsDatatype = ModelConfigDataTypeToTritonServerDataType(input_cells_dtype);
 
    RETURN_IF_ERROR(backend::ParseShape(input_cells, "dims", &m_inputCellsNbShape));
 
    // The output tensors are written by fixed name, so the configured names
    // must be exactly the expected set (order is irrelevant).
    std::set<std::string> configured_outputs;
    for (size_t i = 0; i < outputs.ArraySize(); ++i) {
        common::TritonJson::Value output;
        RETURN_IF_ERROR(outputs.IndexAsObject(i, &output));
        const char *output_name;
        size_t output_name_len;
        RETURN_IF_ERROR(
            output.MemberAsString("name", &output_name, &output_name_len));
        configured_outputs.emplace(output_name, output_name_len);
    }
    for (const auto &expected : outputNames) {
        RETURN_ERROR_IF_FALSE(
            configured_outputs.count(expected) == 1, TRITONSERVER_ERROR_INVALID_ARG,
            std::string("model configuration is missing output '") + expected + "'");
    }
 
    // Count the instances Triton is going to create, so the embedded Athena
    // application can be brought up with one event-store slot per instance.
    m_totalInstanceCount = 0;
    common::TritonJson::Value instance_groups;
    if (ModelConfig().Find("instance_group", &instance_groups)) {
        for (size_t i = 0; i < instance_groups.ArraySize(); ++i) {
            common::TritonJson::Value group;
            RETURN_IF_ERROR(instance_groups.IndexAsObject(i, &group));
 
            int64_t count = 1;
            if (group.Find("count")) {
                RETURN_IF_ERROR(group.MemberAsInt("count", &count));
            }
            RETURN_ERROR_IF_FALSE(
                count >= 0, TRITONSERVER_ERROR_INVALID_ARG,
                std::string("instance_group count must not be negative"));
 
            size_t devices = 1;
            common::TritonJson::Value gpus;
            if (group.Find("gpus", &gpus) && gpus.ArraySize() > 0) {
                devices = gpus.ArraySize();
            }
            m_totalInstanceCount += static_cast<size_t>(count) * devices;
        }
    }
    // No instance_group at all, or one that resolves to nothing, still means
    // Triton creates a single instance.
    if (m_totalInstanceCount == 0) {
        m_totalInstanceCount = 1;
    }
 
    LOG_MESSAGE(TRITONSERVER_LOG_INFO,
                (std::string("'traccc' backend: model configured with ") +
                 std::to_string(m_totalInstanceCount) +
                 " instance(s), one event slot each").c_str());
 
    return nullptr; // success
}

Member Data Documentation

cellFeatures

int64_t triton::backend::traccc::ModelState::cellFeatures

Definition at line 213 of file TracccTritonBackend.cxx.

m_inputCellsDatatype

TRITONSERVER_DataType triton::backend::traccc::ModelState::m_inputCellsDatatype

private

Definition at line 220 of file TracccTritonBackend.cxx.

m_inputCellsName

std::string triton::backend::traccc::ModelState::m_inputCellsName

private

Definition at line 218 of file TracccTritonBackend.cxx.

m_inputCellsNbShape

std::vector<int64_t> triton::backend::traccc::ModelState::m_inputCellsNbShape

private

Definition at line 222 of file TracccTritonBackend.cxx.

m_totalInstanceCount

size_t triton::backend::traccc::ModelState::m_totalInstanceCount = 1

private

Definition at line 224 of file TracccTritonBackend.cxx.

---

The documentation for this class was generated from the following file:

• TracccTritonBackend.cxx