void LLVMWorkerThread::execute()
{
WorkerMessage* message;
LLVMCooperativeThreadArray cta(this);
report("LLVMWorker thread is alive, waiting for command.");
threadReceive(message);
while(message->type != WorkerMessage::Kill)
{
try
{
switch(message->type)
{
case WorkerMessage::LaunchCta:
{
report(" Launching CTA " << message->ctaId
<< " on thread " << id() << ".");
cta.executeCta(message->ctaId);
threadSend(message);
}
break;
case WorkerMessage::SetupCta:
{
report(" Setting up CTA for kernel '" << message->kernel->name
<< "' on thread " << id() << ".");
cta.setup(*message->kernel);
threadSend(message);
}
break;
case WorkerMessage::FlushCta:
{
report(" Flushing translation cache on thread " << id() << ".");
cta.flushTranslatedKernels();
threadSend(message);
}
break;
default: assertM(false, "Invalid message type.");
}
}
catch(const hydrazine::Exception& e)
{
report("Operation failed, replying with exception.");
message->type = WorkerMessage::Exception;
message->errorMessage = e.what();
threadSend(message);
}
threadReceive(message);
}
report("Received kill command, joining.");
threadSend(message);
}
void CpdDeliverSingleMessage () {
if (!CpdIsFrozen()) return; /* Do something only if we are in freeze mode */
if ( (CkpvAccess(lastBreakPointMsg) != NULL) && (CkpvAccess(lastBreakPointObject) != NULL) ) {
EntryInfo * breakPointEntryInfo = CpvAccess(breakPointEntryTable)->get(CkpvAccess(lastBreakPointIndex));
if (breakPointEntryInfo != NULL) {
if (_conditionalDelivery) {
if (_conditionalDelivery==1) conditionalShm->msgs[conditionalShm->count++] = -1;
void *env = UsrToEnv(CkpvAccess(lastBreakPointMsg));
CmiReference(env);
CdsFifo_Enqueue(CpvAccess(conditionalQueue),env);
}
breakPointEntryInfo->call(CkpvAccess(lastBreakPointMsg), CkpvAccess(lastBreakPointObject));
}
CkpvAccess(lastBreakPointMsg) = NULL;
CkpvAccess(lastBreakPointObject) = NULL;
#if CMK_BIGSIM_CHARM
((workThreadInfo*)cta(threadinfo))->stopScheduler();
#endif
}
else {
// we were not stopped at a breakpoint, then deliver the first message in the debug queue
if (!CdsFifo_Empty(CkpvAccess(debugQueue))) {
CkpvAccess(skipBreakpoint) = 1;
char *queuedMsg = (char *)CdsFifo_Dequeue(CkpvAccess(debugQueue));
if (_conditionalDelivery) {
if (_conditionalDelivery==1) conditionalShm->msgs[conditionalShm->count++] = 0;
CmiReference(queuedMsg);
CdsFifo_Enqueue(CpvAccess(conditionalQueue),queuedMsg);
}
#if CMK_BIGSIM_CHARM
stopVTimer();
BgProcessMessageDefault(cta(threadinfo), queuedMsg);
startVTimer();
#else
CmiHandleMessage(queuedMsg);
#endif
CkpvAccess(skipBreakpoint) = 0;
}
}
}
void CpdContinueFromBreakPoint ()
{
CpdUnFreeze();
if ( (CkpvAccess(lastBreakPointMsg) != NULL) && (CkpvAccess(lastBreakPointObject) != NULL) )
{
EntryInfo * breakPointEntryInfo = CpvAccess(breakPointEntryTable)->get(CkpvAccess(lastBreakPointIndex));
if (breakPointEntryInfo != NULL) {
breakPointEntryInfo->call(CkpvAccess(lastBreakPointMsg), CkpvAccess(lastBreakPointObject));
#if CMK_BIGSIM_CHARM
((workThreadInfo*)cta(threadinfo))->stopScheduler();
#endif
} else {
// This means that the breakpoint got deleted in the meanwhile
}
}
CkpvAccess(lastBreakPointMsg) = NULL;
CkpvAccess(lastBreakPointObject) = NULL;
}
static void CpdDeliverMessageInt(int msgNum) {
void *m;
void *debugQ=CkpvAccess(debugQueue);
CdsFifo_Enqueue(debugQ, (void*)(-1)); // Enqueue a guard
for (int i=0; i<msgNum; ++i) CdsFifo_Enqueue(debugQ, CdsFifo_Dequeue(debugQ));
CkpvAccess(skipBreakpoint) = 1;
char *queuedMsg = (char *)CdsFifo_Dequeue(debugQ);
if (_conditionalDelivery==1) conditionalShm->msgs[conditionalShm->count++] = msgNum;
if (_conditionalDelivery) {
CmiReference(queuedMsg);
CdsFifo_Enqueue(CpvAccess(conditionalQueue), queuedMsg);
}
#if CMK_BIGSIM_CHARM
stopVTimer();
BgProcessMessageDefault(cta(threadinfo), queuedMsg);
startVTimer();
#else
CmiHandleMessage(queuedMsg);
#endif
CkpvAccess(skipBreakpoint) = 0;
while ((m=CdsFifo_Dequeue(debugQ)) != (void*)(-1)) CdsFifo_Enqueue(debugQ, m);
}
static void _call_freeze_on_break_point(void * msg, void * object)
{
//Save breakpoint entry point index. This is retrieved from msg.
//So that the appropriate EntryInfo can be later retrieved from the hash table
//of break point function entries, on continue.
// If the counter "skipBreakpoint" is not zero we actually do not freeze and deliver the regular message
EntryInfo * breakPointEntryInfo = CpvAccess(breakPointEntryTable)->get(CkMessageToEpIdx(msg));
if (CkpvAccess(skipBreakpoint) > 0 || CkpvAccess(_debugEntryTable)[CkMessageToEpIdx(msg)].isBreakpoint==false) {
CkAssert(breakPointEntryInfo != NULL);
breakPointEntryInfo->call(msg, object);
if (CkpvAccess(skipBreakpoint) > 0) CkpvAccess(skipBreakpoint) --;
} else {
CkpvAccess(lastBreakPointMsg) = msg;
CkpvAccess(lastBreakPointObject) = object;
CkpvAccess(lastBreakPointIndex) = CkMessageToEpIdx(msg);
CpdNotify(CPD_BREAKPOINT,breakPointEntryInfo->name);
CpdFreeze();
#if CMK_BIGSIM_CHARM
stopVTimer();
((workThreadInfo*)cta(threadinfo))->scheduler(-1);
#endif
}
}
void BgScheduler(int nmsg)
{
ASSERT(tTHREADTYPE == WORK_THREAD);
// end current log
int isinterrupt = 0;
if (genTimeLog) {
if (BgIsInALog(tTIMELINEREC)) {
isinterrupt = 1;
BgLogEntryCommit(tTIMELINEREC);
tTIMELINEREC.bgPrevLog = BgLastLog(tTIMELINEREC);
}
}
stopVTimer();
((workThreadInfo*)cta(threadinfo))->scheduler(nmsg);
// begin a new log, and make dependency
startVTimer();
if (genTimeLog && isinterrupt)
{
BgTimeLog *curlog = BgLastLog(tTIMELINEREC);
BgTimeLog *newLog = BgStartLogByName(tTIMELINEREC, -1, (char*)"BgSchedulerEnd", BgGetCurTime(), curlog);
}
}
void BgExitScheduler()
{
ASSERT(tTHREADTYPE == WORK_THREAD);
((workThreadInfo*)cta(threadinfo))->stopScheduler();
}
