void TasksCleanup() { #ifdef PBRT_USE_GRAND_CENTRAL_DISPATCH return; #else // // PBRT_USE_GRAND_CENTRAL_DISPATCH { MutexLock lock(*taskQueueMutex); Assert(taskQueue.size() == 0); } static const int nThreads = NumSystemCores(); workerSemaphore.Post(nThreads); if (threads != NULL) { #ifdef PBRT_HAS_PTHREADS for (int i = 0; i < nThreads; ++i) { int err = pthread_join(threads[i], NULL); if (err != 0) Severe("Error from pthread_join: %s", strerror(err)); } #endif #ifdef WIN32 WaitForMultipleObjects(nThreads, threads, TRUE, INFINITE); for (int i = 0; i < nThreads; ++i) { CloseHandle(threads[i]); } #endif // WIN32 delete[] threads; threads = NULL; } #endif // PBRT_USE_GRAND_CENTRAL_DISPATCH }
/** * Reads the SimStepData from a Calculation thread and adds it to the intern SSD buffer and the SRDF buffer. * parameter: pointer from type SimStepData, it points on a data struct in a Calculation thread */ bool setResultData(SimStepData* p_SimStepData_from_Calculation) { bool retValue = true; /* * This part is necessary for the producer &consumer problem with districted buffer * The any entity which want to use the array must pas this part */ // Try to enter the ghSemaphore_NumberFreeSlots gate. ghSemaphore_NumberFreeSlots.Wait(); ssdMutex.Lock(); /******************************************************************** * Entity has pas the synchronization sektion and can work on the SSD buffer * Restrictions: if the simulation has been reseted the first time value must be VALID_TIME_AFTER_RESET * otherwise the result won't be added to the system */ //block used by normal running simulation if(!simulationReset && !simulationChangetime){ addDataToSSD(p_SimStepData_from_Calculation); //cout << "add time: " << p_SimStepData_from_Calculation->forTimeStep << endl; fflush(stdout); }else{//block used once after simulation has been reseted or more if the next time to add into the ssd is not VALID_TIME_AFTER_RESET if(simulationReset){ if(p_SimStepData_from_Calculation->forTimeStep == VALID_TIME_AFTER_RESET || p_SimStepData_from_Calculation->forTimeStep == 0){ addDataToSSD(p_SimStepData_from_Calculation); //cout << "add after reset time: " << p_SimStepData_from_Calculation->forTimeStep << endl; fflush(stdout); simulationReset = false; } else{ //cout << "no chance for reset ;) time: " << p_SimStepData_from_Calculation->forTimeStep << endl; fflush(stdout); } } else{ if(simulationChangetime){ if(compareDouble(p_SimStepData_from_Calculation->forTimeStep, VALID_TIME_AFTER_CHANGETIME)){ //cout << "add after change time: " << p_SimStepData_from_Calculation->forTimeStep << endl; fflush(stdout); addDataToSSD(p_SimStepData_from_Calculation); simulationChangetime = false; } else{ //cout << "no chance for change ;) time: " << p_SimStepData_from_Calculation->forTimeStep << endl; fflush(stdout); } } } } //Work on SSD and SRDF buffer ended ********************************** // Release the mutex if (!ssdMutex.Unlock()) { //printf("ReleaseMutex ssdMutex error: %d\n", GetLastError()); return false; } //if(debugResultManager) { cout << "set released mutex" << endl; fflush(stdout); } // Release the semaphore ghSemaphore_NumberUsedSlots ghSemaphore_NumberUsedSlots.Post(); return retValue; }
int main(int argc, char *argv[]) { Semaphore sem; Thread thread(_ThreadFun1, &sem); thread.Start(); for (int i=0; i<2; i++) { sem.Post(); sleep(1); } }
int main() { Semaphore *sem = new Semaphore("/tmp.test.trigger"); sem->Post(); cout<<"trigger on."<<endl; delete sem; return 0; }
void EnqueueTasks(const vector<Task *> &tasks) { if (PbrtOptions.nCores == 1) { for (unsigned int i = 0; i < tasks.size(); ++i) tasks[i]->Run(); return; } #ifdef PBRT_USE_GRAND_CENTRAL_DISPATCH for (uint32_t i = 0; i < tasks.size(); ++i) dispatch_group_async_f(gcdGroup, gcdQueue, tasks[i], lRunTask); #else if (!threads) TasksInit(); { MutexLock lock(*taskQueueMutex); for (unsigned int i = 0; i < tasks.size(); ++i) taskQueue.push_back(tasks[i]); } tasksRunningCondition.Lock(); numUnfinishedTasks += tasks.size(); tasksRunningCondition.Unlock(); workerSemaphore.Post(tasks.size()); #endif }
void EnqueueTasks(const vector<Task *> &tasks) { #ifdef PBRT_USE_GRAND_CENTRAL_DISPATCH static bool oneThread = (getenv("PBRT_NTHREADS") && atoi(getenv("PBRT_NTHREADS")) == 1); for (u_int i = 0; i < tasks.size(); ++i) if (oneThread) dispatch_sync_f(gcdQueue, tasks[i], lRunTask); else dispatch_group_async_f(gcdGroup, gcdQueue, tasks[i], lRunTask); #else if (!threads) TasksInit(); { MutexLock lock(*taskQueueMutex); for (unsigned int i = 0; i < tasks.size(); ++i) taskQueue.push_back(tasks[i]); } tasksRunningCondition.Lock(); numUnfinishedTasks += tasks.size(); tasksRunningCondition.Unlock(); workerSemaphore.Post(tasks.size()); #endif }