Parallel::Parallel(int threadCount, ParallelFactory* factory) { // Cache the number of threads _threadCount = threadCount; // Remember the ID of the current thread _parentThread = std::this_thread::get_id(); factory->addThreadIndex(_parentThread, 0); // Initialize shared data members and launch threads in a critical section { std::unique_lock<std::mutex> lock(_mutex); // Initialize shared data members _target = nullptr; _assigner = nullptr; _limit = 0; _active.assign(threadCount, true); _exception = nullptr; _terminate = false; _next = 0; // Create the extra parallel threads with one-based index (parent thread has index zero) for (int index = 1; index < threadCount; index++) { _threads.push_back(std::thread(&Parallel::run, this, index)); factory->addThreadIndex(_threads.back().get_id(), index); } } // Wait until all parallel threads are ready waitForThreads(); }
void stopThreads() { threadStop = 1; if(threads!= NULL) { waitForThreads(); } threadStop = 0; }
int main(int argc, char* argv[]) { init(); atexit(freeMem); if(argc <= 1) { // rendern zu OpenGL fileMode = 0; glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(633, 641); glutCreateWindow("Mandelbrot"); initGL(); glutKeyboardFunc(keyboard); glutMouseFunc(mouse); glutMotionFunc(mousemove); glutDisplayFunc(render); glutIdleFunc(repaint); glutReshapeFunc(reshape); glutMainLoop(); } else { // rendern zur Datei fileMode = 1; sizeX = 1024; sizeY = 1024; maxIterations=500; // loadPosition(); startThreads(); waitForThreads(); writeTGA(); } return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { processArgs(argc, argv); cout << " NumIters " << NumIters << "," << " NumEntries " << NumEntries << endl; if (LockType == FallbackLock::MUTEX_LOCK) { GLock = new MutexFallbackLock(PmxLock); cout << "Allocated Pthread Mutex lock" << endl; } else if (LockType == FallbackLock::SPIN_LOCK) { GLock = new SpinFallbackLock(PspLock); cout << "Allocated Pthread Spin lock" << endl; } else if (LockType == FallbackLock::HLE_LOCK) { GLock = new HLELock(); cout << "Allocated HLE Spin lock" << endl; } else if (LockType == FallbackLock::CUSTOM_LOCK) { GLock = new CustomSpinLock(); cout << "Allocated Custom Spin lock" << endl; } else { cerr << "Error: invalid lock type specified, exiting..." << LockType; } SharedTable = new KaLib::HashTable<int>( NumEntries * NumThreads, GLock); for (int ec = NumThreads * NumEntries; ec > 0; --ec) { int v = rand(); SharedTable->insert(ec, v); } ThreadWorker_t worker = executeThreadLoopSimple; Timer coreTimer("Workers"); coreTimer.Start(); createWorkerThreads(NumThreads, worker); waitForThreads(NumThreads); coreTimer.Stop(); Timer checker("VerifyHashTable"); checker.Start(); checkTable(*SharedTable, NumThreads, NumEntries); checker.Stop(); delete SharedTable; coreTimer.PrintElapsedTime("RESULT: Filling up the hash table finished in "); checker.PrintElapsedTime("Verification of Hash table done in "); return 0; }
int main(void) { srand(time(NULL)); createQueues(); setupThreads(); createThreads(cpuThread, cpuThreads, NUMBER_OF_CPU_THREADS); createThreads(ioThread, ioThreads, NUMBER_OF_IO_THREADS); createThreads(submissionThread, submissionThreads, NUMBER_OF_SUBMISSION_THREADS); waitForThreads(cpuThreads); waitForThreads(ioThreads); waitForThreads(submissionThreads); printf("All threads complete.\n"); return EXIT_SUCCESS; }
/************************************************** * Main * **************************************************/ int main(int argc, const char* argv[]) { parseArgs(argc, argv); // Print("main thread starting the test..."); // FOR DEBUG InitLocks(); if (!createThreads()) { // returns true if all threads were created successfully ErrorExit(RES_CREATE_FAILED); } waitForThreads(); waitOrExit(); Print("main thread is calling return from main()"); // FOR DEBUG return RES_SUCCESS; }
bool myMasterFunc() { releaseThreads(); // do my chunk of work work[0].work_func( 0 ); waitForThreads(); bool ret = true; for(int n = 0; n < nWorkers; n++) { if( work[n].ret == false ) ret = false; } return( ret ); }
void shutdownThreads() { #ifdef MEM_MULTICORE int n; for( n = 1; n < nWorkers; n++ ) { work[n].exit = true; work[n].work_func = NULL; } releaseThreads(); waitForThreads(); for(int n = 1; n < nWorkers; n++) { WaitForSingleObject( tn[n], INFINITE ); } #endif }
void Parallel::call(ParallelTarget* target, ProcessAssigner* assigner) { // Verify that we're being called from our parent thread if (std::this_thread::get_id() != _parentThread) throw FATALERROR("Parallel call not invoked from thread that constructed this object"); // Initialize shared data members and activate threads in a critical section { std::unique_lock<std::mutex> lock(_mutex); // Copy the arguments so they can be used from any of the threads _target = target; _assigner = assigner; _limit = assigner->nvalues(); // Initialize the number of active threads (i.e. not waiting for new work) if (assigner->parallel()) _active.assign(_threadCount, true); // Clear the exception pointer _exception = 0; // Initialize the loop variable _next = 0; // Wake all parallel threads, if multithreading is allowed if (assigner->parallel()) _conditionExtra.notify_all(); } // Do some work ourselves as well doWork(); // Wait until all parallel threads are done if (assigner->parallel()) waitForThreads(); // Check for and process the exception, if any if (_exception) { throw *_exception; // throw by value (the memory for the heap-allocated exception is leaked) } }
void launchThreads() { #ifdef MEM_MULTICORE int *nArg = (int*)malloc(sizeof(int) *(nWorkers + 1)); int n; for( n = 1; n < nWorkers; n++ ) { nArg[n] = n; work[n].exit = false; work[n].work_func = NULL; tn[n] = (HANDLE) _beginthreadex( NULL, 0, myThreadFunc, (void *) (&nArg[n]), 0, &tid[n] ); } // XXX if this isn't here subsequent barrier roundtrips // are more expensive. Why? releaseThreads(); waitForThreads(); if(nArg) free(nArg); #endif }
Parallel::Parallel(int threadCount, ParallelFactory* factory) : _assigner(0) { // remember the current thread _parentThread = QThread::currentThread(); factory->addThreadIndex(_parentThread, 0); // initialize the number of active threads (i.e. not waiting for new work) other than the current thread _terminate = false; _active = threadCount - 1; // create and start the extra parallel threads for (int index=1; index<threadCount; index++) { Thread* thread = new Thread(this); thread->start(); _threads << thread; factory->addThreadIndex(thread, index); } // wait until all parallel threads are ready waitForThreads(); }
void LinearBarrierActive::wait (const size_t threadIndex, const size_t __threadCount) { waitForThreads(threadIndex,numThreads); }
int main(int argc, char* argv[]){ FILE *file; char *line=NULL;//size of line allocated by getline size_t length=0;//number of bytes to read (allocated by getline) ssize_t read;//number of characters read int j; //counter for current threads char *buf; //for path char *directory; //for path char prompt[30]; strcpy(prompt,"Prompt"); char *history[512]; //array of up to 512 previous commands int hIndex = 0; //index for next history entry /*Reading in files needs to be done one line at a time for both batch and interpreted *so that every command on a line can be executed at once */ if(argc==2){ //batch mode //file is argv[1] if((file=fopen(argv[1],"r"))==NULL){ perror(argv[1]); return 1; } } else if(argc==1){ //interactive mode //file is stdin printf("\nEnter commands separated by a semi-colon.\n"); printf("To edit the prompt, type: editPrompt WhateverPromptYouWant\n"); printf("To get a list of previously entered commands, type: displayHistory\n"); printf("To look at your path, type: myPATH\n"); //Margarita printf("To exit this shell, type in 'quit'.\n\n"); printf("%s> ",prompt); file=stdin; } else{ //incorrect number of arguments printf("\nIncorrect number of arguments.\n"); printf("Run the program by itself, or with one file of commands.\n"); printf("Ex. './shell' or './shell commands'\n\n"); return 0; } //reads each line while((read=getline(&line,&length,file))!=-1){ //Break up line and execute all commands using threading char *command; command=strtok(line,";"); i = 0; //reads each command one at a time until null/newline while(command!=NULL && strcmp(command, "\n")!=0){ //trimming whitespace around commands command = trimwhitespace(command); //checks for quit if(strcmp(command,"quit")==0 || strcmp(command,"quit\n")==0 || strcmp(command," quit")==0 || strcmp(command,"exit")==0 || strcmp(command,"exit\n")==0 || strcmp(command," exit")==0){ waitForThreads(); printf("Exiting shell..\n"); exit(0); } //customizable prompt char * editPrompt = strstr(command, (char *)"editPrompt "); //ptr to name of new prompt if (editPrompt != NULL){ int k = 11; //add or remove terminating characters in the following loop conditionals to specify syntax eg: ...!= '"' to terminate string at the end of quotations while (editPrompt[k]!= '\0' && editPrompt[k] != ';' && editPrompt[k] != '\n' /*&& editPrompt[k] != ' '*/){ prompt[k-11] = editPrompt[k]; k++; } prompt[k-11] = '\0'; break; } //display command history editPrompt = strstr(command, (char *)"displayHistory"); //lazy use of previous variable if (editPrompt != NULL){ int k; for(k = 0; k < hIndex; k++){ printf(">%s\n",history[k]); } break; } //display PATH editPrompt = strstr(command, (char *)"myPATH"); if(editPrompt != NULL){ buf = (char *)malloc(PATH_MAX+1); directory = getcwd(buf, PATH_MAX+1); if(buf != NULL){ printf("Your path is: %s\n", directory); break; } else { printf("Error finding path. Error num: %d\n", errno); break; } } //adds command to history history[hIndex] = (char *) malloc(strlen(command)); strcpy (history[hIndex++],command); //creates a thread pthread_create(&tid[i],NULL,function,command); //increment command=strtok(NULL,";"); i++; } //waits for all the threads to finish waitForThreads(); //prompts for more inputs if in interactive mode if(argc==1){ printf("\n%s>",prompt); } } return 0; }
int main(int argc, char *argv[]) { int c; ThreadWorker_t worker = NULL; while (1) { static struct option longOptions[] = { {"verbose", no_argument, &VerboseFlag, 1}, {"iters", required_argument, 0, 'i'}, {"threads", required_argument, 0, 't'}, {"dumplevel", required_argument, 0, 'd'}, {"numretries",required_argument, 0, 'r'}, {"locktype", required_argument, 0, 'l'}, {"sharedmode",required_argument, 0, 's'}, {0, 0, 0, 0} }; int optionIndex = 0; c = getopt_long(argc, argv, "i:t:d:r:l:s:", longOptions, &optionIndex); if (c == -1) break; switch (c) { case 0: if (longOptions[optionIndex].flag != 0) break; printf("option %s\n", longOptions[optionIndex].name); break; case 'i': NumIters = atoi(optarg); break; case 't': NumThreads = atoi(optarg); break; case 'd': DumpLevel = atoi(optarg); break; case 'r': MaxRetries = atoi(optarg); break; case 'l': LockType = atoi(optarg); break; case 's': SharedMode = atoi(optarg); break; default: abort(); }; } printf(" NumIters = %d \n", NumIters); if (LockType == FallbackLock::MUTEX_LOCK) { GLock = new MutexFallbackLock(PmxLock); cout << "Allocated Pthread Mutex lock" << endl; } else if (LockType == FallbackLock::SPIN_LOCK) { GLock = new SpinFallbackLock(PspLock); cout << "Allocated Pthread Spin lock" << endl; } else if (LockType == FallbackLock::HLE_LOCK) { GLock = new HLELock(); cout << "Allocated HLE Spin lock" << endl; } else if (LockType == FallbackLock::CUSTOM_LOCK) { GLock = new CustomSpinLock(); cout << "Allocated Custom Spin lock" << endl; } else { cerr << "Error: invalid lock type specified, exiting..." << LockType; exit(1); } /* SharedArray = (ULong*) malloc(((8+1) * (NumIters+1) + 1) * sizeof(ULong)); */ int* rawPtr = (int*) malloc(64*1024*1024 * sizeof(ULong)); SharedArray = (int*)((char*) rawPtr + (CACHE_LINE_BYTES - ((ULong)rawPtr & 0x3f))); memset(SharedArray, 0, 64*1024*1024 * sizeof(int)); if (SharedMode) { worker = executeThreadLoopShared; } else { worker = executeThreadLoopPrivate; } Timer coreTimer("Worker Threads"); coreTimer.Start(); createLoopThreads(NumThreads, worker); waitForThreads(NumThreads); coreTimer.Stop(); printCheckSumOfArray(NumThreads, NumIters); coreTimer.PrintElapsedTime("Worker threads finished in "); cout << "Final Index = \n" << SharedIndex; if (VerboseFlag) printSharedArray(NumThreads, NumIters); return 0; }
int main (int argc, char *argv[]) { // Program description std::cerr << "map_back: context of significant kmers\n"; // Do parsing and checking of command line params // If no input options, give quick usage rather than full help boost::program_options::variables_map vm; if (argc == 1) { std::cerr << "Usage: map_back -k seer_output.txt -r references.txt > mappings.txt\n\n" << "For full option details run map_back -h\n"; return 0; } else if (parseCommandLine(argc, argv, vm)) { return 1; } // Set number of threads size_t num_threads = vm["threads"].as<size_t>(); if (num_threads < 1) { num_threads = 1; } // Read all sequences into memory as Fasta objects std::cerr << "Reading reference sequences into memory...\n"; std::vector<Fasta> sequence_cache = readSequences(vm["references"].as<std::string>()); // Loop through significant kmers std::cerr << "Now mapping significant kmers...\n"; std::ifstream kmer_file(vm["kmers"].as<std::string>().c_str()); if (!kmer_file) { throw std::runtime_error("Could not open kmer_file " + vm["kmers"].as<std::string>() + "\n"); } else { // Set up list of threads, and mutex lock on std out std::mutex out_mtx; std::list<std::future<void>> threads; // Read the header std::string header; std::getline(kmer_file, header); int num_covar_fields = parseHeader(header); Significant_kmer sig_kmer(num_covar_fields); while(kmer_file) { kmer_file >> sig_kmer; // Check the read into sig_kmer hasn't reached end of file if (!kmer_file.eof()) { assert(num_threads >= 1); std::cout << sig_kmer.sequence(); // sig_kmer samples and sample cache are sorted in the same order, so // can go through linearly std::vector<std::string> search_names = sig_kmer.samples_found(); std::vector<std::string>::iterator search_names_it = search_names.begin(); for (std::vector<Fasta>::iterator all_names_it = sequence_cache.begin(); all_names_it != sequence_cache.end(); ++all_names_it) { // For each sample we know the kmer is in, print all matches to // the kmer if (all_names_it->get_name() == *search_names_it) { // Thread each search (i.e. per sample per kmer) if (num_threads > 1) { // Check if four searches are running. If so, wait for the // next one to finish. Wait (for a max of 100ms) so this // thread doesn't consume processing waitForThreads(threads, num_threads - 1); // Start a new thread asynchronously, at the back of the // queue threads.push_back(std::async(std::launch::async, &Fasta::printMappings, *all_names_it, std::ref(std::cout), sig_kmer.sequence(), std::ref(out_mtx))); } else { all_names_it->printMappings(std::cout, sig_kmer.sequence(), out_mtx); } ++search_names_it; if (search_names_it == search_names.end()) { break; } } } // Tab between every sample, line break after every kmer if (num_threads > 1) { waitForThreads(threads, 0); } std::cout << std::endl; } } std::cerr << "Done.\n"; } }