C++ Allocator::alloc方法代码示例

static bool fillUp(Allocator &a, size_t allocSize, vector<Pointer> &out) {
    int Max = (2 * sizeof(buf) / allocSize); // To avoid creating an infinite loop.

    for (int i = 0; i < Max; i++ ) try {
        out.push_back( a.alloc(allocSize) );
        writeTo(out.back(), allocSize);
    } catch (AllocError &) {
        return true;
    }

    return false;
}

inline MemRef BasicArray<T>::create_array(std::size_t size, Allocator& alloc)
{
    std::size_t byte_size_0 = calc_aligned_byte_size(size); // Throws
    // Adding zero to Array::initial_capacity to avoid taking the
    // address of that member
    std::size_t byte_size = std::max(byte_size_0, Array::initial_capacity+0); // Throws

    MemRef mem = alloc.alloc(byte_size); // Throws

    bool is_inner_bptree_node = false;
    bool has_refs = false;
    bool context_flag = false;
    int width = sizeof (T);
    init_header(mem.m_addr, is_inner_bptree_node, has_refs, context_flag, wtype_Multiply,
                width, size, byte_size);

    return mem;
}

int main() {

  Allocator a = Allocator();
  
  char *c;
  c = (char *)a.alloc(16);
  // at this point the memory should all be set to 0xDEAD, repeating
  for (size_t i = 0; i < 16; ++i) {
    std::cout << char(*(c + i) + 55);
  }
  std::cout << std::endl;

  *c = 'A';
  
  std::cout << *c << std::endl;

  a.free(c);
  
  return(0);
}

void NeuralClassifier::TRAIN_DATA_BITS(char* train_file, char* model, int n_hu)
{

	  cout<<"Training.......... ."<<endl;
	Allocator *allocator = new Allocator;
	int num_of_features = 9;
    int my_digit = 5;
	
	DiskXFile out_model_file(model, "w");

	// creating the mlp
	ConnectedMachine mlp[10];
	Linear *c1[10];
	Tanh *c2[10];
	Linear *c3[10];
	Tanh *c4[10];
	  cout<<"Addng layers......... ."<<endl;
	for(int count = my_digit; count <= my_digit; count++)
	{
		c1[count]= new(allocator) Linear(num_of_features,n_hu);
		c2[count]= new(allocator) Tanh(n_hu);
		c3[count]= new(allocator) Linear(n_hu,1);
		c4[count]= new(allocator) Tanh(1);

		mlp[count].addFCL(c1[count]);
		mlp[count].addFCL(c2[count]);
		mlp[count].addFCL(c3[count]);
		mlp[count].addFCL(c4[count]);
		mlp[count].build();
		mlp[count].setPartialBackprop();
    }
	  cout<<"Reading data.......... ."<<endl;
	DataSet *train_set;
	train_set=new(allocator) MatDataSet(train_file,num_of_features,1,false,-1,false);

	Criterion *criterion[10];
	// creating the trainer
	Trainer **trainers = (Trainer **)allocator->alloc(sizeof(Trainer *)*10);
	  cout<<"Training each digit.......... ."<<endl;
	/*Training each digit*/
	for(int count = my_digit; count <= my_digit; count++)
	{
		long trained_with_one = 0;
		long trainedAsNotFive=0;
		cout<<"Training digit "<<count<<endl;
		for(int t = 0; t < train_set->n_examples; t++)
		{
		
			train_set->setExample(t);
				if((t%500) == 0)  {
				cout<<"Example "<<t<<" Target is "<<train_set->targets->frames[0][0]<<endl;
				
			}
            
			if(train_set->targets->frames[0][0] == count)
			{
				
                train_set->targets->frames[0][0] = 1;
				trained_with_one++;
				//cout<<"Example "<<t<<" Target is "<<train_set->targets->frames[0][0]<<endl;
			}
			else {
		//		cout<<"---------------Example "<<t<<" Target is "<<train_set->targets->frames[0][0]<<endl;
                train_set->targets->frames[0][0] = -1;
				trainedAsNotFive++;

			}
		}
	 
		cout<<"examples trained with one: "<<trained_with_one<<endl;
		cout<<"examples trained not five: "<<trainedAsNotFive<<endl;
        cout<<"total number of examples: "<<train_set->n_examples<<endl;
				
		criterion[count] = new(allocator) MSECriterion(1);
		trainers[count] = new(allocator) StochasticGradient(&mlp[count], criterion[count]);

		trainers[count]->setIOption("max iter",100);
			  cout<<"Train digit.......... ."<<endl;
		trainers[count]->train(train_set, NULL);

			  cout<<"Save file.......... ."<<endl;
		mlp[count].saveXFile(&out_model_file);
	}
	delete(allocator);
}

int GMM(char *datafile, float means[N_GAUSS][3], float var[N_GAUSS][3], float logw[N_GAUSS])
{
	real accuracy = 0.001; //end accuracy
	real threshold = 0.001; //variance threshold
	int max_iter_kmeans = 50; //max number of iterations of KMeans
	int max_iter_gmm = 50; //max number of iterations of GMM
	int n_gaussians = N_GAUSS; //number of Gaussians
	real prior = 0.001; //prior on the weights

	int max_load = -1; //max number of examples to load for train
	int the_seed = -1; //the random seed

	bool norm = false; //normalize the datas
	char *save_model_file = "model.txt"; //the model file
	int k_fold = -1; //number of folds, if you want to do cross-validation
	bool binary_mode = true; //binary mode for files

	Allocator *allocator = new Allocator;

	//==================================================================== 
	//=================== Create the DataSet ... =========================
	//==================================================================== 
	
	MatDataSet data(datafile, -1, 0, true, max_load, binary_mode);
	MeanVarNorm* mv_norm = NULL;
	if(norm)
		mv_norm = new(allocator)MeanVarNorm (&data);

	//==================================================================== 
	//=================== Training Mode  =================================
	//==================================================================== 

	if(the_seed == -1)
		Random::seed();
	else
		Random::manualSeed((long)the_seed);

	if(norm)
		data.preProcess(mv_norm);

	//=================== Create the GMM... =========================

	// create a KMeans object to initialize the GMM
	KMeans kmeans(data.n_inputs, n_gaussians);
	kmeans.setROption("prior weights",prior);

	// the kmeans trainer
	EMTrainer kmeans_trainer(&kmeans);
	kmeans_trainer.setROption("end accuracy", accuracy);
	kmeans_trainer.setIOption("max iter", max_iter_kmeans);

	// the kmeans measurer
	MeasurerList kmeans_measurers;
	DiskXFile *filektv = new(allocator) DiskXFile("kmeans_train_val", "w");
	NLLMeasurer nll_kmeans_measurer(kmeans.log_probabilities,&data,filektv);
	kmeans_measurers.addNode(&nll_kmeans_measurer);

	// create the GMM
	DiagonalGMM gmm(data.n_inputs,n_gaussians,&kmeans_trainer);
	
	// set the training options
	real* thresh = (real*)allocator->alloc(data.n_inputs*sizeof(real));
	initializeThreshold(&data,thresh,threshold);	
	gmm.setVarThreshold(thresh);
	gmm.setROption("prior weights",prior);
	gmm.setOOption("initial kmeans trainer measurers", &kmeans_measurers);

	//=================== Measurers and Trainer  ===============================

	// Measurers on the training dataset
	MeasurerList measurers;
	DiskXFile *filegtv = new(allocator) DiskXFile("gmm_train_val", "w");
	NLLMeasurer nll_meas(gmm.log_probabilities, &data, filegtv);
	measurers.addNode(&nll_meas);

	// The Gradient Machine Trainer
	EMTrainer trainer(&gmm);
	trainer.setIOption("max iter", max_iter_gmm);
	trainer.setROption("end accuracy", accuracy);
	//trainer.setBOption("viterbi", true);

	//=================== Let's go... ===============================

	if(k_fold <= 0)
	{
		trainer.train(&data, &measurers);

		if(strcmp(save_model_file, ""))
		{
			DiskXFile model_(save_model_file, "w");
			//cmd.saveXFile(&model_);
			if(norm)
				mv_norm->saveXFile(&model_);
			model_.taggedWrite(&n_gaussians, sizeof(int), 1, "n_gaussians");
			model_.taggedWrite(&data.n_inputs, sizeof(int), 1, "n_inputs");
			gmm.saveXFile(&model_);
			for (int i = 0; i < N_GAUSS; i++) {
				logw[i] = gmm.log_weights[i];
				for (int j = 0; j < 3; j++) {
					means[i][j] = gmm.means[i][j];
//.........这里部分代码省略.........