static VALUE OpenVX_targets_list(VALUE self)
{
vx_uint32 t,value = 0;
vx_status status = VX_FAILURE;
vx_char targetname[VX_MAX_TARGET_NAME];
vx_target target = 0;
VALUE array;
status = vxQueryContext(context, VX_QUERY_CONTEXT_NUMTARGETS, &value, sizeof(value));
REXT_PRINT("status = %d, targets = %d\n", status, value);
if (status == VX_SUCCESS)
{
array = rb_ary_new2(value);
for (t = 0; t < value; t++)
{
target = vxGetTargetByIndex(context, t);
if (target)
{
status = vxQueryTarget(target, VX_QUERY_TARGET_NAME, targetname, sizeof(targetname));
if (status == VX_SUCCESS)
rb_ary_push(array, rb_str_new2(targetname));
}
}
}
return array;
}
static jint getNumTargets(JNIEnv *env, jobject obj)
{
vx_context context = (vx_context)GetHandle(env, obj, ContextClass, handleName);
jint value = 0;
vx_status status = vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_TARGETS, &value, sizeof(value));
if (status != VX_SUCCESS)
value = 0;
return value;
}
static VALUE OpenVX_references(VALUE self)
{
vx_uint32 value = 0;
vx_status status = VX_FAILURE;
status = vxQueryContext(context, VX_QUERY_CONTEXT_NUMREFS, &value, sizeof(value));
REXT_PRINT("status = %d, references = %d\n", status, value);
if (status == VX_SUCCESS)
return INT2FIX(value);
else
return INT2FIX(0);
}
static VALUE OpenVX_targets(VALUE self)
{
vx_uint32 value = 0;
vx_status status = VX_FAILURE;
status = vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_TARGETS, &value, sizeof(value));
REXT_PRINT("status = %d, targets = %d\n", status, value);
if (status == VX_SUCCESS)
return INT2FIX(value);
else
return INT2FIX(0);
}
static VALUE OpenVX_kernels(VALUE self)
{
vx_uint32 value = 0;
vx_status status = VX_FAILURE;
status = vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_UNIQUE_KERNELS, &value, sizeof(value));
REXT_PRINT("status = %d, numkernels = %d\n", status, value);
if (status == VX_SUCCESS)
return INT2FIX(value);
else
return INT2FIX(0);
}
void Init_openvxruby()
{
context = vxCreateContext();
vx_status status = vxQueryContext(context, VX_QUERY_CONTEXT_IMPLEMENTATION, implementation, sizeof(implementation));
if (status != VX_SUCCESS)
{
REXT_PRINT("context = "VX_FMT_REF" status = %d\n", context, status);
strncpy(implementation, "khronos.sample (bad)", sizeof(implementation));
}
rb_mOpenVXString = rb_str_new2(implementation);
rubyext_modules(Qnil, modules, dimof(modules));
// there is no "unload"
}
vx_target vxFindTarget(vx_context context, vx_char name[VX_MAX_TARGET_NAME])
{
vx_uint32 t, targets;
vx_target target = 0;
vx_char targetName[VX_MAX_TARGET_NAME];
vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_NUMTARGETS, &targets, sizeof(targets));
for (t = 0u; t < targets; t++)
{
target = vxGetTargetByIndex(context,t);
vxQueryTarget(target, VX_TARGET_ATTRIBUTE_NAME, &targetName, VX_MAX_TARGET_NAME);
if (strncmp(targetName, name, VX_MAX_TARGET_NAME) == 0)
{
break;
}
vxReleaseTarget(&target);
target = 0;
}
return target;
}
vx_bool vxFindAllTargetsOfKernelsByName(vx_context context, vx_char kname[VX_MAX_KERNEL_NAME], vx_char *targets[VX_MAX_TARGET_NAME])
{
vx_bool ret = vx_false_e;
vx_uint32 k = 0u, t = 0u, num_targets = 0u;
vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_TARGETS, &num_targets, sizeof(num_targets));
for (t = 0u; t < num_targets; t++)
{
vx_target target = vxGetTargetByIndex(context, t);
vx_uint32 num_kernels = 0;
/* clear out the name */
memset(targets[t], 0, VX_MAX_TARGET_NAME);
if (vxQueryTarget(target, VX_TARGET_ATTRIBUTE_NUMKERNELS, &num_kernels, sizeof(num_kernels)) == VX_SUCCESS)
{
vx_size size = num_kernels * sizeof(vx_kernel_info_t);
vx_kernel_info_t *kernels = malloc(size);
if (vxQueryTarget(target, VX_TARGET_ATTRIBUTE_KERNELTABLE, kernels, size) == VX_SUCCESS)
{
for (k = 0u; k < num_kernels; k++)
{
/* target kernel names are allowed to have variant strings */
vx_char string[VX_MAX_KERNEL_NAME], *ker;
strncpy(string, kernels[k].name, VX_MAX_KERNEL_NAME);
ker = strtok(string, ":");
/* if it has any variants of this kernel it is ok */
if (strncmp(kname, ker, VX_MAX_KERNEL_NAME) == 0)
{
/* fill in the name if it has this kernel */
if (vxQueryTarget(target, VX_TARGET_ATTRIBUTE_NAME, targets[t], VX_MAX_TARGET_NAME) == VX_SUCCESS)
{
ret = vx_true_e;
}
break;
}
}
}
free(kernels);
}
}
return ret;
}
vx_bool vxCreateListOfAllTargets(vx_context context, vx_char **targets[], vx_uint32 *num_targets)
{
vx_bool ret = vx_false_e;
vx_uint32 t = 0u;
if (vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_TARGETS, num_targets, sizeof(*num_targets)) == VX_SUCCESS)
{
*targets = (vx_char **)calloc(*num_targets, sizeof(vx_char *));
if (*targets)
{
for (t = 0u; t < *num_targets; t++)
{
vx_target target = vxGetTargetByIndex(context, t);
(*targets)[t] = (vx_char *)calloc(VX_MAX_TARGET_NAME, sizeof(vx_char));
if ((*targets)[t])
{
if (vxQueryTarget(target, VX_TARGET_ATTRIBUTE_NAME, (*targets)[t], VX_MAX_TARGET_NAME) == VX_SUCCESS)
{
ret = vx_true_e;
}
else
{
ret = vx_false_e;
break;
}
}
}
if (ret == vx_false_e)
{
do {
if (t > 0)
free((*targets)[--t]);
} while (t != 0);
}
}
}
return ret;
}
int main(int argc, char *argv[])
{
vx_status status = VX_SUCCESS;
vx_context context = vxCreateContext();
if (vxGetStatus((vx_reference)context) == VX_SUCCESS)
{
vx_char implementation[VX_MAX_IMPLEMENTATION_NAME];
vx_char *extensions = NULL;
vx_int32 m, modules = 0;
vx_uint32 k, kernels = 0;
vx_uint32 p, parameters = 0;
vx_uint32 a = 0;
vx_uint16 vendor, version;
vx_size size = 0;
vx_kernel_info_t *table = NULL;
// take each arg as a module name to load
for (m = 1; m < argc; m++)
{
if (vxLoadKernels(context, argv[m]) != VX_SUCCESS)
printf("Failed to load module %s\n", argv[m]);
else
printf("Loaded module %s\n", argv[m]);
}
vxPrintAllLog(context);
vxRegisterHelperAsLogReader(context);
vxQueryContext(context, VX_CONTEXT_VENDOR_ID, &vendor, sizeof(vendor));
vxQueryContext(context, VX_CONTEXT_VERSION, &version, sizeof(version));
vxQueryContext(context, VX_CONTEXT_IMPLEMENTATION, implementation, sizeof(implementation));
vxQueryContext(context, VX_CONTEXT_MODULES, &modules, sizeof(modules));
vxQueryContext(context, VX_CONTEXT_EXTENSIONS_SIZE, &size, sizeof(size));
printf("implementation=%s (%02x:%02x) has %u modules\n", implementation, vendor, version, modules);
extensions = malloc(size);
if (extensions)
{
vx_char *line = extensions, *token = NULL;
vxQueryContext(context, VX_CONTEXT_EXTENSIONS, extensions, size);
do {
token = strtok(line, " ");
if (token)
printf("extension: %s\n", token);
line = NULL;
} while (token);
free(extensions);
}
status = vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, &kernels, sizeof(kernels));
if (status != VX_SUCCESS) goto exit;
printf("There are %u kernels\n", kernels);
size = kernels * sizeof(vx_kernel_info_t);
table = malloc(size);
status = vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNEL_TABLE, table, size);
for (k = 0; k < kernels && table != NULL && status == VX_SUCCESS; k++)
{
vx_kernel kernel = vxGetKernelByEnum(context, table[k].enumeration);
if (kernel && vxGetStatus((vx_reference)kernel) == VX_SUCCESS)
{
status = vxQueryKernel(kernel, VX_KERNEL_PARAMETERS, ¶meters, sizeof(parameters));
printf("\t\tkernel[%u]=%s has %u parameters (%d)\n",
table[k].enumeration,
table[k].name,
parameters,
status);
for (p = 0; p < parameters; p++)
{
vx_parameter parameter = vxGetKernelParameterByIndex(kernel, p);
vx_enum type = VX_TYPE_INVALID, dir = VX_INPUT;
vx_uint32 tIdx, dIdx;
status = VX_SUCCESS;
status |= vxQueryParameter(parameter, VX_PARAMETER_TYPE, &type, sizeof(type));
status |= vxQueryParameter(parameter, VX_PARAMETER_DIRECTION, &dir, sizeof(dir));
for (tIdx = 0; tIdx < dimof(parameter_names); tIdx++)
if (parameter_names[tIdx].tenum == type)
break;
for (dIdx = 0; dIdx < dimof(direction_names); dIdx++)
if (direction_names[dIdx].tenum == dir)
break;
if (status == VX_SUCCESS)
printf("\t\t\tparameter[%u] type:%s dir:%s\n", p,
parameter_names[tIdx].name,
direction_names[dIdx].name);
vxReleaseParameter(¶meter);
}
for (a = 0; a < dimof(attribute_names); a++)
{
switch (attribute_names[a].type)
{
case VX_TYPE_SIZE:
{
vx_size value = 0;
if (VX_SUCCESS == vxQueryKernel(kernel, attribute_names[a].tenum, &value, sizeof(value)))
printf("\t\t\tattribute[%u] %s = "VX_FMT_SIZE"\n",
attribute_names[a].tenum & VX_ATTRIBUTE_ID_MASK,
attribute_names[a].name,
value);
break;
}
case VX_TYPE_UINT32:
{
vx_uint32 value = 0;
if (VX_SUCCESS == vxQueryKernel(kernel, attribute_names[a].tenum, &value, sizeof(value)))
printf("\t\t\tattribute[%u] %s = %u\n",
attribute_names[a].tenum & VX_ATTRIBUTE_ID_MASK,
attribute_names[a].name,
value);
break;
}
default:
break;
}
}
vxReleaseKernel(&kernel);
}
else
{
printf("ERROR: kernel %s is invalid (%d) !\n", table[k].name, status);
}
}
for (m = 1; m < argc; m++)
{
if (vxUnloadKernels(context, argv[m]) != VX_SUCCESS)
printf("Failed to unload module %s\n", argv[m]);
else
printf("Unloaded module %s\n", argv[m]);
}
exit:
if (table) free(table);
vxReleaseContext(&context);
}
return 0;
}
int CVxParamTensor::Initialize(vx_context context, vx_graph graph, const char * desc)
{
// get object parameters and create object
const char * ioParams = desc;
if (!_strnicmp(desc, "tensor:", 7) || !_strnicmp(desc, "virtual-tensor:", 15)) {
bool isVirtual = false;
if (!_strnicmp(desc, "virtual-tensor:", 15)) {
isVirtual = true;
desc += 8;
}
char objType[64], data_type[64];
ioParams = ScanParameters(desc, "tensor:<num-of-dims>,{dims},<data-type>,<fixed-point-pos>", "s:D,L,s,d", objType, &m_num_of_dims, &m_num_of_dims, m_dims, data_type, &m_fixed_point_pos);
m_data_type = ovxName2Enum(data_type);
if (isVirtual) {
m_tensor = vxCreateVirtualTensor(graph, m_num_of_dims, m_dims, m_data_type, m_fixed_point_pos);
}
else {
m_tensor = vxCreateTensor(context, m_num_of_dims, m_dims, m_data_type, m_fixed_point_pos);
}
}
else if (!_strnicmp(desc, "tensor-from-roi:", 16)) {
char objType[64], masterName[64];
ioParams = ScanParameters(desc, "tensor-from-view:<tensor>,<view>", "s:s,D,L,L", objType, masterName, &m_num_of_dims, &m_num_of_dims, m_start, &m_num_of_dims, m_end);
auto itMaster = m_paramMap->find(masterName);
if (itMaster == m_paramMap->end())
ReportError("ERROR: tensor [%s] doesn't exist for %s\n", masterName, desc);
vx_tensor masterTensor = (vx_tensor)itMaster->second->GetVxObject();
m_tensor = vxCreateTensorFromView(masterTensor, m_num_of_dims, m_start, m_end);
}
else if (!_strnicmp(desc, "tensor-from-handle:", 19)) {
char objType[64], data_type[64], memory_type_str[64];
ioParams = ScanParameters(desc, "tensor-from-handle:<num-of-dims>,{dims},<data-type>,<fixed-point-pos>,{strides},<num-handles>,<memory-type>",
"s:D,L,s,d,L,D,s", objType, &m_num_of_dims, &m_num_of_dims, m_dims, data_type, &m_fixed_point_pos, &m_num_of_dims, m_stride, &m_num_handles, memory_type_str);
if(m_num_handles > MAX_BUFFER_HANDLES)
ReportError("ERROR: num-handles is out of range: " VX_FMT_SIZE " (must be less than %d)\n", m_num_handles, MAX_BUFFER_HANDLES);
m_data_type = ovxName2Enum(data_type);
vx_uint64 memory_type = 0;
if (GetScalarValueFromString(VX_TYPE_ENUM, memory_type_str, &memory_type) < 0)
ReportError("ERROR: invalid memory type enum: %s\n", memory_type_str);
m_memory_type = (vx_enum)memory_type;
memset(m_memory_handle, 0, sizeof(m_memory_handle));
if (m_memory_type == VX_MEMORY_TYPE_HOST) {
// allocate all handles on host
for (vx_size active_handle = 0; active_handle < m_num_handles; active_handle++) {
vx_size size = m_dims[m_num_of_dims-1] * m_stride[m_num_of_dims-1];
m_memory_handle[active_handle] = malloc(size);
if (!m_memory_handle[active_handle])
ReportError("ERROR: malloc(%d) failed\n", (int)size);
}
}
#if ENABLE_OPENCL
else if (m_memory_type == VX_MEMORY_TYPE_OPENCL) {
// allocate all handles on opencl
cl_context opencl_context = nullptr;
vx_status status = vxQueryContext(context, VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT, &opencl_context, sizeof(opencl_context));
if (status)
ReportError("ERROR: vxQueryContext(*,VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT,...) failed (%d)\n", status);
for (vx_size active_handle = 0; active_handle < m_num_handles; active_handle++) {
vx_size size = m_dims[m_num_of_dims-1] * m_stride[m_num_of_dims-1];
cl_int err = CL_SUCCESS;
m_memory_handle[active_handle] = clCreateBuffer(opencl_context, CL_MEM_READ_WRITE, size, NULL, &err);
if (!m_memory_handle[active_handle] || err)
ReportError("ERROR: clCreateBuffer(*,CL_MEM_READ_WRITE,%d,NULL,*) failed (%d)\n", (int)size, err);
}
}
#endif
else ReportError("ERROR: invalid memory-type enum: %s\n", memory_type_str);
m_active_handle = 0;
m_tensor = vxCreateTensorFromHandle(context, m_num_of_dims, m_dims, m_data_type, m_fixed_point_pos, m_stride, m_memory_handle[m_active_handle], m_memory_type);
}
else ReportError("ERROR: unsupported tensor type: %s\n", desc);
vx_status ovxStatus = vxGetStatus((vx_reference)m_tensor);
if (ovxStatus != VX_SUCCESS){
printf("ERROR: tensor creation failed => %d (%s)\n", ovxStatus, ovxEnum2Name(ovxStatus));
if (m_tensor) vxReleaseTensor(&m_tensor);
throw - 1;
}
m_vxObjRef = (vx_reference)m_tensor;
// io initialize
return InitializeIO(context, graph, m_vxObjRef, ioParams);
}
