c - 选择CL平台后读取文件时出现段错误

Question

我是 OpenCL 新手。我正在尝试从文件中读取数据并在 OpenCL 中使用该数据进行一些计算。但是，当我添加代码来选择平台时，读取功能不再起作用。之前是可以用的。

更多信息:输入文件格式只是一个 float 列表，每行一个数字。这是我添加的代码片段:

cl_uint numPlatforms;

  int err;
  err = clGetPlatformIDs(0, NULL, &numPlatforms);
  if (err != CL_SUCCESS || numPlatforms <= 0)
    {
      printf("Error: Failed to find a platform!\n%s\n",err_code(err));
      return EXIT_FAILUR;
    }

整个文件:

#include <stdio.h>
#include <time.h>
#include <assert.h>
#include <stdlib.h> 
#include <math.h> 
#include <CL/cl.h>

#include <sys/time.h>


#define STR_SIZE 256

void fatal(char *s)
{
  fprintf(stderr, "Error: %s\n", s);
}

void read(float *vec, int numRows, int numCols, int layers, char *file)
{
  int i, j, k;
  FILE *fp;
  char str[STR_SIZE];
  float val;
  if((fp = fopen(file,"r"))==0) printf("Could not open file to read\n");
  for (i = 0; i < numRows; i++)
    for (j = 0; j < numCols; j++)
      for(k = 0; k < layers; k++)
        {
          fgets(str, STR_SIZE, fp);
          if(feof(fp)) fatal("not enough lines\n");
          if(sscanf(str, "%f", &val) != 1) fatal("invalid file format\n");
          vec[i*numCols + j + k * numRows * numCols] = val;     
        }
  fclose(fp);
}

void write(float *vec, int numRows, int numCols, int layers, char *file)
{
  int i, j, k, index = 0;
  FILE *fp;
  char str[STR_SIZE];
  if((fp = fopen(file,"w"))==0) printf("Could not open file to write\n");
  for(i = 0; i < numRows; i++)
    for(j = 0; j < numCols; j++)
      for (k = 0; k < layers; k++)
        {
          sprintf(str, "%d\t%g\n", index, vec[i*numCols+j + numRows * numCols * k]);
          fputs(str,fp);
          index++;  
        }   
  fclose(fp);   
}


int main(int argc, char** argv)
{

  char *pfile, *tfile, *ofile;

  pfile = argv[3];
  tfile = argv[4];
  ofile = argv[5];

  int numCols = atoi(argv[1]);
  int numRows = atoi(argv[1]);
  int layers = atoi(argv[2]);


  float *powerIn, *tempOut, *tempIn, *tempCopy;

  int size = numCols * numRows * layers;

  powerIn = (float*)calloc(size, sizeof(float));
  tempIn = (float*)calloc(size,sizeof(float));
  tempOut = (float*)calloc(size, sizeof(float));
  float* answer = (float*)calloc(size, sizeof(float));

  read(powerIn,numRows, numCols, layers, pfile);
  read(tempIn, numRows, numCols, layers, tfile);

  size_t global;                   

  cl_device_id     device_id;     
  cl_context       context;       
  cl_command_queue commands;     
  cl_program       program;       
  cl_kernel        ko_vadd;             
memcpy(tempCopy,tempIn, size * sizeof(float));
  cl_mem d_a;                     // device memory used for the input  a vector
  cl_mem d_b;                     // device memory used for the input  b vector
  cl_mem d_c;                     // device memory used for the output c vector
  //This piece of code causes the problem. Without it, the program works fine.
  cl_uint numPlatforms;


  int err;
  err = clGetPlatformIDs(0, NULL, &numPlatforms);
  if (err != CL_SUCCESS || numPlatforms <= 0)
    {
      printf("Error: Failed to find a platform!\n%s\n",err_code(err));
      return EXIT_FAILUR;
    }

  write(tempIn,numRows, numCols, layers, ofile);
  free(tempIn);
  free(tempOut); 
  free(powerIn);
  return 0;
}   

err_code.c:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <CL/cl.h>

char *err_code (cl_int err_in)
{
    switch (err_in) {

        case CL_SUCCESS :
            return (char*)" CL_SUCCESS ";
        case CL_DEVICE_NOT_FOUND :
            return (char*)" CL_DEVICE_NOT_FOUND ";
        case CL_DEVICE_NOT_AVAILABLE :
            return (char*)" CL_DEVICE_NOT_AVAILABLE ";
        case CL_COMPILER_NOT_AVAILABLE :
            return (char*)" CL_COMPILER_NOT_AVAILABLE ";
        case CL_MEM_OBJECT_ALLOCATION_FAILURE :
            return (char*)" CL_MEM_OBJECT_ALLOCATION_FAILURE ";
        case CL_OUT_OF_RESOURCES :
            return (char*)" CL_OUT_OF_RESOURCES ";
        case CL_OUT_OF_HOST_MEMORY :
            return (char*)" CL_OUT_OF_HOST_MEMORY ";
        case CL_PROFILING_INFO_NOT_AVAILABLE :
            return (char*)" CL_PROFILING_INFO_NOT_AVAILABLE ";
        case CL_MEM_COPY_OVERLAP :
            return (char*)" CL_MEM_COPY_OVERLAP ";
        case CL_IMAGE_FORMAT_MISMATCH :
            return (char*)" CL_IMAGE_FORMAT_MISMATCH ";
        case CL_IMAGE_FORMAT_NOT_SUPPORTED :
            return (char*)" CL_IMAGE_FORMAT_NOT_SUPPORTED ";
        case CL_BUILD_PROGRAM_FAILURE :
            return (char*)" CL_BUILD_PROGRAM_FAILURE ";
        case CL_MAP_FAILURE :
            return (char*)" CL_MAP_FAILURE ";
        case CL_MISALIGNED_SUB_BUFFER_OFFSET :
            return (char*)" CL_MISALIGNED_SUB_BUFFER_OFFSET ";
        case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST :
            return (char*)" CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST ";
        case CL_INVALID_VALUE :
            return (char*)" CL_INVALID_VALUE ";
        case CL_INVALID_DEVICE_TYPE :
            return (char*)" CL_INVALID_DEVICE_TYPE ";
        case CL_INVALID_PLATFORM :
            return (char*)" CL_INVALID_PLATFORM ";
        case CL_INVALID_DEVICE :
            return (char*)" CL_INVALID_DEVICE ";
        case CL_INVALID_CONTEXT :
            return (char*)" CL_INVALID_CONTEXT ";
        case CL_INVALID_QUEUE_PROPERTIES :
            return (char*)" CL_INVALID_QUEUE_PROPERTIES ";
        case CL_INVALID_COMMAND_QUEUE :
            return (char*)" CL_INVALID_COMMAND_QUEUE ";
        case CL_INVALID_HOST_PTR :
            return (char*)" CL_INVALID_HOST_PTR ";
        case CL_INVALID_MEM_OBJECT :
            return (char*)" CL_INVALID_MEM_OBJECT ";
        case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR :
            return (char*)" CL_INVALID_IMAGE_FORMAT_DESCRIPTOR ";
        case CL_INVALID_IMAGE_SIZE :
            return (char*)" CL_INVALID_IMAGE_SIZE ";
        case CL_INVALID_SAMPLER :
            return (char*)" CL_INVALID_SAMPLER ";
        case CL_INVALID_BINARY :
            return (char*)" CL_INVALID_BINARY ";
        case CL_INVALID_BUILD_OPTIONS :
            return (char*)" CL_INVALID_BUILD_OPTIONS ";
        case CL_INVALID_PROGRAM :
            return (char*)" CL_INVALID_PROGRAM ";
        case CL_INVALID_PROGRAM_EXECUTABLE :
            return (char*)" CL_INVALID_PROGRAM_EXECUTABLE ";
        case CL_INVALID_KERNEL_NAME :
            return (char*)" CL_INVALID_KERNEL_NAME ";
        case CL_INVALID_KERNEL_DEFINITION :
            return (char*)" CL_INVALID_KERNEL_DEFINITION ";
        case CL_INVALID_KERNEL :
            return (char*)" CL_INVALID_KERNEL ";
        case CL_INVALID_ARG_INDEX :
            return (char*)" CL_INVALID_ARG_INDEX ";
        case CL_INVALID_ARG_VALUE :
            return (char*)" CL_INVALID_ARG_VALUE ";
        case CL_INVALID_ARG_SIZE :
            return (char*)" CL_INVALID_ARG_SIZE ";
        case CL_INVALID_KERNEL_ARGS :
            return (char*)" CL_INVALID_KERNEL_ARGS ";
        case CL_INVALID_WORK_DIMENSION :
            return (char*)" CL_INVALID_WORK_DIMENSION ";
        case CL_INVALID_WORK_GROUP_SIZE :
            return (char*)" CL_INVALID_WORK_GROUP_SIZE ";
        case CL_INVALID_WORK_ITEM_SIZE :
            return (char*)" CL_INVALID_WORK_ITEM_SIZE ";
        case CL_INVALID_GLOBAL_OFFSET :
            return (char*)" CL_INVALID_GLOBAL_OFFSET ";
        case CL_INVALID_EVENT_WAIT_LIST :
            return (char*)" CL_INVALID_EVENT_WAIT_LIST ";
        case CL_INVALID_EVENT :
            return (char*)" CL_INVALID_EVENT ";
        case CL_INVALID_OPERATION :
            return (char*)" CL_INVALID_OPERATION ";
        case CL_INVALID_GL_OBJECT :
            return (char*)" CL_INVALID_GL_OBJECT ";
        case CL_INVALID_BUFFER_SIZE :
            return (char*)" CL_INVALID_BUFFER_SIZE ";
        case CL_INVALID_MIP_LEVEL :
            return (char*)" CL_INVALID_MIP_LEVEL ";
        case CL_INVALID_GLOBAL_WORK_SIZE :
            return (char*)" CL_INVALID_GLOBAL_WORK_SIZE ";
        case CL_INVALID_PROPERTY :
            return (char*)" CL_INVALID_PROPERTY ";
        default:
            return (char*)"UNKNOWN ERROR";

    }
}

生成文件:

ifndef CC
    CC = gcc
endif

CCFLAGS=-O3 -lm -g

LIBS = -lOpenCL -fopenmp

3D: 3D.c err_code.c 
    $(CC) $^ $(CCFLAGS) $(LIBS) -o $@


clean:
    rm -f 3D

Answer 1

我的一些观察表明这些是可能的问题。

memcpy(tempCopy,tempIn, size * sizeof(float));

此处未分配 tempCopy 的内存。您需要为其分配第一个内存。

在read函数中有几行

if((fp = fopen(file,"r"))==0) printf("Could not open file to read\n");

如果文件打开失败，您仍然可以读取文件。当fopen失败时需要return语句。并注意任何操作失败时的break/return。不进行进一步处理。您可以在代码中查看许多条件检查，如果失败，则只显示消息，不采取任何操作(break/return)并进行进一步处理。首先纠正这个。

此外，在 for 循环中，您还有以下几行

     fgets(str, STR_SIZE, fp);
      if(feof(fp)) fatal("not enough lines\n");

这里你首先读取文件，然后检查它是否为空。这是错误的方式。您首先检查文件是否为空。如果为空则中断循环，否则读取它。喜欢

    if(!feof(fp))
    {
      fgets(str, STR_SIZE, fp);
    }
    else
    {
       fatal("not enough lines\n");
       break;
    }

此外，read 和 write 都是 unix 系统调用。这会导致冲突。因此，请务必更改用户定义函数的名称。