void Decode(config * conf){ #ifdef ENABLE_PARSEC_HOOKS __parsec_roi_begin(); #endif RecvBlock(conf); Decompress(NULL); CheckCache(NULL); if (strcmp(conf->outfile, "") == 0) Reassemble(NULL); else Reassemble(conf->outfile); #ifdef ENABLE_PARSEC_HOOKS __parsec_roi_end(); #endif }
int main(int argc, char *argv[]) { #ifdef PARSEC_VERSION #define __PARSEC_STRING(x) #x #define __PARSEC_XSTRING(x) __PARSEC_STRING(x) std::cout << "PARSEC Benchmark Suite Version "__PARSEC_XSTRING(PARSEC_VERSION) << std::endl << std::flush; #else std::cout << "PARSEC Benchmark Suite" << std::endl << std::flush; #endif //PARSEC_VERSION #ifdef ENABLE_PARSEC_HOOKS __parsec_bench_begin(__parsec_fluidanimate); #endif if(argc < 4 || argc >= 6) { std::cout << "Usage: " << argv[0] << " <threadnum> <framenum> <.fluid input file> [.fluid output file]" << std::endl; return -1; } int threadnum = atoi(argv[1]); int framenum = atoi(argv[2]); //Check arguments if(threadnum != 1) { std::cerr << "<threadnum> must be 1 (serial version)" << std::endl; return -1; } if(framenum < 1) { std::cerr << "<framenum> must at least be 1" << std::endl; return -1; } #ifdef ENABLE_CFL_CHECK std::cout << "WARNING: Check for Courant–Friedrichs–Lewy condition enabled. Do not use for performance measurements." << std::endl; #endif InitSim(argv[3]); #ifdef ENABLE_VISUALIZATION InitVisualizationMode(&argc, argv, &AdvanceFrame, &numCells, &cells, &cnumPars); #endif #ifndef ENABLE_VISUALIZATION //core of benchmark program (the Region-of-Interest) #ifdef ENABLE_PARSEC_HOOKS __parsec_roi_begin(); #endif for(int i = 0; i < framenum; ++i) { AdvanceFrame(); } #ifdef ENABLE_PARSEC_HOOKS __parsec_roi_end(); #endif #else //ENABLE_VISUALIZATION Visualize(); #endif //ENABLE_VISUALIZATION if(argc > 4) SaveFile(argv[4]); CleanUpSim(); #ifdef ENABLE_PARSEC_HOOKS __parsec_bench_end(); #endif return 0; }
DWORD WINAPI bs_thread(LPVOID tid_ptr){ #else int bs_thread(void *tid_ptr) { #endif int i, j; fptype price; fptype priceDelta; int tid = *(int *)tid_ptr; int start = tid * (numOptions / nThreads); int end = start + (numOptions / nThreads); for (j=0; j<NUM_RUNS; j++) { #ifdef ENABLE_OPENMP #pragma omp parallel for for (i=0; i<numOptions; i++) { #else //ENABLE_OPENMP for (i=start; i<end; i++) { #endif //ENABLE_OPENMP /* Calling main function to calculate option value based on * Black & Sholes's equation. */ price = BlkSchlsEqEuroNoDiv( sptprice[i], strike[i], rate[i], volatility[i], otime[i], otype[i], 0); prices[i] = price; #ifdef ERR_CHK priceDelta = data[i].DGrefval - price; if( fabs(priceDelta) >= 1e-4 ){ printf("Error on %d. Computed=%.5f, Ref=%.5f, Delta=%.5f\n", i, price, data[i].DGrefval, priceDelta); numError ++; } #endif } } return 0; } int main (int argc, char **argv) { FILE *file; int i; int loopnum; fptype * buffer; int * buffer2; int rv; #ifdef PARSEC_VERSION #define __PARSEC_STRING(x) #x #define __PARSEC_XSTRING(x) __PARSEC_STRING(x) printf("PARSEC Benchmark Suite Version "__PARSEC_XSTRING(PARSEC_VERSION)"\n"); fflush(NULL); #else printf("PARSEC Benchmark Suite\n"); fflush(NULL); #endif //PARSEC_VERSION #ifdef ENABLE_PARSEC_HOOKS __parsec_bench_begin(__parsec_blackscholes); #endif if (argc != 4) { printf("Usage:\n\t%s <nthreads> <inputFile> <outputFile>\n", argv[0]); exit(1); } nThreads = atoi(argv[1]); char *inputFile = argv[2]; char *outputFile = argv[3]; //Read input data from file file = fopen(inputFile, "r"); if(file == NULL) { printf("ERROR: Unable to open file %s.\n", inputFile); exit(1); } rv = fscanf(file, "%i", &numOptions); if(rv != 1) { printf("ERROR: Unable to read from file %s.\n", inputFile); fclose(file); exit(1); } if(nThreads > numOptions) { printf("WARNING: Not enough work, reducing number of threads to match number of options.\n"); nThreads = numOptions; } #if !defined(ENABLE_THREADS) && !defined(ENABLE_OPENMP) if(nThreads != 1) { printf("Error: <nthreads> must be 1 (serial version)\n"); exit(1); } #endif // alloc spaces for the option data data = (OptionData*)malloc(numOptions*sizeof(OptionData)); prices = (fptype*)malloc(numOptions*sizeof(fptype)); for ( loopnum = 0; loopnum < numOptions; ++ loopnum ) { rv = fscanf(file, "%f %f %f %f %f %f %c %f %f", &data[loopnum].s, &data[loopnum].strike, &data[loopnum].r, &data[loopnum].divq, &data[loopnum].v, &data[loopnum].t, &data[loopnum].OptionType, &data[loopnum].divs, &data[loopnum].DGrefval); if(rv != 9) { printf("ERROR: Unable to read from file %s with loopnum %d.\n", inputFile, loopnum); fclose(file); exit(1); } } rv = fclose(file); if(rv != 0) { printf("ERROR: Unable to close file %s.\n", inputFile); exit(1); } #ifdef ENABLE_THREADS // pthread_mutexattr_init( &_M4_normalMutexAttr); // pthread_mutexattr_settype( &_M4_normalMutexAttr, PTHREAD_MUTEX_NORMAL); _M4_numThreads = nThreads; { int _M4_i; for ( _M4_i = 0; _M4_i < MAX_THREADS; _M4_i++) { _M4_threadsTable[_M4_i] = -1; } } ; #endif printf("Num of Options: %d\n", numOptions); printf("Num of Runs: %d\n", NUM_RUNS); #define PAD 256 #define LINESIZE 64 buffer = (fptype *) malloc(5 * numOptions * sizeof(fptype) + PAD); sptprice = (fptype *) (((unsigned long long)buffer + PAD) & ~(LINESIZE - 1)); strike = sptprice + numOptions; rate = strike + numOptions; volatility = rate + numOptions; otime = volatility + numOptions; buffer2 = (int *) malloc(numOptions * sizeof(fptype) + PAD); otype = (int *) (((unsigned long long)buffer2 + PAD) & ~(LINESIZE - 1)); for (i=0; i<numOptions; i++) { otype[i] = (data[i].OptionType == 'P') ? 1 : 0; sptprice[i] = data[i].s; strike[i] = data[i].strike; rate[i] = data[i].r; volatility[i] = data[i].v; otime[i] = data[i].t; } printf("Size of data: %d\n", numOptions * (sizeof(OptionData) + sizeof(int))); #ifdef ENABLE_PARSEC_HOOKS __parsec_roi_begin(); #endif #ifdef ENABLE_THREADS int tids[nThreads]; pthread_t thread_table[nThreads]; for(i=0; i<nThreads; i++) { tids[i]=i; } for(i=0; i<nThreads; i++) { // fprintf(stderr, "create %d thread\n", i); pthread_create(&thread_table[i],NULL,(void *(*)(void *))bs_thread,(void *)&tids[i]); } for(i=0; i<nThreads; i++) { pthread_join(thread_table[i], NULL); } #else//ENABLE_THREADS #ifdef ENABLE_OPENMP { int tid=0; omp_set_num_threads(nThreads); bs_thread(&tid); } #else //ENABLE_OPENMP #ifdef WIN32 if (nThreads > 1) { HANDLE threads[MAX_THREADS]; int nums[MAX_THREADS]; for(i=0; i<nThreads; i++) { nums[i] = i; threads[i] = CreateThread(0, 0, bs_thread, &nums[i], 0, 0); } WaitForMultipleObjects(nThreads, threads, TRUE, INFINITE); } else #endif { int tid=0; bs_thread(&tid); } #endif //ENABLE_OPENMP #endif //ENABLE_THREADS #ifdef ENABLE_PARSEC_HOOKS __parsec_roi_end(); #endif //Write prices to output file file = fopen(outputFile, "w"); if(file == NULL) { printf("ERROR: Unable to open file %s.\n", outputFile); exit(1); } rv = fprintf(file, "%i\n", numOptions); if(rv < 0) { printf("ERROR: Unable to write to file %s.\n", outputFile); fclose(file); exit(1); } for(i=0; i<numOptions; i++) { rv = fprintf(file, "%.18f\n", prices[i]); if(rv < 0) { printf("ERROR: Unable to write to file %s.\n", outputFile); fclose(file); exit(1); } } rv = fclose(file); if(rv != 0) { printf("ERROR: Unable to close file %s.\n", outputFile); exit(1); } #ifdef ERR_CHK printf("Num Errors: %d\n", numError); #endif free(data); free(prices); #ifdef ENABLE_PARSEC_HOOKS __parsec_bench_end(); #endif return 0; }
void Frame() { long starttime,stoptime,exectime,i; Init_Options(); printf("*****Entering init_decomposition with num_nodes = %ld\n",num_nodes); fflush(stdout); Init_Decomposition(); printf("*****Exited init_decomposition with num_nodes = %ld\n",num_nodes); fflush(stdout); Global = (struct GlobalMemory *)NU_MALLOC(sizeof(struct GlobalMemory),0); BARINIT(Global->SlaveBarrier, num_nodes); BARINIT(Global->TimeBarrier, num_nodes); LOCKINIT(Global->IndexLock); LOCKINIT(Global->CountLock); ALOCKINIT(Global->QLock,MAX_NUMPROC+1); /* load dataset from file to each node */ #ifndef RENDER_ONLY CLOCK(starttime); Load_Map(filename); CLOCK(stoptime); mclock(stoptime,starttime,&exectime); printf("wall clock execution time to load map: %lu ms\n", exectime); #endif CLOCK(starttime); #ifndef RENDER_ONLY Compute_Normal(); #ifdef PREPROCESS Store_Normal(filename); #endif #else Load_Normal(filename); #endif CLOCK(stoptime); mclock(stoptime,starttime,&exectime); printf("wall clock execution time to compute normal: %lu ms\n", exectime); CLOCK(starttime); #ifndef RENDER_ONLY Compute_Opacity(); #ifdef PREPROCESS Store_Opacity(filename); #endif #else Load_Opacity(filename); #endif CLOCK(stoptime); mclock(stoptime,starttime,&exectime); printf("wall clock execution time to compute opacity: %lu ms\n", exectime); Compute_Pre_View(); shd_length = LOOKUP_SIZE; Allocate_Shading_Table(&shd_address,shd_length); /* allocate space for image */ image_len[X] = frust_len; image_len[Y] = frust_len; image_length = image_len[X] * image_len[Y]; Allocate_Image(&image_address,image_length); if (num_nodes == 1) { block_xlen = image_len[X]; block_ylen = image_len[Y]; num_blocks = 1; num_xblocks = 1; num_yblocks = 1; image_block = image_address; } else { num_xblocks = ROUNDUP((float)image_len[X]/(float)block_xlen); num_yblocks = ROUNDUP((float)image_len[Y]/(float)block_ylen); num_blocks = num_xblocks * num_yblocks; Lallocate_Image(&image_block,block_xlen*block_ylen); } CLOCK(starttime); #ifndef RENDER_ONLY Compute_Octree(); #ifdef PREPROCESS Store_Octree(filename); #endif #else Load_Octree(filename); #endif CLOCK(stoptime); mclock(stoptime,starttime,&exectime); printf("wall clock execution time to compute octree: %lu ms\n", exectime); #ifdef PREPROCESS return; #endif if (adaptive) { printf("1.\n"); for (i=0; i<NI; i++) { mask_image_len[i] = image_len[i]; } mask_image_length = image_length; Allocate_MImage(&mask_image_address, mask_image_length); if (num_nodes == 1) mask_image_block = (PIXEL *)mask_image_address; else Lallocate_Image(&mask_image_block, block_xlen*block_ylen); printf("2.\n"); } #ifndef RENDER_ONLY Deallocate_Map(&map_address); #endif Global->Index = NODE0; printf("\nRendering...\n"); //printf("node\tframe\ttime\titime\trays\thrays\tsamples trilirped\n"); #ifdef ENABLE_PARSEC_HOOKS __parsec_roi_begin(); #endif CREATE(Render_Loop, num_nodes); }