void SpinUpGPUThreads(ProcessorQueue &analysis_queue, ComputationPlanner &analysis_compute_plan)
{
if (analysis_compute_plan.use_gpu_acceleration) {
// create gpu thread for multi flow fit
CreateGpuThreadsForFitType(analysis_queue.GetGpuInfo(),
analysis_compute_plan.numBkgWorkers_gpu, analysis_queue.GetGpuQueue(),
analysis_compute_plan.valid_devices);
// create gpu thread for single flow fit
/* CreateGpuThreadsForFitType(analysis_queue.GetSingleFitGpuInfo(), GPU_SINGLE_FLOW_FIT,
analysis_compute_plan.numSingleFlowFitGpuWorkers, analysis_queue.GetSingleFitGpuQueue(),
analysis_compute_plan.valid_devices);*/
}
}
void *BkgFitWorkerCpu(void *arg)
{
ProcessorQueue* pq = static_cast<ProcessorQueue*>(arg);
assert(pq);
WorkerInfoQueue* curQ = NULL;
bool done = false;
WorkerInfoQueueItem item;
while (!done)
{
//item = TryGettingFittingJobForCpuFromQueue(pq, &curQ);
item = pq->TryGettingFittingJob(&curQ);
if (item.finished == true)
{
// we are no longer needed...go away!
done = true;
curQ->DecrementDone();
continue;
}
int event = * ( (int *) item.private_data);
if (event == MULTI_FLOW_REGIONAL_FIT)
{
DoMultiFlowRegionalFit(item);
}
else if (event == INITIAL_FLOW_BLOCK_ALLBEAD_FIT)
{
DoInitialBlockOfFlowsAllBeadFit(item);
}
else if (event == INITIAL_FLOW_BLOCK_REMAIN_REGIONAL_FIT)
{
DoInitialBlockOfFlowsRemainingRegionalFit(item);
}
else if (event == SINGLE_FLOW_FIT) {
DoSingleFlowFitAndPostProcessing(item);
}
else if (event == POST_FIT_STEPS) {
DoPostFitProcessing(item);
}
else if (event == imageInitBkgModel)
{
DoConstructSignalProcessingFitterAndData (item);
}
// indicate we finished that bit of work
curQ->DecrementDone();
}
return (NULL);
}
void AllocateProcessorQueue (ProcessorQueue &my_queue,ComputationPlanner &analysis_compute_plan, int numRegions)
{
//create queue for passing work to thread pool
my_queue.SetCpuQueue(new WorkerInfoQueue (numRegions*analysis_compute_plan.numBkgWorkers+1));
if (analysis_compute_plan.use_gpu_acceleration) {
if(analysis_compute_plan.numMultiFlowFitGpuWorkers) {
my_queue.AllocateMultiFitGpuInfo(analysis_compute_plan.numMultiFlowFitGpuWorkers);
my_queue.SetMultiFitGpuQueue(new WorkerInfoQueue (numRegions*analysis_compute_plan.numBkgWorkers_gpu+1));
}
if(analysis_compute_plan.numSingleFlowFitGpuWorkers) {
my_queue.AllocateSingleFitGpuInfo(analysis_compute_plan.numSingleFlowFitGpuWorkers);
my_queue.SetSingleFitGpuQueue(new WorkerInfoQueue (numRegions*analysis_compute_plan.numBkgWorkers_gpu+1));
}
}
{
int cworker;
pthread_t work_thread;
// spawn threads for doing background correction/fitting work
for (cworker = 0; cworker < analysis_compute_plan.numBkgWorkers; cworker++)
{
int t = pthread_create (&work_thread, NULL, BkgFitWorkerCpu,
&my_queue);
pthread_detach(work_thread);
if (t)
fprintf (stderr, "Error starting thread\n");
}
}
fprintf (stdout, "Number of CPU threads for beadfind: %d\n", analysis_compute_plan.numBkgWorkers);
if (analysis_compute_plan.use_gpu_acceleration)
fprintf (stdout, "Number of GPU threads for background model: %d\n", analysis_compute_plan.numBkgWorkers_gpu);
else
fprintf (stdout, "Number of CPU threads for background model: %d\n", analysis_compute_plan.numBkgWorkers);
}
void WaitForRegionsToFinishProcessing (ProcessorQueue &analysis_queue, ComputationPlanner &analysis_compute_plan)
{
// wait for all of the regions to finish processing before moving on to the next
// image
// Need better logic...This is just following the different steps involved in signal processing
analysis_queue.GetCpuQueue()->WaitTillDone();
if (analysis_queue.GetMultiFitGpuQueue())
analysis_queue.GetMultiFitGpuQueue()->WaitTillDone();
analysis_queue.GetCpuQueue()->WaitTillDone();
if (analysis_queue.GetSingleFitGpuQueue())
analysis_queue.GetSingleFitGpuQueue()->WaitTillDone();
if (analysis_compute_plan.use_gpu_acceleration)
analysis_queue.GetCpuQueue()->WaitTillDone();
}
void AllocateProcessorQueue (ProcessorQueue &my_queue,ComputationPlanner &analysis_compute_plan, int numRegions)
{
//create queue for passing work to thread pool
my_queue.SetCpuQueue(new WorkerInfoQueue (numRegions*analysis_compute_plan.numBkgWorkers+1));
if (analysis_compute_plan.use_gpu_acceleration) {
if(analysis_compute_plan.numBkgWorkers_gpu) {
my_queue.AllocateGpuInfo(analysis_compute_plan.numBkgWorkers_gpu);
my_queue.SetGpuQueue(new WorkerInfoQueue (numRegions*analysis_compute_plan.numBkgWorkers_gpu+1));
}
}
// decide on whether to use both CPU and GPU for bkg model fitting jobs
if (analysis_compute_plan.use_gpu_only_fitting) {
my_queue.turnOffHeterogeneousComputing();
}
if (!analysis_compute_plan.gpu_multiflow_fit) {
my_queue.turnOffGpuMultiFlowFitting();
}
if (!analysis_compute_plan.gpu_singleflow_fit) {
my_queue.turnOffGpuSingleFlowFitting();
}
{
int cworker;
pthread_t work_thread;
// spawn threads for doing background correction/fitting work
for (cworker = 0; cworker < analysis_compute_plan.numBkgWorkers; cworker++)
{
int t = pthread_create (&work_thread, NULL, BkgFitWorkerCpu,
&my_queue);
pthread_detach(work_thread);
if (t)
fprintf (stderr, "Error starting thread\n");
}
}
fprintf (stdout, "Number of CPU threads for beadfind: %d\n", analysis_compute_plan.numBkgWorkers);
if (analysis_compute_plan.use_gpu_acceleration)
fprintf (stdout, "Number of GPU threads for background model: %d\n", analysis_compute_plan.numBkgWorkers_gpu);
else
fprintf (stdout, "Number of CPU threads for background model: %d\n", analysis_compute_plan.numBkgWorkers);
}
void AssignQueueForItem (ProcessorQueue &analysis_queue,ComputationPlanner &analysis_compute_plan)
{
(void) analysis_compute_plan;
analysis_queue.GetCpuQueue()->PutItem(analysis_queue.item);
}
// helper function which cleans all pending jobs
void abortPendingJobs(){
while( ! queue->empty() ){
void * job = queue->pollNextJob();
jobAborted(job);
}
}
inline bool mayStartJob(){
return queue->mayEnqueue();
}
// process all person who are inactive ( such as ,visitor wait in holding area for his owner, person wait in queue...)
void FireEvacuationEvent::ProcessInActivePerson( InputTerminal* _pInTerm )
{
int iProcessorCount = _pInTerm->procList->getProcessorCount();
for( int i=0; i<iProcessorCount; ++i )
{
Processor* pProc = _pInTerm->procList->getProcessor( i );
if( pProc->getProcessorType() == HoldAreaProc )
{
HoldingArea* pHoldArea = (HoldingArea*)pProc;
SortedMobileElementList* pOccupants = pHoldArea->GetOccupants();
int iPersonCount = pOccupants->getCount();
for( int j=0; j<iPersonCount; ++j )
{
Person* pPerson = (Person*)pOccupants->getItem( j );
TerminalMobElementBehavior* spTerminalBehavior = pPerson->getTerminalBehavior();
if( spTerminalBehavior&&!spTerminalBehavior->IfAlreadyEvacuate() )
{
long lSeconds = Default_Person_Response_Time;
long lSpeed = Default_Person_Speed_Impact;
const ProbabilityDistribution* pDistTime = _pInTerm->paxDataList->getResponseTime()->FindFit( pPerson->getType() );
if( pDistTime )
{
lSeconds = (long)pDistTime->getRandomValue();
}
const ProbabilityDistribution* pDistSpeed = _pInTerm->paxDataList->getImpactEmer()->FindFit( pPerson->getType() );
if( pDistSpeed )
{
lSpeed = (long)pDistSpeed->getRandomValue();
}
pPerson->setSpeed( pPerson->getSpeed() + lSpeed );
pPerson->setState( EvacuationFire );
spTerminalBehavior->SetFireEvacuateFlag( true );
pPerson->generateEvent( this->time + lSeconds,false);
}
}
}/*
else if( pProc->getProcessorType() == LineProc )
{
LineProcessor* pLineProc = (LineProcessor*)pProc;
SortedMobileElementList* pOccupants = pLineProc->GetOccupants();
int iPersonCount = pOccupants->getCount();
for( int j=0; j<iPersonCount; ++j )
{
Person* pPerson = (Person*)pOccupants->getItem( j );
if( !pPerson->IfAlreadyEvacuate() )
{
long lSeconds = Default_Person_Response_Time;
long lSpeed = Default_Person_Speed_Impact;
const ProbabilityDistribution* pDistTime = _pInTerm->paxDataList->getResponseTime()->FindFit( pPerson->getType() );
if( pDistTime )
{
lSeconds = pDistTime->getRandomValue();
}
const ProbabilityDistribution* pDistSpeed = _pInTerm->paxDataList->getSpeedImpact()->FindFit( pPerson->getType() );
if( pDistSpeed )
{
lSpeed = pDistSpeed->getRandomValue();
}
pPerson->setSpeed( pPerson->getSpeed() + lSpeed );
pPerson->setState( EvacuationFire );
pPerson->SetFireEvacuateFlag( true );
pPerson->generateEvent( this->time + lSeconds);
}
}
}*/
else if( pProc->getProcessorType() == IntegratedStationProc )
{
IntegratedStation* pStation = ( IntegratedStation* )pProc;
SortedMobileElementList* pOccupants = pStation->GetOccupants();
int iPersonCount = pOccupants->getCount();
for( int j=0; j<iPersonCount; ++j )
{
Person* pPerson = (Person*)pOccupants->getItem( j );
TerminalMobElementBehavior* spTerminalBehavior = pPerson->getTerminalBehavior();
if( spTerminalBehavior&&pPerson->getState() != OnVehicle && !spTerminalBehavior->IfAlreadyEvacuate() )
{
long lSeconds = Default_Person_Response_Time;
long lSpeed = Default_Person_Speed_Impact;
const ProbabilityDistribution* pDistTime = _pInTerm->paxDataList->getResponseTime()->FindFit( pPerson->getType() );
if( pDistTime )
{
lSeconds = (long)pDistTime->getRandomValue();
}
const ProbabilityDistribution* pDistSpeed = _pInTerm->paxDataList->getImpactEmer()->FindFit( pPerson->getType() );
if( pDistSpeed )
{
lSpeed = (long)pDistSpeed->getRandomValue();
}
pPerson->setSpeed( pPerson->getSpeed() + lSpeed );
pPerson->setState( EvacuationFire );
spTerminalBehavior->SetFireEvacuateFlag( true );
pPerson->generateEvent( this->time + lSeconds ,false);
spTerminalBehavior->DisablePersonOnStation();//leave station now
}
}
}
else
{
ProcessorQueue* pQueue = pProc->GetProcessorQueue();
if( pQueue )
{
MobileElementList* pWaitList = pQueue->GetWaitList();
int iCount = pWaitList->getCount();
for( int j=0; j<iCount; ++j )
{
Person* pPerson = (Person*) pWaitList->getItem( j );
TerminalMobElementBehavior* spTerminalBehavior = pPerson->getTerminalBehavior();
if(spTerminalBehavior&&!spTerminalBehavior->IfAlreadyEvacuate() )
{
long lSeconds = Default_Person_Response_Time;
long lSpeed = Default_Person_Speed_Impact;
const ProbabilityDistribution* pDistTime = _pInTerm->paxDataList->getResponseTime()->FindFit( pPerson->getType() );
if( pDistTime )
{
lSeconds = (long)pDistTime->getRandomValue();
}
const ProbabilityDistribution* pDistSpeed = _pInTerm->paxDataList->getImpactEmer()->FindFit( pPerson->getType() );
if( pDistSpeed )
{
lSpeed = (long)pDistSpeed->getRandomValue();
}
pPerson->setSpeed( pPerson->getSpeed() + lSpeed );
pPerson->setState( EvacuationFire );
spTerminalBehavior->SetFireEvacuateFlag( true );
pPerson->generateEvent( this->time + lSeconds ,false);
}
}
}
}
}
}
