static BOOL compare_vec4(struct vec4 *vec, float x, float y, float z, float w, unsigned int ulps)
{
return compare_float(vec->x, x, ulps)
&& compare_float(vec->y, y, ulps)
&& compare_float(vec->z, z, ulps)
&& compare_float(vec->w, w, ulps);
}
static boolean
test_format_unpack_z_float(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
unsigned i, j;
boolean success;
format_desc->unpack_z_float(&unpacked[0][0], sizeof unpacked[0],
test->packed, 0,
format_desc->block.width, format_desc->block.height);
success = TRUE;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
if (!compare_float(test->unpacked[i][j][0], unpacked[i][j])) {
success = FALSE;
}
}
}
if (!success) {
print_unpacked_z_float(format_desc, "FAILED: ", unpacked, " obtained\n");
print_unpacked_rgba_doubl(format_desc, " ", test->unpacked, " expected\n");
}
return success;
}
int
scomplex_test()
{
grpc_error_t ret;
scomplex scalarIn, scalarOut;
scomplex a[N], b[N];
int success = 1;
int i;
int handleInitialized = 0;
scalarIn.r = 1.0;
scalarIn.i = 2.0;
scalarOut.r = 0.0;
scalarOut.i = 0.0;
for (i = 0; i < N; i++) {
a[i].r = i;
a[i].i = i + 0.1;
b[i].r = 0;
b[i].i = 0;
}
ret = grpc_function_handle_default(&handles, MODULE_NAME "/scomplex_test");
if (ret != GRPC_NO_ERROR) {
fprintf(stderr, "grpc_function_handle_default() error. (%s)\n",
grpc_error_string(ret));
success = 0;
goto finalize;
}
handleInitialized = 1;
ret = grpc_call(&handles, N, scalarIn, a, &scalarOut, b);
if (ret != GRPC_NO_ERROR) {
fprintf(stderr, "grpc_call() error. (%s)\n",
grpc_error_string(ret));
success = 0;
goto finalize;
}
if ((scalarOut.r != scalarIn.r) || (scalarOut.i != scalarIn.i)) {
success = 0;
if (verbose) {
printf("scomplex_test: scalarIn(%f, %f) != scalarOut(%f, %f)\n",
scalarIn.r, scalarIn.i, scalarOut.r, scalarOut.i);
}
}
for (i = 0; i < N; i++) {
if (!compare_float(a[i].r, b[i].r) || !compare_float(a[i].i, b[i].i)) {
success = 0;
if (verbose) {
printf("scomplex_test: a[%d](%f, %f) != b[%d](%f, %f)\n",
i, a[i].r, a[i].i, i, b[i].r, b[i].i);
}
}
}
finalize:
if (handleInitialized != 0) {
ret = grpc_function_handle_destruct(&handles);
if (ret != GRPC_NO_ERROR) {
fprintf(stderr, "grpc_function_handle_destruct() error. (%s)\n",
grpc_error_string(ret));
success = 0;
}
handleInitialized = 0;
}
return success;
}
int
float_test()
{
grpc_error_t ret;
float scalarIn, scalarOut;
float a[N], b[N];
int success = 1;
int i;
int handleInitialized = 0;
ret = grpc_function_handle_default(&handles, MODULE_NAME "/float_test");
if (ret != GRPC_NO_ERROR) {
fprintf(stderr,
"grpc_function_handle_default() error. (%s)\n",
grpc_error_string(ret));
success = 0;
goto finalize;
}
handleInitialized = 1;
scalarIn = 1.0;
scalarOut = 0.0;
for (i = 0; i < N; i++) {
a[i] = i;
b[i] = 0;
}
ret = grpc_call(&handles, N, scalarIn, a, &scalarOut, b);
if (ret != GRPC_NO_ERROR) {
fprintf(stderr, "grpc_call() error. (%s)\n",
grpc_error_string(ret));
success = 0;
goto finalize;
}
if (scalarOut != scalarIn) {
success = 0;
if (verbose) {
printf("float_test: scalarIn(%f) != scalarOut(%f)\n",
scalarIn, scalarOut);
}
}
for (i = 0; i < N; i++) {
if (!compare_float(a[i], b[i])) {
success = 0;
if (verbose) {
printf("float_test: a[%d](%f) != b[%d](%f)\n",
i, a[i], i, b[i]);
}
}
}
finalize:
if (handleInitialized != 0) {
ret = grpc_function_handle_destruct(&handles);
if (ret != GRPC_NO_ERROR) {
fprintf(stderr, "grpc_function_handle_destruct() error. (%s)\n",
grpc_error_string(ret));
success = 0;
}
handleInitialized = 0;
}
return success;
}
int main(int argc, const char* argv[]) {
icl_args* args = icl_init_args();
icl_parse_args(argc, argv, args);
icl_print_args(args);
chdir(PATH);
int size = args->size;
float* input1 = (float*) malloc(sizeof(float) * size);
float* input2 = (float*) malloc(sizeof(float) * size);
float* alpha = (float*) malloc(sizeof(float) * size);
float* beta = (float*) malloc(sizeof(float) * size);
float* output = (float*) malloc(sizeof(float) * size);
fill_random_float(input2, size, 1, -1.0f, 1.0f);
qsort(input2, size, sizeof(float), float_compare);
float step = 2.0f / size;
for(int i=0; i < size; i++)
input1[i] = -1.0f + i * step;
fill_random_float(alpha, size, 1, -1.0f, 1.0f);
fill_random_float(beta, size, 1, -1.0f, 1.0f);
icl_init_devices(args->device_type);
icl_start_energy_measurement();
if (icl_get_num_devices() != 0) {
icl_device* dev = icl_get_device(args->device_id);
icl_print_device_short_info(dev);
icl_kernel* kernel = icl_create_kernel(dev, "lin_reg.cl", "lin_reg", "", ICL_SOURCE);
size_t szLocalWorkSize = args->local_size;
float multiplier = size/(float)szLocalWorkSize;
if(multiplier > (int)multiplier)
multiplier += 1;
size_t szGlobalWorkSize = (int)multiplier * szLocalWorkSize;
for (int i = 0; i < args->loop_iteration; ++i) {
icl_buffer* buf_input1 = icl_create_buffer(dev, CL_MEM_READ_ONLY, sizeof(float) * size);
icl_buffer* buf_input2 = icl_create_buffer(dev, CL_MEM_READ_ONLY, sizeof(float) * size);
icl_buffer* buf_alpha = icl_create_buffer(dev, CL_MEM_READ_ONLY, sizeof(float) * size);
icl_buffer* buf_beta = icl_create_buffer(dev, CL_MEM_READ_ONLY, sizeof(float) * size);
icl_buffer* buf_output = icl_create_buffer(dev, CL_MEM_WRITE_ONLY, sizeof(float) * size);
icl_write_buffer(buf_input1, CL_TRUE, sizeof(float) * size, &input1[0], NULL, NULL);
icl_write_buffer(buf_input2, CL_TRUE, sizeof(float) * size, &input2[0], NULL, NULL);
icl_write_buffer(buf_alpha, CL_TRUE, sizeof(float) * size, &alpha[0], NULL, NULL);
icl_write_buffer(buf_beta, CL_TRUE, sizeof(float) * size, &beta[0], NULL, NULL);
icl_run_kernel(kernel, 1, &szGlobalWorkSize, &szLocalWorkSize, NULL, NULL, 6,
(size_t)0, (void *)buf_input1,
(size_t)0, (void *)buf_input2,
(size_t)0, (void *)buf_alpha,
(size_t)0, (void *)buf_beta,
(size_t)0, (void *)buf_output,
sizeof(cl_int), (void *)&size);
icl_read_buffer(buf_output, CL_TRUE, sizeof(float) * size, &output[0], NULL, NULL);
icl_release_buffers(5, buf_input1, buf_input2, buf_alpha, buf_beta, buf_output);
}
icl_release_kernel(kernel);
}
icl_stop_energy_measurement();
if (args->check_result) {
printf("======================\n= Linear Regression Done\n");
float* output2 = (float *)malloc(sizeof(float) * size);
for(unsigned int j = 0; j < size; ++j) {
const int gid = j;
float a = alpha[gid];
float b = beta[gid];
float error = 0;
for(int i=0; i<size; i++) {
float e = (a * input1[i] + b) - input2[i];
error += e * e;
}
output2[gid] = error;
}
bool check = compare_float(output, output2, size, 0.000001);
printf("======================\n");
printf("Result check: %s\n", check ? "OK" : "FAIL");
free(output2);
} else {
printf("Result check: OK\n");
}
icl_release_args(args);
icl_release_devices();
free(input1);
free(input2);
free(alpha);
free(beta);
free(output);
}
void Painter::paint() {
size_t dominant = 0;
size_t numActive = genome_.countActiveChromosomes();
if (numActive == 0)
dominant = genome_.findDominantChromosome();
result_ = oImg_.clone();
for (size_t i = 0; i < genome_.size(); ++i) {
Chromosome& c = genome_[i];
if (!c.isActive() && !(numActive == 0 && i == dominant))
continue;
Mat kernel = c.makeKernel();
Point anchor(-1, -1);
double delta = 0;
int ddepth = -1;
if(c.getOperation() == PASS) {
filter2D(result_.clone(), result_, ddepth, kernel, anchor, delta, BORDER_DEFAULT);
} else {
Mat after;
filter2D(oImg_.clone(), after, ddepth, kernel, anchor, delta, BORDER_DEFAULT);
switch (c.getOperation()) {
case PASS:
CHECK(false);
break;
case SUBSTRACT:
result_ = result_ - after;
break;
case ADD:
result_ = result_ + after;
break;
default:
CHECK(false);
break;
}
}
}
double pixError = 0;
Mat rNorm;
Mat pNorm;
normalize(result_, rNorm, 0, 255, CV_MINMAX);
normalize(pImg_, pNorm, 0, 255, CV_MINMAX);
Scalar rMean;
Scalar pMean;
Scalar rSdv;
Scalar pSdv;
meanStdDev(rNorm, rMean, rSdv);
meanStdDev(pNorm, pMean, pSdv);
double mean = (fabs(rMean.val[0] - pMean.val[0]) / 255.0
+ fabs(rMean.val[1] - pMean.val[1]) / 255.0
+ fabs(rMean.val[2] - pMean.val[2]) / 255.0)
/ 3.0;
double sdv = (fabs(rSdv.val[0] - pSdv.val[0]) / 255.0
+ fabs(rSdv.val[1] - pSdv.val[1]) / 255.0
+ fabs(rSdv.val[2] - pSdv.val[2]) / 255.0)
/ 3.0;
///std::cerr << "mean: " << mean << "sdv: " << sdv << std::endl;
pixError = 1-0 - ((mean + sdv) / 2.0);
/*for (int row = 0; row < rNorm.rows; ++row) {
uchar* pr = rNorm.ptr(row);
uchar* pp = pNorm.ptr(row);
for (int col = 0; col < rNorm.cols * 3; ++col) {
pixError += 1.0 - (abs((*pp++) - (*pr++)) / 255.0);
}
}*/
pixelError_ = pixError ;// / (result_.rows * result_.cols * 3);
// histError_ = cv::compareHist(makeHistogramGray(result_), pImgHist_, CV_COMP_INTERSECT) / (result_.rows * result_.cols) ;
resultDFT_ = make_dft(result_);
fftError_ = compare_float(resultDFT_, pImgDFT_);
histError_ = compare_float_binarize(resultDFT_, pImgDFT_);
//(((double)(pImg_.rows * pImg_.cols) - count_diff_pixels(makeFFT(result_), pImgDFT_)) / ((double)pImg_.rows * pImg_.cols));
fitness_ = (histError_ * pixelError_ * fftError_);
fitness_ = (fitness_ / pow(std::exp(-fitness_),2)) / (1 / pow(std::exp(-1),2));
}
