TInt DBmOmapChannel::BindInterrupt(MBMInterruptLatencyIsr* aIsr)
{
BM_ASSERT(!iIsr);
BM_ASSERT(!iInterruptLatencyIsr);
iInterruptLatencyIsr = aIsr;
return BindInterrupt();
}
void DBMLChannel::Dfc(TAny* ptr)
{
DBMLChannel* lCh = (DBMLChannel*) ptr;
BM_ASSERT(lCh->iPendingInterruptRequest);
BM_ASSERT(lCh->iInterruptThread);
NKern::ThreadRequestSignal(&lCh->iInterruptThread->iNThread);
lCh->iPendingInterruptRequest = EFalse;
}
const Field& State::at(int x, int y) const {
BM_ASSERT(x >= 0);
BM_ASSERT(y >= 0);
BM_ASSERT(x < width);
BM_ASSERT(y < height);
return fields[x][y];
}
TInt DBMLChannel::KernelPreemptionLatencyThreadEntry(TAny* ptr)
{
DBMLChannel* lCh = (DBMLChannel*) ptr;
lCh->KernelPreemptionLatencyThread();
BM_ASSERT(0);
return 0;
}
State fromProto(const protocol::Global& g) {
State res;
res.tick = g.tick();
res.our_doc_id = g.your_doc_id();
res.width = g.width();
res.height = g.height();
res.fields =
std::vector<std::vector<Field>>(res.width,
std::vector<Field>(res.height));
BM_ASSERT(g.fields_size() == int(res.width * res.height));
for (uint32_t y = 0; y < res.height; ++y) {
for (uint32_t x = 0; x < res.width; ++x) {
res.fields[x][y] = fromProto(g.fields(y * res.width + x));
}
}
if (g.has_error()) {
res.error = fromProto(g.error());
}
return res;
}
FieldElement fromProto(const protocol::Field::ElementInfo& ei) {
switch (fromProto(ei.type())) {
case ElementType::FLUXCAPATITOR:
BM_ASSERT(ei.has_flux_capatitor());
return fromProto(ei.flux_capatitor());
case ElementType::DOC:
BM_ASSERT(ei.has_doc());
return fromProto(ei.doc());
case ElementType::ENEMY:
BM_ASSERT(ei.has_enemy());
return fromProto(ei.enemy());
case ElementType::WALL:
return Wall{};
case ElementType::CHEST:
BM_ASSERT(ei.has_chest());
return fromProto(ei.chest());
case ElementType::DELOREAN:
BM_ASSERT(ei.has_delorean());
return fromProto(ei.delorean());
case ElementType::CAPABILITY:
BM_ASSERT(ei.has_capability());
return fromProto(ei.capability());
case ElementType::BLANK:
LOGE("This should never happen (fromProto(FieldElement) blank)");
return {};
}
BM_ASSERT(false);
}
void DBmOmapChannel::RequestInterrupt()
{
BM_ASSERT(iIsr || iInterruptLatencyIsr);
TOmap::SetRegister32(KGPTimerBase+KHoGpTimer_TMAR, TOmap::Register32(KGPTimerBase+KHoGpTimer_TCRR) + KBMOmapInterruptDelayTicks);
// Clear Match interrupt
TOmap::SetRegister32(KGPTimerBase+KHoGpTimer_TISR, KHtGpTimer_TISR_Match);
// Enable Match interrupt
TOmap::SetRegister32(KGPTimerBase+KHoGpTimer_TIER, KHtGpTimer_TIER_Match);
}
void DBmOmapChannel::Isr(TAny* ptr)
{
DBmOmapChannel* mCh = (DBmOmapChannel*) ptr;
BM_ASSERT(mCh->iIsr || mCh->iInterruptLatencyIsr);
if (mCh->iIsr)
{
mCh->iIsr->Isr(TUint(TOmap::Register32(KGPTimerBase + KHoGpTimer_TCRR)));
}
else
{
mCh->iInterruptLatencyIsr->InterruptLatencyIsr(TOmap::Register32(KGPTimerBase+KHoGpTimer_TCRR) - TOmap::Register32(KGPTimerBase+KHoGpTimer_TMAR));
}
TOmap::ModifyRegister32(KGPTimerBase+KHoGpTimer_TIER, KHtGpTimer_TIER_Match, KClear32);
}
MBMChild* BMProgram::SpawnRemoteChild(TBMSpawnArgs* args)
{
CRemoteChild* child = new CRemoteChild(this);
BM_ERROR(KErrNoMemory, child);
//
// Create the child process and pass args as a UNICODE command line.
// (we suppose that the args size is multiple of sizeof(TUint16))
//
BM_ASSERT((args->iSize % sizeof(TUint16)) == 0);
TInt r = child->iChild.Create(RProcess().FileName(), TPtrC((TUint16*) args, args->iSize/sizeof(TUint16)));
BM_ERROR(r, (r == KErrNone) );
child->iChild.Logon(child->iExitStatus);
child->iChild.Resume();
return child;
}
void DBMLChannel::KernelPreemptionLatencyThread()
{
for(;;)
{
NKern::WaitForAnyRequest();
if(iKernelThreadExitSemaphore)
break;
TBMTicks now = PChannel()->TimerStamp();
iTime = Delta(iTime, now);
BM_ASSERT(iUserThread);
NKern::ThreadRequestSignal(&iUserThread->iNThread);
}
NKern::FSSignal(iKernelThreadExitSemaphore);
Kern::Exit(0);
}
ElementType fromProto(protocol::Field::ElementType et) {
switch (et) {
case protocol::Field::FLUXCAPATITOR:
return ElementType::FLUXCAPATITOR;
case protocol::Field::DOC:
return ElementType::DOC;
case protocol::Field::ENEMY:
return ElementType::ENEMY;
case protocol::Field::WALL:
return ElementType::WALL;
case protocol::Field::CHEST:
return ElementType::CHEST;
case protocol::Field::DELOREAN:
return ElementType::DELOREAN;
case protocol::Field::CAPABILITY:
return ElementType::CAPABILITY;
}
BM_ASSERT(false);
}
const T& as() const {
BM_ASSERT(is<T>());
return boost::get<T>(element);
}
//
// The benchmark-suite entry point.
//
GLDEF_C TInt E32Main()
{
RTest test(_L("Benchmark Suite"));
test.Title();
AddProperty();
AddThread();
AddIpc();
AddSync();
AddOverhead();
AddrtLatency();
TInt r = User::LoadPhysicalDevice(KBMPddFileName);
BM_ERROR(r, (r == KErrNone) || (r == KErrAlreadyExists));
r = User::LoadLogicalDevice(KBMLddFileName);
BM_ERROR(r, (r == KErrNone) || (r == KErrAlreadyExists));
r = ::bmTimer.Open();
BM_ERROR(r, (r == KErrNone));
r = ::bmDriver.Open();
BM_ERROR(r, (r == KErrNone));
TBMTimeInterval::Init();
TInt seconds = KBMSecondsPerProgram;
TInt len = User::CommandLineLength();
if (len)
{
//
// Copy the command line in a buffer
//
TInt size = len * sizeof(TUint16);
HBufC8* hb = HBufC8::NewMax(size);
BM_ERROR(KErrNoMemory, hb);
TPtr cmd((TUint16*) hb->Ptr(), len);
User::CommandLine(cmd);
//
// Check for the TBMSpawnArgs magic number.
//
TBMSpawnArgs* args = (TBMSpawnArgs*) hb->Ptr();
if (args->iMagic == TBMSpawnArgs::KMagic)
{
//
// This is a child process - call it's entry point
//
return ::ChildMain(args);
}
else
{
//
// A real command line - the time (in seconds) for each benchmark program.
//
TLex l(cmd);
r = l.Val(seconds);
if (r != KErrNone)
{
test.Printf(_L("Usage: bm_suite <seconds>\n"));
BM_ERROR(r, 0);
}
}
delete hb;
}
{
TBMTicks ticks = 1;
TBMNs ns;
::bmTimer.TicksToNs(&ticks, &ns);
test.Printf(_L("High resolution timer tick %dns\n"), TInt(ns));
test.Printf(_L("High resolution timer period %dms\n"), BMNsToMs(TBMTimeInterval::iStampPeriodNs));
}
test.Start(_L("Performance Benchmark Suite"));
BMProgram* prog = ::bmSuite;
while (prog) {
//
// For each program from the benchmark-suite's list
//
//
// Remember the number of open handles. Just for a sanity check ....
//
TInt start_thc, start_phc;
RThread().HandleCount(start_phc, start_thc);
test.Printf(_L("%S\n"), &prog->Name());
//
// A benchmark-suite's thread can run at any of three possible absolute priorities:
// KBMPriorityLow, KBMPriorityMid and KBMPriorityHigh.
// The main thread starts individual benchmark programs at KBMPriorityMid
//
prog->iOrigAbsPriority = BMProgram::SetAbsPriority(RThread(), KBMPriorityMid);
//
// First of all figure out how many iteration would be required to run this program
// for the given number of seconds.
//
TInt count;
TBMNs ns = 0;
TBMUInt64 iter = KBMCalibrationIter;
for (;;)
{
TBMTimeInterval ti;
ti.Begin();
prog->Run(iter, &count);
ns = ti.EndNs();
// run at least 100ms (otherwise, could be too much impricise ...)
if (ns > BMMsToNs(100)) break;
iter *= 2;
}
test.Printf(_L("%d iterations in %dms\n"), TInt(iter), BMNsToMs(ns));
iter = (BMSecondsToNs(seconds) * iter) / ns;
test.Printf(_L("Go for %d iterations ...\n"), TInt(iter));
//
// Now the real run ...
//
TBMResult* results = prog->Run(iter, &count);
// Restore the original priority
BMProgram::SetAbsPriority(RThread(), prog->iOrigAbsPriority);
//
// Now print out the results
//
for (TInt i = 0; i < count; ++i)
{
if (results[i].iMax)
{
test.Printf(_L("%S. %d iterations; Avr: %dns; Min: %dns; Max: %dns\n"),
&results[i].iName, TInt(results[i].iIterations),
TInt(results[i].iAverage), TInt(results[i].iMin), TInt(results[i].iMax));
TInt j;
BM_ASSERT((TBMResult::KHeadSize % 4) == 0);
test.Printf(_L("Head:"));
for (j = 0; j < TBMResult::KHeadSize; j += 4)
{
test.Printf(_L(" %d %d %d %d "),
TInt(results[i].iHead[j]), TInt(results[i].iHead[j+1]),
TInt(results[i].iHead[j+2]), TInt(results[i].iHead[j+3]));
}
test.Printf(_L("\n"));
BM_ASSERT((TBMResult::KTailSize % 4) == 0);
test.Printf(_L("Tail:"));
for (j = 0; j < TBMResult::KTailSize; j += 4)
{
test.Printf(_L(" %d %d %d %d "),
TInt(results[i].iTail[j]), TInt(results[i].iTail[j+1]),
TInt(results[i].iTail[j+2]), TInt(results[i].iTail[j+3]));
}
test.Printf(_L("\n"));
}
else
{
test.Printf(_L("%S. %d iterations; Avr: %dns\n"),
&results[i].iName, TInt(results[i].iIterations), TInt(results[i].iAverage));
}
}
//
// Sanity check for open handles
//
TInt end_thc, end_phc;
RThread().HandleCount(end_phc, end_thc);
BM_ASSERT(start_thc == end_thc);
BM_ASSERT(start_phc == end_phc);
// and also for pending requests ...
BM_ASSERT(RThread().RequestCount() == 0);
prog = prog->Next();
//
// This can be used to run forever ...
//
// if (prog == NULL)
// prog = ::bmSuite;
//
}
test.End();
::bmDriver.Close();
::bmTimer.Close();
return 0;
}
