Example #1
0
void initAligned()
{
	weightsAligned.reset(connsCount);
	srcConnsAligned.reset(connsCount);
	tgtConnsAligned.reset(connsCount);
	for(int i = 0; i < connsCount; i++)
	{
		weightsAligned[i] = weights[i];
		srcConnsAligned[i] = srcConns[i];
		tgtConnsAligned[i] = tgtConns[i];
	}
	endConnsAligned.reset(layersCount);
	endNodesAligned.reset(layersCount);
	for(int i = 0; i < layersCount; i++)
	{
		endConnsAligned[i] = endConns[i];
		endNodesAligned[i] = endNodes[i];
	}
	outputsAligned.reset(outputsCount);
	for(int i = 0; i < outputsCount; i++)
	{
		outputsAligned[i] = 0;
	}
	outputIdsAligned.reset(outputIds.size());
	for(int i = 0; i < outputIds.size(); i++)
	{
		outputIdsAligned[i] = outputIds[i];
	}
}
// Free the resources allocated during initialization
void cleanup() {
  for(unsigned i = 0; i < num_devices; ++i) {
    if(kernel && kernel[i]) {
      clReleaseKernel(kernel[i]);
    }
    if(queue && queue[i]) {
      clReleaseCommandQueue(queue[i]);
    }
#if USE_SVM_API == 0
    if(input_a_buf && input_a_buf[i]) {
      clReleaseMemObject(input_a_buf[i]);
    }
    if(input_b_buf && input_b_buf[i]) {
      clReleaseMemObject(input_b_buf[i]);
    }
    if(output_buf && output_buf[i]) {
      clReleaseMemObject(output_buf[i]);
    }
#else
    if(input_a[i].get())
      input_a[i].reset();
    if(output[i].get())
      output[i].reset();
#endif /* USE_SVM_API == 0 */
  }
#if USE_SVM_API == 1
  if(input_b.get())
    input_b.reset();
#endif /* USE_SVM_API == 1 */

  if(program) {
    clReleaseProgram(program);
  }
  if(context) {
    clReleaseContext(context);
  }
}
// Initialize the data for the problem. Requires num_devices to be known.
void init_problem() {
  if(num_devices == 0) {
    checkError(-1, "No devices");
  }

  // Generate input matrices A and B. For matrix A, we divide up the host
  // buffers so that the buffers are aligned for each device. The whole of
  // matrix B is used by each device, so it does not need to be divided.
  printf("Generating input matrices\n");
  input_a.reset(num_devices);
  output.reset(num_devices);
#if USE_SVM_API == 0
  for(unsigned i = 0; i < num_devices; ++i) {
    input_a[i].reset(rows_per_device[i] * A_width);
    output[i].reset(rows_per_device[i] * C_width);

    for(unsigned j = 0; j < rows_per_device[i] * A_width; ++j) {
      input_a[i][j] = rand_float();
    }
  }

  input_b.reset(B_height * B_width);
  for(unsigned i = 0; i < B_height * B_width; ++i) {
    input_b[i] = rand_float();
  }
#else
  for(unsigned i = 0; i < num_devices; ++i) {
    input_a[i].reset(context, rows_per_device[i] * A_width);
    output[i].reset(context, rows_per_device[i] * C_width);

    cl_int status;

    status = clEnqueueSVMMap(queue[i], CL_TRUE, CL_MAP_WRITE,
        (void *)input_a[i], rows_per_device[i] * A_width * sizeof(float), 0, NULL, NULL);
    checkError(status, "Failed to map input A");

    for(unsigned j = 0; j < rows_per_device[i] * A_width; ++j) {
      input_a[i][j] = rand_float();
    }

    status = clEnqueueSVMUnmap(queue[i], (void *)input_a[i], 0, NULL, NULL);
    checkError(status, "Failed to unmap input A");
  }

  input_b.reset(context, B_height * B_width);

  cl_int status;

  for (unsigned i = 0; i < num_devices; ++i) {
    status = clEnqueueSVMMap(queue[i], CL_TRUE, CL_MAP_WRITE,
        (void *)input_b, B_height * B_width * sizeof(float), 0, NULL, NULL);
    checkError(status, "Failed to map input B");
  }

  for(unsigned i = 0; i < B_height * B_width; ++i) {
    input_b[i] = rand_float();
  }

  for (unsigned i = 0; i < num_devices; ++i) {
    status = clEnqueueSVMUnmap(queue[i], (void *)input_b, 0, NULL, NULL);
    checkError(status, "Failed to unmap input B");
  }
#endif /* USE_SVM_API == 0 */
}
Example #4
0
 bool initProblem()
{
	string genome_path("K:\\nn\\opencl\\altera\\fnn\\simple_genome.xml");
	ifstream infile(genome_path);
	if (!infile.is_open()) {
		printf("Failed to open genome file.");
		return false;
	}
	string line;
	getline(infile, line);
	nodesCount = atoi(line.c_str());
	getline(infile, line);
	inputsCount = atoi(line.c_str());
	getline(infile, line);
	outputsCount = atoi(line.c_str());
	getline(infile, line);
	layersCount = atoi(line.c_str());
	getline(infile, line);
	string buf; // Have a buffer string
	stringstream ssWeights(line); // Insert the string into a stream
	while (ssWeights >> buf)
		weights.push_back(strtod(buf.c_str(), 0));
	connsCount = weights.size();
	// source connections
	getline(infile, line);
	stringstream ssSrcConns(line);
	while (ssSrcConns >> buf)
		srcConns.push_back(atoi(buf.c_str()));
	// target connections
	getline(infile, line);
	stringstream ssTgtConns(line);
	while (ssTgtConns >> buf)
		tgtConns.push_back(atoi(buf.c_str()));
	// layers end connections
	getline(infile, line);
	stringstream ssEndConns(line);
	while (ssEndConns >> buf)
		endConns.push_back(atoi(buf.c_str()));
	// layers end nodes
	getline(infile, line);
	stringstream ssEndNodes(line);
	while (ssEndNodes >> buf)
		endNodes.push_back(atoi(buf.c_str()));
	// output ids
	getline(infile, line);
	stringstream ssOut(line);
	while (ssOut >> buf)
		outputIds.push_back(atoi(buf.c_str()));
	
	string validation_set("K:\\nn\\opencl\\altera\\fnn\\cross-validate.txt");
	ifstream vs_infile(validation_set);
	if (!vs_infile.is_open()) {
		printf("Failed to open validation dataset.");
		return false;
	}
	float feature;
	while(getline(vs_infile, line)) {
		stringstream ssIrisDatasetLine(line);
		vector<float> row;
		while (ssIrisDatasetLine >> feature)
		{
			//printf((line + "\n").c_str());
			row.push_back(feature);
			//printf("Add item %f from row %s \n", feature, line.c_str());
			if(ssIrisDatasetLine.peek() == ';')
			{
				ssIrisDatasetLine.ignore();
			}
		}
		validationSet.push_back(row);
	}

	if(validationSet.size() == 0)
	{
		printf("Failed to parse validation dataset.");
		return false;
	}

	//printf("First row size %llu", validationSet[0].size());

	inputValuesAligned.reset(validationSet[0].size() - 3);
	for(int i = 0; i < 4; i++)
	{
		inputValuesAligned[i] = validationSet[0][i];
	}

	initAligned();
	return true;
}