Now partition searching is kind of effective

src/BSD.cpp

@@ -4,7 +4,7 @@
 int	main(int argc,char* argv[]){
 	set_default();
 	
-	int area_a =	search_order();
-	//search_partition(parameter_input_bit_width,start_order);
+	//int area_a =	search_order();
+	search_partition();
 };
 

src/BSD.h

@@ -92,7 +92,7 @@ public:
 	uint64_t	io_generator_single_vec(uint64_t* input_data,int which_bit_output);
 	int	set_random_input_data(bool** mask_input_data);
 	int	mask_random_input_data(int depth,bool* mask,int amount,int* most_influence,bool** mask_input_data);
-	int	next_bit_layer(int depth,int order_num);
+	int	next_bit_layer(int depth);
 	int	next_bit_layer_0(int depth);
 	int	next_bit_layer_1(int depth);
 	int	next_bit_layer_old(int depth);
@@ -128,7 +128,7 @@ public:
 	
 
 	int	BDD_infer(BDD_node** BDD,int* most_influence);
-	int 	print_circuit(BDD_node** BDD,int* most_influence);
+	int 	print_circuit(BDD_node** BDD,int* most_influence, int node_depth, char* start_node_index_string);
 	int	BDD_FULL_PROCESS();
 	
 	bool*	left_son_mask		;
@@ -155,13 +155,16 @@ public:
 	int	BSD_samples_train_each_layer();
 	int	BSD_samples_sort_each_layer();
 
-	int**	BSD_variable_order;
+	int*	BSD_variable_order;
 	int	BSD_variable_order_number;
 	int	feature_area;
 
 	int*	split_nodes_each_layer;
 	int*	accuracy_each_layer;
 	bool*	output_partition_set;
+
+	node_index* start_node_index;
+	char* 	    start_node_index_string ;
 	//huanglue 
 	void 	BSD_switch_layer(int i);
 	int * 	BDD_split_nodes_each_layer = nullptr;
@@ -194,9 +197,11 @@ public:
 
 	split_nodes_each_layer = new int [parameter_input_bit_width+1];
 	accuracy_each_layer    = new int [parameter_input_bit_width+1];
-	BSD_variable_order     = new int* [parameter_max_orders];
+	BSD_variable_order     = new int [parameter_input_bit_width+1];
 	BDD_split_nodes_each_layer = new int [parameter_input_bit_width+1];
 	output_partition_set  =  new bool [parameter_output_bit_width];
+	start_node_index	= new node_index [parameter_output_bit_width];
+	start_node_index_string = new char [parameter_output_bit_width];
 	};
 	
 	//~BDD_class(){
@@ -248,22 +253,26 @@ int	BDD_class::BSD_samples_sort_each_layer(){
 
 bool	BDD_class::io_generator_single(bool* input_data,int which_bit_output){
 
+	int	origin_which_bit_output = this->start_node_index[which_bit_output].root_node_index;
+	for (int i=0;i<this->start_node_index[which_bit_output].node_depth;i++){
+		input_data[this->start_node_index[which_bit_output].expand_input_bit_index[i]] = this->start_node_index[which_bit_output].expand_input_bit_data[i];
+	}
 	#ifdef SINGLE_BITS	
-		if (output_partition_set[which_bit_output]==1){
-			bool output_bit_s =  io_generator_outer_single( input_data,  which_bit_output) ;
+		//if (output_partition_set[which_bit_output]==1){
+			bool output_bit_s =  io_generator_outer_single( input_data,  origin_which_bit_output) ;
 			return output_bit_s;
-		}else{
-			return 0;
-		}
+		//}else{
+		//	return 0;
+		//}
 	#else
 		bool	output_bit;
 		bool*	output_bits = new bool [parameter_output_bit_width];
-		if (output_partition_set[which_bit_output]==1){
+		//if (output_partition_set[which_bit_output]==1){
 					output_bits 	= io_generator_function(input_data,output_bits);
 					output_bit = output_bits[which_bit_output] ;
-		}
-		else
-					output_bit = 0;
+		//}
+		//else
+		//			output_bit = 0;
 		delete	[] output_bits;
 		return	output_bit;
 	#endif
@@ -272,21 +281,28 @@ bool	BDD_class::io_generator_single(bool* input_data,int which_bit_output){
 
 uint64_t	BDD_class::io_generator_single_vec(uint64_t* input_data,int which_bit_output){
 	
+	int	origin_which_bit_output = this->start_node_index[which_bit_output].root_node_index;
+	for (int i=0;i<this->start_node_index[which_bit_output].node_depth;i++){
+		if(this->start_node_index[which_bit_output].expand_input_bit_data[i] == 0)
+			input_data[this->start_node_index[which_bit_output].expand_input_bit_index[i]] = uint64_t(0);
+		else
+			input_data[this->start_node_index[which_bit_output].expand_input_bit_index[i]] = ~uint64_t(0);
+	}
 	#ifdef SINGLE_BITS	
-		if (output_partition_set[which_bit_output]==1){
-			uint64_t  output_bit_s =  io_generator_outer_vec_single( input_data,  which_bit_output) ;
+		//if (output_partition_set[which_bit_output]==1){
+			uint64_t  output_bit_s =  io_generator_outer_vec_single( input_data,  origin_which_bit_output) ;
 			return output_bit_s;
-		}else
-			return 0;
+		//}else
+		//	return 0;
 	#else
 		uint64_t	output_bit;
 		uint64_t*	output_bits = new uint64_t [parameter_output_bit_width];
-		if (output_partition_set[which_bit_output]==1){
+		//if (output_partition_set[which_bit_output]==1){
 					output_bits 	= io_generator_function_vec(input_data,output_bits);
 					output_bit = output_bits[which_bit_output] ;
-		}
-		else
-					output_bit = 0;
+		//}
+		//else
+		//			output_bit = 0;
 		delete	[] output_bits;
 		return	output_bit;
 	#endif
@@ -406,7 +422,7 @@ int BDD_class::train_BDD(BDD_node** BDD,int* most_influence,int start_depth, int
 				for(int zj=0;zj<parameter_input_bit_width+1;zj++){
 					BDD_partition[zi].has_been_unfold[zj] 	= has_been_unfold[zj];
 					BDD_partition[zi].most_influence[zj] 	= most_influence[zj];
-					BDD_partition[zi].BSD_variable_order[0][zj] 	= BSD_variable_order[zi+1][zj];
+					BDD_partition[zi].BSD_variable_order[zj] 	= BSD_variable_order[zj];
 				}
 				for(int zj=0;zj<BDD_partition[zi].how_many_start_nodes;zj++){
 					if(partition_index[zi][zj] < BDD_width_each_layer[i]){
@@ -473,9 +489,6 @@ int BDD_class::train_BDD(BDD_node** BDD,int* most_influence,int start_depth, int
 
 					delete [] split_nodes_each_layer;
 					delete [] accuracy_each_layer   ;
-					for (int zj=0;zj<parameter_max_orders;zj++){
-						delete [] BSD_variable_order[zj] ;
-					}
 					delete []BSD_variable_order     ;
 
 			for(zi=0;zi<partition_into_how_many_parts;zi++){
@@ -511,7 +524,7 @@ int BDD_class::train_BDD(BDD_node** BDD,int* most_influence,int start_depth, int
 			BDD[i+1][zi].non_equal_number = 0;
 		}
 		BSD_samples = BSD_samples_sort;
-		most_influence[i] = next_bit_layer(i,order_num);
+		most_influence[i] = next_bit_layer(i);
  
 		BSD_samples = int(BSD_samples_train/63)*63; //一定要是vec_length的整数倍
 		cout<<BSD_samples<<endl;
@@ -1246,6 +1259,17 @@ int	BDD_class::BDD_FULL_PROCESS(){
 	for (j=0;j<parameter_max_samples;j++){
 		mask_input_data[j] 	= new bool[parameter_input_bit_width+2];
 	}
+	int start_node_ij=0;
+	for (int i=0;i<parameter_output_bit_width;i++){
+		if(i==start_node_index[start_node_ij].root_node_index){
+			start_node_index_string[i] = '1';
+			start_node_ij ++;
+		}
+		else{
+			start_node_index_string[i] = '0';
+		}
+		
+	}
 //	for (j=0;j<parameter_max_orders;j++){
 //		BSD_variable_order[j]     = new int [parameter_input_bit_width];
 //	}
@@ -1370,12 +1394,12 @@ int	BDD_class::BDD_FULL_PROCESS(){
 	
 	//cout<<"Start infer"<<endl;
 	//BDD_infer(BDD,most_influence);
-		print_circuit(BDD,most_influence);
-	if(circuit_accuracy==1)
-		print_circuit(BDD,most_influence);
+		//print_circuit(BDD,most_influence);
+	if(circuit_accuracy>0.9999)
+		print_circuit(BDD,most_influence,start_depth,start_node_index_string);
 	delete [] test_input_data;
 	for (int vi=0;vi<parameter_input_bit_width;vi++){
-		BSD_variable_order[0][vi] = most_influence[vi];
+		BSD_variable_order[vi] = most_influence[vi];
 	}	
 		//GLOBAL_BDD_nodes += total_nodes_amount; 
 		//GLOBAL_BDD_split_nodes += total_split_nodes; 

src/next_layer_bit.h

@@ -117,15 +117,15 @@ int	BDD_class::next_bit_layer_single(int depth,int which_node_this_layer){
 };
 
 
-int	BDD_class::next_bit_layer(int depth,int order_num){
+int	BDD_class::next_bit_layer(int depth){
 	//cout<<"Depth: "<<depth<<" Order num: "<<BSD_variable_order_number<<endl;
 	if((depth < BSD_variable_order_number) ){
 		for(int i = depth;i<BSD_variable_order_number;i++){
-			if(!has_been_unfold[BSD_variable_order[order_num][depth]]){
-				most_influence[depth] = BSD_variable_order[order_num][depth];
+			if(!has_been_unfold[BSD_variable_order[depth]]){
+				most_influence[depth] = BSD_variable_order[depth];
 				has_been_unfold[most_influence[depth]]=1;
 				cout<<most_influence[depth]<<endl;
-				return  BSD_variable_order[order_num][depth];
+				return  BSD_variable_order[depth];
 			}
 			else{
 				;

src/print_circuit.h

 
-int BDD_class::print_circuit(BDD_node** BDD,int* most_influence){
+int BDD_class::print_circuit(BDD_node** BDD,int* most_influence,int node_depth, char* start_node_index_string){
  int i,j;
  int zi;
  
  char  output_file_name[100];
 //sprintf(output_file_name,"rtl/module_output_bit_%d.v",which_bit_output);
- sprintf(output_file_name,"rtl/function_%d_id_%d.v",circuit_index,BDD_id);
+// sprintf(output_file_name,"rtl/function_%d_id_%d.v",circuit_index,BDD_id);
+ sprintf(output_file_name,"rtl/function_layer_%d_nodes_%s.v",node_depth,start_node_index_string);
 // string  output_file_name << output_file_name_begin << which_bit_output << output_file_name_end;
 
  
@@ -134,9 +135,22 @@ int BDD_class::print_circuit(BDD_node** BDD,int* most_influence){
  output_module_file << "//total BDD nodes recursive	= "<<total_nodes_amount_recursive<<endl; 
  output_module_file << "//total split modes recursive	= "<<total_split_nodes_recursive<<endl; 
  output_module_file << "//train time	= "<<train_time<<endl; 
- output_module_file << "module function_"<<circuit_index<<"_BDD_id_"<<BDD_id<<" (i,o);"<<endl<<endl; 
+// output_module_file << "module function_"<<circuit_index<<"_BDD_id_"<<BDD_id<<" (i,o);"<<endl<<endl; 
+ output_module_file << "module function_layer_"<<node_depth<<"_nodes_"<<start_node_index_string<<"	(i,o_index);"<<endl<<endl;
  output_module_file << "input 	["<<parameter_input_bit_width-1<<":0] i;"<<endl; 
- output_module_file << "output	["<<how_many_start_nodes-1<<":0]  o;"<<endl<<endl;
+ output_module_file << "output	["<<parameter_output_bit_width-1<<":0]  o_index;"<<endl<<endl;
+
+ 
+ output_module_file << "wire	["<<how_many_start_nodes-1<<":0]  o;"<<endl<<endl;
+ 
+int ij=0;
+for(int i=0;i<parameter_output_bit_width;i++){
+	if(start_node_index_string[i]=='1'){
+ 		output_module_file << "assign	o_index["<<i<<"] = o["<<ij<<"];"<<endl;
+		ij++;
+	}
+}
+output_module_file <<endl;
 
 if(partition_depth ==  total_BDD_depth){
 	 for (i=0;i<total_BDD_depth+1;i++){

src/top.h

@@ -11,7 +11,7 @@ int parameter_output_bit_width			= PO_WIDTH;
 
 
 extern const int	parameter_search_iterations	= 10; 		//最大设计次数
-extern const int	parameter_test_ios 		= 1000000;	//测试要求多少样本
+extern const int	parameter_test_ios 		= 10000;	//测试要求多少样本
 extern const int	parameter_max_samples 		= 64*100;	//BSD每一个节点最多进行多少次采样,至少为64
 extern const double 	parameter_early_stop_accuracy	= 1;		//允许的错误率,如果完全不允许，设为1; 	
 									//没有特殊需要不要设到<1，会慢一些。