TEST_P(HogDetect, Accuracy) { PRINT_PARAM(devInfo); ASSERT_NO_THROW( CV_GpuHogDetectTestRunner runner; runner.run(); );
TEST_P(AddArray, Accuracy) { PRINT_PARAM(devInfo); PRINT_TYPE(type); PRINT_PARAM(size); cv::Mat dst_gold; cv::add(mat1, mat2, dst_gold); cv::Mat dst; ASSERT_NO_THROW( cv::gpu::GpuMat gpuRes; cv::gpu::add(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpuRes); gpuRes.download(dst); );
TEST_P(SURF, EmptyDataTest) { PRINT_PARAM(devInfo); cv::gpu::SURF_GPU fdetector; cv::gpu::GpuMat image; std::vector<cv::KeyPoint> keypoints; std::vector<float> descriptors; ASSERT_NO_THROW( fdetector(image, cv::gpu::GpuMat(), keypoints, descriptors); );
TEST_P(Merge, Accuracy) { if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) return; PRINT_PARAM(devInfo); PRINT_TYPE(type); PRINT_PARAM(size); cv::Mat dst; ASSERT_NO_THROW( std::vector<cv::gpu::GpuMat> dev_src; cv::gpu::GpuMat dev_dst; for (size_t i = 0; i < src.size(); ++i) dev_src.push_back(cv::gpu::GpuMat(src[i])); cv::gpu::merge(dev_src, dev_dst); dev_dst.download(dst); );
TEST_P(StereoBlockMatching, Regression) { PRINT_PARAM(devInfo); cv::Mat disp; ASSERT_NO_THROW( cv::gpu::GpuMat dev_disp; cv::gpu::StereoBM_GPU bm(0, 128, 19); bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp); dev_disp.download(disp); );
int main(int argc, char *argv[]) { //global timing clock_t start_g=clock(), diff_g; //////////////////////////test function starts\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ char buffer[1024]; FILE *fp = fopen("dist.in", "r"); int num, i; char comment[20]; char arr_data[800]; int fin_num; for(i=0; i<799; i++){arr_data[i] = 'x';} int run = 0; //read file into num of test, comments and number char array while (fgets(buffer, sizeof(buffer), fp) != NULL) { sscanf(buffer, "%i;%s %s", &num, comment, arr_data); printf( "\n%i: %s\n", num, arr_data ); int k = 0; //count the number of numbers in the char array int num_count = 1; //one comma less then numbers while(arr_data[k] != 0 ) { if(arr_data[k] == ',') {num_count++;} k++; } printf("Nums in the array: %i", num_count); //initialise double array int data[num_count]; // = {[0 ... num_coun] = 0}; //converting char array to int array int acc_len = 0; for(i=0; i<num_count; i++){ fin_num = 0; int num_len = 0; while(arr_data[acc_len+num_len] != ',' && arr_data[acc_len+num_len] != 0){num_len++;} //printf("\n%i's num lenght is %i ,", i, num_len); acc_len = acc_len + num_len +1; //printf(" start of next number is %i", acc_len); int decim; for(decim = acc_len - num_len -1; decim < acc_len -1; decim++){ int d = arr_data[decim] - '0'; int pow_c; int out = 1; for(pow_c = 0; pow_c <acc_len-decim-2; pow_c++) {out = out*10;} //printf("\nNumber %i for %i", out*d, d); //(acc_len-decim-2) fin_num = fin_num + out*d; //printf("\nResulting number: \n%i on inter %i", fin_num, decim); if(decim == acc_len -2) { data[i] = fin_num; //printf("NUM FROM ARRAY: %i", data[i]); } } //printf("\n"); } printf("\nPrinting array as int array: "); for(i=0; i<num_count; i++){ printf("%i,", data[i]);} printf("\n"); //transferring data to X array int X[num_count]; for(i=0; i<num_count; i++){ X[i] = data[i];} //////////////////////////end of file to array parsing\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ int x_n = (int)(sizeof(X)/sizeof(*X)); int depth = (int) ((log(x_n)+0.1)/log(2)); double tree[depth][x_n]; double cdf[x_n]; int histogram[sizeof(X)/sizeof(*X)] ; int ddd; for (ddd=0; ddd<x_n; ddd++) {histogram[ddd] =0;} int hist[sizeof(X)/sizeof(*X)] ; int step_size; int num_of_points; int position_num; int i, j; //pdf to cdf cdf[0] = X[0]; for (i = 1; i < x_n; i++) { cdf[i] = cdf[i - 1] + X[i]; } //normalised cdf for (i = 0; i < x_n; i++) { cdf[i] = cdf[i]/cdf[x_n-1]; } //print cdf printf("cdf: "); for(i = 0; i < x_n; i++) { printf("%g ", cdf[i]); } printf("\n"); // cdf to tree array printf("TREE OUTPUT:\n "); for(i = 0; i < depth; i++) { step_size = x_n/pow(2, i); num_of_points = pow(2, i); position_num; for(j = 0; j < num_of_points; j++) { if(j == 0) {position_num = step_size *(j + 1)* 0.5 - 1;} else {position_num = step_size *j + step_size * 0.5 - 1;} tree[i][j] = cdf[position_num]; printf(" %g |", tree[i][j]); } printf("\n"); } printf("\n"); //tree array check /* for ( i = 0; i < depth; i++ ) { printf("\n"); for ( j = 0; j < x_n; j++ ) { printf("T[%d][%d] = %f ", i,j, tree[i][j] ); } } */ // tree walk //int err_count = 0; int jj; //global timing //sgenrand(time(NULL)); int curr_pos, check; int chunk; /* Repeat experiment in chunks. */ srand(SEED); printf("# Info: $Header: /home/ma/p/pruess/.cvsroot/manna_range/dmitry_20151021/manna_stack_clean_edited.c,v 1.2 2015/10/21 11:37:00 pruess Exp $\n"); preamble(argc, argv); PRINT_PARAM(SEED, "%lu"); PRINT_PARAM(LENGTH, "%lu"); PRINT_PARAM(DROP_LOCATION, "%lu"); PRINT_PARAM(total_malloced, "%lli"); printf("# Info: Expected avalanche size: <s>(x) = 1+(1/2) (<s>(x+1)+<s>(x-1)), BC <s>(0)=0, <s>(L+1)=0, solved by <s>(x)=(L+1-x)x/2.\n"); printf("# Info: Here L=LENGTH=%lu and x=DROP_LOCATION+1=%lu, so expect %g\n", LENGTH, DROP_LOCATION+1, ((double)(DROP_LOCATION+1))*((double)(LENGTH-DROP_LOCATION))/2.); for (chunk=1; ((chunk<=NUM_CHUNKS) || (NUM_CHUNKS<0)); chunk++) { MOMENTS_INIT(size); for (drop = 0; drop < N_ROLLS; drop++) { // big droppping cycle long long int size=0; #if (0) #define PUSH(a) stack[stack_used++]=(a) #define POP(a) (a)=stack[--stack_used] if(lattice[DROP_LOCATION] == 0) { lattice[DROP_LOCATION] = 1; } else { PUSH(DROP_LOCATION); PUSH(DROP_LOCATION); lattice[DROP_LOCATION] = 0; size++; } /* If validated, optimse by turning stack operations into macros, * optime random number drawing (rather than having doubles in the tree * have integers there and draw an integer to compare against), * optimise the shuffling of particles. * * I have added MOMENT macros for size. */ while(stack_used != 0) { POP(curr_pos); /* This code with the "check" looks clumsy. I suppose * you are "following through" topplings? I would think * there is no point doing this later. Anyway, we validate * this code and take it from there. */ do { double test_num = ((double)rand())/((double)RAND_MAX); //tree walk int x_pos = 0, y_pos = 0; for(y_pos = 0; y_pos < depth ; y_pos++) { if (test_num > tree[y_pos][x_pos]) {x_pos = (x_pos+1) * 2 - 1; } else {x_pos = x_pos * 2;} //printf("\nThe current position is : %i, %i", y_pos, x_pos); } curr_pos = curr_pos+ x_pos-1; //move_ball(curr_pos); //printf("\nshift: %i, RAND: %f", x_pos-1, test_num); if((curr_pos>=0) && (curr_pos<LENGTH)) { if(lattice[curr_pos] == 0) { lattice[curr_pos] = 1; } else { size++; lattice[curr_pos] = 0; PUSH(curr_pos); } } else {break;} }while( (lattice[curr_pos] != 1)); }/* end of while(stack_used != 0) look */ #endif #if (1) { int npos; #define PUSH(a) stack[stack_used++]=(a) #define POP(a) (a)=stack[--stack_used] if (lattice[DROP_LOCATION]++==1) { PUSH(DROP_LOCATION); while(stack_used) { POP(curr_pos); do { size++; lattice[curr_pos]-=2; double test_num = ((double)rand())/((double)RAND_MAX); // start of tree walk //tree walk int x_pos = 0, y_pos = 0; for(y_pos = 0; y_pos < depth ; y_pos++) { if (test_num > tree[y_pos][x_pos]) {x_pos = (x_pos+1) * 2 - 1; } else {x_pos = x_pos * 2;} //printf("\nThe current position is : %i, %i", y_pos, x_pos); } npos = curr_pos+ x_pos-1; //move_ball(curr_pos); //end of tree walk if ((npos>=0) && (npos<LENGTH)) { if (lattice[npos]++==1) {PUSH(npos);} } test_num = ((double)rand())/((double)RAND_MAX); // start of tree walk //tree walk x_pos = 0, y_pos = 0; for(y_pos = 0; y_pos < depth ; y_pos++) { if (test_num > tree[y_pos][x_pos]) {x_pos = (x_pos+1) * 2 - 1; } else {x_pos = x_pos * 2;} //printf("\nThe current position is : %i, %i", y_pos, x_pos); } npos = curr_pos+ x_pos-1; //move_ball(curr_pos); //end of tree walk if ((npos>=0) && (npos<LENGTH)) { if (lattice[npos]++==1) {PUSH(npos);} } } while (lattice[curr_pos]>1); } } } #endif //printf("size is %i\n", size); MOMENTS(size,size); } /* end of iterations loop */ MOMENTS_OUT(size); } /* chunk */ postamble(); } }
int main(int argc, char *argv[]) { //sgenrand(time(NULL)); int k, curr_pos, check; int chunk; /* Repeat experiment in chunks. */ srand(SEED); printf("# Info: $Header: /home/ma/p/pruess/.cvsroot/manna_range/dmitry_20151021/manna_stack_clean_edited.c,v 1.2 2015/10/21 11:37:00 pruess Exp $\n"); preamble(argc, argv); PRINT_PARAM(SEED, "%lu"); PRINT_PARAM(LENGTH, "%lu"); PRINT_PARAM(DROP_LOCATION, "%lu"); PRINT_PARAM(total_malloced, "%lli"); printf("# Info: Expected avalanche size: <s>(x) = 1+(1/2) (<s>(x+1)+<s>(x-1)), BC <s>(0)=0, <s>(L+1)=0, solved by <s>(x)=(L+1-x)x/2.\n"); printf("# Info: Here L=LENGTH=%lu and x=DROP_LOCATION+1=%lu, so expect %g\n", LENGTH, DROP_LOCATION+1, ((double)(DROP_LOCATION+1))*((double)(LENGTH-DROP_LOCATION))/2.); for (chunk=1; ((chunk<=NUM_CHUNKS) || (NUM_CHUNKS<0)); chunk++) { MOMENTS_INIT(size); for (drop = 0; drop < N_ROLLS; drop++) { // big droppping cycle size=0; /* printf("(%i.)", drop); for(k = 0; k<LENGTH; k++) { printf("\%i", lattice[k]); } printf("\n"); */ #if (1) if(check_cell(DROP_LOCATION) == 0) { lattice[DROP_LOCATION] = 1; } else { stack_push(DROP_LOCATION); stack_push(DROP_LOCATION); lattice[DROP_LOCATION] = 0; } /* If validated, optimse by turning stack operations into macros, * optime random number drawing (rather than having doubles in the tree * have integers there and draw an integer to compare against), * optimise the shuffling of particles. * * I have added MOMENT macros for size. */ while(stack_used != 0) { curr_pos = stack_pop(); /* This code with the "check" looks clumsy. I suppose * you are "following through" topplings? I would think * there is no point doing this later. Anyway, we validate * this code and take it from there. */ do { curr_pos = move_ball(curr_pos); if(curr_pos >= LENGTH || curr_pos < 0) { check = 0 ; } /* Why not just "else" instead of the "if"? */ if(curr_pos < LENGTH && curr_pos >= 0) { check = check_cell(curr_pos); if (check == 1) { stack_push(curr_pos); } else { check = 0; } } }while(check != 0); }/* end of while(stack_used != 0) look */ #endif #if (0) { int npos; #define PUSH(a) stack[stack_used++]=(a) #define POP(a) (a)=stack[--stack_used] if (lattice[DROP_LOCATION]++==1) { PUSH(DROP_LOCATION); while(stack_used) { size++; POP(curr_pos); do { lattice[curr_pos]-=2; npos=curr_pos+ ( (rand()>RAND_MAX/2) ? 1 : -1); if ((npos>=0) && (npos<LENGTH)) { if (lattice[npos]++==1) {PUSH(npos);} } if ((npos>=0) && (npos<LENGTH)) { if (lattice[npos]++==1) {PUSH(npos);} } } while (lattice[curr_pos]>1); } } } #endif //printf("size is %i\n", size); MOMENTS(size,size); } /* end of iterations loop */ MOMENTS_OUT(size); } /* chunk */ }
int main(int argc, char** argv) { printf("*** DRAM to DRAM copy microbenchmark - baremtal ***\n"); PRINT_PARAM(REGION_SIZE); PRINT_PARAM(ITERATIONS); int i; unsigned long j; // Allocate the src and dst regions //volatile uint8_t * const src = (uint8_t *) 0; //volatile uint8_t * const dst = (uint8_t *) src + REGION_SIZE; for (i = 0; i < ITERATIONS; i++) { // Source and destination addresses //unsigned long s = 0; //unsigned long d = 0; // Start timer //time_t start, end; //start=clock(); for (j = 0; j < REGION_SIZE; j++) { #ifdef READ_WRIE #ifdef RAND_READ s = rand() % REGION_SIZE; #else s += STRIDE; if (s>=REGION_SIZE) s = s%REGION_SIZE+1; #endif #ifdef RAND_WRITE d = rand() % REGION_SIZE; #else d += STRIDE; if (d>=REGION_SIZE) d = d%REGION_SIZE+1; #endif // copy the chunk dst[d] = src[s]; #elif defined(READ) // TODO #else // TODO #endif } // Stop timer, print report //end=clock(); //double secs = ((end-start)/CLOCKS_PER_SEC); //double usecs_per_byte = (secs / REGION_SIZE) * MILLION; //printf("Run %d\t = %f s (%.9f us/B)\n", i, secs, usecs_per_byte); } return 0; }
int main(int argc, char** argv) { printf("*** DRAM to DRAM copy microbenchmark - with OS ***\n"); PRINT_PARAM(ITERATIONS); PRINT_PARAM(CHUNK_SIZE); PRINT_PARAM(REGION_SIZE); PRINT_PARAM(REGION_CHUNKS); PRINT_PARAM(READ_RAND); PRINT_PARAM(WRITE_RAND); #if defined(READ_SEQ) || defined(WRITE_SEQ) PRINT_PARAM(STRIDE_SIZE); PRINT_PARAM(STRIDE_CHUNKS); #endif int i; unsigned long j; // Allocate the src and dst regions // (uint16_t because chunk size is 16B) uint16_t *src = (uint16_t *) malloc(REGION_SIZE); assert(src); uint16_t *dst = (uint16_t *) malloc(REGION_SIZE); assert(dst); // Source and destination addresses unsigned long s = 0; unsigned long d = 0; // Timer //time_t start, end; struct timeval tvs, tve; // Disable caching //dCacheDisable(); // Start timer //start=clock(); gettimeofday(&tvs, NULL); for (i = 0; i < ITERATIONS; i++) { for (j = 0; j < REGION_CHUNKS; j++) { #ifdef READ_WRITE //printf("j=%lu \t dst addr=%p \t src addr=%p\n", j, dst+d, src+s); // Copy 16B memcpy(dst, src, CHUNK_SIZE); //dst[d] = src[s]; #ifdef RAND_READ s = rand() % REGION_CHUNKS; #else s += STRIDE_CHUNKS; if (s >= REGION_CHUNKS) s = s % REGION_CHUNKS + 1; #endif #ifdef RAND_WRITE d = rand() % REGION_SIZE; #else d += STRIDE_CHUNKS; if (d >= REGION_CHUNKS) d = d % REGION_CHUNKS + 1; #endif #elif defined(READ) // TODO #else // TODO #endif } // Reset addresses s = 0; d = 0; // Flush cache // TODO } // Stop timer, print report //end=clock(); gettimeofday(&tve, NULL); double secs = tve.tv_usec - tvs.tv_usec; //double secs = ((end-start)/CLOCKS_PER_SEC); double usecs_per_byte = (secs / REGION_SIZE) * MILLION; //printf("Run %d\t = %f s (%.9f us/B)\n", i, secs, usecs_per_byte); printf("total time = %f s (%.9f us/B)\n", secs, usecs_per_byte); // Free memory resources free(src); free(dst); return 0; }