Add search Partition; Debug memory leakage with un-delete vectors

src/BSD.cpp

@@ -32,7 +32,7 @@ using namespace std;
 
 //电路的parameter	Circuit_parameter
 int			circuit_index	 		= 9999;		//电路编号
-extern const int	parameter_max_orders		= 8;
+int			parameter_max_orders		= 4;
 
 
 
@@ -55,7 +55,7 @@ int	GLOBAL_program_time;
 int**	variable_order ;
 int	variable_order_number;
 
-int	BSD_execute(int variable_order_number,int** variable_order, int partition_depth, int partition_parts,int order_num);
+int	BSD_execute(int variable_order_number,int** variable_order, int partition_depth, int partition_parts,int order_num, bool* output_partition_set);
 //bool	truth_table [1024*1024];
 
 #include"BSD.h"
@@ -89,8 +89,12 @@ public:
 
 	BSD_features BSD_features_0;
 //double	variable_features[parameter_input_bit_width];
-void	search_order(int search_iterations, bool allow_partition);
+int	search_order(int search_iterations,bool*  partition_set,int start_order_depth, int* start_order);
 int	search_reward(BSD_features BSD_features_0);
+int	search_partition(int start_order_depth, int* start_order);
+
+bool*	default_partition_set;
+int*	default_start_order;
 
 int	main(int argc,char* argv[]){
 
@@ -98,7 +102,10 @@ int	main(int argc,char* argv[]){
 	GLOBAL_BDD_id_number 	= 0;
 	GLOBAL_BDD_nodes 	= 0;
 	GLOBAL_BDD_split_nodes 	= 0;
-
+	default_start_order 	= new int  [parameter_input_bit_width];	
+	default_partition_set 	= new bool [parameter_output_bit_width];	
+	for(int i=0;i<parameter_output_bit_width;i++)
+		default_partition_set[i] = 1;
 	//io generator来自真值表，不来自写好的文件
  	//char*  truth_table_name = new char [100];
 	//int    truth_table_input_width;
@@ -122,16 +129,89 @@ int	main(int argc,char* argv[]){
 	//		else
 	//			truth_table[i] = 1;
 	//	}
+	//search_order();
+	//int* start_order_a = new int [parameter_input_bit_width];	
+	//int area_a =	search_order(10,output_partition_set_a,0,start_order_a);
+	int* start_order 	= new int  [parameter_input_bit_width];	
+	int area_a =	search_order(1000,default_partition_set,0,start_order);
+	//search_partition(parameter_input_bit_width,start_order);
+};
+int search_partition(int start_order_depth, int* start_order){
+	random_device rd;	
+	mt19937 gen(rd());
+	int   best_area = 999999;
+	int   best_area_a = 999999;
+	int   best_area_b = 999999;
+	bool* best_output_partition_set_a = new bool [parameter_output_bit_width];	
+	bool* best_output_partition_set_b = new bool [parameter_output_bit_width];	
+	int*  best_start_order_a = new int [parameter_input_bit_width];	
+	int*  best_start_order_b = new int [parameter_input_bit_width];	
+	for (int i=0;i<parameter_output_bit_width;i++){
+		best_output_partition_set_a[i]=0;
+		best_output_partition_set_b[i]=0;
+	}
+	for (int j=0;j<2;j++){
+		bool* output_partition_set_a = new bool [parameter_output_bit_width];	
+		bool* output_partition_set_b = new bool [parameter_output_bit_width];	
+		for (int i=0;i<parameter_output_bit_width;i++){
+			output_partition_set_a[i]=(gen()%2==0);
+			output_partition_set_b[i]=1-output_partition_set_a[i];
+		}
+		
+		int area=0;;
+		int* start_order_a = new int [parameter_input_bit_width];	
+		int* start_order_b = new int [parameter_input_bit_width];	
+		for(int i=0;i<parameter_input_bit_width;i++){
+			start_order_a[i] = 0;
+			start_order_b[i] = 0;
+		}
+		int area_a =	search_order(10,output_partition_set_a,start_order_depth,start_order);
+		int area_b =	search_order(10,output_partition_set_b,start_order_depth,start_order);
+		area = area_a + area_b;
+		if(area<best_area){
+			best_area = area;
+			best_area_a = area_a;
+			best_area_b = area_b;
+			for (int i=0;i<parameter_output_bit_width;i++){
+				best_output_partition_set_a[i]=output_partition_set_a[i];
+				best_output_partition_set_b[i]=output_partition_set_b[i];
+			}
+			for (int i=0;i<parameter_input_bit_width;i++){
+				best_start_order_a[i]=start_order_a[i];
+				best_start_order_b[i]=start_order_b[i];
+			}
+		}
+		cout<<"###########################################################################"<<endl;
+		cout<<"Design Area:		"<<area<<"	"<<area_a<<"	+ "<<area_b<<endl;
+		cout<<"Best Design Area:	"<<best_area<<"	"<<best_area_a<<"	+ "<<best_area_b<<endl;
+		cout<<"###########################################################################"<<endl;
+		delete [] output_partition_set_a;
+		delete [] output_partition_set_b;
+		delete [] start_order_a;
+		delete [] start_order_b;
+	}
+		parameter_max_orders		*= 2;
+		int area=0;	
+		int area_a =	search_order(200,best_output_partition_set_a,parameter_input_bit_width,best_start_order_a);
+		int area_b =	search_order(200,best_output_partition_set_b,parameter_input_bit_width,best_start_order_b);
+		area = area_a + area_b;
+		
+		cout<<"###########################################################################"<<endl;
+		cout<<"Final Design Area:		"<<area<<"	"<<area_a<<"	+ "<<area_b<<endl;
+		cout<<"Best Design Area:		"<<best_area<<"	"<<best_area_a<<"	+ "<<best_area_b<<endl;
+		cout<<"###########################################################################"<<endl;
+	delete []  best_output_partition_set_a;	
+	delete []  best_output_partition_set_b;	
+	delete []  best_start_order_a;	
+	delete []  best_start_order_b;	
 
 
-	search_order(parameter_search_iterations,false);
-
 };
-
-int BSD_execute(int variable_order_number,int** variable_order, int partition_depth, int partition_parts,int order_num){
+int BSD_execute(int variable_order_number,int** variable_order, int partition_depth, int partition_parts,int order_num,bool*  output_partition_set){
 
 	cout<<"BSD execute start"<<endl;	
 	BDD_class BDD_class_main;
+	BDD_class_main.output_partition_set 	= output_partition_set;
 	BDD_class_main.which_demo_function 	= GLOBAL_which_demo_function;
 	for (int j=0;j<parameter_max_orders;j++){
 		//cout<<"j"<<j<<endl;
@@ -222,7 +302,7 @@ int search_reward(BSD_features BSD_features_0){
 
 };
 
-void search_order(int search_iterations, bool allow_partition){
+int search_order(int search_iterations,bool* output_partition_set,int start_order_depth, int* start_order){
         ofstream result_0("result_0_20bit",ios::app);
         ofstream result_10("result_10_20bit",ios::app);
         ofstream result_100("result_100_20bit",ios::app);
@@ -231,32 +311,43 @@ void search_order(int search_iterations, bool allow_partition){
 	variable_order = new int* [parameter_max_orders];
 	for (int vi=0;vi<parameter_max_orders;vi++){
 		variable_order[vi] = new int [parameter_input_bit_width];
+		for (int vj=0;vj<parameter_input_bit_width;vj++)
+			variable_order[vi][vj]=0;
 	}
 
 	int	best_area=9999999; 
 	int	best_reward=9999999; 
 	int	best_area_depth = 2;
-	int*	best_BDD_split_nodes = new int [parameter_input_bit_width];
 	int**	best_variable_order;
 
+	int*	best_BDD_split_nodes = new int [parameter_input_bit_width];
 	int*	best_areas	= new int [parameter_max_orders];
 	int*	best_rewards	= new int [parameter_max_orders];
 	int*	best_area_depths= new int [parameter_max_orders];
+	for (int vi=0;vi<parameter_max_orders;vi++){
+		best_areas[vi] = 0;
+		best_rewards[vi] = 0;
+		best_area_depths[vi] = 0;
+	}
 	int best_reward_max = 0;
 	int best_order_num=0;
 
 	best_variable_order = new int* [parameter_max_orders];
 	for (int vi=0;vi<parameter_max_orders;vi++){
 		best_variable_order[vi] = new int [parameter_input_bit_width];
+		for (int vj=0;vj<parameter_input_bit_width;vj++)
+			best_variable_order[vi][vj]=0;
 	}
 
-	int area;
-	int reward;
-	int	mutation_depth;
+	int area =0;
+	int reward =0;
+	int	mutation_depth =0;
 	random_device rd;	
 	mt19937 gen(rd());
 
 	double*	feature_variable = new double [parameter_input_bit_width];
+		for (int vj=0;vj<parameter_input_bit_width;vj++)
+			feature_variable[vj]=0;
 
 	int best_area_0;
 	int best_area_10;
@@ -310,10 +401,18 @@ void search_order(int search_iterations, bool allow_partition){
 		int	min_feature = 9999999;
 		cout<<"Current best variable order: "<<endl;
 		for(int vj=0;vj<parameter_max_orders;vj++){
+			if(i==0){
+				for(int vi=0;vi<parameter_input_bit_width;vi++){
+					variable_order[vj][vi] = start_order[vi];
+					cout<<variable_order[vj][vi]<<" ";
+				}
+			}
+			else{
 				for(int vi=0;vi<best_area_depth;vi++){
 					variable_order[vj][vi] = best_variable_order[vj][vi];
 					cout<<variable_order[vj][vi]<<" ";
 				}
+			}
 			cout<<endl;
 		}
 		cout<<endl;
@@ -327,6 +426,7 @@ void search_order(int search_iterations, bool allow_partition){
 		//else
 		// 	learning_rate= 2;
 		learning_rate=1;
+		if(i==0)	learning_rate =0;
 		for (int zi=0;zi<learning_rate;zi++){	
 			//for(int vv = 0;vv<parameter_max_orders;vv++){	
 				int vv = order_num;
@@ -396,15 +496,13 @@ void search_order(int search_iterations, bool allow_partition){
 		//	feature_variable[variable_order[j]] = 9999999;
 
 		//}
-		
-		if (i<parameter_max_orders){
-			reward = 	BSD_execute(0,variable_order,partition_depth,partition_parts,0);
+		if (i==0)
+			reward = 	BSD_execute(start_order_depth,variable_order,partition_depth,partition_parts,0,output_partition_set);
+		else if (i<parameter_max_orders){
+			reward = 	BSD_execute(0,variable_order,partition_depth,partition_parts,0,output_partition_set);
 		}
 		else{
-			reward = 	BSD_execute(best_area_depth,variable_order,partition_depth,partition_parts,order_num);
-			if(allow_partition){
-				partition_depth = 4;
-			}
+			reward = 	BSD_execute(best_area_depth,variable_order,partition_depth,partition_parts,order_num,output_partition_set);
 		}
 
 
@@ -495,11 +593,28 @@ void search_order(int search_iterations, bool allow_partition){
 			for(int zi=0;zi<parameter_max_orders;zi++){
 				cout<<"Reward["<<zi<<"]	"<<best_rewards[zi]<<endl;
 			}
+			cout<<"Best Order:	";
+			for (int vj=0;vj<parameter_input_bit_width;vj++){
+				start_order[vj]=best_variable_order[best_order_num][vj];
+				cout<<start_order[vj]<<" ";
+			}
+			cout<<endl;
 			//cout<<"Best Design Area:	"<<BSD_features_0.BSD_area<<endl;
 			cout<<endl;
 		}
 	parameter_early_stop_split_nodes = 99999999;
-	area = 	BSD_execute(parameter_input_bit_width,best_variable_order,best_partition_depth,best_partition_parts,best_order_num);
+	area = 	BSD_execute(parameter_input_bit_width,best_variable_order,best_partition_depth,best_partition_parts,best_order_num,output_partition_set);
 
+	delete [] best_BDD_split_nodes ;
+	delete [] best_areas	;
+	delete [] best_rewards	;
+	delete [] best_area_depths;
+	for (int vi=0;vi<parameter_max_orders;vi++){
+		delete [] variable_order[vi];
+		delete [] best_variable_order[vi];
+	}
+	delete [] variable_order;
+	delete [] best_variable_order;
+	return area;
 };
 

src/BSD.h

@@ -143,7 +143,7 @@ public:
 
 	int*	split_nodes_each_layer;
 	int*	accuracy_each_layer;
-
+	bool*	output_partition_set;
 	//huanglue 
 	void 	BSD_switch_layer(int i);
 	int * 	BDD_split_nodes_each_layer = nullptr;
@@ -173,6 +173,7 @@ public:
 	accuracy_each_layer    = new int [parameter_input_bit_width+1];
 	BSD_variable_order     = new int* [parameter_max_orders];
 	BDD_split_nodes_each_layer = new int [parameter_input_bit_width+1];
+	output_partition_set  =  new bool [parameter_output_bit_width];
 	};
 	
 	
@@ -197,31 +198,35 @@ int	BDD_class::BSD_samples_sort_each_layer(){
 
 
 
-bool*	BDD_class::io_generator(bool input_data[parameter_input_bit_width],bool* output_bits){
-	//bool*	output_bits = new bool [parameter_output_bit_width];
-	output_bits = io_generator_function(input_data,output_bits);
-	//io_read_times += 1;
-	return	output_bits;
-};
+//bool*	BDD_class::io_generator(bool input_data[parameter_input_bit_width],bool* output_bits){
+//	//bool*	output_bits = new bool [parameter_output_bit_width];
+//	output_bits = io_generator_function(input_data,output_bits);
+//	//io_read_times += 1;
+//	return	output_bits;
+//};
 
 bool	BDD_class::io_generator_single(bool input_data[parameter_input_bit_width],int which_bit_output){
 	
 	bool	output_bit;
 	bool*	output_bits = new bool [100];
 	output_bits 	= io_generator_function(input_data,output_bits);
+	if (output_partition_set[which_bit_output]==1)
 				output_bit = output_bits[which_bit_output] ;
+	else
+				output_bit = 0;
 	delete	[] output_bits;
 	return	output_bit;
 };
 #ifdef INPUT_AIG
-int*	BDD_class::io_generator_vec(int input_data[parameter_input_bit_width],int* output_bits){
-	//bool*	output_bits = new bool [parameter_output_bit_width];
-			//cout<<"Debug 4"<<endl;
-	output_bits = io_generator_function_vec(input_data,output_bits);
-			//cout<<"Debug 5"<<endl;
-	//io_read_times += 1;
-	return	output_bits;
-};
+//int*	BDD_class::io_generator_vec(int input_data[parameter_input_bit_width],int* output_bits){
+//	//bool*	output_bits = new bool [parameter_output_bit_width];
+//			//cout<<"Debug 4"<<endl;
+//	int* output_data_temp = new int [100];
+//	output_bits = io_generator_function_vec(input_data,output_bits);
+//			//cout<<"Debug 5"<<endl;
+//	//io_read_times += 1;
+//	return	output_bits;
+//};
 
 int	BDD_class::io_generator_single_vec(int input_data[parameter_input_bit_width],int which_bit_output){
 	
@@ -231,7 +236,10 @@ int	BDD_class::io_generator_single_vec(int input_data[parameter_input_bit_width]
 	int*	output_bits = new int [100];
 			//cout<<"Debug 3"<<endl;
 	output_bits 	= io_generator_function_vec(input_data,output_bits);
+	if (output_partition_set[which_bit_output]==1)
 				output_bit = output_bits[which_bit_output] ;
+	else
+				output_bit = 0;
 	//cout<<"which bit output	"<<which_bit_output<<"	"<<hex<<output_bit<<endl;
 	delete	[] output_bits;
 	return	output_bit;
@@ -546,6 +554,8 @@ int BDD_class::train_BDD(BDD_node** BDD,int* most_influence,int start_depth, int
 			delete [] vec_input_right ;
 			delete [] vec_output_left ;
 			delete [] vec_output_right;
+			delete [] vec_input_left_int  ;
+			delete [] vec_input_right_int ;
 				
 	 	}
 	#else

src/top.h

@@ -2,7 +2,7 @@ extern const int	parameter_input_bit_width 	= 33+5; 	//输入bit有几位,写在
 extern const int	parameter_output_bit_width	= 25 ;	 	//输出bit有几位
 #include"io_generator/c1908.h"
 #include"c1908_vec.h"
-//#define INPUT_AIG
+#define INPUT_AIG
 //#include"io_generator_function.h"
 
 int			parameter_search_iterations	= 1000; //最大设计次数