Initial commit

engine/network/src/Replicator.StatsItem.cpp

@@ -0,0 +1,159 @@
+#include "DataModel/DataModel.hpp"
+// d9mz - member access into incomplete type 'DataModel'
+#include "Replicator.StatsItem.hpp"
+#include "Script/ScriptContext.hpp"
+#include "ClientReplicator.hpp"
+
+using namespace Aya;
+using namespace Network;
+
+struct JobInfo
+{
+    double dutyCycle;
+    double stepsPerSecond;
+    double stepTime;
+    int count;
+
+    JobInfo()
+        : dutyCycle(0)
+        , stepTime(0)
+        , stepsPerSecond(0)
+        , count(0)
+    {
+    }
+};
+
+void DeserializedStatsItem::process(Replicator& replicator)
+{
+    ClientReplicator* rep = aya_static_cast<ClientReplicator*>(&replicator);
+    rep->statsReceivedSignal(stats);
+}
+
+void writeTaskSchedulerStats(DataModel* dm, RakNet::BitStream& bitStream)
+{
+    std::vector<boost::shared_ptr<const TaskScheduler::Job>> jobs;
+    TaskScheduler::singleton().getJobsInfo(jobs);
+
+    boost::unordered_map<std::string, JobInfo> aggregatedJobInfos;
+
+    // BitStream:
+    // end flag (bool)
+    // job name (string)
+    // duty cycle (float)
+    // steps per second (float)
+    // step time (float)
+
+    for (std::vector<boost::shared_ptr<const TaskScheduler::Job>>::iterator iter = jobs.begin(); iter != jobs.end(); iter++)
+    {
+        shared_ptr<const TaskScheduler::Job> job = *iter;
+        if (job->getArbiter().get() != dm)
+            continue;
+
+        const std::string& name = job->name;
+
+        JobInfo& info = aggregatedJobInfos[name];
+        info.dutyCycle += job->averageDutyCycle();
+        info.stepsPerSecond += job->averageStepsPerSecond();
+        info.stepTime += job->averageStepTime();
+        info.count++;
+    }
+
+    // calculate replicator job averages and write to bit stream
+    for (boost::unordered_map<std::string, JobInfo>::iterator iter = aggregatedJobInfos.begin(); iter != aggregatedJobInfos.end(); iter++)
+    {
+        bitStream << false; // more items
+
+        bitStream << iter->first;
+        bitStream << (float)(iter->second.dutyCycle / iter->second.count);
+        bitStream << (float)(iter->second.stepsPerSecond / iter->second.count);
+        bitStream << (float)(iter->second.stepTime / iter->second.count);
+    }
+    bitStream << true; // done with jobs
+}
+
+void writeScriptStats(DataModel* dm, RakNet::BitStream& bitStream)
+{
+    ScriptContext* sc = dm->find<ScriptContext>();
+    std::string scriptsJson;
+    sc->setCollectScriptStats(true);
+
+    std::vector<ScriptContext::ScriptStat> scriptStats;
+    sc->getScriptStatsTyped(scriptStats);
+
+    for (std::vector<ScriptContext::ScriptStat>::iterator iter = scriptStats.begin(); iter != scriptStats.end(); iter++)
+    {
+        bitStream << false; // more stats info
+
+        bitStream << iter->name;
+        bitStream << (float)iter->activity;
+        bitStream << (int)iter->invocationCount;
+    }
+    bitStream << true; // done with stats info
+}
+
+bool Replicator::StatsItem::write(RakNet::BitStream& bitStream)
+{
+    writeItemType(bitStream, Item::ItemTypeStats);
+
+    float totalPhysicsFPS = 0;
+    float dataPacketsTotal = 0;
+    float dataSizeTotal = 0;
+    float physicsPacketsTotal = 0;
+    float physicsSizeTotal = 0;
+    float totalPing = 0;
+    float totalNewDataItems = 0;
+    float totalSentDataItems = 0;
+
+    Instances::const_iterator end = replicator.getParent()->getChildren()->end();
+    for (Instances::const_iterator iter = replicator.getParent()->getChildren()->begin(); iter != end; ++iter)
+    {
+        // accumulate stats for all replicator
+        if (Replicator* r = Instance::fastDynamicCast<Replicator>(iter->get()))
+        {
+            const ReplicatorStats& s = r->stats();
+            totalPhysicsFPS += r->stats().physicsSenderStats.physicsPacketsSent.rate();
+            dataPacketsTotal += r->stats().dataPacketsSent.rate();
+            dataSizeTotal += r->stats().dataPacketsSentSize.value();
+            physicsPacketsTotal += r->stats().physicsSenderStats.physicsPacketsSent.rate();
+            physicsSizeTotal += r->stats().physicsSenderStats.physicsPacketsSentSize.value();
+            totalPing += r->stats().dataPing.value();
+            totalNewDataItems += (float)s.dataNewItemsPerSec.getCount();
+            totalSentDataItems += (float)s.dataItemsSentPerSec.getCount();
+        }
+    }
+
+    int numChildren = replicator.getParent()->numChildren();
+
+    switch (version)
+    {
+    case 2:
+    {
+        DataModel* dm = DataModel::get(&replicator);
+        writeTaskSchedulerStats(dm, bitStream);
+        writeScriptStats(dm, bitStream);
+    }
+        // fall through
+    case 1:
+    {
+        bitStream << (totalPing / numChildren);                        // average ping
+        bitStream << (totalPhysicsFPS / numChildren);                  // average physics sender fps
+        bitStream << dataPacketsTotal * dataSizeTotal / 1000.0f;       // total data KB per sec
+        bitStream << physicsPacketsTotal * physicsSizeTotal / 1000.0f; // total physics KB per sec
+        bitStream << totalSentDataItems / totalNewDataItems;           // data throughput
+    }
+    default:
+        break;
+    }
+
+    return true;
+}
+
+shared_ptr<DeserializedItem> Replicator::StatsItem::read(Replicator& replicator, RakNet::BitStream& bitStream)
+{
+    shared_ptr<DeserializedStatsItem> deserializedData(new DeserializedStatsItem());
+
+    ClientReplicator* rep = aya_static_cast<ClientReplicator*>(&replicator);
+    deserializedData->stats = rep->readStats(bitStream);
+
+    return deserializedData;
+}