Discussion :

[ImmoTPA]

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:rogram&, int, int, _cl_mem*&, int, _cl_mem*&, _cl_mem*&)'
main.cpp.text+0xc42): undefined reference to `computeWeights(cl::CommandQueue&, cl:rogram&, int, int, _cl_mem*&, _cl_mem*&, double)'
main.cpp.text+0xcf9): undefined reference to `computeInterpolation(cl::CommandQueue&, cl:rogram&, 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[darkman19320]

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.

[ImmoTPA]

Oui pardon le voici (merci de ton aide !)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[darkman19320]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[ImmoTPA]

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 ?

[darkman19320]

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

Tu peux l'ajouter stp?

[ImmoTPA]

Bien entendu, merci de te donner autant de mal.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[prgasp77]

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.

[Iradrille]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);