void ExecuteThread::run(void *arg /* = 0 */)
{
if(mProcess == NULL)
return;
DWORD wait = WAIT_OBJECT_0 - 1; // i.e., not WAIT_OBJECT_0
while(! checkForStop() && (wait = WaitForSingleObject(mProcess, 200)) != WAIT_OBJECT_0) ;
Sim::postEvent(Sim::getRootGroup(), new ExecuteCleanupEvent(this, wait == WAIT_OBJECT_0), -1);
}
void loadPartition(struct gbSelect* select, struct sqlConnection* conn)
/* Sync the database with the state in the genbank respository for a given
* partition of the data. The gbLoadedTbl is loaded as needed for new
* release. forceLoad overrides checking the gbLoaded table */
{
checkForStop(); /* don't even get started */
/* Need to make sure this release has been loaded into the gbLoaded obj */
gbLoadedTblUseRelease(gLoadedTbl, select->release);
/* if reloading, clean everything out */
if (gReload)
removeForReload(select, conn, gWorkDir);
/* do a cheap check to see if it possible there is something
* to load, before much longer examination of per-sequence tables.*/
if ((gOptions.flags & DBLOAD_BYPASS_GBLOADED) || anyUpdatesNeedLoaded(select))
doLoadPartition(select);
checkForStop(); /* database committed */
}
void ThreadPool::WorkerThread::run( void* arg )
{
#ifdef TORQUE_DEBUG
{
// Set the thread's name for debugging.
char buffer[ 2048 ];
dSprintf( buffer, sizeof( buffer ), "ThreadPool(%s) WorkerThread %i", mPool->mName.c_str(), mIndex );
_setName( buffer );
}
#endif
#if defined(TORQUE_OS_XENON)
// On Xbox 360 you must explicitly assign software threads to hardware threads.
// This will distribute job threads across the secondary CPUs leaving both
// primary CPU cores available to the "main" thread. This will help prevent
// more L2 thrashing of the main thread/core.
static U32 sCoreAssignment = 2;
XSetThreadProcessor( GetCurrentThread(), sCoreAssignment );
sCoreAssignment = sCoreAssignment < 6 ? sCoreAssignment + 1 : 2;
#endif
while( 1 )
{
if( checkForStop() )
{
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[ThreadPool::WorkerThread] thread '%i' exits", getId() );
#endif
dFetchAndAdd( mPool->mNumThreads, ( U32 ) -1 );
return;
}
// Mark us as potentially blocking.
dFetchAndAdd( mPool->mNumThreadsReady, ( U32 ) -1 );
bool waitForSignal = false;
{
// Try to take an item from the queue. Do
// this in a separate block, so we'll be
// releasing the item after we have finished.
WorkItemWrapper workItem;
if( mPool->mWorkItemQueue.takeNext( workItem ) )
{
// Mark us as non-blocking as this loop definitely
// won't wait on the semaphore.
dFetchAndAdd( mPool->mNumThreadsReady, 1 );
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[ThreadPool::WorkerThread] thread '%i' takes item '0x%x'", getId(), *workItem );
#endif
workItem->process();
}
else
waitForSignal = true;
}
if( waitForSignal )
{
dFetchAndAdd( mPool->mNumThreadsAwake, ( U32 ) -1 );
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[ThreadPool::WorkerThread] thread '%i' going to sleep", getId() );
#endif
mPool->mSemaphore.acquire();
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[ThreadPool::WorkerThread] thread '%i' waking up", getId() );
#endif
dFetchAndAdd( mPool->mNumThreadsAwake, 1 );
dFetchAndAdd( mPool->mNumThreadsReady, 1 );
}
}
}
void databaseUpdate(struct gbSelect* select)
/* update the database from genbank state on disk */
{
struct sqlConnection *conn = hAllocConn(gDatabase);
struct gbStatusTbl* statusTbl;
boolean maxShrinkageExceeded;
char typePrefix[32], tmpDir[PATH_LEN];
gbVerbEnter(3, "update %s", gbSelectDesc(select));
/* Setup tmp dir for load, must be unique for each update due to
* initialLoad feature */
if (select->accPrefix != NULL)
safef(typePrefix, sizeof(typePrefix), "%s.%s", gbFmtSelect(select->type),
select->accPrefix);
else
safef(typePrefix, sizeof(typePrefix), "%s", gbFmtSelect(select->type));
safef(tmpDir, sizeof(tmpDir), "%s/%s/%s/%s",
gWorkDir, select->release->name, select->release->genome->database,
typePrefix);
if (!(gOptions.flags & DBLOAD_DRY_RUN))
gbMakeDirs(tmpDir);
/* Build list of entries that need processed. This also flags updates that
* have the change and new entries so we can limit the per-update processing.
*/
statusTbl = gbBuildState(conn, select, &gOptions, gMaxShrinkage, tmpDir,
gbVerbose, FALSE, &maxShrinkageExceeded);
if (maxShrinkageExceeded)
{
fprintf(stderr, "Warning: switching to dryRun mode due to maxShrinkage being exceeded\n");
gMaxShrinkageError = TRUE;
gOptions.flags |= DBLOAD_DRY_RUN;
}
if (gOptions.flags & DBLOAD_DRY_RUN)
{
gbVerbLeave(3, "dry run, skipping update %s", gbSelectDesc(select));
gbStatusTblFree(&statusTbl);
hFreeConn(&conn);
return;
}
checkForStop(); /* last safe place */
/* count global number of extFileChgs */
gExtFileChged += statusTbl->numExtChg;
/* first clean out old and changed */
deleteOutdated(conn, select, statusTbl, tmpDir);
/* meta data MUST be done first, it sets some gbStatus data */
processMetaData(conn, select, statusTbl, tmpDir);
processAligns(conn, select, statusTbl, tmpDir);
/* now it's safe to update the status table, delay commit for initialLoad */
if (gOptions.flags & DBLOAD_INITIAL)
slSafeAddHead(&gPendingStatusUpdates,
gbStatusTblUpdate(statusTbl, conn, FALSE));
else
gbStatusTblUpdate(statusTbl, conn, TRUE);
/* add this and partition to the loaded table, if not already there.
* set the extFile updated flag updates were done or this is the initial load */
updateLoadedTbl(select);
if (gOptions.flags & DBLOAD_INITIAL)
gbLoadedTblSetExtFileUpdated(gLoadedTbl, select);
if ((gOptions.flags & DBLOAD_INITIAL) == 0)
gbLoadedTblCommit(gLoadedTbl);
/* print before freeing memory */
gbVerbLeave(3, "update %s", gbSelectDesc(select));
gbStatusTblFree(&statusTbl);
hFreeConn(&conn);
}
