Ejemplo n.º 1
0
/*
 * Merge the classes of r1 and r2
 * - both r1 and r2 must be free roots and have compatible types
 * - if both r1 and r2 are boolean, they may have arbitrary polarity
 * This adds either the substitution [r1 := r2] or [r2 := r1]
 */
void intern_tbl_merge_classes(intern_tbl_t *tbl, term_t r1, term_t r2) {
  assert(intern_tbl_root_is_free(tbl, r1) &&
         intern_tbl_root_is_free(tbl, r2));

  if (! intern_tbl_term_present(tbl, r1)) {
    partition_add(tbl, r1);
  }

  if (! intern_tbl_term_present(tbl, r2)) {
    partition_add(tbl, r2);
  }

  partition_merge(tbl, r1, r2);
}
Ejemplo n.º 2
0
/**
 * Search the graph for fragments and integrate them into partitions
 */
void greedyBFS_fragment_scan(list_graph* graph, partition* parray, int pnum){

	int i = 0;

	//Search for unpartitioned nodes
	for (i = 0; i < graph->size; i++){

		if (graph->vertex[i].color == 0){

			edge* head = graph->vertex[i].edge_list;
			int attached = 0;

			//Attempt to find a nearby partition to attach to
			while(head != NULL){
				if (graph->vertex[head->id].color != 0){
					partition_add(&parray[graph->vertex[head->id].partition], i, head->wgt);
					graph->vertex[i].partition = graph->vertex[head->id].partition;
					graph->vertex[i].color = 2;
					attached = 1;
				}

				head = head->next;
			}

			//Place the vertex in the partition with highest available space
			if (!attached){

				int minwgt = parray[0].wgt;
				int sp = 0;
				int j;

				for (j = 1; j < pnum; j++){
					if (parray[j].wgt < minwgt){
						minwgt = parray[i].wgt;
						sp = j;
					}
				}

				partition_add(&parray[sp], i, 0);
				graph->vertex[i].partition = sp;
				graph->vertex[i].color = 2;
			}
		}
	}
}
Ejemplo n.º 3
0
/*
 * Add the substitution [r1 := r2] to the table.
 * The substitution must be valid.
 */
void intern_tbl_add_subst(intern_tbl_t *tbl, term_t r1, term_t r2) {
  assert(intern_tbl_root_is_free(tbl, r1));

  if (! intern_tbl_term_present(tbl, r1)) {
    partition_add(tbl, r1);
  }

  if (! intern_tbl_term_present(tbl, r2)) {
    partition_add_frozen(tbl, r2);
  }

  partition_merge(tbl, r1, r2);
}
Ejemplo n.º 4
0
/**
 * Expand a partition
 */
list* greedyBFS_grow(list_graph* graph, partition* p, int source, int dest){

	//Prepare the queue
	list* q = (list*) malloc ( sizeof(list));
	list_init(q);

	//Get the Adjacency list of the vertex
	if (graph->vertex[dest].color == 2){
		//Someone else already took our node
		return NULL;
	}

	//Check for constraints
	if(list_contains(&(p->constraints), dest)){
		return NULL;
	}

	//Put the node in the partition
	graph->vertex[dest].color = 2;
	partition_add(p, dest, 0);

	//Add the new constraints to the partition
	partition_constraint_add(p, &(graph->vertex[dest].constraints));


	//Check the adjacency list
	edge* head = graph->vertex[dest].edge_list;

	while(head != NULL){

		if(graph->vertex[head->id].color < 2){

			//Color Grey
			graph->vertex[head->id].color = 1;

			//Enqueue
			list_insert(q, head->id);
		}

		head = head->next;
	}
	return q;
}
Ejemplo n.º 5
0
/**
 * Create an array of unbalanced partitions according to a distribution vector
 */
partition* greedyBFS_helper(list_graph* graph, int pnum, int* seeds){

	//Allocate space for the data structures
	partition* parray = (partition *) malloc(sizeof(partition)*pnum);
	list* dest_list = (list *) malloc(sizeof(list)*pnum);
	list* src_list = (list *) malloc(sizeof(list)*pnum);
	int* src = (int*) malloc(sizeof(int)*pnum);
	int* dest = (int*) malloc(sizeof(int)*pnum);

	//Initialize the data structures and perform the initial discovery process
	int i, tmp;
	int maxtmp = -1;
	int maxi = -1;

	/**
	 * Initialization
	 */
	for ( i = 0; i < pnum; i++){
		//Mark seeds as partitioned
		graph->vertex[seeds[i]].color = 2;

		//Initialize and insert
		partition_init(&parray[i], graph->id, i);
		partition_add(&parray[i], seeds[i], 0);

		//Populate the lists with starting nodes and constraints
		list_init(&src_list[i]);
		list_init(&dest_list[i]);
		partition_constraint_add(&parray[i], &(graph->vertex[seeds[i]].constraints));
		greedyBFS_discovery(graph, &dest_list[i], &parray[i], seeds[i]);

		//Find the best seed to start with
		tmp = greedyBFS_peek(graph, &parray[i], seeds[i]);

		if (tmp > maxtmp){
			maxi = i;
			maxtmp = tmp;
		}

		//Set initial src and dst
		src[i] = seeds[i];
		dest[i] = list_pop(&dest_list[i]);
		list_insert(&src_list[i], dest[i]);
	}

	/**
	 * Partitioning
	 */
	while (maxtmp != -1){

		printf("[%d]->[%d]:[%d]\n", src[maxi], dest[maxi], maxi);
		//Grow the partition
		list* l = greedyBFS_grow(graph, &parray[maxi], src[maxi], dest[maxi]);

		//Insert new data into the queue
		int pop = list_pop(l);
		while (pop != -1){
			list_insert(&dest_list[maxi], pop);
			pop = list_pop(l);
		}

		//update src and dest if needed
		dest[maxi] = list_pop(&dest_list[maxi]);
		if (dest[maxi] >= 0)
			list_insert(&src_list[maxi], dest[maxi]);

		if (dest[maxi] != -1){
			while(greedyBFS_peek(graph, &parray[maxi], src[maxi]) == -1){
				src[maxi] = list_pop(&src_list[maxi]);
			if(src[maxi] == -1)
				break;
			}
		}


		//Find the new best partition and update src and dest if needed
		maxtmp = -1;
		for ( i = 0; i < pnum; i++){

			if (src[i] == -1)
				tmp = -1;
			else
				tmp = greedyBFS_peek(graph, &parray[i], src[i]);

			if (tmp > maxtmp){
				maxi = i;
				maxtmp = tmp;
			}
		}
	}



	/**
	 * Fragments
	 */
	/*int alloc = graph->wgt;
	greedyBFS_grow(graph, &parray[i], *seeds++, alloc);*/

	//greedyBFS_fragment_scan(graph, parray, pnum);

	/**
	 * Cleanup
	 */
	return parray;
}
Ejemplo n.º 6
0
int main() {
  uint32_t i;
  int32_t x, y, rx, ry;

  init_partition(&partition, 0);
  printf("\n*** Initial partition ***\n");
  print_partition_details(&partition);

  for (i=0; i<40; i++) {
    x = random() % N;
    printf("--- testing %"PRId32" ---\n", x);
    y = partition_find(&partition, x);
    if (y < 0) {
      printf("item %"PRId32" not present; adding it\n", x);
      partition_add(&partition, x);
    } else {
      printf("root[%"PRId32"] = %"PRId32"\n", x, y);
    }
  }

  printf("\n*** Partition ***\n");
  print_partition_details(&partition);
  printf("\n");

  print_partition(&partition);
  printf("\n");

  for (x=0; x<N; x++) {
    aux[x] = partition_find(&partition, x);
  }
  for (i=1; i<10; i++) {
    do { x = random() % N; } while (aux[x] < 0);
    do { y = random() % N; } while (x == y || aux[y] < 0);

    x = partition_find(&partition, x);
    y = partition_find(&partition, y);
    if (x != y) {
      printf("--- Merging %"PRId32" and %"PRId32" ---\n", x, y);
      partition_merge(&partition, x, y);
    }
  }
  printf("\n");
  print_partition(&partition);

  reset_partition(&partition);

  for (i=0; i<100; i++) {
    x = random() % 300;
    rx = partition_find(&partition, x);
    if (rx < 0) {
      partition_add(&partition, x);
      rx = x;
    }
    y = random() % 300;
    ry = partition_find(&partition, y);
    if (ry < 0) {
      partition_add(&partition, y);
      ry = y;
    }
    if (rx != ry) {
      partition_merge(&partition, rx, ry);
    }
  }

  printf("\n\n");
  print_partition(&partition);

  delete_partition(&partition);

  return 0;
}