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");
}
}
