birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove statistics profiler

Browse Source 
Signed-off-by: Jeremy Ong <jcong@amazon.com>
This commit is contained in:
Jeremy Ong
2021-08-17 14:51:29 -06:00
parent df9b4d4a2f
commit a5f072f7a9
28 changed files with 41 additions and 2332 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Framework/AzCore/Tests/Components.cpp
+2 -2
View File
@@ -1255,7 +1255,7 @@ namespace UnitTest
int ChildFunction1(int input)
{
AZ_PROFILE_SCOPE(System, "Child1");
AZ_PROFILE_SCOPE(AzCore, "Child1");
int result = 5;
for (int i = 0; i < 10000; ++i)
{
@@ -1266,7 +1266,7 @@ namespace UnitTest
int Profile1(int numIterations)
{
AZ_PROFILE_SCOPE(System, "Custom name");
AZ_PROFILE_SCOPE(AzCore, "Custom name");
int result = 0;
for (int i = 0; i < numIterations; ++i)
{
Code/Framework/AzCore/Tests/Math/ObbTests.cpp
+7 -7
View File
@@ -6,16 +6,16 @@
*
*/
#include <AzCore/Math/Obb.h>
#include <AzCore/Math/Aabb.h>
#include <AzCore/Math/Vector3.h>
#include <AzCore/Math/Transform.h>
#include <AzCore/UnitTest/TestTypes.h>
#include <AZTestShared/Math/MathTestHelpers.h>
#include <AzCore/Math/Aabb.h>
#include <AzCore/Math/Obb.h>
#include <AzCore/Math/Transform.h>
#include <AzCore/Math/Vector3.h>
#include <AzCore/UnitTest/TestTypes.h>
using namespace AZ;
namespace UnitTest
namespace UnitTest::ObbTests
{
const Vector3 position(1.0f, 2.0f, 3.0f);
const Quaternion rotation = Quaternion::CreateRotationZ(Constants::QuarterPi);
@@ -151,4 +151,4 @@ namespace UnitTest
EXPECT_NEAR(obb.GetDistanceSq(Vector3(2.4f, 0.5f, 1.5f)), 0.5532f, 1e-3f);
EXPECT_NEAR(obb.GetDistanceSq(Vector3(1.1f, 7.3f, 5.8f)), 1.3612f, 1e-3f);
}
}
} // namespace UnitTest::ObbTests
Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
-847
View File
@@ -1,847 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AzCore/UnitTest/TestTypes.h>
#include <AzCore/UnitTest/UnitTest.h>
#include <AzTest/AzTest.h>
#include <AzCore/Math/Crc.h>
#include <AzCore/std/string/string.h>
#include <AzCore/std/parallel/thread.h>
#include <AzCore/std/parallel/shared_spin_mutex.h>
#include <AzCore/Debug/TraceMessagesDrillerBus.h>
#include <AzCore/Statistics/StatisticalProfilerProxy.h>
//REMARK: The macros CODE_PROFILER_PROXY_PUSH_TIME and CODE_PROFILER_PUSH_TIME will be redefined
//several times in this file to accommodate for the different specializations of the StatisticalProfiler<>
//template.
#ifdef CODE_PROFILER_PROXY_PUSH_TIME
#undef CODE_PROFILER_PROXY_PUSH_TIME
#endif
#ifdef CODE_PROFILER_PUSH_TIME
#undef CODE_PROFILER_PUSH_TIME
#endif
namespace UnitTest
{
class StatisticalProfilerTest
: public AllocatorsFixture
{
public:
StatisticalProfilerTest()
{
}
void SetUp() override
{
AllocatorsFixture::SetUp();
}
~StatisticalProfilerTest()
{
}
void TearDown() override
{
AllocatorsFixture::TearDown();
}
}; //class StatisticalProfilerTest
TEST_F(StatisticalProfilerTest, StatisticalProfilerStringNoMutex_ProfileCode_ValidateStatistics)
{
//Helper macro.
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfiler<> profiler;
const AZStd::string statNamePerformance("PerformanceResult");
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
const int iter_count = 10;
{
CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
#undef CODE_PROFILER_PUSH_TIME
}
TEST_F(StatisticalProfilerTest, StatisticalProfilerCrc32NoMutex_ProfileCode_ValidateStatistics)
{
//Helper macro.
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<AZ::Crc32>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfiler<AZ::Crc32> profiler;
const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
const AZStd::string statNamePerformance("PerformanceResult");
const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
const int iter_count = 10;
{
CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
#undef CODE_PROFILER_PUSH_TIME
}
TEST_F(StatisticalProfilerTest, StatisticalProfilerStringWithSharedSpinMutex__ProfileCode_ValidateStatistics)
{
//Helper macro.
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
const AZStd::string statNamePerformance("PerformanceResult");
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
const int iter_count = 10;
{
CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
#undef CODE_PROFILER_PUSH_TIME
}
TEST_F(StatisticalProfilerTest, StatisticalProfilerCrc32WithSharedSpinMutex__ProfileCode_ValidateStatistics)
{
//Helper macro.
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex> profiler;
const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
const AZStd::string statNamePerformance("PerformanceResult");
const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
const int iter_count = 10;
{
CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
#undef CODE_PROFILER_PUSH_TIME
}
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
static void simple_thread01(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
{
const AZStd::string simple_thread("simple_thread1");
const AZStd::string simple_thread_loop("simple_thread1_loop");
CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
static int counter = 0;
for (int i = 0; i < loop_cnt; i++)
{
CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
counter++;
}
}
static void simple_thread02(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
{
const AZStd::string simple_thread("simple_thread2");
const AZStd::string simple_thread_loop("simple_thread2_loop");
CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
static int counter = 0;
for (int i = 0; i < loop_cnt; i++)
{
CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
counter++;
}
}
static void simple_thread03(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
{
const AZStd::string simple_thread("simple_thread3");
const AZStd::string simple_thread_loop("simple_thread3_loop");
CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
static int counter = 0;
for (int i = 0; i < loop_cnt; i++)
{
CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
counter++;
}
}
#undef CODE_PROFILER_PUSH_TIME
TEST_F(StatisticalProfilerTest, StatisticalProfilerStringWithSharedSpinMutex_RunProfiledThreads_ValidateStatistics)
{
AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
const AZStd::string statIdThread1 = "simple_thread1";
const AZStd::string statNameThread1("simple_thread1");
const AZStd::string statIdThread1Loop = "simple_thread1_loop";
const AZStd::string statNameThread1Loop("simple_thread1_loop");
const AZStd::string statIdThread2 = "simple_thread2";
const AZStd::string statNameThread2("simple_thread2");
const AZStd::string statIdThread2Loop = "simple_thread2_loop";
const AZStd::string statNameThread2Loop("simple_thread2_loop");
const AZStd::string statIdThread3 = "simple_thread3";
const AZStd::string statNameThread3("simple_thread3");
const AZStd::string statIdThread3Loop = "simple_thread3_loop";
const AZStd::string statNameThread3Loop("simple_thread3_loop");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
//Let's kickoff the threads to see how much contention affects the profiler's performance.
const int iter_count = 10;
AZStd::thread t1(AZStd::bind(&simple_thread01, &profiler, iter_count));
AZStd::thread t2(AZStd::bind(&simple_thread02, &profiler, iter_count));
AZStd::thread t3(AZStd::bind(&simple_thread03, &profiler, iter_count));
t1.join();
t2.join();
t3.join();
ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
}
TEST_F(StatisticalProfilerTest, StatisticalProfilerProxy_ProfileCode_ValidateStatistics)
{
#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
AZ::Statistics::StatisticalProfilerProxy profilerProxy;
AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdPerformance = "PerformanceResult";
const AZStd::string statNamePerformance("PerformanceResult");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdBlock = "Block";
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
proxy->ActivateProfiler(Terrain, true);
const int iter_count = 10;
{
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdPerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
//Clean Up
proxy->ActivateProfiler(Terrain, false);
#undef CODE_PROFILER_PROXY_PUSH_TIME
}
#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
static void simple_thread1(int loop_cnt)
{
const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread1("simple_thread1");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread1_loop("simple_thread1_loop");
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread1);
static int counter = 0;
for (int i = 0; i < loop_cnt; i++)
{
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread1_loop);
counter++;
}
}
static void simple_thread2(int loop_cnt)
{
const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread2("simple_thread2");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread2_loop("simple_thread2_loop");
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread2);
static int counter = 0;
for (int i = 0; i < loop_cnt; i++)
{
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread2_loop);
counter++;
}
}
static void simple_thread3(int loop_cnt)
{
const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread3("simple_thread3");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread3_loop("simple_thread3_loop");
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread3);
static int counter = 0;
for (int i = 0; i < loop_cnt; i++)
{
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread3_loop);
}
}
#undef CODE_PROFILER_PROXY_PUSH_TIME
TEST_F(StatisticalProfilerTest, StatisticalProfilerProxy3_RunProfiledThreads_ValidateStatistics)
{
AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
AZ::Statistics::StatisticalProfilerProxy profilerProxy;
AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1 = "simple_thread1";
const AZStd::string statNameThread1("simple_thread1");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1Loop = "simple_thread1_loop";
const AZStd::string statNameThread1Loop("simple_thread1_loop");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2 = "simple_thread2";
const AZStd::string statNameThread2("simple_thread2");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2Loop = "simple_thread2_loop";
const AZStd::string statNameThread2Loop("simple_thread2_loop");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3 = "simple_thread3";
const AZStd::string statNameThread3("simple_thread3");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3Loop = "simple_thread3_loop";
const AZStd::string statNameThread3Loop("simple_thread3_loop");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
proxy->ActivateProfiler(Terrain, true);
//Let's kickoff the threads to see how much contention affects the profiler's performance.
const int iter_count = 10;
AZStd::thread t1(AZStd::bind(&simple_thread1, iter_count));
AZStd::thread t2(AZStd::bind(&simple_thread2, iter_count));
AZStd::thread t3(AZStd::bind(&simple_thread3, iter_count));
t1.join();
t2.join();
t3.join();
ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
//Clean Up
proxy->ActivateProfiler(Terrain, false);
}
/** Trace message handler to track messages during tests
*/
struct MyTraceMessageSink final
: public AZ::Debug::TraceMessageDrillerBus::Handler
{
MyTraceMessageSink()
{
AZ::Debug::TraceMessageDrillerBus::Handler::BusConnect();
}
~MyTraceMessageSink()
{
AZ::Debug::TraceMessageDrillerBus::Handler::BusDisconnect();
}
//////////////////////////////////////////////////////////////////////////
// TraceMessageDrillerBus
void OnPrintf(const char* window, const char* message) override
{
OnOutput(window, message);
}
void OnOutput(const char* window, const char* message) override
{
printf("%s: %s\n", window, message);
}
}; //struct MyTraceMessageSink
class Suite_StatisticalProfilerPerformance
: public AllocatorsFixture
{
public:
MyTraceMessageSink* m_testSink;
Suite_StatisticalProfilerPerformance() :m_testSink(nullptr)
{
}
void SetUp() override
{
AllocatorsFixture::SetUp();
m_testSink = new MyTraceMessageSink();
}
~Suite_StatisticalProfilerPerformance()
{
}
void TearDown() override
{
// clearing up memory
delete m_testSink;
AllocatorsFixture::TearDown();
}
}; //class Suite_StatisticalProfilerPerformance
TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringNoMutex_1ThreadPerformance)
{
//Helper macro.
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfiler<> profiler;
const AZStd::string statNamePerformance("PerformanceResult");
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
const int iter_count = 1000000;
{
CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
profiler.LogAndResetStats("StatisticalProfilerStringNoMutex");
ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
#undef CODE_PROFILER_PUSH_TIME
}
TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerCrc32NoMutex_1ThreadPerformance)
{
//Helper macro.
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<AZ::Crc32>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfiler<AZ::Crc32> profiler;
const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
const AZStd::string statNamePerformance("PerformanceResult");
const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
const int iter_count = 1000000;
{
CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
profiler.LogAndResetStats("StatisticalProfilerCrc32NoMutex");
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
#undef CODE_PROFILER_PUSH_TIME
}
TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringWithSharedSpinMutex_1ThreadPerformance)
{
//Helper macro.
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
const AZStd::string statNamePerformance("PerformanceResult");
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
const int iter_count = 1000000;
{
CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
profiler.LogAndResetStats("StatisticalProfilerStringWithSharedSpinMutex");
ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
#undef CODE_PROFILER_PUSH_TIME
}
TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerCrc32WithSharedSpinMutex_1ThreadPerformance)
{
//Helper macro.
#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex> profiler;
const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
const AZStd::string statNamePerformance("PerformanceResult");
const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
const int iter_count = 1000000;
{
CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
profiler.LogAndResetStats("StatisticalProfilerCrc32WithSharedSpinMutex");
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
#undef CODE_PROFILER_PUSH_TIME
}
TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringWithSharedSpinMutex3Threads_3ThreadsPerformance)
{
AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
const AZStd::string statIdThread1 = "simple_thread1";
const AZStd::string statNameThread1("simple_thread1");
const AZStd::string statIdThread1Loop = "simple_thread1_loop";
const AZStd::string statNameThread1Loop("simple_thread1_loop");
const AZStd::string statIdThread2 = "simple_thread2";
const AZStd::string statNameThread2("simple_thread2");
const AZStd::string statIdThread2Loop = "simple_thread2_loop";
const AZStd::string statNameThread2Loop("simple_thread2_loop");
const AZStd::string statIdThread3 = "simple_thread3";
const AZStd::string statNameThread3("simple_thread3");
const AZStd::string statIdThread3Loop = "simple_thread3_loop";
const AZStd::string statNameThread3Loop("simple_thread3_loop");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
//Let's kickoff the threads to see how much contention affects the profiler's performance.
const int iter_count = 1000000;
AZStd::thread t1(AZStd::bind(&simple_thread01, &profiler, iter_count));
AZStd::thread t2(AZStd::bind(&simple_thread02, &profiler, iter_count));
AZStd::thread t3(AZStd::bind(&simple_thread03, &profiler, iter_count));
t1.join();
t2.join();
t3.join();
ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
profiler.LogAndResetStats("3_Threads_StatisticalProfiler");
ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
}
#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerProxy_1ThreadPerformance)
{
AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
AZ::Statistics::StatisticalProfilerProxy profilerProxy;
AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdPerformance = "PerformanceResult";
const AZStd::string statNamePerformance("PerformanceResult");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdBlock = "Block";
const AZStd::string statNameBlock("Block");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
proxy->ActivateProfiler(Terrain, true);
const int iter_count = 1000000;
{
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdPerformance)
int counter = 0;
for (int i = 0; i < iter_count; i++)
{
CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdBlock)
counter++;
}
}
ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
profiler.LogAndResetStats("StatisticalProfilerProxy");
//Clean Up
proxy->ActivateProfiler(Terrain, false);
}
#undef CODE_PROFILER_PROXY_PUSH_TIME
TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerProxy_3ThreadsPerformance)
{
AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
AZ::Statistics::StatisticalProfilerProxy profilerProxy;
AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1 = "simple_thread1";
const AZStd::string statNameThread1("simple_thread1");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1Loop = "simple_thread1_loop";
const AZStd::string statNameThread1Loop("simple_thread1_loop");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2 = "simple_thread2";
const AZStd::string statNameThread2("simple_thread2");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2Loop = "simple_thread2_loop";
const AZStd::string statNameThread2Loop("simple_thread2_loop");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3 = "simple_thread3";
const AZStd::string statNameThread3("simple_thread3");
const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3Loop = "simple_thread3_loop";
const AZStd::string statNameThread3Loop("simple_thread3_loop");
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
proxy->ActivateProfiler(Terrain, true);
//Let's kickoff the threads to see how much contention affects the profiler's performance.
const int iter_count = 1000000;
AZStd::thread t1(AZStd::bind(&simple_thread1, iter_count));
AZStd::thread t2(AZStd::bind(&simple_thread2, iter_count));
AZStd::thread t3(AZStd::bind(&simple_thread3, iter_count));
t1.join();
t2.join();
t3.join();
ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
profiler.LogAndResetStats("3_Threads_StatisticalProfilerProxy");
//Clean Up
proxy->ActivateProfiler(Terrain, false);
}
}//namespace UnitTest
Code/Framework/AzCore/Tests/Statistics.cpp
-263
View File
@@ -1,263 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AzCore/UnitTest/TestTypes.h>
#include <AzCore/UnitTest/UnitTest.h>
#include <AzTest/AzTest.h>
#include <AzCore/Math/Crc.h>
#include <AzCore/std/string/string.h>
#include <AzCore/Statistics/StatisticsManager.h>
using namespace AZ;
using namespace Debug;
namespace UnitTest
{
class StatisticsTest
: public AllocatorsFixture
{
public:
StatisticsTest()
{
}
void SetUp() override
{
AllocatorsFixture::SetUp();
m_dataSamples = AZStd::make_unique<AZStd::vector<u32>>();
const u32 numSamples = 100;
m_dataSamples->set_capacity(numSamples);
for (u32 i = 0; i < numSamples; ++i)
{
m_dataSamples->push_back(i);
}
}
~StatisticsTest()
{
}
void TearDown() override
{
// clearing up memory
m_dataSamples = nullptr;
AllocatorsFixture::TearDown();
}
protected:
AZStd::unique_ptr<AZStd::vector<u32>> m_dataSamples;
}; //class StatisticsTest
TEST_F(StatisticsTest, RunningStatistic_ProcessAnArrayOfNumbers_GetExpectedStatisticalData)
{
Statistics::RunningStatistic runningStat;
ASSERT_TRUE(m_dataSamples.get() != nullptr);
const AZStd::vector<u32>& dataSamples = *m_dataSamples;
for (u32 sample : dataSamples)
{
runningStat.PushSample(sample);
}
EXPECT_EQ(runningStat.GetNumSamples(), dataSamples.size());
EXPECT_EQ(runningStat.GetMostRecentSample(), dataSamples.back());
EXPECT_EQ(runningStat.GetMinimum(), dataSamples[0]);
EXPECT_EQ(runningStat.GetMaximum(), dataSamples.back());
EXPECT_NEAR(runningStat.GetAverage(), 49.5, 0.001);
EXPECT_NEAR(runningStat.GetVariance(), 841.666, 0.001);
EXPECT_NEAR(runningStat.GetStdev(), 29.011, 0.001);
EXPECT_NEAR(runningStat.GetVariance(Statistics::VarianceType::P), 833.25, 0.001);
EXPECT_NEAR(runningStat.GetStdev(Statistics::VarianceType::P), 28.866, 0.001);
//Reset the stat object.
runningStat.Reset();
EXPECT_EQ(runningStat.GetNumSamples(), 0);
EXPECT_EQ(runningStat.GetAverage(), 0.0);
EXPECT_EQ(runningStat.GetStdev(), 0.0);
}
TEST_F(StatisticsTest, StatisticsManager_AddAndRemoveStatisticistics_CollectionIntegrityIsCorrect)
{
Statistics::StatisticsManager<> statsManager;
AZStd::string statName0("stat0");
AZStd::string statName1("stat1");
AZStd::string statName2("stat2");
AZStd::string statName3("stat3");
EXPECT_TRUE(statsManager.AddStatistic(statName0, statName0, ""));
EXPECT_TRUE(statsManager.AddStatistic(statName1, statName1, ""));
EXPECT_TRUE(statsManager.AddStatistic(statName2, statName2, ""));
EXPECT_TRUE(statsManager.AddStatistic(statName3, statName3, ""));
//Validate the number of running statistics object we have so far.
{
AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
statsManager.GetAllStatistics(allStats);
EXPECT_TRUE(allStats.size() == 4);
}
//Try to add an Stat that already exist. expect to fail.
EXPECT_EQ(statsManager.AddStatistic(statName1), nullptr);
//Remove stat1.
statsManager.RemoveStatistic(statName1);
//Validate the number of running statistics object we have so far.
{
AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
statsManager.GetAllStatistics(allStats);
EXPECT_TRUE(allStats.size() == 3);
}
//Add stat1 again, expect to pass.
EXPECT_TRUE(statsManager.AddStatistic(statName1));
//Get a pointer to stat2.
Statistics::NamedRunningStatistic* stat2 = statsManager.GetStatistic(statName2);
ASSERT_TRUE(stat2 != nullptr);
EXPECT_EQ(stat2->GetName(), statName2);
}
TEST_F(StatisticsTest, StatisticsManager_DistributeSamplesAcrossStatistics_StatisticsAreCorrect)
{
Statistics::StatisticsManager<> statsManager;
AZStd::string statName0("stat0");
AZStd::string statName1("stat1");
AZStd::string statName2("stat2");
AZStd::string statName3("stat3");
EXPECT_TRUE(statsManager.AddStatistic(statName3));
EXPECT_TRUE(statsManager.AddStatistic(statName0));
EXPECT_TRUE(statsManager.AddStatistic(statName2));
EXPECT_TRUE(statsManager.AddStatistic(statName1));
//Distribute the 100 samples of data evenly across the 4 running statistics.
ASSERT_TRUE(m_dataSamples.get() != nullptr);
const AZStd::vector<u32>& dataSamples = *m_dataSamples;
const size_t numSamples = dataSamples.size();
const size_t numSamplesPerStat = numSamples / 4;
size_t sampleIndex = 0;
size_t nextStopIndex = numSamplesPerStat;
while (sampleIndex < nextStopIndex)
{
statsManager.PushSampleForStatistic(statName0, dataSamples[sampleIndex]);
sampleIndex++;
}
nextStopIndex += numSamplesPerStat;
while (sampleIndex < nextStopIndex)
{
statsManager.PushSampleForStatistic(statName1, dataSamples[sampleIndex]);
sampleIndex++;
}
nextStopIndex += numSamplesPerStat;
while (sampleIndex < nextStopIndex)
{
statsManager.PushSampleForStatistic(statName2, dataSamples[sampleIndex]);
sampleIndex++;
}
nextStopIndex += numSamplesPerStat;
while (sampleIndex < nextStopIndex)
{
statsManager.PushSampleForStatistic(statName3, dataSamples[sampleIndex]);
sampleIndex++;
}
EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetAverage(), 12.0, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetAverage(), 37.0, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetAverage(), 62.0, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetAverage(), 87.0, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetStdev(), 7.359, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetStdev(), 7.359, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetStdev(), 7.359, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetStdev(), 7.359, 0.001);
//Reset one of the stats.
statsManager.ResetStatistic(statName2);
EXPECT_EQ(statsManager.GetStatistic(statName2)->GetAverage(), 0.0);
//Reset all of the stats.
statsManager.ResetAllStatistics();
EXPECT_EQ(statsManager.GetStatistic(statName0)->GetNumSamples(), 0);
EXPECT_EQ(statsManager.GetStatistic(statName1)->GetNumSamples(), 0);
EXPECT_EQ(statsManager.GetStatistic(statName2)->GetNumSamples(), 0);
EXPECT_EQ(statsManager.GetStatistic(statName3)->GetNumSamples(), 0);
}
TEST_F(StatisticsTest, StatisticsManagerCrc32_DistributeSamplesAcrossStatistics_StatisticsAreCorrect)
{
Statistics::StatisticsManager<AZ::Crc32> statsManager;
AZ::Crc32 statName0 = AZ_CRC("stat0", 0xb8927780);
AZ::Crc32 statName1 = AZ_CRC("stat1", 0xcf954716);
AZ::Crc32 statName2 = AZ_CRC("stat2", 0x569c16ac);
AZ::Crc32 statName3 = AZ_CRC("stat3", 0x219b263a);
EXPECT_TRUE(statsManager.AddStatistic(statName3) != nullptr);
EXPECT_TRUE(statsManager.AddStatistic(statName0) != nullptr);
EXPECT_TRUE(statsManager.AddStatistic(statName2) != nullptr);
EXPECT_TRUE(statsManager.AddStatistic(statName1) != nullptr);
EXPECT_TRUE(statsManager.GetStatistic(statName3) != nullptr);
EXPECT_TRUE(statsManager.GetStatistic(statName0) != nullptr);
EXPECT_TRUE(statsManager.GetStatistic(statName1) != nullptr);
EXPECT_TRUE(statsManager.GetStatistic(statName2) != nullptr);
//Distribute the 100 samples of data evenly across the 4 running statistics.
ASSERT_TRUE(m_dataSamples.get() != nullptr);
const AZStd::vector<u32>& dataSamples = *m_dataSamples;
const size_t numSamples = dataSamples.size();
const size_t numSamplesPerStat = numSamples / 4;
size_t sampleIndex = 0;
size_t nextStopIndex = numSamplesPerStat;
while (sampleIndex < nextStopIndex)
{
statsManager.PushSampleForStatistic(statName0, dataSamples[sampleIndex]);
sampleIndex++;
}
nextStopIndex += numSamplesPerStat;
while (sampleIndex < nextStopIndex)
{
statsManager.PushSampleForStatistic(statName1, dataSamples[sampleIndex]);
sampleIndex++;
}
nextStopIndex += numSamplesPerStat;
while (sampleIndex < nextStopIndex)
{
statsManager.PushSampleForStatistic(statName2, dataSamples[sampleIndex]);
sampleIndex++;
}
nextStopIndex += numSamplesPerStat;
while (sampleIndex < nextStopIndex)
{
statsManager.PushSampleForStatistic(statName3, dataSamples[sampleIndex]);
sampleIndex++;
}
EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetAverage(), 12.0, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetAverage(), 37.0, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetAverage(), 62.0, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetAverage(), 87.0, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetStdev(), 7.359, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetStdev(), 7.359, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetStdev(), 7.359, 0.001);
EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetStdev(), 7.359, 0.001);
//Reset one of the stats.
statsManager.ResetStatistic(statName2);
EXPECT_EQ(statsManager.GetStatistic(statName2)->GetAverage(), 0.0);
//Reset all of the stats.
statsManager.ResetAllStatistics();
EXPECT_EQ(statsManager.GetStatistic(statName0)->GetNumSamples(), 0);
EXPECT_EQ(statsManager.GetStatistic(statName1)->GetNumSamples(), 0);
EXPECT_EQ(statsManager.GetStatistic(statName2)->GetNumSamples(), 0);
EXPECT_EQ(statsManager.GetStatistic(statName3)->GetNumSamples(), 0);
}
}//namespace UnitTest
Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
-207
View File
@@ -1,207 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AzCore/UnitTest/TestTypes.h>
#include <AzCore/UnitTest/UnitTest.h>
#include <AzTest/AzTest.h>
#include <AzCore/std/string/string.h>
#include <AzCore/std/parallel/thread.h>
#include <AzCore/Statistics/TimeDataStatisticsManager.h>
#include <AzCore/Component/Component.h>
#include <AzCore/Component/ComponentApplication.h>
#include <AzCore/Component/TickBus.h>
#include <AzCore/Component/EntityUtils.h>
#include <AzCore/Debug/FrameProfilerBus.h>
#include <AzCore/Debug/FrameProfilerComponent.h>
using namespace AZ;
using namespace Debug;
namespace UnitTest
{
/**
* Validate functionality of the convenience class TimeDataStatisticsManager.
* It is a specialized version of RunningStatisticsManager that works with Timer type
* of registers that can be captured with the FrameProfilerBus::OnFrameProfilerData()
*/
class TimeDataStatisticsManagerTest
: public AllocatorsFixture
, public FrameProfilerBus::Handler
{
static constexpr const char* PARENT_TIMER_STAT = "ParentStat";
static constexpr const char* CHILD_TIMER_STAT0 = "ChildStat0";
static constexpr const char* CHILD_TIMER_STAT1 = "ChildStat1";
public:
TimeDataStatisticsManagerTest()
: AllocatorsFixture()
{
}
void SetUp() override
{
AllocatorsFixture::SetUp();
m_statsManager = AZStd::make_unique<Statistics::TimeDataStatisticsManager>();
}
void TearDown() override
{
m_statsManager = nullptr;
AllocatorsFixture::TearDown();
}
//////////////////////////////////////////////////////////////////////////
// FrameProfilerBus
virtual void OnFrameProfilerData(const FrameProfiler::ThreadDataArray& data)
{
for (size_t iThread = 0; iThread < data.size(); ++iThread)
{
const FrameProfiler::ThreadData& td = data[iThread];
FrameProfiler::ThreadData::RegistersMap::const_iterator regIt = td.m_registers.begin();
for (; regIt != td.m_registers.end(); ++regIt)
{
const FrameProfiler::RegisterData& rd = regIt->second;
u32 unitTestCrc = AZ_CRC("UnitTest", 0x8089cea8);
if (unitTestCrc != rd.m_systemId)
{
continue; //Not for us.
}
ASSERT_EQ(ProfilerRegister::PRT_TIME, rd.m_type);
const FrameProfiler::FrameData& fd = rd.m_frames.back();
m_statsManager->PushTimeDataSample(rd.m_name, fd.m_timeData);
}
}
}
//////////////////////////////////////////////////////////////////////////
int ChildFunction0(int numIterations, int sleepTimeMilliseconds)
{
AZ_PROFILE_SCOPE(AzCore, CHILD_TIMER_STAT0);
AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
int result = 5;
for (int i = 0; i < numIterations; ++i)
{
result += i % 3;
}
return result;
}
int ChildFunction1(int numIterations, int sleepTimeMilliseconds)
{
AZ_PROFILE_SCOPE(AzCore, CHILD_TIMER_STAT1);
AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
int result = 5;
for (int i = 0; i < numIterations; ++i)
{
result += i % 3;
}
return result;
}
int ParentFunction(int numIterations, int sleepTimeMilliseconds)
{
AZ_PROFILE_SCOPE(AzCore, PARENT_TIMER_STAT);
AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
int result = 0;
result += ChildFunction0(numIterations, sleepTimeMilliseconds);
result += ChildFunction1(numIterations, sleepTimeMilliseconds);
return result;
}
void run()
{
Debug::FrameProfilerBus::Handler::BusConnect();
ComponentApplication app;
ComponentApplication::Descriptor desc;
desc.m_useExistingAllocator = true;
desc.m_enableDrilling = false; // we already created a memory driller for the test (AllocatorsFixture)
ComponentApplication::StartupParameters startupParams;
startupParams.m_allocator = &AllocatorInstance<SystemAllocator>::Get();
Entity* systemEntity = app.Create(desc, startupParams);
systemEntity->CreateComponent<FrameProfilerComponent>();
systemEntity->Init();
systemEntity->Activate(); // start frame component
const int sleepTimeAllFuncsMillis = 1;
const int numIterations = 10;
for (int iterationCounter = 0; iterationCounter < numIterations; ++iterationCounter)
{
ParentFunction(numIterations, sleepTimeAllFuncsMillis);
//Collect all samples.
app.Tick();
}
//Verify we have three running stats.
{
AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
m_statsManager->GetAllStatistics(allStats);
EXPECT_EQ(allStats.size(), 3);
}
AZStd::string parentStatName(PARENT_TIMER_STAT);
AZStd::string child0StatName(CHILD_TIMER_STAT0);
AZStd::string child1StatName(CHILD_TIMER_STAT1);
ASSERT_TRUE(m_statsManager->GetStatistic(parentStatName) != nullptr);
ASSERT_TRUE(m_statsManager->GetStatistic(child0StatName) != nullptr);
ASSERT_TRUE(m_statsManager->GetStatistic(child1StatName) != nullptr);
EXPECT_EQ(m_statsManager->GetStatistic(parentStatName)->GetNumSamples(), numIterations);
EXPECT_EQ(m_statsManager->GetStatistic(child0StatName)->GetNumSamples(), numIterations);
EXPECT_EQ(m_statsManager->GetStatistic(child1StatName)->GetNumSamples(), numIterations);
const double minimumExpectDurationOfChildFunctionMicros = 1;
const double minimumExpectDurationOfParentFunctionMicros = 1;
EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetMinimum(), minimumExpectDurationOfParentFunctionMicros);
EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetAverage(), minimumExpectDurationOfParentFunctionMicros);
EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetMaximum(), minimumExpectDurationOfParentFunctionMicros);
EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetMinimum(), minimumExpectDurationOfChildFunctionMicros);
EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetAverage(), minimumExpectDurationOfChildFunctionMicros);
EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetMaximum(), minimumExpectDurationOfChildFunctionMicros);
EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetMinimum(), minimumExpectDurationOfChildFunctionMicros);
EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetAverage(), minimumExpectDurationOfChildFunctionMicros);
EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetMaximum(), minimumExpectDurationOfChildFunctionMicros);
//Let's validate TimeDataStatisticsManager::RemoveStatistics()
m_statsManager->RemoveStatistic(child1StatName);
ASSERT_TRUE(m_statsManager->GetStatistic(parentStatName) != nullptr);
ASSERT_TRUE(m_statsManager->GetStatistic(child0StatName) != nullptr);
EXPECT_EQ(m_statsManager->GetStatistic(child1StatName), nullptr);
//Let's store the sample count for both parentStatName and child0StatName.
const AZ::u64 numSamplesParent = m_statsManager->GetStatistic(parentStatName)->GetNumSamples();
const AZ::u64 numSamplesChild0 = m_statsManager->GetStatistic(child0StatName)->GetNumSamples();
//Let's call child1 function again and call app.Tick(). child1StatName should be readded to m_statsManager.
ChildFunction1(numIterations, sleepTimeAllFuncsMillis);
app.Tick();
ASSERT_TRUE(m_statsManager->GetStatistic(child1StatName) != nullptr);
EXPECT_EQ(m_statsManager->GetStatistic(parentStatName)->GetNumSamples(), numSamplesParent);
EXPECT_EQ(m_statsManager->GetStatistic(child0StatName)->GetNumSamples(), numSamplesChild0);
EXPECT_EQ(m_statsManager->GetStatistic(child1StatName)->GetNumSamples(), 1);
Debug::FrameProfilerBus::Handler::BusDisconnect();
app.Destroy();
}
AZStd::unique_ptr<Statistics::TimeDataStatisticsManager> m_statsManager;
};//class TimeDataStatisticsManagerTest
TEST_F(TimeDataStatisticsManagerTest, Test)
{
run();
}
//End of all Tests of TimeDataStatisticsManagerTest
}//namespace UnitTest
Code/Framework/AzCore/Tests/azcoretests_files.cmake
-2
View File
@@ -60,13 +60,11 @@ set(FILES
SerializeContextFixture.h
Slice.cpp
State.cpp
Statistics.cpp
StreamerTests.cpp
StringFunc.cpp
SystemFile.cpp
TaskTests.cpp
TickBusTest.cpp
TimeDataStatistics.cpp
UUIDTests.cpp
XML.cpp
Debug/AssetTracking.cpp