在 C++ 中运行 ExecuTorch 模型教程

usingexecutorch::aten::Tensor;
usingexecutorch::aten::TensorImpl;
usingexecutorch::extension::FileDataLoader;
usingexecutorch::extension::MallocMemoryAllocator;
usingexecutorch::runtime::Error;
usingexecutorch::runtime::EValue;
usingexecutorch::runtime::HierarchicalAllocator;
usingexecutorch::runtime::MemoryManager;
usingexecutorch::runtime::Method;
usingexecutorch::runtime::MethodMeta;
usingexecutorch::runtime::Program;
usingexecutorch::runtime::Result;
usingexecutorch::runtime::Span;

Result<FileDataLoader>loader=
FileDataLoader::from("/tmp/model.pte");
assert(loader.ok());

Result<Program>program=Program::load(&loader.get());
assert(program.ok());

// Method names map back to Python nn.Module method names. Most users will only
// have the singular method "forward".
constchar*method_name="forward";

// MethodMeta is a lightweight structure that lets us gather metadata
// information about a specific method. In this case we are looking to get the
// required size of the memory planned buffers for the method "forward".
Result<MethodMeta>method_meta=program->method_meta(method_name);
assert(method_meta.ok());

std::vector<std::unique_ptr<uint8_t[]>>planned_buffers;// Owns the Memory
std::vector<Span<uint8_t>>planned_arenas;// Passed to the allocator

size_tnum_memory_planned_buffers=method_meta->num_memory_planned_buffers();

// It is possible to have multiple layers in our memory hierarchy; for example,
// SRAM and DRAM.
for(size_tid=0;id<num_memory_planned_buffers;++id){
// .get() will always succeed because id < num_memory_planned_buffers.
size_tbuffer_size=
static_cast<size_t>(method_meta->memory_planned_buffer_size(id).get());
planned_buffers.push_back(std::make_unique<uint8_t[]>(buffer_size));
planned_arenas.push_back({planned_buffers.back().get(),buffer_size});
}
HierarchicalAllocatorplanned_memory(
{planned_arenas.data(),planned_arenas.size()});

// Version of MemoryAllocator that uses malloc to handle allocations rather then
// a fixed buffer.
MallocMemoryAllocatormethod_allocator;

// Assemble all of the allocators into the MemoryManager that the Executor will
// use.
MemoryManagermemory_manager(&method_allocator,&planned_memory);

Result<Method>method=program->load_method(method_name);
assert(method.ok());

// Create our input tensor.
floatdata[1*3*256*256];
Tensor::SizesTypesizes[]={1,3,256,256};
Tensor::DimOrderTypedim_order={0,1,2,3};
TensorImplimpl(
ScalarType::Float,// dtype
4,// number of dimensions
sizes,
data,
dim_order);
Tensort(&impl);

// Implicitly casts t to EValue
Errorset_input_error=method->set_input(t,0);
assert(set_input_error==Error::Ok);

Errorexecute_error=method->execute();
assert(execute_error==Error::Ok);

EValueoutput=method->get_output(0);
assert(output.isTensor());