void test_generate_mask(void) {
// generate_mask(1, 1 + 4) = 0000 0000 0000 1111 == 15
assert(generate_mask(1, 1 + 4) == 15);
// generate_mask(5, 5 + 4) = 0000 0000 1111 0000 == 240
assert(generate_mask(5, 5 + 4) == 240);
};
candidate*
immaculate_conception (CUZMEM_CONTEXT ctx)
{
unsigned long long DNA;
unsigned int loc, gpu_mem_free, gpu_mem_total, gpu_mem_req;
unsigned int creating = 1;
cuzmem_plan* entry = ctx->plan;
candidate* c = (candidate*)malloc (sizeof(candidate));
cuMemGetInfo (&gpu_mem_free, &gpu_mem_total);
while (creating) {
c->DNA = rand();
c->DNA = c->DNA << 32;
c->DNA = c->DNA + rand();
c->DNA &= generate_mask(ctx->num_knobs);
// gpu memory utilization
gpu_mem_req = 0;
entry = ctx->plan;
while (entry != NULL) {
if (entry->gold_member) {
loc = (c->DNA >> entry->id) & 0x0001;
gpu_mem_req += entry->size * loc;
}
entry = entry->next;
}
// check constraint
if (gpu_mem_req > gpu_mem_free * MIN_GPU_MEM) {
creating = 0;
}
}
/*
* Runs benchmark.
*/
int main(int argc, char **argv)
{
int i; /* Loop index. */
double *mask; /* Mask. */
uint64_t end; /* End time. */
uint64_t start; /* Start time. */
unsigned char *img; /* Image. */
readargs(argc, argv);
timer_init();
srandnum(seed);
/* Benchmark initialization. */
if (verbose)
printf("initializing...\n");
start = timer_get();
img = smalloc(p->imgsize*p->imgsize*sizeof(char));
for (i = 0; i < p->imgsize*p->imgsize; i++)
img[i] = randnum() & 0xff;
mask = smalloc(p->masksize*p->masksize*sizeof(double));
generate_mask(mask);
end = timer_get();
if (verbose)
printf(" time spent: %f\n", timer_diff(start, end)*MICROSEC);
/* Apply filter. */
if (verbose)
printf("applying filter...\n");
start = timer_get();
gauss_filter(img, p->imgsize, mask, p->masksize);
end = timer_get();
total = timer_diff(start, end);
/* Print timing statistics. */
printf("timing statistics:\n");
printf(" master: %f\n", master*MICROSEC);
for (i = 0; i < nclusters; i++)
printf(" slave %d: %f\n", i, slave[i]*MICROSEC);
printf(" communication: %f\n", communication*MICROSEC);
printf(" total time: %f\n", total*MICROSEC);
/* House keeping. */
free(mask);
free(img);
return (0);
}
/*
Algorithm:
1) extract original bits sector from num
2) apply NOT to extracted bits sector
3) clear original bits sector in num to zeros
4) copy converted bits sector to original num
*/
int invert_sector(int num, int start_position, int bits_count) {
int sector = 0;
// extract original bits sector from num
sector = num & generate_mask(start_position, start_position + bits_count);
// apply NOT to extracted bits sector
sector = ~sector;
// clear original bits sector in num to zeros
num &= ~generate_mask(start_position, start_position + bits_count);
// copy converted bits sector to original num
return num & sector;
}
int main (int argc, char **argv)
{
char **population; //include every parent that is about to have childen
//long long type can represent upto 20 bits of 1 and 0,
//chroms longer than 20bits will be splited to array of long long numbers
char chrom1[] = "10101010001101011";
char chrom2[] = "11010000110010010";
int length = sizeof(chrom1)-1;
double crossover = (double)0.5; //this determines the crossover point in chrom
//generate mask for crossover
char *mask1 = (char *) malloc(length*sizeof(char));
char *mask2 = (char *) malloc(length*sizeof(char));
generate_mask(mask1, mask2, length, crossover);
printf("input 1: %15s (%d) 2: %15s (%d) Length: %d\n", chrom1, fitness(chrom1,length), chrom2, fitness(chrom2, length), length);
printf("masks 1: %15s 2: %15s\n", mask1, mask2);
char *ptr1,*ptr2;
//convert the above 4 string values to decimal int following binary rule.
long long ret1 = strtoul(chrom1, &ptr1, 2);
long long ret2 = strtoul(chrom2, &ptr2, 2);
long long m1 = strtoul(mask1, &ptr1, 2);
long long m2 = strtoul(mask2, &ptr2, 2);
//crossover operation
long long ichild1 = (ret1 & m2) ^ (ret2 & m1);
long long ichild2 = (ret1 & m1) ^ (ret2 & m2);
//convert binary format childern to string, in order to add them to parent pool.
char *child1 = (char *)malloc(length * sizeof(char));
char *child2 = (char *)malloc(length * sizeof(char));
sprintf(child1,"%lld",int_to_binary(ichild1));
sprintf(child2,"%lld",int_to_binary(ichild2));
printf("child 1: %18s 2: %s",child1,child2);
return 0;
}
void ws::message_generator::generate_header()
{
body.push_back(opcode | (1 << 7)); //apply FIN bit
generate_payload_length();
generate_mask();
}
int ff_opencl_unsharp_init(AVFilterContext *ctx)
{
int ret = 0;
char build_opts[96];
UnsharpContext *unsharp = ctx->priv;
ret = av_opencl_init(NULL);
if (ret < 0)
return ret;
ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_luma_mask,
sizeof(uint32_t) * (2 * unsharp->luma.steps_x + 1) * (2 * unsharp->luma.steps_y + 1),
CL_MEM_READ_ONLY, NULL);
if (ret < 0)
return ret;
ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_chroma_mask,
sizeof(uint32_t) * (2 * unsharp->chroma.steps_x + 1) * (2 * unsharp->chroma.steps_y + 1),
CL_MEM_READ_ONLY, NULL);
if (ret < 0)
return ret;
ret = generate_mask(ctx);
if (ret < 0)
return ret;
unsharp->opencl_ctx.plane_num = PLANE_NUM;
unsharp->opencl_ctx.command_queue = av_opencl_get_command_queue();
if (!unsharp->opencl_ctx.command_queue) {
av_log(ctx, AV_LOG_ERROR, "Unable to get OpenCL command queue in filter 'unsharp'\n");
return AVERROR(EINVAL);
}
snprintf(build_opts, 96, "-D LU_RADIUS_X=%d -D LU_RADIUS_Y=%d -D CH_RADIUS_X=%d -D CH_RADIUS_Y=%d",
2*unsharp->luma.steps_x+1, 2*unsharp->luma.steps_y+1, 2*unsharp->chroma.steps_x+1, 2*unsharp->chroma.steps_y+1);
unsharp->opencl_ctx.program = av_opencl_compile("unsharp", build_opts);
if (!unsharp->opencl_ctx.program) {
av_log(ctx, AV_LOG_ERROR, "OpenCL failed to compile program 'unsharp'\n");
return AVERROR(EINVAL);
}
if (unsharp->opencl_ctx.use_fast_kernels) {
if (!unsharp->opencl_ctx.kernel_luma) {
unsharp->opencl_ctx.kernel_luma = clCreateKernel(unsharp->opencl_ctx.program, "unsharp_luma", &ret);
if (ret != CL_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "OpenCL failed to create kernel 'unsharp_luma'\n");
return ret;
}
}
if (!unsharp->opencl_ctx.kernel_chroma) {
unsharp->opencl_ctx.kernel_chroma = clCreateKernel(unsharp->opencl_ctx.program, "unsharp_chroma", &ret);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "OpenCL failed to create kernel 'unsharp_chroma'\n");
return ret;
}
}
}
else {
if (!unsharp->opencl_ctx.kernel_default) {
unsharp->opencl_ctx.kernel_default = clCreateKernel(unsharp->opencl_ctx.program, "unsharp_default", &ret);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR, "OpenCL failed to create kernel 'unsharp_default'\n");
return ret;
}
}
}
return ret;
}
//! Writes data to a register.
//! \param[in] val Value to write.
static void write(uint32_t val)
{
Mut::write(reinterpret_cast<volatile uint32_t*>(addr), offset, generate_mask(width, offset), val);
}
//! Reads data from a register.
static uint32_t read()
{
return Mut::read(reinterpret_cast<volatile uint32_t*>(addr), offset, generate_mask(width, offset));
}
static uint32_t read()
{
mut_t::read(
reinterpret_cast<volatile uint32_t*>(addr), offset,
generate_mask(offset, width));
}
/*
* Runs benchmark.
*/
int main(int argc, char **argv)
{
int i; /* Loop index. */
int *mask; /* Mask. */
uint64_t end; /* End time. */
uint64_t start; /* Start time. */
char *img; /* Image. */
int numcorners=0; /* Total corners detected */
#ifdef _XEON_PHI_
double power;
#endif
readargs(argc, argv);
timer_init();
srandnum(seed);
omp_set_num_threads(nthreads);
/* Benchmark initialization. */
if (verbose)
printf("initializing...\n");
start = timer_get();
img = smalloc(p->imgsize*p->imgsize*sizeof(char));
for (i = 0; i < p->imgsize*p->imgsize; i++){
char val = randnum() & 0xff;
img[i] = (val>0) ? val : val*(-1);
}
mask = smalloc(p->maskrows*p->maskcolumns*sizeof(int));
generate_mask(mask);
end = timer_get();
if (verbose)
printf(" time spent: %f\n", timer_diff(start, end)*MICROSEC);
#ifdef _XEON_PHI_
power_init();
#endif
/* Detect corners. */
if (verbose)
printf("detecting corners...\n");
start = timer_get();
numcorners = fast(img, p->imgsize, mask);
end = timer_get();
#ifdef _XEON_PHI_
power = power_end();
#endif
printf("timing statistics:\n");
printf(" total time: %f\n", timer_diff(start, end)*MICROSEC);
#ifdef _XEON_PHI_
printf(" average power: %f\n", power*0.000001);
#endif
printf(" corners detected: %d\n", numcorners);
/* House keeping. */
free(mask);
free(img);
return (0);
}
