static void rows_reordered_cb (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer new_order, RBDisplayPageMenu *menu) { GtkTreePath *root; root = get_root_path (menu); if (root != NULL) { if (gtk_tree_path_compare (path, root) == 0) rebuild_menu (menu); gtk_tree_path_free (root); } }
/** * Send a HSM request to Lustre, described in \param request. * * \param path Fullpath to the file to operate on. * \param request The request, allocated with llapi_hsm_user_request_alloc(). * * \return 0 on success, an error code otherwise. */ int llapi_hsm_request(const char *path, const struct hsm_user_request *request) { int rc; int fd; rc = get_root_path(WANT_FD, NULL, &fd, (char *)path, -1); if (rc) return rc; rc = ioctl(fd, LL_IOC_HSM_REQUEST, request); /* If error, save errno value */ rc = rc ? -errno : 0; close(fd); return rc; }
static int path_menu_index (RBDisplayPageMenu *menu, GtkTreePath *path) { GtkTreePath *root; GtkTreePath *compare; int depth; int *indices; int index; compare = gtk_tree_path_copy (path); if (gtk_tree_path_up (compare) == FALSE) { gtk_tree_path_free (compare); return -1; } if (gtk_tree_path_get_depth (compare) == 0) { gtk_tree_path_free (compare); return -1; } root = get_root_path (menu); if (root == NULL) { gtk_tree_path_free (compare); return -1; } if (gtk_tree_path_compare (compare, root) != 0) { gtk_tree_path_free (root); gtk_tree_path_free (compare); return -1; } indices = gtk_tree_path_get_indices_with_depth (path, &depth); index = count_items (menu, indices[depth-1]); gtk_tree_path_free (root); gtk_tree_path_free (compare); return index; }
bool Application::is_correctly_installed() { const char* root_path = get_root_path(); return strlen(root_path) > 0; }
int main(int argc, char *argv[]) { const std::string root_path = get_root_path(); std::string proto_file; std::string model_file; std::string image_file; std::string save_name="save.jpg"; const char * device=nullptr; int res; while( ( res=getopt(argc,argv,"p:m:i:hd:"))!= -1) { switch(res) { case 'p': proto_file=optarg; break; case 'm': model_file=optarg; break; case 'i': image_file=optarg; break; case 'd': device=optarg; break; case 'h': std::cout << "[Usage]: " << argv[0] << " [-h]\n" << " [-p proto_file] [-m model_file] [-i image_file]\n"; return 0; default: break; } } const char *model_name = "mssd_300"; if(proto_file.empty()) { proto_file = root_path + DEF_PROTO; std::cout<< "proto file not specified,using "<<proto_file<< " by default\n"; } if(model_file.empty()) { model_file = root_path + DEF_MODEL; std::cout<< "model file not specified,using "<<model_file<< " by default\n"; } if(image_file.empty()) { image_file = root_path + DEF_IMAGE; std::cout<< "image file not specified,using "<<image_file<< " by default\n"; } // init tengine init_tengine_library(); if (request_tengine_version("0.1") < 0) return 1; if (load_model(model_name, "caffe", proto_file.c_str(), model_file.c_str()) < 0) return 1; std::cout << "load model done!\n"; // create graph graph_t graph = create_runtime_graph("graph", model_name, NULL); if (!check_graph_valid(graph)) { std::cout << "create graph0 failed\n"; return 1; } if(device!=nullptr) { set_graph_device(graph,device); } //dump_graph(graph); // input int img_h = 300; int img_w = 300; int img_size = img_h * img_w * 3; float *input_data = (float *)malloc(sizeof(float) * img_size); int node_idx=0; int tensor_idx=0; tensor_t input_tensor = get_graph_input_tensor(graph, node_idx, tensor_idx); if(!check_tensor_valid(input_tensor)) { printf("Get input node failed : node_idx: %d, tensor_idx: %d\n",node_idx,tensor_idx); return 1; } int dims[] = {1, 3, img_h, img_w}; set_tensor_shape(input_tensor, dims, 4); prerun_graph(graph); int repeat_count = 1; const char *repeat = std::getenv("REPEAT_COUNT"); if (repeat) repeat_count = std::strtoul(repeat, NULL, 10); //warm up get_input_data_ssd(image_file, input_data, img_h, img_w); set_tensor_buffer(input_tensor, input_data, img_size * 4); run_graph(graph, 1); struct timeval t0, t1; float total_time = 0.f; for (int i = 0; i < repeat_count; i++) { get_input_data_ssd(image_file, input_data, img_h, img_w); gettimeofday(&t0, NULL); set_tensor_buffer(input_tensor, input_data, img_size * 4); run_graph(graph, 1); gettimeofday(&t1, NULL); float mytime = (float)((t1.tv_sec * 1000000 + t1.tv_usec) - (t0.tv_sec * 1000000 + t0.tv_usec)) / 1000; total_time += mytime; } std::cout << "--------------------------------------\n"; std::cout << "repeat " << repeat_count << " times, avg time per run is " << total_time / repeat_count << " ms\n"; tensor_t out_tensor = get_graph_output_tensor(graph, 0,0);//"detection_out"); int out_dim[4]; get_tensor_shape( out_tensor, out_dim, 4); float *outdata = (float *)get_tensor_buffer(out_tensor); int num=out_dim[1]; float show_threshold=0.5; post_process_ssd(image_file,show_threshold, outdata, num,save_name); put_graph_tensor(out_tensor); put_graph_tensor(input_tensor); postrun_graph(graph); free(input_data); destroy_runtime_graph(graph); remove_model(model_name); return 0; }
static struct netboot_info * netboot_info_init(struct in_addr iaddr) { boolean_t have_root_path = FALSE; struct netboot_info * info = NULL; char * root_path = NULL; info = (struct netboot_info *)kalloc(sizeof(*info)); bzero(info, sizeof(*info)); info->client_ip = iaddr; info->image_type = kNetBootImageTypeUnknown; /* check for a booter-specified path then a NetBoot path */ MALLOC_ZONE(root_path, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK); if (root_path == NULL) panic("netboot_info_init: M_NAMEI zone exhausted"); if (PE_parse_boot_argn("rp0", root_path, MAXPATHLEN) == TRUE || PE_parse_boot_argn("rp", root_path, MAXPATHLEN) == TRUE || PE_parse_boot_argn("rootpath", root_path, MAXPATHLEN) == TRUE) { if (imageboot_format_is_valid(root_path)) { printf("netboot_info_init: rp0='%s' isn't a network path," " ignoring\n", root_path); } else { have_root_path = TRUE; } } if (have_root_path == FALSE) { have_root_path = get_root_path(root_path); } if (have_root_path) { const char * server_name = NULL; char * mount_point = NULL; char * image_path = NULL; struct in_addr server_ip; if (parse_image_path(root_path, &server_ip, &server_name, &mount_point, &image_path)) { info->image_type = kNetBootImageTypeNFS; info->server_ip = server_ip; info->server_name_length = strlen(server_name) + 1; info->server_name = (char *)kalloc(info->server_name_length); info->mount_point_length = strlen(mount_point) + 1; info->mount_point = (char *)kalloc(info->mount_point_length); strlcpy(info->server_name, server_name, info->server_name_length); strlcpy(info->mount_point, mount_point, info->mount_point_length); printf("netboot: NFS Server %s Mount %s", server_name, info->mount_point); if (image_path != NULL) { boolean_t needs_slash = FALSE; info->image_path_length = strlen(image_path) + 1; if (image_path[0] != '/') { needs_slash = TRUE; info->image_path_length++; } info->image_path = (char *)kalloc(info->image_path_length); if (needs_slash) { info->image_path[0] = '/'; strlcpy(info->image_path + 1, image_path, info->image_path_length - 1); } else { strlcpy(info->image_path, image_path, info->image_path_length); } printf(" Image %s", info->image_path); } printf("\n"); } else if (strncmp(root_path, kNetBootRootPathPrefixHTTP, strlen(kNetBootRootPathPrefixHTTP)) == 0) { info->image_type = kNetBootImageTypeHTTP; save_path(&info->image_path, &info->image_path_length, root_path); printf("netboot: HTTP URL %s\n", info->image_path); } else { printf("netboot: root path uses unrecognized format\n"); } /* check for image-within-image */ if (info->image_path != NULL) { if (PE_parse_boot_argn(IMAGEBOOT_ROOT_ARG, root_path, MAXPATHLEN) || PE_parse_boot_argn("rp1", root_path, MAXPATHLEN)) { /* rp1/root-dmg is the second-level image */ save_path(&info->second_image_path, &info->second_image_path_length, root_path); } } if (info->second_image_path != NULL) { printf("netboot: nested image %s\n", info->second_image_path); } } FREE_ZONE(root_path, MAXPATHLEN, M_NAMEI); return (info); }
bool Application::is_correctly_installed() { return !is_empty_string(get_root_path()); }