/* deserializes a single kernel
* Note this has two modes of operation:
* 1) if name_len and name_match are non-NULL, it only fills in pocl_binary_kernel
* with metadata (doesn't unpack files) and only if the name matches - used by
* pocl_binary_get_kernel_metadata()
* 2) if name_len and name_match are NULL, unpacks kernel cachedir on disk, but
* does not set up kernel metadata of pocl_binary_kernel argument - used by
* pocl_binary_deserialize() */
static int
pocl_binary_deserialize_kernel_from_buffer(unsigned char **buf,
pocl_binary_kernel *kernel,
const char* name_match,
size_t name_len,
char* basedir)
{
unsigned i;
unsigned char *buffer = *buf;
memset(kernel, 0, sizeof(pocl_binary_kernel));
BUFFER_READ(kernel->struct_size, uint64_t);
BUFFER_READ(kernel->binaries_size, uint64_t);
BUFFER_READ(kernel->arginfo_size, uint32_t);
BUFFER_READ_STR2(kernel->kernel_name, kernel->sizeof_kernel_name);
BUFFER_READ(kernel->num_args, uint32_t);
BUFFER_READ(kernel->num_locals, uint32_t);
if (name_len > 0 && name_match)
{
if (strncmp(kernel->kernel_name, name_match, kernel->sizeof_kernel_name))
{
*buf = *buf + kernel->struct_size;
return -11111;
}
kernel->dyn_arguments = calloc((kernel->num_args + kernel->num_locals),
sizeof(struct pocl_argument));
POCL_RETURN_ERROR_COND((!kernel->dyn_arguments), CL_OUT_OF_HOST_MEMORY);
for (i=0; i < (kernel->num_args + kernel->num_locals); i++)
{
BUFFER_READ(kernel->dyn_arguments[i].size, uint64_t);
kernel->dyn_arguments[i].value = NULL;
}
kernel->arg_info = calloc(kernel->num_args, sizeof(struct pocl_argument_info));
POCL_RETURN_ERROR_COND((!kernel->arg_info), CL_OUT_OF_HOST_MEMORY);
for (i=0; i < kernel->num_args; i++)
{
pocl_argument_info *ai = &kernel->arg_info[i];
BUFFER_READ(ai->access_qualifier, cl_kernel_arg_access_qualifier);
BUFFER_READ(ai->address_qualifier, cl_kernel_arg_address_qualifier);
BUFFER_READ(ai->type_qualifier, cl_kernel_arg_type_qualifier);
BUFFER_READ(ai->is_local, char);
BUFFER_READ(ai->is_set, char);
BUFFER_READ(ai->type, uint32_t);
BUFFER_READ_STR(ai->name);
BUFFER_READ_STR(ai->type_name);
}
}
else
{
static unsigned char*
read_header(pocl_binary *b, const unsigned char *buffer)
{
memset(b, 0, sizeof(pocl_binary));
memcpy(b->pocl_id, buffer, POCLCC_STRING_ID_LENGTH);
buffer += POCLCC_STRING_ID_LENGTH;
BUFFER_READ(b->device_id, uint64_t);
BUFFER_READ(b->version, uint32_t);
BUFFER_READ(b->num_kernels, uint32_t);
memcpy(b->program_build_hash, buffer, sizeof(SHA1_digest_t));
buffer += sizeof(SHA1_digest_t);
return (unsigned char*)buffer;
}
cl_int
pocl_binary_get_kernel_names(unsigned char *binary,
char **kernel_names,
size_t num_kernels)
{
pocl_binary b;
unsigned char *buffer = read_header(&b, binary);
assert(num_kernels == b.num_kernels);
uint64_t struct_size;
unsigned char *orig_buffer;
unsigned i, len;
for (i=0; i < num_kernels; i++)
{
orig_buffer = buffer;
BUFFER_READ(struct_size, uint64_t);
// skip binaries_size & arginfo_size
buffer += sizeof(uint64_t) + sizeof(uint32_t);
BUFFER_READ_STR2(kernel_names[i], len);
kernel_names[i][len] = 0;
buffer = orig_buffer + struct_size;
}
return CL_SUCCESS;
}
int16_t RectifierParser::getAnswer() {
errorCounter_++;
parseCounter_++;
int16_t receiveRxBufferResult = serial_.receiveRxBuffer();
// get minimum bytes with message length
if (receiveRxBufferResult < 0) {
return receiveRxBufferResult; // Error code, if receiveRxBuffer() get error
}
uint16_t bytesRead = (uint16_t)receiveRxBufferResult;
if (bytesRead < RECTIFIER_MIN_LENGTH) {
return RectifierParseState::GET_MINIMAL_FRAME_ERROR;
}
const char* data = serial_.getBuffer();
if (!checkByte(0x7e, data, bytesRead)) {
return RectifierParseState::CHECK_START_TAIL_BYTE_ERROR;
}
BUFFER_READ_BCD(frame_.address, data, bytesRead);
BUFFER_READ_BCD(frame_.length, data, bytesRead);
if (frame_.length < (bytesRead - RECTIFIER_CS_TAIL_LENGTH)) {
return RectifierParseState::GET_MINIMAL_FRAME_ERROR;
}
//data = serial_.getBuffer();
BUFFER_READ(frame_.cid, data, bytesRead);
if (!RectifierInfoParser::makeRectifierInfoParser((int16_t)frame_.cid, parser_))
return RectifierParseState::MAKE_INFO_PARSER_ERROR;
int8_t parserResult = parser_->parseInfo(data, bytesRead, frame_.length);
if (RectifierParseState::OK != parserResult) return parserResult;
pParsedMesage_ = parser_->getData();
errorCounter_--;
return parser_->getCid();
}
