bool RunData::decodeMessage(const uint8_t *buf) {
auto runData = GetRunInfo(buf);
if (runData->info_type_type() == InfoTypes_RunStart) {
auto runStartData = static_cast<const RunStart *>(runData->info_type());
setStartTimeInNanoseconds(runStartData->start_time());
setInstrumentName(runStartData->instrument_name()->str());
setRunNumber(runStartData->run_number());
setNumberOfPeriods(runStartData->n_periods());
return true;
}
if (runData->info_type_type() == InfoTypes_RunStop) {
auto runStopData = static_cast<const RunStop *>(runData->info_type());
setStopTime(runStopData->stop_time());
return true;
}
return false; // this is not a RunData message
}
void
printMutableList(bdescr *bd)
{
StgPtr p;
debugBelch("mutable list %p: ", bd);
for (; bd != NULL; bd = bd->link) {
for (p = bd->start; p < bd->free; p++) {
debugBelch("%p (%s), ", (void *)*p, info_type((StgClosure *)*p));
}
}
debugBelch("\n");
}
/*
Check the static objects list.
*/
void
checkStaticObjects ( StgClosure* static_objects )
{
StgClosure *p = static_objects;
const StgInfoTable *info;
while (p != END_OF_STATIC_OBJECT_LIST) {
p = UNTAG_STATIC_LIST_PTR(p);
checkClosure(p);
info = get_itbl(p);
switch (info->type) {
case IND_STATIC:
{
const StgClosure *indirectee;
indirectee = UNTAG_CONST_CLOSURE(((StgIndStatic *)p)->indirectee);
ASSERT(LOOKS_LIKE_CLOSURE_PTR(indirectee));
ASSERT(LOOKS_LIKE_INFO_PTR((StgWord)indirectee->header.info));
p = *IND_STATIC_LINK((StgClosure *)p);
break;
}
case THUNK_STATIC:
p = *THUNK_STATIC_LINK((StgClosure *)p);
break;
case FUN_STATIC:
p = *STATIC_LINK(info,(StgClosure *)p);
break;
case CONSTR:
case CONSTR_NOCAF:
case CONSTR_1_0:
case CONSTR_2_0:
case CONSTR_1_1:
p = *STATIC_LINK(info,(StgClosure *)p);
break;
default:
barf("checkStaticObjetcs: strange closure %p (%s)",
p, info_type(p));
}
}
}
/*
Check the static objects list.
*/
void
checkStaticObjects ( StgClosure* static_objects )
{
StgClosure *p = static_objects;
StgInfoTable *info;
while (p != END_OF_STATIC_LIST) {
checkClosure(p);
info = get_itbl(p);
switch (info->type) {
case IND_STATIC:
{
StgClosure *indirectee = UNTAG_CLOSURE(((StgIndStatic *)p)->indirectee);
ASSERT(LOOKS_LIKE_CLOSURE_PTR(indirectee));
ASSERT(LOOKS_LIKE_INFO_PTR((StgWord)indirectee->header.info));
p = *IND_STATIC_LINK((StgClosure *)p);
break;
}
case THUNK_STATIC:
p = *THUNK_STATIC_LINK((StgClosure *)p);
break;
case FUN_STATIC:
p = *FUN_STATIC_LINK((StgClosure *)p);
break;
case CONSTR_STATIC:
p = *STATIC_LINK(info,(StgClosure *)p);
break;
default:
barf("checkStaticObjetcs: strange closure %p (%s)", p,
#ifndef HaLVM_TARGET_OS
info_type(p)
#else
"[HaLVM has no info_type()]"
#endif
);
}
}
}
Task_Entry::Propagation_Status
Task_Entry::merge_dispatches (ACE_Unbounded_Set <Dispatch_Entry *> &dispatch_entries,
ACE_CString &unresolved_locals,
ACE_CString &unresolved_remotes)
{
Task_Entry::Propagation_Status result = SUCCEEDED;
switch (info_type ())
{
case RtecScheduler::DISJUNCTION:
// Prohibit two-way dispatches of a disjunction group, and
// disjunctively merge its one-way dispatches. NOTE: one
// interpretation of disjunction for two-way calls is that the
// caller calls one OR the other, but this is problematic: how
// do we map the dispatches for this ?
if (prohibit_dispatches (RtecBase::TWO_WAY_CALL) < 0)
result = TWO_WAY_DISJUNCTION;
if (disjunctive_merge (RtecBase::ONE_WAY_CALL,
dispatch_entries,
unresolved_locals,
unresolved_remotes) < 0)
result = INTERNAL_ERROR;
break;
case RtecScheduler::CONJUNCTION:
// Prohibit two-way dispatches of a conjunction group,
// and conjunctively merge its one-way dispatches.
// NOTE: one interpretation of disjunction for two-way calls
// is that the caller calls BOTH, so that there is a
// disjunctive merge of each two-way, as for the OPERATION
// (prohibit for now, as the additional complexity of allowing
// conjunctions of two-ways, but not disjunctions does not
// buy us anything, anyway).
if (prohibit_dispatches (RtecBase::TWO_WAY_CALL) < 0)
result = TWO_WAY_CONJUNCTION;
if (conjunctive_merge (RtecBase::ONE_WAY_CALL,
dispatch_entries,
unresolved_locals,
unresolved_remotes) < 0)
result = INTERNAL_ERROR;
break;
case RtecScheduler::OPERATION:
case RtecScheduler::REMOTE_DEPENDANT:
// Disjunctively merge the operation's two-way dispatches, and
// conjunctively merge its one-way dispatches.
if (disjunctive_merge (RtecBase::TWO_WAY_CALL,
dispatch_entries,
unresolved_locals,
unresolved_remotes) < 0)
result = INTERNAL_ERROR;
if (conjunctive_merge (RtecBase::ONE_WAY_CALL,
dispatch_entries,
unresolved_locals,
unresolved_remotes) < 0)
result = INTERNAL_ERROR;
break;
default:
// There should not be any other kind of RT_Info, or if there
// is, the above switch logic is in need of repair.
result = UNRECOGNIZED_INFO_TYPE;
break;
}
return result;
}
void prettyPrintClosure_ (StgClosure *obj)
{
StgInfoTable *info;
StgConInfoTable *con_info;
/* collapse any indirections */
unsigned int type;
type = get_itbl(obj)->type;
while (type == IND ||
type == IND_STATIC ||
type == IND_PERM)
{
obj = ((StgInd *)obj)->indirectee;
type = get_itbl(obj)->type;
}
/* find the info table for this object */
info = get_itbl(obj);
/* determine what kind of object we have */
switch (info->type)
{
/* full applications of data constructors */
case CONSTR:
case CONSTR_1_0:
case CONSTR_0_1:
case CONSTR_1_1:
case CONSTR_0_2:
case CONSTR_2_0:
case CONSTR_STATIC:
case CONSTR_NOCAF_STATIC:
{
nat i;
char *descriptor;
/* find the con_info for the constructor */
con_info = get_con_itbl (obj);
/* obtain the name of the constructor */
descriptor = GET_CON_DESC(con_info);
debugBelch ("(%s", descriptor);
/* process the payload of the closure */
/* we don't handle non pointers at the moment */
for (i = 0; i < info->layout.payload.ptrs; i++)
{
debugBelch (" ");
prettyPrintClosure_ ((StgClosure *) obj->payload[i]);
}
debugBelch (")");
break;
}
/* if it isn't a constructor then just print the closure type */
default:
{
debugBelch ("<%s>", info_type(obj));
break;
}
}
}