Features/evolution dashboard

source/Base/Resources.h

@@ -4,7 +4,7 @@
 
 namespace Const
 {
-    std::string const ProgramVersion = "5.0.0-alpha.21";
+    std::string const ProgramVersion = "5.0.0-alpha.22";
     std::string const DiscordURL = "https://discord.gg/7bjyZdXXQ2";
     std::string const AlienServerURL = "api.alien-project.org";
 

source/Base/StringHelper.cpp

@@ -24,14 +24,19 @@ std::string StringHelper::format(uint64_t n, char separator)
 }
 
 std::string StringHelper::format(float v, int fracPartDecimals)
+{
+    return format(static_cast<double>(v), fracPartDecimals);
+}
+
+std::string StringHelper::format(double v, int fracPartDecimals)
 {
     std::string result;
     if (v < 0) {
         result = "-";
         v = -v;
     }
     auto scale = static_cast<uint64_t>(std::llround(std::pow(10.0, fracPartDecimals)));
-    auto scaled = static_cast<uint64_t>(std::llround(static_cast<double>(v) * scale));
+    auto scaled = static_cast<uint64_t>(std::llround(v * scale));
     result += format(scaled / scale);
     if (fracPartDecimals > 0) {
         result += ".";
@@ -105,6 +110,23 @@ std::string StringHelper::formatInHex(uint64_t value)
     return ss.str();
 }
 
+std::string StringHelper::formatInThousands(double value)
+{
+    if (value == 0.0) {
+        return "0";
+    }
+    auto result = format(value / 1000, 3);
+    if (result.find('.') != std::string::npos) {
+        while (result.back() == '0') {
+            result.pop_back();
+        }
+        if (result.back() == '.') {
+            result.pop_back();
+        }
+    }
+    return result + "K";
+}
+
 void StringHelper::copy(char* target, int maxSize, std::string const& source)
 {
     auto sourceSize = source.size();

source/Base/StringHelper.h

@@ -10,10 +10,12 @@ class StringHelper
 public:
     static std::string format(uint64_t n, char separator = ',');
     static std::string format(float v, int decimalsAfterPoint);
+    static std::string format(double v, int decimalsAfterPoint);
     static std::string format(std::chrono::seconds duration);
     static std::string format(std::chrono::milliseconds duration);
     static std::string format(std::chrono::system_clock::time_point const& timePoint);
     static std::string formatInHex(uint64_t value);
+    static std::string formatInThousands(double value);  //e.g. 12000 -> "12K", 1000000 -> "1,000K"
 
     static void copy(char* target, int maxSize, std::string const& source);
     static bool compare(char const* target, int maxSize, char const* source);

source/Cli/Main.cpp

@@ -36,7 +36,7 @@ int main(int argc, char** argv)
         app.add_option(
             "-o",
             outputFilename,
-            "Specifies the name of the output file for the simulation. The *.settings.json and *.statistics.csv file will also be saved.");
+            "Specifies the name of the output file for the simulation. The *.settings.json and *.statistics.bin file will also be saved.");
         app.add_option("-t", timesteps, "The number of time steps to be calculated.");
         app.add_flag(
             "-p,--profile",

source/EngineImpl/DescConverterService.cpp

@@ -936,6 +936,7 @@ CreatureDesc DescConverterService::createCreatureDesc(TOs const& to, int creatur
     result._lineageId = creatureTO.lineageId;
     NumberGenerator::get().adaptMaxLineageId(creatureTO.lineageId);
     result._accumulatedMutations = creatureTO.accumulatedMutations;
+    result._accumulatedMutationsInLineage = creatureTO.accumulatedMutationsInLineage;
     result._headUpdateId = creatureTO.headUpdateId;
 
     return result;
@@ -1258,6 +1259,7 @@ void DescConverterService::convertCreatureToTO(
     creatureTO.mutationState = creatureDesc._mutationState;
     creatureTO.lineageId = creatureDesc._lineageId;
     creatureTO.accumulatedMutations = creatureDesc._accumulatedMutations;
+    creatureTO.accumulatedMutationsInLineage = creatureDesc._accumulatedMutationsInLineage;
     creatureTO.genomeArrayIndex = genomeTOIndexById.at(creatureDesc._genomeId);
 }
 

source/EngineImpl/EngineWorker.cpp

@@ -99,11 +99,6 @@ Desc EngineWorker::getInspectedSimulationData(std::vector<uint64_t> objectsIds)
     return DescConverterService::get().convertTOtoDescription(dataTO);
 }
 
-StatisticsRawData EngineWorker::getStatisticsRawData() const
-{
-    return _simulationCudaFacade->getStatisticsRawData();
-}
-
 StatisticsHistory const& EngineWorker::getStatisticsHistory() const
 {
     return _simulationCudaFacade->getStatisticsHistory();
@@ -114,6 +109,11 @@ void EngineWorker::setStatisticsHistory(StatisticsHistoryData const& data)
     _simulationCudaFacade->setStatisticsHistory(data);
 }
 
+StatisticsEntry EngineWorker::getStatisticsEntry() const
+{
+    return _simulationCudaFacade->getStatisticsEntry();
+}
+
 void EngineWorker::addAndSelectSimulationData(Desc&& dataToUpdate)
 {
     EngineWorkerGuard access(this);
@@ -263,7 +263,6 @@ void EngineWorker::setCurrentTimestep(uint64_t value)
 {
     EngineWorkerGuard access(this);
     _simulationCudaFacade->setCurrentTimestep(value);
-    resetTimeIntervalStatistics();
 }
 
 SimulationParameters EngineWorker::getSimulationParameters() const
@@ -538,10 +537,6 @@ void EngineWorker::testOnly_syncNumberGenerator()
     NumberGenerator::get().adaptMaxIds(maxIds);
 }
 
-void EngineWorker::resetTimeIntervalStatistics()
-{
-    _simulationCudaFacade->resetTimeIntervalStatistics();
-}
 
 void EngineWorker::processJobs()
 {

source/EngineImpl/EngineWorker.h

@@ -14,14 +14,14 @@
 #include <EngineInterface/CudaSettings.h>
 #include <EngineInterface/Definitions.h>
 #include <EngineInterface/GeometryBuffers.h>
+#include <EngineInterface/StatisticsEntry.h>
 #include <EngineInterface/PreviewDesc.h>
 #include <EngineInterface/SelectionShallowData.h>
 #include <EngineInterface/SettingsForSimulation.h>
 #include <EngineInterface/ShallowUpdateSelectionData.h>
 #include <EngineInterface/SimulationParameters.h>
 #include <EngineInterface/SimulationParametersUpdateConfig.h>
 #include <EngineInterface/StatisticsHistory.h>
-#include <EngineInterface/StatisticsRawData.h>
 
 #include <EngineKernels/Definitions.h>
 
@@ -55,9 +55,9 @@ class EngineWorker
     Desc getSimulationData(IntVector2D const& rectUpperLeft, IntVector2D const& rectLowerRight);
     Desc getSelectedSimulationData(bool includeClusters);
     Desc getInspectedSimulationData(std::vector<uint64_t> objectsIds);
-    StatisticsRawData getStatisticsRawData() const;
     StatisticsHistory const& getStatisticsHistory() const;
     void setStatisticsHistory(StatisticsHistoryData const& data);
+    StatisticsEntry getStatisticsEntry() const;
 
     void addAndSelectSimulationData(Desc&& dataToUpdate);
     void setSimulationData(Desc const& dataToUpdate);
@@ -132,7 +132,6 @@ class EngineWorker
     void testOnly_syncNumberGenerator();
 
 private:
-    void resetTimeIntervalStatistics();
     void processJobs();
 
     void syncSimulationWithRenderingIfDesired();

source/EngineImpl/SimulationCudaFacade.cu

@@ -29,7 +29,6 @@
 #include <EngineKernels/GarbageCollectorKernels.cuh>
 #include <EngineKernels/GeometryKernels.cuh>
 #include <EngineKernels/Map.cuh>
-#include <EngineKernels/MaxAgeBalancer.cuh>
 #include <EngineKernels/SelectionResult.cuh>
 #include <EngineKernels/SimulationData.cuh>
 #include <EngineKernels/SimulationStatistics.cuh>
@@ -50,7 +49,10 @@
 
 namespace
 {
-    std::chrono::milliseconds const StatisticsUpdate(30);
+    // The evolution statistics kernels are heavy; running them at wall-clock-throttled (i.e. run-to-run varying)
+    // timesteps perturbs the simulation's GPU execution timing and makes simulation runs non-reproducible.
+    // They are therefore scheduled at deterministic timestep intervals instead.
+    auto constexpr EvolutionStatisticsUpdateInterval = 10;
     ArraySizesForGpuEntities const PreviewCapacityGpu{10000, 10000, 10000000};
     ArraySizesForTOs const PreviewCapacityTO{1000, 1000, 1000, 10000, 10000, 10000, 10000000};
 }
@@ -76,7 +78,6 @@ _SimulationCudaFacade::_SimulationCudaFacade(uint64_t timestep, SettingsForSimul
     _cudaTOProvider = std::make_shared<_CudaTOProvider>();
     _cudaSimulationStatistics = std::make_shared<SimulationStatistics>();
     _cudaPreviewStatistics = std::make_shared<SimulationStatistics>();
-    _maxAgeBalancer = std::make_shared<_MaxAgeBalancer>();
 
     _simulationTimestep = timestep;
     _cudaSimulationData->init({_settings.worldSizeX, _settings.worldSizeY}, timestep);
@@ -112,6 +113,7 @@ _SimulationCudaFacade::~_SimulationCudaFacade() noexcept
             _cudaSimulationData->free();
             _cudaPreviewData->free();
             _cudaSimulationStatistics->free();
+            _cudaPreviewStatistics->free();
             _cudaSelectionResult->free();
 
             SimulationKernelsService::get().shutdown();
@@ -430,41 +432,42 @@ ArraySizesForTOs _SimulationCudaFacade::estimateCapacityNeededForTO() const
     return DataAccessKernelsService::get().estimateCapacityNeededForTO(_settings.cudaSettings, getSimulationDataPtrCopy());
 }
 
-StatisticsRawData _SimulationCudaFacade::getStatisticsRawData()
+void _SimulationCudaFacade::updateStatistics()
 {
-    std::lock_guard lock(_mutexForStatistics);
-    if (_statisticsData) {
-        return *_statisticsData;
-    } else {
-        return StatisticsRawData();
-    }
+    updateEvolutionStatistics();
 }
 
-void _SimulationCudaFacade::updateStatistics()
+void _SimulationCudaFacade::updateEvolutionStatistics()
 {
     StatisticsKernelsService::get().updateStatistics(_settings.cudaSettings, getSimulationDataPtrCopy(), *_cudaSimulationStatistics);
     syncAndCheck();
 
+    auto statisticsEntry = _cudaSimulationStatistics->getStatisticsEntry();
     {
         std::lock_guard lock(_mutexForStatistics);
-        _statisticsData = _cudaSimulationStatistics->getStatistics();
+        _statisticsEntry = statisticsEntry;
     }
-    StatisticsService::get().addDataPoint(_statisticsHistory, _statisticsData->timeline, getCurrentTimestep());
+    StatisticsService::get().addDataPoint(_statisticsHistory, statisticsEntry, getCurrentTimestep());
 }
 
 StatisticsHistory const& _SimulationCudaFacade::getStatisticsHistory() const
 {
     return _statisticsHistory;
 }
 
-void _SimulationCudaFacade::setStatisticsHistory(StatisticsHistoryData const& data)
+StatisticsEntry _SimulationCudaFacade::getStatisticsEntry()
 {
-    StatisticsService::get().rewriteHistory(_statisticsHistory, data, getCurrentTimestep());
+    std::lock_guard lock(_mutexForStatistics);
+    if (_statisticsEntry) {
+        return *_statisticsEntry;
+    } else {
+        return StatisticsEntry();
+    }
 }
 
-void _SimulationCudaFacade::resetTimeIntervalStatistics()
+void _SimulationCudaFacade::setStatisticsHistory(StatisticsHistoryData const& data)
 {
-    _cudaSimulationStatistics->resetAccumulatedStatistics();
+    StatisticsService::get().rewriteHistory(_statisticsHistory, data, getCurrentTimestep());
 }
 
 uint64_t _SimulationCudaFacade::getCurrentTimestep() const
@@ -582,7 +585,7 @@ TOs _SimulationCudaFacade::getPreviewData()
 void _SimulationCudaFacade::testOnly_mutate(uint64_t objectId)
 {
     checkAndProcessSimulationParameterChanges();
-    TestKernelsService::get().testOnly_mutate(_settings.cudaSettings, getSimulationDataPtrCopy(), objectId);
+    TestKernelsService::get().testOnly_mutate(_settings.cudaSettings, getSimulationDataPtrCopy(), *_cudaSimulationStatistics, objectId);
     syncAndCheck();
 
     resizeArraysIfNecessary();
@@ -811,19 +814,15 @@ void _SimulationCudaFacade::calcTimestepsInternal(uint64_t timesteps, bool force
             resizeArraysIfNecessary();
         }
 
-        auto statistics = getStatisticsRawData();
         {
             std::lock_guard lock(_mutexForSimulationParameters);
-            if (SimulationParametersUpdateService::get().updateSimulationParametersAfterTimestep(
-                    _settings, _maxAgeBalancer, simulationData, getCurrentTimestep(), statistics)) {
+            if (SimulationParametersUpdateService::get().updateSimulationParametersAfterTimestep(_settings, simulationData, getCurrentTimestep())) {
                 CHECK_FOR_DEVICE_ERRORS(
                     cudaMemcpyToSymbol(cudaSimulationParameters, &_settings.simulationParameters, sizeof(SimulationParameters), 0, cudaMemcpyHostToDevice));
             }
         }
-        auto now = std::chrono::steady_clock::now();
-        if (!_lastStatisticsUpdateTime || now - *_lastStatisticsUpdateTime > StatisticsUpdate) {
-            _lastStatisticsUpdateTime = now;
-            updateStatistics();
+        if (getCurrentTimestep() % EvolutionStatisticsUpdateInterval == 0) {
+            updateEvolutionStatistics();
         }
     }
     if (forceUpdateStatistics) {

source/EngineImpl/SimulationCudaFacade.cuh

@@ -13,12 +13,12 @@
 #include <EngineInterface/ArraySizesForTOs.h>
 #include <EngineInterface/Definitions.h>
 #include <EngineInterface/GeometryBuffers.h>
+#include <EngineInterface/StatisticsEntry.h>
 #include <EngineInterface/SelectionShallowData.h>
 #include <EngineInterface/SettingsForSimulation.h>
 #include <EngineInterface/ShallowUpdateSelectionData.h>
 #include <EngineInterface/SimulationParametersUpdateConfig.h>
 #include <EngineInterface/StatisticsHistory.h>
-#include <EngineInterface/StatisticsRawData.h>
 
 #include <EngineKernels/Definitions.cuh>
 #include <EngineKernels/TOs.cuh>
@@ -83,12 +83,11 @@ public:
 
     ArraySizesForTOs estimateCapacityNeededForTO() const;
 
-    StatisticsRawData getStatisticsRawData();
     void updateStatistics();
     StatisticsHistory const& getStatisticsHistory() const;
     void setStatisticsHistory(StatisticsHistoryData const& data);
+    StatisticsEntry getStatisticsEntry();
 
-    void resetTimeIntervalStatistics();
     uint64_t getCurrentTimestep() const;
     void setCurrentTimestep(uint64_t timestep);
 
@@ -121,6 +120,8 @@ public:
 private:
     void initCuda();
 
+    void updateEvolutionStatistics();
+
     void syncAndCheck();
     void copyDataTOtoGpu(TOs const& cudaTO, TOs const& to);
     void copyDataTOtoHost(TOs const& to, TOs const& cudaTO);
@@ -153,10 +154,8 @@ private:
     TOProvider _collectionTOProvider;
 
     mutable std::mutex _mutexForStatistics;
-    std::optional<std::chrono::steady_clock::time_point> _lastStatisticsUpdateTime;
-    std::optional<StatisticsRawData> _statisticsData;
     StatisticsHistory _statisticsHistory;
+    std::optional<StatisticsEntry> _statisticsEntry;
     std::shared_ptr<SimulationStatistics> _cudaSimulationStatistics;
     std::shared_ptr<SimulationStatistics> _cudaPreviewStatistics;
-    MaxAgeBalancer _maxAgeBalancer;
 };

source/EngineImpl/SimulationFacadeImpl.cpp

@@ -320,11 +320,6 @@ IntVector2D _SimulationFacadeImpl::getWorldSize() const
     return _worldSize;
 }
 
-StatisticsRawData _SimulationFacadeImpl::getStatisticsRawData() const
-{
-    return _worker.getStatisticsRawData();
-}
-
 StatisticsHistory const& _SimulationFacadeImpl::getStatisticsHistory() const
 {
     return _worker.getStatisticsHistory();
@@ -335,6 +330,11 @@ void _SimulationFacadeImpl::setStatisticsHistory(StatisticsHistoryData const& da
     _worker.setStatisticsHistory(data);
 }
 
+StatisticsEntry _SimulationFacadeImpl::getStatisticsEntry() const
+{
+    return _worker.getStatisticsEntry();
+}
+
 std::optional<int> _SimulationFacadeImpl::getTpsRestriction() const
 {
     auto result = _worker.getTpsRestriction();

source/EngineImpl/SimulationFacadeImpl.h

@@ -88,9 +88,9 @@ class _SimulationFacadeImpl : public _SimulationFacade
     bool updateSelectionIfNecessary() override;
 
     IntVector2D getWorldSize() const override;
-    StatisticsRawData getStatisticsRawData() const override;
     StatisticsHistory const& getStatisticsHistory() const override;
     void setStatisticsHistory(StatisticsHistoryData const& data) override;
+    StatisticsEntry getStatisticsEntry() const override;
 
     std::optional<int> getTpsRestriction() const override;
     void setTpsRestriction(std::optional<int> const& value) override;