problème de Linkage ? opencl

Voilà désolé de vous déranger mais je m'arrache les cheveux sur un problème, et comme je fais du OpenCL pour la première fois je ne sais pas si cela a un rapport ou non.

J'ai les erreurs suivantes données par mon compilateur :

g++ -Wall -std=c++11 -lOpenCL main.cpp YoUtil.cpp libIDAAOS.o -o main
/tmp/ccYhKM4y.o: In function `main':
main.cpp:(.text+0xb97): undefined reference to `computeDistances(cl::CommandQueue&, cl::Program&, int, int, _cl_mem*&, int, _cl_mem*&, _cl_mem*&)'
main.cpp:(.text+0xc42): undefined reference to `computeWeights(cl::CommandQueue&, cl::Program&, int, int, _cl_mem*&, _cl_mem*&, double)'
main.cpp:(.text+0xcf9): undefined reference to `computeInterpolation(cl::CommandQueue&, cl::Program&, int, int, int, _cl_mem*, _cl_mem*, _cl_mem*&, _cl_mem*)'
collect2: error: ld returned 1 exit status

Voici les fichiers qui sont à mon avis concernés par les erreurs mais n'hésitez-pas à demander les autres si j'ai tort :

main.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194

#include <iostream> #include <fstream> #include <cmath> #include <cstdlib> #include "IDALib.h" #include "YoUtil.hpp" #include <string> #include <CL/cl.hpp>   using namespace std;   static void g1(const int NPOINTS, const int DIM, const double(*bounds)[2], const int nDiv, double *grids, const int whichDIM, double *X, int &where) { if (whichDIM == DIM) { // store the grid point & return for (int dim = 0; dim < DIM; ++dim) writeGrid(DIM, NPOINTS, where, dim, grids, X[dim]); // for (int dim = 0; dim < DIM; ++dim) cout << "*" << X[dim] << "* "; cout << endl; ++where; return; } const double inc = (bounds[whichDIM][1] - bounds[whichDIM][0]) / (nDiv - 1); X[whichDIM] = bounds[whichDIM][0]; for (int i = 0; i < nDiv; ++i) { g1(NPOINTS, DIM, bounds, nDiv, grids, whichDIM + 1, X, where); X[whichDIM] += inc; } }   // x1, x2, x3, ... y1, y2, y3, ... z1, z1, z3, ... void computeGridCoordinates(const int DIM, const double(*bounds)[2], const int nDiv, double *grids) { const int NPOINTS = pow(nDiv, DIM); double *X = new double[DIM]; int where = 0; g1(NPOINTS, DIM, bounds, nDiv, grids, 0, X, where); delete[]X; }   int main(int argc, char **argv) { if (argc < 3) { cerr << argv[0] << " [input filename] [output filename]" << endl; return 255; } ifstream inp(argv[1]); if (!inp.good()) { cerr << "\nError opening file: " << argv[1] << endl; return 254; } int DIM, nPoints, nValues, nDivisions; inp >> DIM >> nPoints >> nValues >> nDivisions;   // Allocate memory for storing all necessary data double *knownCoords = new double[DIM * nPoints]; double *knownValues = new double[nPoints * nValues]; double (*bounds)[2] = new double[DIM][2]; // size of DIMS * 2 const int nGrids = (int)pow(nDivisions, DIM); // # of grid points double *gridCoords = new double[(size_t) pow(nDivisions, DIM) * DIM]; double *distances = new double[nGrids * nPoints]; double *weightSum = new double[nGrids]; double *gridValues = new double[nGrids * nValues];   // read data from the specified file and store data into appropriate data structures using write & writeAttribute functions for (int pt = 0; pt < nPoints; ++pt) { for (int dim = 0; dim < DIM; ++dim) { double tmp; inp >> tmp; write(DIM, nPoints, pt, dim, knownCoords, tmp); } for (int attr = 0; attr < nValues; ++attr) { double tmp; inp >> tmp; writeAttribute(nValues, nPoints, pt, attr, knownValues, tmp); } } inp.close(); // show data // for (int i = 0; i < nPoints * DIM; ++i) cout << knownCoords[i] << " "; cout << endl; // for (int i = 0; i < nPoints * nValues; ++i) cout << knownValues[i] << " "; cout << endl;   // int where = 0; // find bounds of known data points   // create context std::vector<cl::CommandQueue> cmdQueues = std::vector<cl::CommandQueue>(); cl::Context *context = getContext(CL_DEVICE_TYPE_GPU, cmdQueues, 0, true);   // create buffers, 0 is the offset, TRUE means blocking cl_mem knownCoords_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(knownCoords), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](),knownCoords_b, CL_TRUE, 0, sizeof(knownCoords_b), knownCoords_b, 0, NULL, NULL);   cl_mem knownValues_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(knownValues), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](), knownValues_b, CL_TRUE, 0, sizeof(knownValues_b), knownValues_b, 0, NULL, NULL);   cl_mem gridCoords_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(gridCoords), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](), gridCoords_b, CL_TRUE, 0, sizeof(gridCoords_b), gridCoords_b, 0, NULL, NULL);   cl_mem distances_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(distances), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](), distances_b, CL_TRUE, 0, sizeof(distances_b), distances, 0, NULL, NULL);   cl_mem weightSum_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(weightSum), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](), weightSum_b, CL_TRUE, 0, sizeof(weightSum_b), weightSum, 0, NULL, NULL);   cl_mem gridValues_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(gridValues), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](), gridValues_b, CL_TRUE, 0, sizeof(gridValues_b), gridValues_b, 0, NULL, NULL);   // parse the source code and build the program std::string source_code = readSourceCode("shepard_extrapolation_kernels.cl"); cl::Program *program = compile(*context, source_code);   stopWatch timer; double t1(0.0); timer.start(); computeBounds(DIM, nPoints, knownCoords, bounds); timer.stop(); t1 += timer.elapsedTime(); // for (int i = 0; i < DIM; ++i) cout << bounds[i][0] << ":" << bounds[i][1] << endl; cout << endl;   // create grid points in unknownCoords computeGridCoordinates(DIM, bounds, nDivisions, gridCoords);   // for (int i = 0; i < nGrids*DIM; ++i) cout << gridCoords[i] << " "; cout << endl;   // step 3. compute distances between all grids points and all known data points double t2(0.0); timer.start(); computeDistances(cmdQueues[0], *program, DIM, nPoints, knownCoords_b, nGrids, gridCoords_b, distances_b); timer.stop(); t2 += timer.elapsedTime(); // for (int i = 0; i < nPoints*nGrids; ++i) cout << distances[i] << " "; cout << endl;   // step 4. turn the distance array into weight array, and compute the total weight double t3(0.0); timer.start(); computeWeights(cmdQueues[0], *program, nGrids, nPoints, distances_b, weightSum_b); timer.stop(); t3 += timer.elapsedTime(); // for (int i = 0; i < nPoints*nGrids; ++i) cout << distances[i] << " "; cout << endl;   // step 5 & 6. compute sum (weights * known Values) / totalWeight double t4(0.0); timer.start(); computeInterpolation(cmdQueues[0], *program, nValues, nGrids, nPoints, distances_b, weightSum_b, knownValues_b, gridValues_b); timer.stop(); t4 += timer.elapsedTime();   // read the results back to the host, CL_TRUE means blocking, 0 is the offset, we read from gridValues_b into gridValues, // 0 events, no events list, no event clEnqueueReadBuffer(cmdQueues[0](), gridValues_b, CL_TRUE, 0, sizeof(gridValues_b), gridValues, 0, NULL, NULL); /* std::cout << "computeBounds : " << t1 << std::endl; std::cout << "computeDistances : " << t2 << std::endl; std::cout << "computeWeights : " << t3 << std::endl; std::cout << "computeInterpolation : " << t4 << std::endl; */ std::cout << t1 << " " << t2 << " " << t3 << " " << t4 << " " << std::endl; // All calculations are finished. Write grid data to the specified output file. ofstream outp(argv[2]); // Output points if (outp.good()) { /* // This part writes scattered data points for (int i = 0; i < nPoints; ++i) { for (int dim = 0; dim < DIM; ++dim) { outp << read(DIM, nPoints, i, dim, knownCoords) << " "; } for (int attr = 0; attr < nValues; ++attr) { outp << readAttribute(nValues, nPoints, i, attr, knownValues); } outp << knownValues[i] << "\n"; } outp << "\n\n"; */   for (int i = 0; i < nGrids; ++i) { for (int dim = 0; dim < DIM; ++dim) { outp << readGrid(DIM, nGrids, i, dim, gridCoords) << " "; } for (int attr = 0; attr < nValues; ++attr) { outp << readGridAttribute(nValues, nGrids, i, attr, gridValues) << " "; } outp << "\n"; }   outp.close(); }   delete[] bounds; delete[] knownCoords; delete[] gridCoords; delete[] weightSum; delete[] distances; delete[] knownValues; delete[] gridValues;   return 0; }

---

libIDAAOS.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329

#include "IDALib.h" #include <iostream> #include <utility> // pair #include <cmath> // sqrt #include <cstdlib> // EXIT_FAILURE #include <limits> #include <cl.hpp>   /* Array of structs format */   double read(const int DIM, const int nPoints, const int whichPt, const int whichDim, const double *coords){ /* Read from known coordinates     DIM - Dimensionality of coordinates   nPoints - Number of known data points   whichPt - which known data point is to be read   whichDim - which dimension of coordinates is to be read   coords - array containing all coordinates of known data points     return the coordinate of the DIM dimension of the whichPt point     */ if(whichPt > nPoints - 1) { std::cout << "The point that you want to read does not exist" << std::endl; exit(EXIT_FAILURE); }   return coords[whichPt * DIM + whichDim]; }     void write(const int DIM, const int nPoints, const int whichPt, const int whichDim, double *coords, const double val){ /* Write to known coordinates     DIM - Dimensionality of coordinates   nPoints - Number of known data points   whichPt - which known data point is to be read   whichDim - which dimension of coordinates is to be read   coords - array containing all coordinates of known data points     */ if(whichPt > nPoints - 1) { std::cout << "The point that you want to write does not exist" << std::endl; }   coords[whichPt * DIM + whichDim] = val; }     double readGrid(const int DIM, const int nGridPoints, const int whichGridPt, const int whichDim, const double *gridCoords){ /* Read grid coordinates     DIM - Dimensionality of coordinates   nGridPoints - Number of points in the grid   whichGridPt - which point in the gread is to be read   whichDim - which dimension of coordinates is to be read   gridCoords - array containing all coordinates of grid points     return the coordinate of the DIM dimension of the whichGridPt     */ if(whichGridPt > nGridPoints - 1) { std::cout << "The point that you want to read does not exist in the grid" << std::endl; exit(EXIT_FAILURE); }   return gridCoords[whichGridPt * DIM + whichDim]; }   void writeGrid(const int DIM, const int nGridPoints, const int whichGridPt, const int whichDim, double *gridCoords, const double val){ /* Write grid coordinates     DIM - Dimensionality of coordinates   nGridPoints - Number of points in the grid   whichGridPt - which point in the gread is to be read   whichDim - which dimension of coordinates is to be read   gridCoords - array containing all coordinates of grid points     */ if(whichGridPt > nGridPoints - 1) { std::cout << "The point that you want to write does not exist in the grid" << std::endl; }   gridCoords[whichGridPt * DIM + whichDim] = val;   }   double readAttribute(const int noAttr, const int nPoints, const int whichPt, const int whichAttr, const double *values){ /* Read known values     noAttr - number of attributes at each point   nPoints - Number of known data points   whichPt - which known data point is to be read   whichAttr - which attribute is to be read   values - array containing all the values     return the value of whichAttr of whichPt     */ if(whichPt > nPoints - 1){ std::cout << "The point that you are trying to read does not exist" << std::endl; exit(EXIT_FAILURE); }   return values[whichPt * noAttr + whichAttr]; }   void writeAttribute(const int noAttr, const int nPoints, const int whichPt, const int whichAttr, double *values, const double val){ /* Write known values     noAttr - number of attributes at each point   nPoints - Number of known data points   whichPt - which known data point is to be read   whichAttr - which attribute is to be read   values - array containing all the values     */ if(whichPt > nPoints - 1){ std::cout << "The point that you are trying to write does not exist" << std::endl; exit(EXIT_FAILURE); }   values[whichPt * noAttr + whichAttr] = val; }   double readGridAttribute(const int noAttr, const int nPoints, const int whichPt, const int whichAttr, const double *values){ /* Read a grid attribute     noAttr - number of attributes at each point   nPoints - Number of known data points   whichPt - which known data point is to be read   whichAttr - which attribute is to be read   values - array containing all the values     return the value of whichAttr of whichPt     */   if(whichPt > nPoints - 1){ std::cout << "The point that you are trying to read does not exist" << std::endl; exit(EXIT_FAILURE); }   return values[whichPt * noAttr + whichAttr];   }     void writeGridAttribute(const int noAttr, const int nPoints, const int whichPt, const int whichAttr, double *values, const double val){ /* Write known values     noAttr - number of attributes at each point   nPoints - Number of known data points   whichPt - which known data point is to be read   whichAttr - which attribute is to be read   values - array containing all the values     */ if(whichPt > nPoints - 1){ std::cout << "The point that you are trying to write does not exist" << std::endl; exit(EXIT_FAILURE); }   values[whichPt * noAttr + whichAttr] = val; }   void computeBounds(const int DIM, const int nPoints, const double *knownCoords, double(*bounds)[2]){ /* Find extremes in each dimension of a given set of scatter points     DIM - Dimensionality of coordinates   nPoints - Number of known data points   knowCoords - array containing all coordinates of known data points   bounds - 2D array to store the extremes, each row corresponds to a dimension     */   for(int i = 0; i < DIM; i++){ double min = std::numeric_limits<double>::max(); double max = std::numeric_limits<double>::min(); for(int j = 0; j < DIM * nPoints; j+= DIM){ if(knownCoords[i + j] < min) min = knownCoords[i + j];   if(knownCoords[i + j] > max) max= knownCoords[i + j]; } bounds[i][0] = min; bounds[i][1] = max; } }   void computeDistances(const int DIM, const int nPoints, const double *knownCoords, const int nGrids, const double *gridCoords, double *distances){ /* Compute distances between all known points and all grid points.     DIM - Dimensionality of coordinates   nPoints - Number of known data points   nGrids - number of points in the grid   knowCoords - array containing all coordinates of known data points   gridCoords - containing all grid points   distances - array containing all the distances all data points and all grid points     */   for(int k = 0; k < nGrids; k++){ for(int i = 0; i < nPoints; i++){ double distance(0.0); for(int j = 0; j < DIM; j++){ distance += pow(knownCoords[i * DIM + j] - gridCoords[k * DIM + j], 2.0); } distances[k * nPoints + i] = sqrt(distance); } }   }   void computeWeights(const int nGrids, const int nPoints, double *distances, double *weightSum, const double p){ /* Compute weights from known points to each grid point     nPoints - Number of known data points   nGrids - number of points in the grid   distances - array containing all the distances all data points and all grid points   weightSum - array containing the weight sums of each grid point   p - parameter to compute sums     */   for(int i = 0; i < nGrids; i++){ double weight(0.0); for(int j = 0; j < nPoints; j++){ double this_weight(0.0); if(distances[i * nPoints + j] == 0){ weight = 0.0; break; } this_weight = 1.0 / pow(distances[i * nPoints + j], p); weight += this_weight; distances[i * nPoints + j] = this_weight; } weightSum[i] = weight; } }     void computeInterpolation(const int nValues, const int nGrids, const int nPoints, const double *distances, const double *weightSum, const double *knownValues, double *gridValues){   /* Compute unknown values on grid points using weights and known values     nValues - number of attributes   nGrids - number of points in the grid   nPoints - number of known points   distances - distances between each pair (known_point, grid_point)   weightSum - Sum of the weights for each grid point     */   for(int i = 0; i < nGrids; i++){ for(int j = 0; j < nValues; j++){ double weigh_value_sum(0.0); bool to_change(true); for(int k = 0; k < nPoints; k++){ weigh_value_sum += distances[i * nPoints + k] * knownValues[nValues * k + j]; if(distances[i * nPoints + k] == 0){ writeGridAttribute(nValues, nGrids, i, j, gridValues, knownValues[nValues * k + j]); to_change = false; break; } } if(to_change) writeGridAttribute(nValues, nGrids, i, j, gridValues, weigh_value_sum / weightSum[i]); } } }   // prepare kernel arguments, work-groups config and launch kernels - No data movements void computeDistances(cl::CommandQueue &cmdQueue, cl::Program &prog, const int DIM, const int nPoints, cl::Buffer &knownCoords, const int nGrids, cl::Buffer &gridCoords, cl::Buffer &distances){   cl_Kernel kernel = clCreateKernel(prog(), "compute_distances", NULL); kernel->setArg(0, DIM); kernel->setArg(1, nPoints); kernel->setArg(2, knownCoords); kernel->setArg(3, nGrids); kernel->setArg(4, gridCoords); kernel->setArg(5, distances); size_t group_size = 4; cl::NDRange local(group_size, group_size, group_size); cl::NDRange global(DIM*nPoints*nGrids + pow(group_size, 3.0) - 1 / pow(group_size, 3.0)); //clEnqueueNDRangeKernel(cmdQueue, kernel, 3, NULL, global, local, 0, NULL, NULL); kernel.bind(cmdQueue, 0, global, local); }   void computeWeights(cl::CommandQueue &cmdQueue, cl::Program &prog, const int nGrids, const int nPoints, cl::Buffer &distances, cl::Buffer &weightSum, const MY_DATA_TYPE p = 2.0){   cl_Kernel kernel = clCreateKernel(prog(), "compute_weights", NULL); clSetKernelArg(kernel, 0, sizeof(cl_int), nGrids); clSetKernelArg(kernel, 1, sizeof(cl_int), nPoints); clSetKernelArg(kernel, 2, sizeof(cl_mem), distances); clSetKernelArg(kernel, 3, sizeof(cl_mem), weightSum; clSetKernelArg(kernel, 4, sizeof(cl_double), p); size_t group_size = 8; cl::NDRange local(group_size, group_size); cl::NDRange global(nGrids*nPoints + pow(group_size, 2.0) - 1 / pow(group_size, 2.0)); //clEnqueueNDRangeKernel(cmdQueue, kernel, 2, NULL, global, local, 0, NULL, NULL); kernel.bind(cmdQueue, 0, global, local); }   void computeInterpolation(cl::CommandQueue &cmdQueue, cl::Program &prog, const int nValues, const int nGrids, const int nPoints, cl::Buffer &distances, cl::Buffer &weightSum, cl::Buffer &knownValues, cl::Buffer &gridValues){   cl_Kernel kernel = clCreateKernel(prog(), "compute_interpolation", NULL); kernel->setArg(0, nValues); kernel->setArg(1, nGrids); kernel->setArg(2, nPoints); kernel->setArg(3, distances); kernel->setArg(4, weightSum); kernel->setArg(5, knownValues); kernel->setArg(6, gridValues); size_t group_size = 4; cl::NDRange local(group_size, group_size, group_size); cl::NDRange global(nValues*nGrids*nPoints + pow(group_size, 3.0) - 1 / pow(group_size, 3.0)); //clEnqueueNDRangeKernel(cmdQueue, kernel, 3, NULL, global, local, 0, NULL, NULL); // 0 is the offset kernel.bind(cmdQueue, 0, global, local); }   // page 111 pour enqueue un kernel // conversion page 137 // max and co 177

---

Je remercie tous ceux qui auront eu la gentillesse de lire jusqu'ici et ceux qui pourront éventuellement m'aider car je suis perdu.

Immo

Salut,

Est-ce que tu as un fichier d'en-tête pour les fonctions définies dans libIDAAOS.cpp? Si ce n'est pas le cas, crées en un et rajoutes les squelettes des fonctions dedans et inclue ce fichier dans main.cpp.

Oui pardon le voici (merci de ton aide !)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

#ifndef IDALIB #define IDALIB   #include <CL/cl.hpp> #define __CL_ENABLE_EXCEPTIONS     typedef double MY_DATA_TYPE;   // read/write to known coordinates MY_DATA_TYPE read(const int DIM, const int nPoints, const int whichPt, const int whichDim, const MY_DATA_TYPE *coords); void write(const int DIM, const int nPoints, const int whichPt, const int whichDim, MY_DATA_TYPE *coords, const MY_DATA_TYPE val);   // read/write to grid coordinates MY_DATA_TYPE readGrid(const int DIM, const int nGridPoints, const int whichGridPt, const int whichDim, const MY_DATA_TYPE *gridCoords); void writeGrid(const int DIM, const int nGridPoints, const int whichGridPt, const int whichDim, MY_DATA_TYPE *gridCoords, const MY_DATA_TYPE val);   // read/write to known values MY_DATA_TYPE readAttribute(const int noAttr, const int nPoints, const int whichPt, const int whichAttr, const MY_DATA_TYPE *values); void writeAttribute(const int noAttr, const int nPoints, const int whichPt, const int whichAttr, MY_DATA_TYPE *values, const MY_DATA_TYPE val);   // read/write to grid values MY_DATA_TYPE readGridAttribute(const int noAttr, const int nPoints, const int whichPt, const int whichAttr, const MY_DATA_TYPE *values); void writeGridAttribute(const int noAttr, const int nPoints, const int whichPt, const int whichAttr, MY_DATA_TYPE *values, const MY_DATA_TYPE val);   void computeBounds(const int DIM, const int nPoints, const MY_DATA_TYPE *knownCoords, MY_DATA_TYPE(*bounds)[2]); void computeDistances(const int DIM, const int nPoints, const MY_DATA_TYPE *knownCoords, const int nGrids, const MY_DATA_TYPE *gridCoords, MY_DATA_TYPE *distances); void computeWeights(const int nGrids, const int nPoints, MY_DATA_TYPE *distances, MY_DATA_TYPE *weightSum, const MY_DATA_TYPE p = 2.0); void computeInterpolation(const int nValues, const int nGrids, const int nPoints, const MY_DATA_TYPE *distances, const MY_DATA_TYPE *weightSum, const MY_DATA_TYPE *knownValues, MY_DATA_TYPE *gridValues);   // For OpenCL version void computeDistances(cl::CommandQueue &cmdQueue, cl::Program &prog, const int DIM, const int nPoints, cl_mem &knownCoords, const int nGrids, cl_mem &gridCoords, cl_mem &distances); void computeWeights(cl::CommandQueue &cmdQueue, cl::Program &prog, const int nGrids, const int nPoints, cl_mem &distances, cl_mem &weightSum, const MY_DATA_TYPE p = 2.0); void computeInterpolation(cl::CommandQueue &cmdQueue, cl::Program &prog, const int nValues, const int nGrids, const int nPoints, cl_mem distances, cl_mem weightSum, cl_mem &knownValues, cl_mem gridValues);   #endif

---

Je n'ai pas testé mais je suis quasi sûr que c'est à cause des const int ou const double que tu demande et que tu passes un int classique (double). Je pense que tu voulais utiliser une référence constante (même si elle n'a pas vraiment lieu d'être ici).

Essaie avec ces squelettes de fonctions:

Code:

---

1 2 3 4

// For OpenCL version void computeDistances(cl::CommandQueue &cmdQueue, cl::Program &prog, int DIM, int nPoints, cl_mem &knownCoords, int nGrids, cl_mem &gridCoords, cl_mem &distances); void computeWeights(cl::CommandQueue &cmdQueue, cl::Program &prog, int nGrids, int nPoints, cl_mem &distances, cl_mem &weightSum, MY_DATA_TYPE p = 2.0); void computeInterpolation(cl::CommandQueue &cmdQueue, cl::Program &prog, int nValues, int nGrids, int nPoints, cl_mem distances, cl_mem weightSum, cl_mem &knownValues, cl_mem gridValues);

---

Pour arriver à ce raisonnement, pense à bien regarder le message d'erreur du compilo et compare les squelettes avec ce que le compilo attend et ce que ton code peu fournir. Et on remarque rapidement que le compilo attendait des int, double, etc et non pas des const int, const double, etc...

Bon courage pour la suite!

Hey Darkman merci du coup de main malheureusement j'ai opéré les changements que tu as fait (aussi bien dans IDALib.h que dans libIDAAOS.cpp) et ça n'a rien changé du tout. As-tu une autre idée ?

J'ai essayé de compiler ton code mais il manque le fichier YoUtil.hpp.

Tu peux l'ajouter stp?

Bien entendu, merci de te donner autant de mal.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

#include "YoUtil.hpp" #include <iostream> // for I/O #include <fstream> // for file I/O   using namespace std;   cl::Context *getContext(cl_device_type type, vector<cl::CommandQueue> &cmdQueues, cl_command_queue_properties props, bool verbose) { vector< cl::Platform > platforms; cl::Platform::get(&platforms);   for (cl::Platform &platform : platforms) { vector<cl::Device> devices; platform.getDevices(type, &devices); if (devices.size() == 0) continue;   cl::Context *context = new cl::Context(devices);   // create command queues in the context cmdQueues.clear(); for (auto& device : context->getInfo<CL_CONTEXT_DEVICES>()) { cmdQueues.push_back(cl::CommandQueue(*context, device, props)); }   if (verbose) { cout << "\n\tThere are " << context->getInfo<CL_CONTEXT_NUM_DEVICES>() << " device(s) in the defined context."; cout << "\n\t# of Command queues: " << cmdQueues.size(); } return context; }   if (verbose) cerr << "\nCannot find any platform for given device type: " << type; return nullptr; }   string readSourceCode(const char *filename) { ifstream inp(filename); if (!inp) { cerr << "\nError opening file: " << filename << endl; return ""; }   string kernel((istreambuf_iterator<char>(inp)), istreambuf_iterator<char>());   inp.close(); return kernel; }   cl::Program *compile(cl::Context &context, const string &source, const char *options) { cl::Program *prog = new cl::Program(context, source);   try { // prog->build("-cl-std=CL1.2 -w -cl-kernel-arg-info"); prog->build(options); } catch (cl::Error &e) { cerr << "\nFile: " << __FILE__ << ", line: " << __LINE__ << e.what(); cerr << "\nError no: " << e.err() << endl; for (auto& device : context.getInfo<CL_CONTEXT_DEVICES>()) { cout << "\n=== " << device.getInfo<CL_DEVICE_NAME>() << " ==="; cout << "\nBuild log: " << prog->getBuildInfo<CL_PROGRAM_BUILD_LOG>(device); cout << "\nBuild options used:" << prog->getBuildInfo<CL_PROGRAM_BUILD_OPTIONS>(device); } return nullptr; }   /* // See Table 5.13 of OpenCL 1.2 specification for information that can be queried to program objects cout << "\n\t# devices associated with the program: " << prog->getInfo<CL_PROGRAM_NUM_DEVICES>(); cout << "\n\t# Kernels defined: " << prog->getInfo<CL_PROGRAM_NUM_KERNELS>(); cout << "\n\tProgram kernel names: " << prog->getInfo<CL_PROGRAM_KERNEL_NAMES>(); cout << "\n\tProg sizes: "; for (auto s : prog->getInfo<CL_PROGRAM_BINARY_SIZES>()) cout << s << ";"; */   return prog; }

---

Le header

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124

#ifndef YO_OPENCL_UTIL_HEADER #define YO_OPENCL_UTIL_HEADER   #define __CL_ENABLE_EXCEPTIONS #include <CL/cl.hpp>   #include <string> // for C++ string #include <vector> // for vector container #include <chrono> using namespace std;   // utility function get a context by specifying device type // command queue properties CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE -> not enable by default // CL_QUEUE_PROFILING_ENABLE -> to record performance cl::Context *getContext(cl_device_type type, vector<cl::CommandQueue> &cmdQueues, cl_command_queue_properties props = 0, bool verbose = false);   // utility function to load OpenCL source code and store it into a string std::string readSourceCode(const char *filename);   // utility function compile the CL source code into Programs cl::Program *compile(cl::Context &, const string &source, const char *option = "-cl-std=CL1.2 -w -cl-kernel-arg-info");   // utility class for stopWatch wrapper using c++11 chrono class stopWatch { chrono::high_resolution_clock::time_point t_start, t_stop; public: void start() { t_start = chrono::high_resolution_clock::now(); } void stop() { t_stop = chrono::high_resolution_clock::now(); } double elapsedTime() { chrono::duration<double> d = t_stop - t_start; return d.count(); } static double resolution() { auto tmp = chrono::high_resolution_clock::period(); return (double)tmp.num / tmp.den; } };   /*   Device Type: CL_DEVICE_TYPE_GPU Device ID: 4098 Board name: AMD Radeon HD 7900 Series Device Topology: PCI[ B#1, D#0, F#0 ] Max compute units: 32 Max work items dimensions: 3 Max work items[0]: 256 Max work items[1]: 256 Max work items[2]: 256 Max work group size: 256   Preferred vector width char: 4 Preferred vector width short: 2 Preferred vector width int: 1 Preferred vector width long: 1 Preferred vector width float: 1 Preferred vector width double: 1 Native vector width char: 4 Native vector width short: 2 Native vector width int: 1 Native vector width long: 1 Native vector width float: 1 Native vector width double: 1 Max clock frequency: 1000Mhz Address bits: 32 Max memory allocation: 1073741824 Image support: Yes Max number of images read arguments: 128 Max number of images write arguments: 8 Max image 2D width: 16384 Max image 2D height: 16384 Max image 3D width: 2048 Max image 3D height: 2048 Max image 3D depth: 2048 Max samplers within kernel: 16 Max size of kernel argument: 1024 Alignment (bits) of base address: 2048 Minimum alignment (bytes) for any datatype: 128 Single precision floating point capability Denorms: No Quiet NaNs: Yes Round to nearest even: Yes Round to zero: Yes Round to +ve and infinity: Yes IEEE754-2008 fused multiply-add: Yes Cache type: Read/Write Cache line size: 64 Cache size: 16384 Global memory size: 3107979264 Constant buffer size: 65536 Max number of constant args: 8 Local memory type: Scratchpad Local memory size: 32768 Kernel Preferred work group size multiple: 64 Error correction support: 0 Unified memory for Host and Device: 0 Profiling timer resolution: 1 Device endianess: Little Available: Yes Compiler available: Yes Execution capabilities: Execute OpenCL kernels: Yes Execute native function: No Queue properties: Out-of-Order: No Profiling : Yes Platform ID: 0x00007f3a8eed7500 Name: Tahiti Vendor: Advanced Micro Devices, Inc. Device OpenCL C version: OpenCL C 1.2 Driver version: 1411.4 (VM) Profile: FULL_PROFILE Version: OpenCL 1.2 AMD-APP (1411.4) Extensions: cl_khr_fp64 cl_amd_fp64 cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_int64_base_atomics cl_khr_int64_extended_atomics cl_khr_3d_image_writes cl_khr_byte_addressable_store cl_khr_gl_sharing cl_ext_atomic_counters_32 cl_amd_device_attribute_query cl_amd_vec3 cl_amd_printf cl_amd_media_ops cl_amd_media_ops2 cl_amd_popcnt cl_khr_image2d_from_buffer cl_khr_spir     */     #endif

---

je tiens à préciser que ce code c'est mon prof qui nous l'a donné pour nous simplifier la vie, je suis donc limité dans les modifications que je peux y apporter, néanmoins si tu vois quelque chose dedans qui si il était différent résoudrait mon problème en 2 sec je veux bien que tu m'en parles :);)

La def : computeDistances(cl::CommandQueue&, cl::Program&, int, int, cl_mem&, int, cl_mem&, cl_mem&);
L'appel : computeDistances(cl::CommandQueue&, cl::Program&, int, int, _cl_mem*&, int, _cl_mem*&, _cl_mem*&);

int et const int sont la même chose pour le type d'une fonction, le const ne s'appliquant qu'à la variable locale accueillant la copie de l'argument.

Citation:

---

Envoyé par ImmoTPA

Code:

---

1 2 3 4 5 6 7 8

void computeDistances(const int DIM, const int nPoints, const MY_DATA_TYPE *knownCoords, const int nGrids, const MY_DATA_TYPE *gridCoords, MY_DATA_TYPE *distances); void computeWeights(const int nGrids, const int nPoints, MY_DATA_TYPE *distances, MY_DATA_TYPE *weightSum, const MY_DATA_TYPE p = 2.0); void computeInterpolation(const int nValues, const int nGrids, const int nPoints, const MY_DATA_TYPE *distances, const MY_DATA_TYPE *weightSum, const MY_DATA_TYPE *knownValues, MY_DATA_TYPE *gridValues);   // For OpenCL version void computeDistances(cl::CommandQueue &cmdQueue, cl::Program &prog, const int DIM, const int nPoints, cl_mem &knownCoords, const int nGrids, cl_mem &gridCoords, cl_mem &distances); void computeWeights(cl::CommandQueue &cmdQueue, cl::Program &prog, const int nGrids, const int nPoints, cl_mem &distances, cl_mem &weightSum, const MY_DATA_TYPE p = 2.0); void computeInterpolation(cl::CommandQueue &cmdQueue, cl::Program &prog, const int nValues, const int nGrids, const int nPoints, cl_mem distances, cl_mem weightSum, cl_mem &knownValues, cl_mem gridValues);

---

---

Hello,

Tu mélange interface C et Wrapper C++ un peu partout dans ton code, c'est assez sale. Utilise l'un ou l'autre mais pas les deux.

Tes fonctions "For OpenCL version" ne sont implémentées nulle part, et pourquoi mélanger des cl::Machin avec des cl_mem ? Ce sont des buffers, utilise donc cl::Buffer (ou remplace les cl::Machin par la version C).

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// prepare kernel arguments, work-groups config and launch kernels - No data movements void computeDistances(cl::CommandQueue &cmdQueue, cl::Program &prog, const int DIM, const int nPoints, cl::Buffer &knownCoords, const int nGrids, cl::Buffer &gridCoords, cl::Buffer &distances){   cl_Kernel kernel = clCreateKernel(prog(), "compute_distances", NULL); kernel->setArg(0, DIM); kernel->setArg(1, nPoints); kernel->setArg(2, knownCoords); kernel->setArg(3, nGrids); kernel->setArg(4, gridCoords); kernel->setArg(5, distances); size_t group_size = 4; cl::NDRange local(group_size, group_size, group_size); cl::NDRange global(DIM*nPoints*nGrids + pow(group_size, 3.0) - 1 / pow(group_size, 3.0)); //clEnqueueNDRangeKernel(cmdQueue, kernel, 3, NULL, global, local, 0, NULL, NULL); kernel.bind(cmdQueue, 0, global, local); }

---

Ce coup ci tu utilises cl::Buffer et plus cl_mem.

A un moment il va falloir savoir ce que tu utilise.

Si tu utilise les type C++, corrige la définition de la fonction et l'appel :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// For OpenCL version void computeDistances(cl::CommandQueue &cmdQueue, cl::Program &prog, const int DIM, const int nPoints, cl::Buffer &knownCoords, const int nGrids, cl::Buffer &gridCoords, cl::Buffer &distances);   // main - Ce coup ci tu utilises l'interface C.. cl_mem knownCoords_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(knownCoords), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](),knownCoords_b, CL_TRUE, 0, sizeof(knownCoords_b), knownCoords_b, 0, NULL, NULL);   cl_mem gridCoords_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(gridCoords), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](), gridCoords_b, CL_TRUE, 0, sizeof(gridCoords_b), gridCoords_b, 0, NULL, NULL);   cl_mem distances_b = clCreateBuffer((*context)(), CL_MEM_READ_WRITE, sizeof(distances), NULL, 0); clEnqueueWriteBuffer(cmdQueues[0](), distances_b, CL_TRUE, 0, sizeof(distances_b), distances, 0, NULL, NULL);   computeDistances(cmdQueues[0], *program, DIM, nPoints, knownCoords_b, nGrids, gridCoords_b, distances_b);   // à remplacer par cl::Buffer knownCoords_b(...); cl::Buffer gridCoords_b(...); cl::Buffer distances_b(...);   computeDistances(cmdQueues[0], *program, DIM, nPoints, knownCoords_b, nGrids, gridCoords_b, distances_b);

---