ClContextDeserializer Class Reference

#include <ClContextDeserializer.hpp>

Public Member Functions
	ClContextDeserializer ()=default
	~ClContextDeserializer ()=default
void	Deserialize (arm_compute::CLCompileContext &clCompileContext, cl::Context &context, cl::Device &device, const std::string &filePath)
	Deserializes the CLCompileContext built-in programs from a binary file.
void	DeserializeFromBinary (arm_compute::CLCompileContext &clCompileContext, cl::Context &context, cl::Device &device, const std::vector< uint8_t > &binaryContent)
	Deserializes the CLCompileContext built-in programs from binary file contents.

Detailed Description

Definition at line 13 of file ClContextDeserializer.hpp.

Constructor & Destructor Documentation

ClContextDeserializer()

ClContextDeserializer ( )

default

~ClContextDeserializer()

~ClContextDeserializer ( )

default

Member Function Documentation

Deserialize()

void Deserialize	(	arm_compute::CLCompileContext &	clCompileContext,
		cl::Context &	context,
		cl::Device &	device,
		const std::string &	filePath )

Deserializes the CLCompileContext built-in programs from a binary file.

Parameters

[in]	clCompileContext	The CLCompileContext to be serialized
[in]	context	The CL Kernel context built-in program will be created from
[in]	device	The CL Kernel device built-in program will be created from
[in]	filePath	The serialized file

Definition at line 36 of file ClContextDeserializer.cpp.

{
    std::vector<std::uint8_t> binaryContent;
#if !SERIALIZER_USE_MMAP
    std::ifstream inputFileStream(filePath, std::ios::binary);
    while (inputFileStream)
    {
        char input;
        inputFileStream.get(input);
        if (inputFileStream)
        {
            binaryContent.push_back(static_cast<std::uint8_t>(input));
        }
    }
    inputFileStream.close();
#else
    struct stat statbuf;
    int fp = open(filePath.c_str(),O_RDONLY);
    if (!fp)
    {
        ARMNN_LOG(error) << (std::string("Cannot open file ") + filePath);
        return;
    }
    fstat(fp,&statbuf);
    const unsigned long dataSize = static_cast<unsigned long>(statbuf.st_size);
    binaryContent.resize(static_cast<long unsigned int>(dataSize));
    void* ptrmem = mmap(NULL, dataSize,PROT_READ,MAP_PRIVATE,fp,0);
    if(ptrmem!=MAP_FAILED)
    {
         memcpy (binaryContent.data(), ptrmem, dataSize);
    }
    close(fp);
    if(ptrmem == MAP_FAILED)
    {
        ARMNN_LOG(error) << (std::string("Cannot map file ") + filePath);
        return;
    }
#endif
 
    DeserializeFromBinary(clCompileContext, context, device, binaryContent);
}

References ARMNN_LOG, DeserializeFromBinary(), and armnn::error.

DeserializeFromBinary()

void DeserializeFromBinary	(	arm_compute::CLCompileContext &	clCompileContext,
		cl::Context &	context,
		cl::Device &	device,
		const std::vector< uint8_t > &	binaryContent )

Deserializes the CLCompileContext built-in programs from binary file contents.

Parameters

[in]	clCompileContext	The CLCompileContext to be serialized
[in]	context	The CL Kernel context built-in program will be created from
[in]	device	The CL Kernel device built-in program will be created from
[in]	filePath	The serialized file

Definition at line 81 of file ClContextDeserializer.cpp.

{
    if (binaryContent.data() == nullptr)
    {
        throw InvalidArgumentException(fmt::format("Invalid (null) binary content {}",
                                                   CHECK_LOCATION().AsString()));
    }
 
    size_t binaryContentSize = binaryContent.size();
    flatbuffers::Verifier verifier(binaryContent.data(), binaryContentSize);
    if (verifier.VerifyBuffer<ClContext>() == false)
    {
        throw ParseException(fmt::format("Buffer doesn't conform to the expected Armnn "
                                         "flatbuffers format. size:{0} {1}",
                                         binaryContentSize,
                                         CHECK_LOCATION().AsString()));
    }
    auto clContext = GetClContext(binaryContent.data());
 
    for (Program const* program : *clContext->programs())
    {
        const char* volatile programName = program->name()->c_str();
        auto programBinary = program->binary();
        std::vector<uint8_t> binary(programBinary->begin(), programBinary->begin() + programBinary->size());
 
        cl::Program::Binaries   binaries{ binary };
        std::vector<cl::Device> devices {device};
        cl::Program             theProgram(context, devices, binaries);
        theProgram.build();
        clCompileContext.add_built_program(programName, theProgram);
    }
}

References CHECK_LOCATION, and armnn::GetClContext().

Referenced by Deserialize().

---

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

• src/backends/cl/ClContextDeserializer.hpp
• src/backends/cl/ClContextDeserializer.cpp