bool CNppThreadPool::Initialize(unsigned int minThreads, unsigned int maxThreads) { if (m_bInitialized) return false; if(minThreads <= 0) { minThreads = 1; } if(maxThreads < minThreads) { return false; } m_minThreads = minThreads; m_maxThreads = maxThreads; unsigned int i = _GetCurrentThreadPoolSize(); for(; i<minThreads; i++) { //create thread workers CWorker * pWorker = new(std::nothrow) CWorker(this); if(NULL == pWorker) { return false; } pWorker->Start(); _WorkerJumpIntoPool(pWorker); } m_bInitialized = true; m_bRun = true; m_bEnableInsertTask = true; return true; }
void input(CWorker*& workers, int size) { for (int i = 0; i < size; i++) { CWorker myWorker = CWorker(); int id, hours; double rate; cout << "Employee ID Number: "; cin >> id; cout << "Employee Pay Rate: "; cin >> rate; cout << "Employee Hours Worked: "; cin >> hours; myWorker.setId(id); myWorker.setRate(rate); myWorker.setHours(hours); workers[i] = myWorker; cout << endl; } }
bool CThreadPoolExecutor::Init(unsigned int minThreads, unsigned int maxThreads, unsigned int maxPendingTasks) { if (minThreads == 0) { return false; } if (maxThreads < minThreads) { return false; } m_minThreads = minThreads; m_maxThreads = maxThreads; m_maxPendingTasks = maxPendingTasks; unsigned int i = m_ThreadPool.size(); for (; i<minThreads; i++) { //创建线程 CWorker * pWorker = new CWorker(this); if (NULL == pWorker) { return false; } EnterCriticalSection(&m_csThreadPoolLock); m_ThreadPool.insert(pWorker); LeaveCriticalSection(&m_csThreadPoolLock); pWorker->Start(); } m_bRun = true; m_bEnableInsertTask = true; return true; }
void workerThread(void *arg) { if(arg == NULL) return; CWorker *pworker = (CWorker*)arg; printf("Worker Server: I'm running.\n"); pworker->RunForever(); }
DWORD CWorker::CMemoryThread::TimerMain(PVOID lpParameter) { CTrace::CEnter Enter(CTrace::Layer::CODINE, L"Worker::MemoryThread::TimerMain(PVOID)"); CWorker *TheWorker = (CWorker*)lpParameter; if (!TheWorker->m_bExit) { char *leak = new char[TheWorker->GetMemory()]; if (!leak) wcout << L"Error in CWorker::CMemoryThread::TimerMain: new failed" << endl; return 0; } return 1; }
//--------------------------------------------------------------------------- // @function: // CAutoTaskProxy::Execute // // @doc: // Execute task in thread owning ATP (synchronous execution); // //--------------------------------------------------------------------------- void CAutoTaskProxy::Execute ( CTask *task ) { GPOS_ASSERT(OwnerOf(task) && "Task not owned by this ATP object"); GPOS_ASSERT(CTask::EtsInit == task->m_status && "Task already scheduled"); // mark task as ready to execute task->SetStatus(CTask::EtsDequeued); GPOS_TRY { // get worker of current thread CWorker *worker = CWorker::Self(); GPOS_ASSERT(NULL != worker); // execute task worker->Execute(task); } GPOS_CATCH_EX(ex) { // mark task as erroneous task->SetStatus(CTask::EtsError); if (m_propagate_error) { GPOS_RETHROW(ex); } } GPOS_CATCH_END; // Raise exception if task encounters an exception if (task->HasPendingExceptions()) { if (m_propagate_error) { GPOS_RETHROW(task->GetErrCtxt()->GetException()); } else { task->GetErrCtxt()->Reset(); } } // mark task as reported task->SetReported(); }
//--------------------------------------------------------------------------- // @function: // CAutoTaskProxy::Execute // // @doc: // Execute task in thread owning ATP (synchronous execution); // //--------------------------------------------------------------------------- void CAutoTaskProxy::Execute ( CTask *ptsk ) { GPOS_ASSERT(FOwnerOf(ptsk) && "Task not owned by this ATP object"); GPOS_ASSERT(CTask::EtsInit == ptsk->m_estatus && "Task already scheduled"); // mark task as ready to execute ptsk->SetStatus(CTask::EtsDequeued); GPOS_TRY { // get worker of current thread CWorker *pwrkr = CWorker::PwrkrSelf(); GPOS_ASSERT(NULL != pwrkr); // execute task pwrkr->Execute(ptsk); } GPOS_CATCH_EX(ex) { // mark task as erroneous ptsk->SetStatus(CTask::EtsError); if (m_fPropagateError) { GPOS_RETHROW(ex); } } GPOS_CATCH_END; // Raise exception if task encounters an exception if (ptsk->FPendingExc()) { if (m_fPropagateError) { GPOS_RETHROW(ptsk->Perrctxt()->Exc()); } else { ptsk->Perrctxt()->Reset(); } } // mark task as reported ptsk->SetReported(); }
bool CThreadPoolExecutor::Execute(Runnable * pRunnable) { if (!m_bEnableInsertTask) { return false; } if (NULL == pRunnable) { return false; } if (m_Tasks.size() >= m_maxPendingTasks) { if (m_ThreadPool.size() < m_maxThreads) { CWorker * pWorker = new CWorker(this, pRunnable); if (NULL == pWorker) { return false; } EnterCriticalSection(&m_csThreadPoolLock); m_ThreadPool.insert(pWorker); LeaveCriticalSection(&m_csThreadPoolLock); pWorker->Start(); } else { return false; } } else { EnterCriticalSection(&m_csTasksLock); m_Tasks.push_back(pRunnable); LeaveCriticalSection(&m_csTasksLock); } return true; }
// Entry point definition. int main(int argc, const char* argv[]) { cout << "~ PART I ~" << endl << endl; // Variable declarations. CWorker myWorker = CWorker(); int id, hours; double rate; // Prompt and get user input. cout << "Employee ID Number: "; cin >> id; cout << "Employee Pay Rate: "; cin >> rate; cout << "Employee Hours Worked: "; cin >> hours; // Put the data in the object. myWorker.setId(id); myWorker.setRate(rate); myWorker.setHours(hours); // Calculate earned pay. myWorker.figureEarned(); // Output it! cout << "Worker " << myWorker.getId() << ':' << "\n\tHours Worked: " << myWorker.getHours() << "\n\tHourly Rate: " << myWorker.getRate() << "\n\tTotal Earned: " << std::fixed << std::setprecision(2) << '$' << myWorker.getEarned() << endl; cout << endl << "~ PART II ~" << endl << endl; // Variable declarations CWorker* myWorkers; int howMany = 0; // Prompt user and get number of employees. cout << "How many employees: "; cin >> howMany; // Create array with howMany values. myWorkers = new CWorker[howMany]; // Grab the input from the user. input(myWorkers, howMany); // Do the hokey-pokey. figure(myWorkers, howMany); // Output it to cout. output(cout, myWorkers, howMany); // Get the number of workers who worked overtime. int numOvertime = overtime(myWorkers, howMany); // Output it. cout << numOvertime << ((numOvertime > 1) ? " workers" : " worker") << " worked overtime." << endl; // Return success to the OS. return 0; }
void PowersaveSchedule(CWorker *me) { // Only Worker 0 should access static vars! static uint64_t changeTimer = 0; uint64_t now = (uint64_t)CTimer::Rdtsc(); me->m_wakeCount++; if (now > me->m_powersaveTimer) { short activeCnt = -1; me->m_powersaveTimer = now + (0.25 * g_clocks_per_sec); pthread_mutex_lock(&g_powersaveLock); g_powersaveWake += me->m_wakeCount; me->m_wakeCount = 0; g_powersaveNoWork += me->m_noWorkCount; me->m_noWorkCount = 0; if (me->m_unitId == 0) { short awake = g_powersaveActiveCnt; float idlePct = 100 * ((float)g_powersaveNoWork / g_powersaveWake); g_powersaveWake = 0; g_powersaveNoWork = 0; #if 0 int i; fprintf(stderr, "Idle: %2.2f%%; ", idlePct); fprintf(stderr, "Resp: "); for (i=0; i<g_settings.num_threads; i++) { fprintf(stderr, "%d ", g_powersaveResponsible[i]); } fprintf(stderr, "\n"); #endif if (idlePct > highIdleMark) { if (now > changeTimer) { if (g_powersaveActiveCnt == 1) { me->m_slowSpin = true; } else if (g_powersaveActiveCnt > 1) { g_powersaveActiveCnt--; } changeTimer = now + activeChangeDelay; } } else if (idlePct < lowIdleMark) { if (me->m_slowSpin == true) { me->m_slowSpin = false; } else if (g_powersaveActiveCnt < g_settings.num_threads) { g_powersaveActiveCnt *= 2; if (g_powersaveActiveCnt > g_settings.num_threads) { g_powersaveActiveCnt = g_settings.num_threads; } } changeTimer = now + activeChangeDelay; } #if 0 if (g_powersaveActiveCnt != awake) { fprintf(stderr, "Powersave: activeCnt is now %d\n", g_powersaveActiveCnt); } #endif // Wake up any sleepers. while (g_powersaveActiveCnt > awake) { if (g_powersaveWorkerActive[awake] == false) { sem_post(&g_powersaveDoorBell[awake]); g_powersaveWorkerActive[awake] = true; awake++; } } } activeCnt = g_powersaveActiveCnt; pthread_mutex_unlock(&g_powersaveLock); short workload = Workload(me->m_unitId, activeCnt); if (workload != me->m_workload) { AdjustWorkload(me, workload); } } // Now, get to work... short i; int rc = 0; for (i=0; i<g_settings.num_threads; i++) { if (me->m_responsibleFor[i]) { CWorker *imp = g_pWorkers[i]; if (imp) { g_pTimers[5]->Start(imp->m_unitId); g_pSamples[2]->Sample(imp->m_freeCurr, imp->m_unitId); rc |= imp->AddCloseMsgToRecvBuffer(); rc |= imp->FlushRecvBuf(); rc |= imp->ProcessRespBuf(); rc |= imp->TransmitFromList(); rc |= imp->HandleDispatchCmds(); g_pTimers[5]->Stop(imp->m_unitId); // Add any pending connections to my event_base. pthread_mutex_lock(&imp->m_psPendLock); while (imp->m_psPendHead) { CConn *c = imp->m_psPendHead; imp->m_psPendHead = c->m_psPendNext; c->m_psPendNext = 0; event_base_set(me->m_base, &c->m_event); event_add(&c->m_event, 0); c->m_bEventActive = true; rc++; } pthread_mutex_unlock(&imp->m_psPendLock); } } } // Adjust no-work count for computing idlePct if (rc == 0) me->m_noWorkCount++; }
bool WorkersCmp(CWorker const &worker1, CWorker const &worker2) { return ((worker1.GetAge() == worker2.GetAge()) && (worker1.GetGender() == worker2.GetGender()) && (worker1.GetHeight() == worker2.GetHeight()) && (worker1.GetWeight() == worker2.GetWeight()) && (worker1.GetPost() == worker2.GetPost()) && (worker1.GetCompany()->GetName() == worker2.GetCompany()->GetName()) && (worker1.GetCompany()->GetWebsite() == worker2.GetCompany()->GetWebsite())); }
void CPersonsAndBuildings::EditWorker() { m_changed = true; cout << "Enter ID: "; size_t id; cin >> id; CWorker *worker = dynamic_cast<CWorker*>(GetPersonByID(CBuildingRelatedPerson::Type::WORKER, id)->get()); cout << "Choose field to edit: " << endl; cout << "1. Age" << endl; cout << "2. Name" << endl; cout << "3. Height" << endl; cout << "4. Weight" << endl; cout << "5. Company" << endl; cout << "6. Specialty" << endl; size_t action; cin >> action; switch (action) { case 1: { cout << "Enter new age: "; worker->SetAge(ReadUnsignedFromStreamLine()); break; } case 2: { cout << "Enter new name: "; string name; getline(cin, name); worker->SetName(name); break; } case 3: { cout << "Enter new height: "; worker->SetHeight(ReadUnsignedFromStreamLine()); break; } case 4: { cout << "Enter new weight: "; worker->SetWeight(ReadUnsignedFromStreamLine()); break; } case 5: { cout << "Enter new company name: "; string name; getline(cin, name); auto target = FindBuildingByName(CBuilding::Type::COMPANY, name); if (target == m_buildings.end()) { ThrowNotFoundException(MakeFirstLetterUppercase(CBuilding::TYPE_TO_NAME.at(CBuilding::Type::COMPANY))); } worker->SetBuilding(*target); break; } case 6: { cout << "Enter new specialty: "; string specialty; getline(cin, specialty); worker->SetSpecialty(specialty); break; } default: throw runtime_error("Wrong action"); } }