fixed heap free in mpi_ngbh_search (786f1e20) · Commits · Luca Tornatore / dADP

.gitignore

+1 −0

Original line number	Diff line number	Diff line
		@@ -2,3 +2,4 @@ main
		sync.sh
		bb
		.ipy*
		scalability_results

src/tree/heap.c

+38 −34

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@ void heapify_max_heap(heap* H, idx_t node){
		/*
		Found gratest between children of node and boundcheck if the node is a leaf
		*/

		while(1)
		{
		largest = (HEAP_LCH(nn) < H -> N) &&
		@@ -51,21 +52,24 @@ void heapify_max_heap(heap* H, idx_t node){
		}
		}

		//if(HEAP_LCH(node) < H -> N){
		// //if(H -> data[HEAP_LCH(node)].value > H -> data[largest].value ) largest = HEAP_LCH(node);
		// largest = (H -> data[HEAP_LCH(nn)].value > H -> data[largest].value ) ? HEAP_LCH(nn) : largest;
		//}
		//if(HEAP_RCH(node) < H -> N){
		// //if(H -> data[HEAP_RCH(node)].value > H -> data[largest].value ) largest = HEAP_RCH(node);
		// largest = (H -> data[HEAP_RCH(nn)].value > H -> data[largest].value ) ? HEAP_RCH(nn) : largest;
		//}
		//if(largest == node){
		// return;
		//}
		//else{
		// swap_heap_node(H -> data + node, H -> data + largest);
		// heapify_max_heap(H, largest);
		//}

		/*
		if(HEAP_LCH(node) < H -> N){
		//if(H -> data[HEAP_LCH(node)].value > H -> data[largest].value ) largest = HEAP_LCH(node);
		largest = (H -> data[HEAP_LCH(nn)].value > H -> data[largest].value ) ? HEAP_LCH(nn) : largest;
		}
		if(HEAP_RCH(node) < H -> N){
		//if(H -> data[HEAP_RCH(node)].value > H -> data[largest].value ) largest = HEAP_RCH(node);
		largest = (H -> data[HEAP_RCH(nn)].value > H -> data[largest].value ) ? HEAP_RCH(nn) : largest;
		}
		if(largest == node){
		return;
		}
		else{
		swap_heap_node(H -> data + node, H -> data + largest);
		heapify_max_heap(H, largest);
		}
		*/
		}

src/tree/kdtreeV2.c

+7 −0

Original line number	Diff line number	Diff line
		@@ -195,12 +195,14 @@ kdnode_v2* make_tree_kdnode_v2(kdnode_v2* t, int start, int end, kdnode_v2* pare
		}
		}

		/*
		#ifdef SWMEM
		if(parent == NULL)
		{
		swapMem_kdv2 = (FLOAT_TYPE)malloc(sizeof(FLOAT_TYPE)data_dims);
		}
		#endif
		*/



		@@ -257,12 +259,14 @@ kdnode_v2* make_tree_kdnode_v2(kdnode_v2* t, int start, int end, kdnode_v2* pare
		n->level = level;
		}

		/*
		#ifdef SWMEM
		if(parent == NULL)
		{
		swapMem_kdv2 = malloc(sizeof(FLOAT_TYPE)*data_dims);
		}
		#endif
		*/

		return n;
		}
		@@ -359,6 +363,9 @@ void kdtree_v2_init(kdtree_v2* tree, FLOAT_TYPE* data, size_t n_nodes, unsigned

		void kdtree_v2_free(kdtree_v2* tree)
		{
		for(uint64_t i = 0; i < tree->n_nodes; ++i)
		if(tree -> _nodes[i].node_list.data) free(tree -> _nodes[i].node_list.data);

		free(tree -> _nodes);
		}

src/tree/tree.c

+46 −9

Original line number	Diff line number	Diff line
		@@ -694,8 +694,22 @@ void top_tree_init(global_context_t ctx, top_kdtree_t tree)
		/* we want procs leaves */
		int l = (int)(ceil(log2((float_t)ctx -> world_size)));
		int tree_nodes = (1 << (l + 1)) - 1;
		//int tree_nodes = compute_n_nodes(ctx -> world_size);
		//MPI_DB_PRINT("Tree nodes %d %d %d %d\n", ctx -> world_size,l, tree_nodes, compute_n_nodes(ctx -> world_size));
		tree->_nodes = (top_kdtree_node_t)malloc(tree_nodes sizeof(top_kdtree_node_t));
		for(int i = 0; i < tree_nodes; ++i)
		{
		tree -> _nodes[i].lch = NULL;
		tree -> _nodes[i].rch = NULL;
		tree -> _nodes[i].parent = NULL;
		tree -> _nodes[i].owner = -1;
		tree -> _nodes[i].n_points = 0;
		tree -> _nodes[i].split_dim = -1;
		tree -> _nodes[i].split_val = 0.f;
		tree -> _nodes[i].lb_node_box = NULL;
		tree -> _nodes[i].ub_node_box = NULL;

		}
		tree->_capacity = tree_nodes;
		tree->dims = ctx->dims;
		tree->count = 0;
		@@ -718,6 +732,7 @@ top_kdtree_node_t* top_tree_generate_node(global_context_t* ctx, top_kdtree_t* t
		top_kdtree_node_t* ptr = tree -> _nodes + tree -> count;
		ptr -> lch = NULL;
		ptr -> rch = NULL;
		ptr -> parent = NULL;
		ptr -> lb_node_box = (float_t)malloc(ctx -> dims sizeof(float_t));
		ptr -> ub_node_box = (float_t)malloc(ctx -> dims sizeof(float_t));
		ptr -> owner = -1;
		@@ -1131,13 +1146,13 @@ void exchange_points(global_context_t* ctx, top_kdtree_t* tree)
		ctx -> local_data = rcvbuffer;

		/* check exchange */
		/*

		for(size_t i = 0; i < ctx -> local_n_points; ++i)
		{
		int o = compute_point_owner(ctx, tree, ctx -> local_data + (i * ctx -> dims));
		if(o != ctx -> mpi_rank) DB_PRINT("rank %d got an error\n",ctx -> mpi_rank);
		}
		*/

		free(points_owners);
		free(points_per_proc);
		free(partition_offset);
		@@ -1176,7 +1191,6 @@ void tree_walk(
		int* point_to_send_count,
		int* point_to_send_capacity)
		{

		if(root -> owner != -1 && root -> owner != ctx -> mpi_rank)
		{

		@@ -1675,6 +1689,13 @@ void mpi_ngbh_search(global_context_t* ctx, datapoint_info_t* dp_info, top_kdtre
		if(local_idx_of_the_point[i]) free(local_idx_of_the_point[i]);
		}

		for(int i = 0; i < ctx -> local_n_points; ++i)
		{
		free(dp_info[i].ngbh.data);
		}

		free(data_to_send_per_proc);
		free(local_idx_of_the_point);
		free(heap_batches_per_node);
		free(rcv_heap_batches);
		free(rcv_work_batches);
		@@ -1870,8 +1891,24 @@ void simulate_master_read_and_scatter(int dims, size_t n, global_context_t *ctx)
		kdtree_v2 local_tree;
		kdtree_v2_init( &local_tree, ctx -> local_data, ctx -> local_n_points, (unsigned int)ctx -> dims);
		int k = 300;
		//int k = 30;

		datapoint_info_t* dp_info = (datapoint_info_t)malloc(ctx -> local_n_points sizeof(datapoint_info_t));
		/* initialize, to cope with valgrind */
		for(uint64_t i = 0; i < ctx -> local_n_points; ++i)
		{
		dp_info[i].ngbh.data = NULL;
		dp_info[i].ngbh.N = 0;
		dp_info[i].ngbh.count = 0;
		dp_info[i].g = 0.f;
		dp_info[i].log_rho = 0.f;
		dp_info[i].log_rho_c = 0.f;
		dp_info[i].log_rho_err = 0.f;
		dp_info[i].array_idx = -1;
		dp_info[i].kstar = -1;
		dp_info[i].is_center = -1;
		dp_info[i].cluster_idx = -1;
		}

		TIME_START
		build_local_tree(ctx, &local_tree);