/** * This uses link_array. It post-processes * this linkage, and prints the appropriate thing. There are no fat * links in it. */ Linkage_info analyze_thin_linkage(Sentence sent, Parse_Options opts, int analyze_pass) { int i; Linkage_info li; PP_node * pp; Postprocessor * postprocessor; Sublinkage *sublinkage; Parse_info pi = sent->parse_info; build_digraph(pi, word_links); memset(&li, 0, sizeof(li)); sublinkage = x_create_sublinkage(pi); postprocessor = sent->dict->postprocessor; compute_link_names(sent); for (i=0; i<pi->N_links; i++) { copy_full_link(&(sublinkage->link[i]), &(pi->link_array[i])); } if (analyze_pass==PP_FIRST_PASS) { post_process_scan_linkage(postprocessor, opts, sent, sublinkage); free_sublinkage(sublinkage); free_digraph(pi, word_links); return li; } /* The code below can be used to generate the "islands" array. For this to work, * however, you have to call "build_digraph" first (as in analyze_fat_linkage). * and then "free_digraph". For some reason this causes a space leak. */ pp = post_process(postprocessor, opts, sent, sublinkage, TRUE); li.N_violations = 0; li.and_cost = 0; li.unused_word_cost = unused_word_cost(sent->parse_info); li.improper_fat_linkage = FALSE; li.inconsistent_domains = FALSE; li.disjunct_cost = disjunct_cost(pi); li.null_cost = null_cost(pi); li.link_cost = link_cost(pi); li.andlist = NULL; if (pp==NULL) { if (postprocessor != NULL) li.N_violations = 1; } else if (pp->violation!=NULL) { li.N_violations++; } free_sublinkage(sublinkage); free_digraph(pi, word_links); return li; }
/** * This uses link_array. It enumerates and post-processes * all the linkages represented by this one. We know this contains * at least one fat link. */ Linkage_info analyze_fat_linkage(Sentence sent, Parse_Options opts, int analyze_pass) { int i; Linkage_info li; DIS_node *d_root; PP_node *pp; Postprocessor *postprocessor; Sublinkage *sublinkage; Parse_info pi = sent->parse_info; PP_node accum; /* for domain ancestry check */ D_type_list * dtl0, * dtl1; /* for domain ancestry check */ sublinkage = x_create_sublinkage(pi); postprocessor = sent->dict->postprocessor; build_digraph(pi, word_links); structure_violation = FALSE; d_root = build_DIS_CON_tree(pi, word_links); /* may set structure_violation to TRUE */ li.N_violations = 0; li.improper_fat_linkage = structure_violation; li.inconsistent_domains = FALSE; li.unused_word_cost = unused_word_cost(sent->parse_info); li.disjunct_cost = disjunct_cost(pi); li.null_cost = null_cost(pi); li.link_cost = link_cost(pi); li.and_cost = 0; li.andlist = NULL; if (structure_violation) { li.N_violations++; free_sublinkage(sublinkage); free_digraph(pi, word_links); free_DIS_tree(d_root); return li; } if (analyze_pass==PP_SECOND_PASS) { li.andlist = build_andlist(sent, word_links); li.and_cost = li.andlist->cost; } else li.and_cost = 0; compute_link_names(sent); for (i=0; i<pi->N_links; i++) accum.d_type_array[i] = NULL; for (;;) { /* loop through all the sub linkages */ for (i=0; i<pi->N_links; i++) { patch_array[i].used = patch_array[i].changed = FALSE; patch_array[i].newl = pi->link_array[i].l; patch_array[i].newr = pi->link_array[i].r; copy_full_link(&sublinkage->link[i], &(pi->link_array[i])); } fill_patch_array_DIS(d_root, NULL, word_links); for (i=0; i<pi->N_links; i++) { if (patch_array[i].changed || patch_array[i].used) { sublinkage->link[i]->l = patch_array[i].newl; sublinkage->link[i]->r = patch_array[i].newr; } else if ((dfs_root_word[pi->link_array[i].l] != -1) && (dfs_root_word[pi->link_array[i].r] != -1)) { sublinkage->link[i]->l = -1; } } compute_pp_link_array_connectors(sent, sublinkage); compute_pp_link_names(sent, sublinkage); /* 'analyze_pass' logic added ALB 1/97 */ if (analyze_pass==PP_FIRST_PASS) { post_process_scan_linkage(postprocessor,opts,sent,sublinkage); if (!advance_DIS(d_root)) break; else continue; } pp = post_process(postprocessor, opts, sent, sublinkage, TRUE); if (pp==NULL) { if (postprocessor != NULL) li.N_violations = 1; } else if (pp->violation == NULL) { /* the purpose of this stuff is to make sure the domain ancestry for a link in each of its sentences is consistent. */ for (i=0; i<pi->N_links; i++) { if (sublinkage->link[i]->l == -1) continue; if (accum.d_type_array[i] == NULL) { accum.d_type_array[i] = copy_d_type(pp->d_type_array[i]); } else { dtl0 = pp->d_type_array[i]; dtl1 = accum.d_type_array[i]; while((dtl0 != NULL) && (dtl1 != NULL) && (dtl0->type == dtl1->type)) { dtl0 = dtl0->next; dtl1 = dtl1->next; } if ((dtl0 != NULL) || (dtl1 != NULL)) break; } } if (i != pi->N_links) { li.N_violations++; li.inconsistent_domains = TRUE; } } else if (pp->violation!=NULL) { li.N_violations++; } if (!advance_DIS(d_root)) break; } for (i=0; i<pi->N_links; ++i) { free_d_type(accum.d_type_array[i]); } /* if (display_on && (li.N_violations != 0) && (verbosity > 3) && should_print_messages) printf("P.P. violation in one part of conjunction.\n"); */ free_sublinkage(sublinkage); free_digraph(pi, word_links); free_DIS_tree(d_root); return li; }
tm_topology_t* hwloc_to_tm(char *filename) { hwloc_topology_t topology; tm_topology_t *res = NULL; hwloc_obj_t *objs = NULL; unsigned topodepth,depth; unsigned int nb_nodes; double *cost; int err, l; unsigned int i; int vl = tm_get_verbose_level(); /* Build the topology */ hwloc_topology_init(&topology); err = hwloc_topology_set_xml(topology,filename); if(err == -1){ if(vl >= CRITICAL) fprintf(stderr,"Error: %s is a bad xml topology file!\n",filename); exit(-1); } #if HWLOC_API_VERSION >= 0x00020000 hwloc_topology_set_all_types_filter(topology, HWLOC_TYPE_FILTER_KEEP_STRUCTURE); #else /* HWLOC_API_VERSION >= 0x00020000 */ hwloc_topology_ignore_all_keep_structure(topology); #endif /* HWLOC_API_VERSION >= 0x00020000 */ hwloc_topology_load(topology); /* Test if symetric */ if(!symetric(topology)){ if(tm_get_verbose_level() >= CRITICAL) fprintf(stderr,"%s not symetric!\n",filename); exit(-1); } /* work on depth */ topodepth = hwloc_topology_get_depth(topology); res = (tm_topology_t*)MALLOC(sizeof(tm_topology_t)); res->oversub_fact = 1; res->nb_constraints = 0; res->constraints = NULL; res->nb_levels = topodepth; res->node_id = (int**)MALLOC(sizeof(int*)*res->nb_levels); res->node_rank = (int**)MALLOC(sizeof(int*)*res->nb_levels); res->nb_nodes = (size_t*)MALLOC(sizeof(size_t)*res->nb_levels); res->arity = (int*)MALLOC(sizeof(int)*res->nb_levels); if(vl >= INFO) printf("topodepth = %d\n",topodepth); /* Build TreeMatch topology */ for( depth = 0 ; depth < topodepth ; depth++ ){ nb_nodes = hwloc_get_nbobjs_by_depth(topology, depth); res->nb_nodes[depth] = nb_nodes; res->node_id[depth] = (int*)MALLOC(sizeof(int)*nb_nodes); res->node_rank[depth] = (int*)MALLOC(sizeof(int)*nb_nodes); objs = (hwloc_obj_t*)MALLOC(sizeof(hwloc_obj_t)*nb_nodes); objs[0] = hwloc_get_next_obj_by_depth(topology,depth,NULL); hwloc_get_closest_objs(topology,objs[0],objs+1,nb_nodes-1); res->arity[depth] = objs[0]->arity; if (depth == topodepth -1){ res->nb_constraints = nb_nodes; res->nb_proc_units = nb_nodes; } if(vl >= DEBUG) printf("\n--%d(%d) **%d**:--\n",res->arity[depth],nb_nodes,res->arity[0]); /* Build process id tab */ for (i = 0; i < nb_nodes; i++){ if(objs[i]->os_index > nb_nodes){ if(vl >= CRITICAL){ fprintf(stderr, "Index of object %d of level %d is %d and larger than number of nodes : %d\n", i, depth, objs[i]->os_index, nb_nodes); } exit(-1); } res->node_id[depth][i] = objs[i]->os_index; res->node_rank[depth][objs[i]->os_index] = i; /* if(depth==topodepth-1) */ } FREE(objs); } cost = (double*)CALLOC(res->nb_levels,sizeof(double)); for(l=0; l<res->nb_levels; l++){ cost[l] = link_cost(l); } res->cost = cost; /* Destroy topology object. */ hwloc_topology_destroy(topology); if(tm_get_verbose_level() >= INFO) printf("\n"); return res; }