IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

samples: Print verbose error messages to stderr (#7795)

Browse Source 
* samples: Print verbose error messages to stderr

Printing error root cause is crucial for efficient debugging.
Moreover `stderr` may have different formatting in comparison
to `stdout` which improves readability.

Signed-off-by: Karol Trzcinski <karolx.trzcinski@intel.com>

* fix code style pre-commit check

Co-authored-by: Vladimir Dudnik <vladimir.dudnik@intel.com>
This commit is contained in:
Karol Trzciński 2021-11-10 09:42:52 +01:00 committed by GitHub
parent 41f7893ae8
commit 76994c6ec9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 144 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
samples/c/hello_classification/main.c
View File

@ -122,15 +122,19 @@ int main(int argc, char** argv) {
// -------------------------------------
IEStatusCode status = ie_core_create("", &core);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_create status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// Step 2. Read a model in OpenVINO Intermediate Representation (.xml and .bin
// files) or ONNX (.onnx file) format
status = ie_core_read_network(core, input_model, NULL, &network);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_read_network status %d, line %d\n", status, __LINE__);
goto err;
}
// check the network topology
status = ie_network_get_inputs_number(network, &network_input_size);
if (status != OK || network_input_size != 1) {
@ -140,7 +144,7 @@ int main(int argc, char** argv) {
status = ie_network_get_outputs_number(network, &network_output_size);
if (status != OK || network_output_size != 1) {
printf("Sample supports topologies with 1 output only\n");
fprintf(stderr, "Sample supports topologies with 1 output only\n");
goto err;
}
// -----------------------------------------------------------------------------------------------------
@ -151,8 +155,10 @@ int main(int argc, char** argv) {
// -----------------------------------------------------
status = ie_network_get_input_name(network, 0, &input_name);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_get_input_name status %d, line %d\n", status, __LINE__);
goto err;
}
/* Mark input as resizable by setting of a resize algorithm.
* In this case we will be able to set an input blob of any shape to an infer
* request. Resize and layout conversions are executed automatically during
@ -160,15 +166,19 @@ int main(int argc, char** argv) {
status |= ie_network_set_input_resize_algorithm(network, input_name, RESIZE_BILINEAR);
status |= ie_network_set_input_layout(network, input_name, NHWC);
status |= ie_network_set_input_precision(network, input_name, U8);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_set_input_* status %d, line %d\n", status, __LINE__);
goto err;
}
// --------------------------- Prepare output blobs
// ----------------------------------------------------
status |= ie_network_get_output_name(network, 0, &output_name);
status |= ie_network_set_output_precision(network, output_name, FP32);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_get_output_* status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
@ -176,15 +186,19 @@ int main(int argc, char** argv) {
// ------------------------------------------
ie_config_t config = {NULL, NULL, NULL};
status = ie_core_load_network(core, network, device_name, &config, &exe_network);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_load_network status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 5. Create infer request
// -------------------------------------------------
status = ie_exec_network_create_infer_request(exe_network, &infer_request);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_exec_network_create_infer_request status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 6. Prepare input
@ -201,28 +215,34 @@ int main(int argc, char** argv) {
// memory
status = ie_blob_make_memory_from_preallocated(&tensorDesc, img.mat_data, size, &imgBlob);
if (status != OK) {
fprintf(stderr, "ERROR ie_blob_make_memory_from_preallocated status %d, line %d\n", status, __LINE__);
image_free(&img);
goto err;
}
// infer_request accepts input blob of any size
status = ie_infer_request_set_blob(infer_request, input_name, imgBlob);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_set_blob status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 7. Do inference
// --------------------------------------------------------
/* Running the request synchronously */
status = ie_infer_request_infer(infer_request);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_infer status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 8. Process output
// ------------------------------------------------------
status = ie_infer_request_get_blob(infer_request, output_name, &output_blob);
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_get_blob status %d, line %d\n", status, __LINE__);
image_free(&img);
goto err;
}

56
samples/c/hello_nv12_input_classification/main.c
View File

@ -178,8 +178,10 @@ int main(int argc, char** argv) {
}
size_t input_width = 0, input_height = 0, img_size = 0;
if (!is_supported_image_size(argv[3], &input_width, &input_height))
if (!is_supported_image_size(argv[3], &input_width, &input_height)) {
fprintf(stderr, "ERROR is_supported_image_size, line %d\n", __LINE__);
return EXIT_FAILURE;
}
const char* input_model = argv[1];
const char* input_image_path = argv[2];
@ -196,15 +198,19 @@ int main(int argc, char** argv) {
// --------------------------- Step 1. Initialize inference engine core
// -------------------------------------
IEStatusCode status = ie_core_create("", &core);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_create status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// Step 2. Read a model in OpenVINO Intermediate Representation (.xml and .bin
// files) or ONNX (.onnx file) format
status = ie_core_read_network(core, input_model, NULL, &network);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_read_network status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 3. Configure input & output
@ -212,8 +218,10 @@ int main(int argc, char** argv) {
// --------------------------- Prepare input blobs
// -----------------------------------------------------
status = ie_network_get_input_name(network, 0, &input_name);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_get_input_name status %d, line %d\n", status, __LINE__);
goto err;
}
/* Mark input as resizable by setting of a resize algorithm.
* In this case we will be able to set an input blob of any shape to an infer
@ -226,15 +234,19 @@ int main(int argc, char** argv) {
// pre-processing
status |= ie_network_set_color_format(network, input_name, NV12);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_set_input_* status %d, line %d\n", status, __LINE__);
goto err;
}
// --------------------------- Prepare output blobs
// ----------------------------------------------------
status |= ie_network_get_output_name(network, 0, &output_name);
status |= ie_network_set_output_precision(network, output_name, FP32);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_set_output_* status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
@ -242,15 +254,19 @@ int main(int argc, char** argv) {
// ------------------------------------------
ie_config_t config = {NULL, NULL, NULL};
status = ie_core_load_network(core, network, device_name, &config, &exe_network);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_load_network status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 5. Create infer request
// -------------------------------------------------
status = ie_exec_network_create_infer_request(exe_network, &infer_request);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_exec_network_create_infer_request status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 6. Prepare input
@ -258,10 +274,14 @@ int main(int argc, char** argv) {
// size converted to NV12 data size: height(NV12) = 3 / 2 * logical height
img_size = input_width * (input_height * 3 / 2);
img_data = (unsigned char*)calloc(img_size, sizeof(unsigned char));
if (NULL == img_data)
if (NULL == img_data) {
fprintf(stderr, "ERROR calloc returned NULL, line %d\n", __LINE__);
goto err;
if (img_size != read_image_from_file(input_image_path, img_data, img_size))
}
if (img_size != read_image_from_file(input_image_path, img_data, img_size)) {
fprintf(stderr, "ERROR ie_exec_network_create_infer_request `img_size` missmatch, line %d\n", __LINE__);
goto err;
}
// --------------------------- Create a blob to hold the NV12 input data
// ------------------------------- Create tensor descriptors for Y and UV
@ -279,27 +299,35 @@ int main(int argc, char** argv) {
status |= ie_blob_make_memory_from_preallocated(&uv_tensor, img_data + y_plane_size, uv_plane_size, &uv_blob);
// Create NV12Blob from Y and UV blobs
status |= ie_blob_make_memory_nv12(y_blob, uv_blob, &nv12_blob);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_blob_make_memory_* status %d, line %d\n", status, __LINE__);
goto err;
}
status = ie_infer_request_set_blob(infer_request, input_name, nv12_blob);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_set_blob status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 7. Do inference
// --------------------------------------------------------
/* Running the request synchronously */
status = ie_infer_request_infer(infer_request);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_infer status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 8. Process output
// ------------------------------------------------------
status = ie_infer_request_get_blob(infer_request, output_name, &output_blob);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_get_blob status %d, line %d\n", status, __LINE__);
goto err;
}
size_t class_num;
struct classify_res* cls = output_blob_to_classify_res(output_blob, &class_num);

102
samples/c/object_detection_sample_ssd/main.c
View File

@ -69,6 +69,7 @@ int ParseAndCheckCommandLine(int argc, char* argv[]) {
config_msg = optarg;
break;
default:
fprintf(stderr, "Unknown argument `%c`. Please use -h option.\n", opt);
return -1;
}
}
@ -76,11 +77,11 @@ int ParseAndCheckCommandLine(int argc, char* argv[]) {
if (help)
return -1;
if (input_model == NULL) {
printf("Model is required but not set. Please set -m option.\n");
fprintf(stderr, "Model is required but not set. Please set -m option.\n");
return -1;
}
if (img_msg == NULL) {
printf("Input is required but not set.Please set -i option.\n");
fprintf(stderr, "Input is required but not set.Please set -i option.\n");
return -1;
}
@ -96,14 +97,14 @@ int ParseAndCheckCommandLine(int argc, char* argv[]) {
void readInputFilesArgument(const char* arg) {
struct stat sb;
if (stat(arg, &sb) != 0) {
printf("%sFile %s cannot be opened!\n", warn, arg);
fprintf(stderr, "%sFile %s cannot be opened!\n", warn, arg);
return;
}
if (S_ISDIR(sb.st_mode)) {
DIR* dp;
dp = opendir(arg);
if (dp == NULL) {
printf("%sFile %s cannot be opened!\n", warn, arg);
fprintf(stderr, "%sFile %s cannot be opened!\n", warn, arg);
return;
}
@ -189,6 +190,7 @@ void parseInputFilesArguments(int argc, char** argv) {
ie_config_t* parseConfig(const char* config_file, char comment) {
FILE* file = fopen(config_file, "r");
if (!file) {
fprintf(stderr, "ERROR file `%s` opening failure\n", config_file);
return NULL;
}
@ -323,7 +325,7 @@ int main(int argc, char** argv) {
/** This file_paths stores paths to the processed images **/
parseInputFilesArguments(argc, argv_temp);
if (!file_num) {
printf("No suitable images were found\n");
fprintf(stderr, "No suitable images were found\n");
free(argv_temp);
return EXIT_FAILURE;
}
@ -334,16 +336,20 @@ int main(int argc, char** argv) {
printf("%sLoading Inference Engine\n", info);
IEStatusCode status = ie_core_create("", &core);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_create status %d, line %d\n", status, __LINE__);
goto err;
}
// ------------------------------ Get Available Devices
// ------------------------------------------------------
ie_core_versions_t ver;
printf("%sDevice info: \n", info);
status = ie_core_get_versions(core, device_name, &ver);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_get_versions status %d, line %d\n", status, __LINE__);
goto err;
}
for (i = 0; i < ver.num_vers; ++i) {
printf(" %s\n", ver.versions[i].device_name);
printf(" %s version ......... %zu.%zu\n",
@ -358,8 +364,10 @@ int main(int argc, char** argv) {
// Custom CPU extension is loaded as a shared library and passed as a
// pointer to base extension
status = ie_core_add_extension(core, custom_ex_library_msg, "CPU");
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_add_extension status %d, line %d\n", status, __LINE__);
goto err;
}
printf("%sCustom extension loaded: %s\n", info, custom_ex_library_msg);
}
@ -369,8 +377,10 @@ int main(int argc, char** argv) {
// description
ie_config_t cfg = {"CONFIG_FILE", custom_plugin_cfg_msg, NULL};
status = ie_core_set_config(core, &cfg, device_name);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_set_config status %d, line %d\n", status, __LINE__);
goto err;
}
printf("%sConfig for device plugin custom extension loaded: %s\n", info, custom_plugin_cfg_msg);
}
// -----------------------------------------------------------------------------------------------------
@ -380,8 +390,10 @@ int main(int argc, char** argv) {
printf("%sLoading network:\n", info);
printf("\t%s\n", input_model);
status = ie_core_read_network(core, input_model, NULL, &network);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_read_network status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 3. Configure input & output
@ -394,7 +406,7 @@ int main(int argc, char** argv) {
size_t input_num = 0;
status = ie_network_get_inputs_number(network, &input_num);
if (status != OK || (input_num != 1 && input_num != 2)) {
printf("Sample supports topologies only with 1 or 2 inputs\n");
fprintf(stderr, "Sample supports topologies only with 1 or 2 inputs\n");
goto err;
}
@ -435,7 +447,7 @@ int main(int argc, char** argv) {
status = ie_network_set_input_precision(network, name, FP32);
if (status != OK || (input_dim.dims[1] != 3 && input_dim.dims[1] != 6)) {
printf("Invalid input info. Should be 3 or 6 values length\n");
fprintf(stderr, "Invalid input info. Should be 3 or 6 values length\n");
goto err;
}
}
@ -464,7 +476,7 @@ int main(int argc, char** argv) {
for (i = 0; i < file_num; ++i) {
c_mat_t img = {NULL, 0, 0, 0, 0, 0};
if (image_read(file_paths[i], &img) == -1) {
printf("%sImage %s cannot be read!\n", warn, file_paths[i]);
fprintf(stderr, "%sImage %s cannot be read!\n", warn, file_paths[i]);
continue;
}
/** Store image data **/
@ -504,7 +516,7 @@ int main(int argc, char** argv) {
}
if (!image_num) {
printf("Valid input images were not found!\n");
fprintf(stderr, "Valid input images were not found!\n");
free(originalImages);
free(images);
goto err;
@ -512,8 +524,10 @@ int main(int argc, char** argv) {
input_shapes_t shapes;
status = ie_network_get_input_shapes(network, &shapes);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_get_input_shapes status %d, line %d\n", status, __LINE__);
goto err;
}
/** Using ie_network_reshape() to set the batch size equal to the number of
* input images **/
@ -521,14 +535,18 @@ int main(int argc, char** argv) {
* **/
shapes.shapes[0].shape.dims[0] = image_num;
status = ie_network_reshape(network, shapes);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_reshape status %d, line %d\n", status, __LINE__);
goto err;
}
ie_network_input_shapes_free(&shapes);
input_shapes_t shapes2;
status = ie_network_get_input_shapes(network, &shapes2);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_get_input_shapes status %d, line %d\n", status, __LINE__);
goto err;
}
size_t batchSize = shapes2.shapes[0].shape.dims[0];
ie_network_input_shapes_free(&shapes2);
printf("%sBatch size is %zu\n", info, batchSize);
@ -541,20 +559,24 @@ int main(int argc, char** argv) {
status = ie_network_get_outputs_number(network, &output_num);
if (status != OK || !output_num) {
printf("Can't find a DetectionOutput layer in the topology\n");
fprintf(stderr, "Can't find a DetectionOutput layer in the topology\n");
goto err;
}
status = ie_network_get_output_name(network, output_num - 1, &output_name);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_get_output_name status %d, line %d\n", status, __LINE__);
goto err;
}
dimensions_t output_dim;
status = ie_network_get_output_dims(network, output_name, &output_dim);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_get_output_dims status %d, line %d\n", status, __LINE__);
goto err;
}
if (output_dim.ranks != 4) {
printf("Incorrect output dimensions for SSD model\n");
fprintf(stderr, "Incorrect output dimensions for SSD model\n");
goto err;
}
@ -569,8 +591,10 @@ int main(int argc, char** argv) {
/** Set the precision of output data provided by the user, should be called
* before load of the network to the device **/
status = ie_network_set_output_precision(network, output_name, FP32);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_network_set_output_precision status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 4. Loading model to the device
@ -581,14 +605,17 @@ int main(int argc, char** argv) {
status = ie_core_load_network(core, network, device_name, config, &exe_network);
config_free(config);
if (status != OK) {
fprintf(stderr, "ERROR ie_core_load_network status %d, line %d\n", status, __LINE__);
goto err;
}
} else {
ie_config_t cfg = {NULL, NULL, NULL};
status = ie_core_load_network(core, network, device_name, &cfg, &exe_network);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_core_load_network status %d, line %d\n", status, __LINE__);
goto err;
}
}
// -----------------------------------------------------------------------------------------------------
@ -596,8 +623,10 @@ int main(int argc, char** argv) {
// -------------------------------------------------
printf("%sCreate infer request\n", info);
status = ie_exec_network_create_infer_request(exe_network, &infer_request);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_exec_network_create_infer_request status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 6. Prepare input
@ -605,22 +634,28 @@ int main(int argc, char** argv) {
/** Creating input blob **/
status = ie_infer_request_get_blob(infer_request, imageInputName, &imageInput);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_get_blob status %d, line %d\n", status, __LINE__);
goto err;
}
/** Filling input tensor with images. First b channel, then g and r channels
* **/
dimensions_t input_tensor_dims;
status = ie_blob_get_dims(imageInput, &input_tensor_dims);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_blob_get_dims status %d, line %d\n", status, __LINE__);
goto err;
}
size_t num_channels = input_tensor_dims.dims[1];
size_t image_size = input_tensor_dims.dims[3] * input_tensor_dims.dims[2];
ie_blob_buffer_t blob_buffer;
status = ie_blob_get_buffer(imageInput, &blob_buffer);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_blob_get_buffer status %d, line %d\n", status, __LINE__);
goto err;
}
unsigned char* data = (unsigned char*)(blob_buffer.buffer);
/** Iterate over all input images **/
@ -651,6 +686,7 @@ int main(int argc, char** argv) {
ie_blob_buffer_t info_blob_buffer;
status |= ie_blob_get_buffer(input2, &info_blob_buffer);
if (status != OK) {
fprintf(stderr, "ERROR ie_blob_get_buffer status %d, line %d\n", status, __LINE__);
ie_blob_free(&input2);
goto err;
}
@ -672,8 +708,10 @@ int main(int argc, char** argv) {
printf("%sStart inference\n", info);
status = ie_infer_request_infer_async(infer_request);
status |= ie_infer_request_wait(infer_request, -1);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_infer_async status %d, line %d\n", status, __LINE__);
goto err;
}
// -----------------------------------------------------------------------------------------------------
// --------------------------- Step 8. Process output
@ -681,13 +719,17 @@ int main(int argc, char** argv) {
printf("%sProcessing output blobs\n", info);
status = ie_infer_request_get_blob(infer_request, output_name, &output_blob);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_infer_request_get_blob status %d, line %d\n", status, __LINE__);
goto err;
}
ie_blob_buffer_t output_blob_buffer;
status = ie_blob_get_cbuffer(output_blob, &output_blob_buffer);
if (status != OK)
if (status != OK) {
fprintf(stderr, "ERROR ie_blob_get_cbuffer status %d, line %d\n", status, __LINE__);
goto err;
}
const float* detection = (float*)(output_blob_buffer.cbuffer);
int** classes = (int**)calloc(image_num, sizeof(int*));