int main(){ Timing timer; #ifdef _DEBUG int size = 4;{ #else for(int size=1; size>0; size*=2){ #endif std::cout << "size: " << size << '\n'; const int times = 10; Matrix a, b; a.resize(size); b.resize(size); a.randomize(); b.randomize(); timer.setDivisor(times); timer.start(); for(int i=0; i<times; i++){ Matrix c = MatrixMultiplication::recursive(a, b); #ifdef _DEBUG c.print(); #endif } timer.end(); timer.reportCPUtime(); timer.start(); for(int i=0; i<times; i++){ Matrix c = MatrixMultiplication::strassen(a, b); #ifdef _DEBUG c.print(); #endif } timer.end(); timer.reportCPUtime(); } return system("pause"); }
int main() { /******************************* [ signal ] ******************************/ Type a = 0; Type b = Ls-1; Vector<Type> t = linspace(a,b,Ls) / Type(Fs); Vector<Type> s = sin( Type(400*PI) * pow(t,Type(2.0)) ); /******************************** [ widow ] ******************************/ a = 0; b = Type(Lg-1); Type u = (Lg-1)/Type(2); Type r = Lg/Type(8); t = linspace(a,b,Lg); Vector<Type> g = gauss(t,u,r); g = g/norm(g); /********************************* [ WFT ] *******************************/ Type runtime = 0; Timing cnt; cout << "Taking windowed Fourier transform." << endl; cnt.start(); Matrix< complex<Type> > coefs = wft( s, g ); cnt.stop(); runtime = cnt.read(); cout << "The running time = " << runtime << " (ms)" << endl << endl; /******************************** [ IWFT ] *******************************/ cout << "Taking inverse windowed Fourier transform." << endl; cnt.start(); Vector<Type> x = iwft( coefs, g ); cnt.stop(); runtime = cnt.read(); cout << "The running time = " << runtime << " (ms)" << endl << endl; cout << "The relative error is : " << "norm(s-x) / norm(s) = " << norm(s-x)/norm(s) << endl << endl; return 0; }
int main() { /******************************* [ signal ] ******************************/ Vector<double> t = linspace( 0.0, (Ls-1)/fs, Ls ); Vector<double> st = sin( 200*PI*pow(t,2.0) ); st = st-mean(st); /******************************** [ CWT ] ********************************/ Matrix< complex<double> > coefs; CWT<double> wavelet("morlet"); wavelet.setScales( fs, fs/Ls, fs/2 ); Timing cnt; double runtime = 0.0; cout << "Taking continuous wavelet transform(Morlet)." << endl; cnt.start(); coefs = wavelet.cwtC(st); cnt.stop(); runtime = cnt.read(); cout << "The running time = " << runtime << " (ms)" << endl << endl; /******************************** [ ICWT ] *******************************/ cout << "Taking inverse continuous wavelet transform." << endl; cnt.start(); Vector<double> xt = wavelet.icwtC(coefs); cnt.stop(); runtime = cnt.read(); cout << "The running time = " << runtime << " (ms)" << endl << endl; cout << "The relative error is : " << endl; cout << "norm(st-xt) / norm(st) = " << norm(st-xt)/norm(st) << endl; cout << endl << endl; /******************************* [ signal ] ******************************/ Vector<float> tf = linspace( float(0.0), (Ls-1)/float(fs), Ls ); Vector<float> stf = sin( float(200*PI) * pow(tf,float(2.0) ) ); stf = stf-mean(stf); /******************************** [ CWT ] ********************************/ CWT<float> waveletf("mexiHat"); waveletf.setScales( float(fs), float(fs/Ls), float(fs/2), float(0.25) ); runtime = 0.0; cout << "Taking continuous wavelet transform(Mexican Hat)." << endl; cnt.start(); Matrix<float> coefsf = waveletf.cwtR(stf); cnt.stop(); runtime = cnt.read(); cout << "The running time = " << runtime << " (ms)" << endl << endl; /******************************** [ ICWT ] *******************************/ cout << "Taking inverse continuous wavelet transform." << endl; cnt.start(); Vector<float> xtf = waveletf.icwtR(coefsf); cnt.stop(); runtime = cnt.read(); cout << "The running time = " << runtime << " (ms)" << endl << endl; cout << "The relative error is : " << endl; cout << "norm(st-xt) / norm(st) = " << norm(stf-xtf)/norm(stf) << endl << endl; return 0; }
static inline Timing now() { Timing t; t.start(); return t; }
int main(int argc, char* argv[]){ // Initialize MPI // Find out my identity in the default communicator MPI_Init(&argc, &argv); int rank; MPI_Comm_rank(MPI_COMM_WORLD, &rank); //used to store the final results std::vector<result_t> finalResults; //init the k value int k = 0; if(argc > 1){ try{ k = atoi(argv[1]); if(k < 0){ throw "just need to throw a random exception to catch`"; } } catch(...){ std::cerr<<"k must be a positive integer"<<std::endl; return 0; } } //init the custom openmpi datatype MPI_Datatype ResultMpiType; //wrapper function to set up the custom type createMPIResultStruct(&ResultMpiType); // Master if (rank == 0){ // ++++++++++++++++++++++++++++++ // Master process // ++++++++++++++++++++++++++++++ // check the arugmumants if (argc < 2){ std::cout << "Usage: " << argv[0] << " [k value] [directory path:default(/cluster)]" << std::endl; return 0; } std::string folderPath; //set the default for the folder to use if(argc == 2){ folderPath = "/cluster"; } else{ folderPath = argv[2]; } Directory dir; if(!dir.set_path(folderPath)){ std::cerr<<"Directory either not found or not a directory"<<std::endl; return 0; } //test for a correct k value try{ k = atoi(argv[1]); if(k < 0){ throw "just need to throw a random exception to catch`"; } } catch(...){ std::cerr<<"k must be a positive integer"<<std::endl; return 0; } auto test = dir.get_files(); searchVector_t searchVector; Timing wallClock; double timeResults[NUM_TIME_RESULTS]; //initlize timing holder for(int i = 0; i < NUM_TIME_RESULTS; i++){ timeResults[i] = 0; } wallClock.start(); //get the first vector the first file in the the directory as the search vector if(!getFirstVector(test.at(0),&searchVector)){ std::cerr << "Couldn't get the search vector" << std::endl; return 0; } std::cout << "Sending work to workers" << std::endl; sendWork(test,&ResultMpiType,k,&finalResults,searchVector.data,timeResults); //wait for the workers to finish to collect the results MPI_Barrier(MPI_COMM_WORLD); wallClock.end(); std::cout<<"wallClock time: "<<wallClock.get_elapse()<<std::endl; //get com size for timming results int threadCount; MPI_Comm_size(MPI_COMM_WORLD, &threadCount); //creat a vector fromt the timing results std::vector<double> finalTimingVec; finalTimingVec.push_back(threadCount); finalTimingVec.push_back(k); finalTimingVec.push_back(wallClock.get_elapse()); finalTimingVec.insert(finalTimingVec.end(),timeResults,timeResults+NUM_TIME_RESULTS); //output the timing vector to the timing for all the tests output_timing_vector_to_file("times.csv",finalTimingVec,1); //output the final results to a vector output_result_vector_to_file("results.csv", &finalResults); } else{ // ++++++++++++++++++++++++++++++ // Workers // ++++++++++++++++++++++++++++++ doWork(&ResultMpiType,k); //used for the barrier in master MPI_Barrier(MPI_COMM_WORLD); } MPI_Type_free(&ResultMpiType); //Shut down MPI MPI_Finalize(); return 1; } // END of main
int doWork(MPI_Datatype* ResultMpiType,const int k){ int rank; MPI_Comm_rank(MPI_COMM_WORLD, &rank); int MAX_RESULT_SIZE = k; char msg[MAX_MSG_SIZE]; float cmpData[SEARCH_VECTOR_SIZE]; double times[2]; MPI_Status status; Timing parserTime; Timing searchTime; Timing workWallTime; workWallTime.start(); std::chrono::duration<double> read_time_elapse; MPI_Recv(cmpData, SEARCH_VECTOR_SIZE, MPI_FLOAT, 0, MPI_ANY_TAG, MPI_COMM_WORLD, &status); if(status.MPI_TAG != SEARCH_VECTOR){ std::cout<< rank << " recieved terminate signal" << std::endl; return 0; } while (1) { // Receive a message from the master MPI_Recv(msg, /* message buffer */ MAX_MSG_SIZE, /* buffer size */ MPI_CHAR, /* data item is an integer */ 0, /* Receive from master */ MPI_ANY_TAG, MPI_COMM_WORLD, /* default communicator */ &status); // Check if we have been terminated by the master // exit from the worker loop if (status.MPI_TAG == TERMINATE) { std::cout<< rank << " recieved terminate signal" << std::endl; return 0; } std::shared_ptr<MapString_t> nameMap(new MapString_t); std::vector<result_t> results; std::shared_ptr<std::vector<float>> dataVector(new std::vector<float>); Parser p(nameMap,dataVector); parserTime.start(); if(!p.parse_file(msg,&read_time_elapse)){ std::cerr<<"could not parse file: "<<msg<<std::endl; return 0; } parserTime.end(); searchTime.start(); int lineLength = p.get_line_length(); int index = 0; for(auto& file : *nameMap){ results.push_back(result_t()); results.at(index).distance = findDist(lineLength, dataVector,file.second,cmpData); strcpy(results.at(index).fileName,file.first.c_str()); index++; } std::sort(results.begin(),results.end(),resultPairSort); results.resize(MAX_RESULT_SIZE); searchTime.end(); MPI_Send(results.data(), /* message buffer */ MAX_RESULT_SIZE, /* buffer size */ *ResultMpiType, /* data item is an integer */ 0, /* destination process rank, the master */ RESULTS, /* user chosen message tag */ MPI_COMM_WORLD); workWallTime.end(); //add the times to an array to be sent to the master times[0] = parserTime.get_elapse(); times[1] = searchTime.get_elapse(); times[2] = workWallTime.get_elapse(); //send out the timing results to be compiled MPI_Send(times, NUM_TIME_RESULTS, MPI_DOUBLE, 0, TIMING, MPI_COMM_WORLD); } return 0; }
void main(void) { int i, k; Timing watch; Point3D mid, ext; float cubeHalfSide = 100.0f; float minSphereRadius; float minHalfBoxExtent; float maxSphereRadius; float maxHalfBoxExtent; // Note: Change the value of 'testCase' in [0, 4] to vary // the number of overlaps in the generated test data. int testCase = 0; switch (testCase) { case 0: minSphereRadius = 1.0f; minHalfBoxExtent = 1.0f; maxSphereRadius = 32.5f; maxHalfBoxExtent = 32.5f; break; case 1: minSphereRadius = 1.0f; minHalfBoxExtent = 1.0f; maxSphereRadius = 55.0f; maxHalfBoxExtent = 55.0f; break; case 2: minSphereRadius = 1.0f; minHalfBoxExtent = 1.0f; maxSphereRadius = 77.5f; maxHalfBoxExtent = 77.5f; break; case 3: minSphereRadius = 13.5f; minHalfBoxExtent = 13.5f; maxSphereRadius = 85.0f; maxHalfBoxExtent = 85.0f; break; case 4: minSphereRadius = 28.0f; minHalfBoxExtent = 28.0f; maxSphereRadius = 99.0f; maxHalfBoxExtent = 99.0f; break; default: minSphereRadius = 1.0f; minHalfBoxExtent = 1.0f; maxSphereRadius = 10.0f; maxHalfBoxExtent = 10.0f; } for (i = 0; i < NUMBER_OF_BV_PAIRS; i++) { sphereArray[i].r = getRandomScalar(minSphereRadius, maxSphereRadius); sphereArray[i].c.x = getRandomScalar(-cubeHalfSide + sphereArray[i].r, cubeHalfSide - sphereArray[i].r); sphereArray[i].c.y = getRandomScalar(-cubeHalfSide + sphereArray[i].r, cubeHalfSide - sphereArray[i].r); sphereArray[i].c.z = getRandomScalar(-cubeHalfSide + sphereArray[i].r, cubeHalfSide - sphereArray[i].r); ext.x = getRandomScalar(minHalfBoxExtent, maxHalfBoxExtent); ext.y = getRandomScalar(minHalfBoxExtent, maxHalfBoxExtent); ext.z = getRandomScalar(minHalfBoxExtent, maxHalfBoxExtent); mid.x = getRandomScalar(-cubeHalfSide + ext.x, cubeHalfSide - ext.x); mid.y = getRandomScalar(-cubeHalfSide + ext.y, cubeHalfSide - ext.y); mid.z = getRandomScalar(-cubeHalfSide + ext.z, cubeHalfSide - ext.z); boxArray[i].min.x = mid.x - ext.x; boxArray[i].min.y = mid.y - ext.y; boxArray[i].min.z = mid.z - ext.z; boxArray[i].max.x = mid.x + ext.x; boxArray[i].max.y = mid.y + ext.y; boxArray[i].max.z = mid.z + ext.z; } /* ==== Method 1 ==== */ noOverlaps[0] = 0; watch.start(); for (k=0; k < REPETITIONS; k++) { for (i = 0; i < NUMBER_OF_BV_PAIRS; i++) { noOverlaps[0] += overlapSphereAABB_Arvo(sphereArray[i], boxArray[i]); } } time[0] = watch.stop() / REPETITIONS; noOverlaps[0] /= REPETITIONS; printResult(algorithmName[0], noOverlaps[0], time[0]); /* ==== Method 2 ==== */ noOverlaps[1] = 0; watch.start(); for (k=0; k < REPETITIONS; k++) { for (i = 0; i < NUMBER_OF_BV_PAIRS; i++) { noOverlaps[1] += overlapSphereAABB_QRI(sphereArray[i], boxArray[i]); } } time[1] = watch.stop() / REPETITIONS; noOverlaps[1] /= REPETITIONS; printResult(algorithmName[1], noOverlaps[1], time[1]); /* ==== Method 3 ==== */ noOverlaps[2] = 0; watch.start(); for (k=0; k < REPETITIONS; k++) { for (i = 0; i < NUMBER_OF_BV_PAIRS; i++) { noOverlaps[2] += overlapSphereAABB_QRF(sphereArray[i], boxArray[i]); } } time[2] = watch.stop() / REPETITIONS; noOverlaps[2] /= REPETITIONS; printResult(algorithmName[2], noOverlaps[2], time[2]); /* ==== Method 4 ==== */ noOverlaps[3] = 0; watch.start(); for (k=0; k < REPETITIONS; k++) { for (i = 0; i < NUMBER_OF_BV_PAIRS; i++) { noOverlaps[3] += overlapSphereAABB_Cons(sphereArray[i], boxArray[i]); } } time[3] = watch.stop() / REPETITIONS; noOverlaps[3] /= REPETITIONS; printResult(algorithmName[3], noOverlaps[3], time[3]); /* ==== Method 5 ==== */ noOverlaps[4] = 0; watch.start(); for (k=0; k < REPETITIONS; k++) { for (i = 0; i < NUMBER_OF_BV_PAIRS; i++) { noOverlaps[4] += overlapSphereAABB_SSE(sphereArray[i], boxArray[i]); } } time[4] = watch.stop() / REPETITIONS; noOverlaps[4] /= REPETITIONS; printResult(algorithmName[4], noOverlaps[4], time[4]); /* ==== Result Summary ==== */ printf("=== Result summary ===\n\n"); printf("Number of overlap tests: %d\n\n", NUMBER_OF_BV_PAIRS); printf("Algorithm\t\tTime\t(Speedup)\n"); printf("%s\t%.4f\n", algorithmName[0], time[0]); for (i = 1; i < NUMBER_OF_METHODS; i++) { printf("%s\t%.4f\t(%.3lf)\n", algorithmName[i], time[i], time[0] / time[i]); } printf("\n"); printf("Overlaps: %.2f percent\n", 100.0f * (float)noOverlaps[0] / NUMBER_OF_BV_PAIRS); int noOverlapsReal = noOverlaps[0]; int noOverlapsConservative = noOverlaps[3]; printf("False positives reported in conservative test: %.3f percent\n", 100.0f * (noOverlapsConservative - noOverlapsReal) / (float)noOverlapsReal); getchar(); }