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

Removes Driller from GridMate

Browse Source 
Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
This commit is contained in:
Esteban Papp
2021-12-02 15:28:44 -08:00
parent f030b8e33a
commit 791e140727
24 changed files with 14 additions and 4794 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Framework/GridMate/Tests/ReplicaBehavior.cpp
-833
View File
@@ -18,7 +18,6 @@
#include <GridMate/Replica/Replica.h>
#include <GridMate/Replica/ReplicaFunctions.h>
#include <GridMate/Replica/ReplicaMgr.h>
#include <GridMate/Replica/ReplicaDrillerEvents.h>
#include <GridMate/Serialize/CompressionMarshal.h>
using namespace GridMate;
@@ -584,837 +583,5 @@ namespace ReplicaBehavior {
AZStd::array<MPSession, 10> m_sessions;
};
/*
* A hook to intercept the payload size of a replica and it's contents.
*/
class ReplicaDrillerHook
: public Debug::ReplicaDrillerBus::Handler
{
public:
ReplicaDrillerHook()
{
}
void OnSendReplicaEnd(Replica* /*replica*/, const void* /*data*/, size_t len) override
{
m_replicaLengths.push_back(len);
}
void ResetCounts([[maybe_unused]] bool trace = false)
{
#if defined(AZ_ENABLE_TRACING)
if (trace && m_replicaLengths.size() > 0)
{
AZ_TracePrintf("GridMate", "Driller saw replicas with the following byte sizes:\n");
for (auto length : m_replicaLengths)
{
AZ_TracePrintf("GridMate", "\t\t\t %d \n", length);
}
}
#endif
m_replicaLengths.clear();
}
AZStd::vector<AZ::u64> m_replicaLengths;
};
template <typename ReplicaChunkType>
class FilteredHook : public ReplicaDrillerHook
{
public:
void OnSendReplicaEnd(Replica* replica, const void* /*data*/, size_t len) override
{
if (ContainsChunkTypeWeWant(replica))
{
m_replicaLengths.push_back(len);
}
}
private:
bool ContainsChunkTypeWeWant(Replica* replica) const
{
auto numChunks = replica->GetNumChunks();
for (size_t i = 0; i < numChunks; i++)
{
auto chunk = replica->GetChunkByIndex(i);
if (chunk->GetDescriptor()->GetChunkName() == ReplicaChunkType::GetChunkName())
{
return true;
}
}
return false;
}
};
/*
* The most basic functionality test for sending datasets that have a default value and have not yet been modified
* from their constructor values.
*
* This is a simple sanity check to ensure the logic sends the update when it's necessary.
*/
class Replica_DontSendDataSets_WithNoDiffFromCtorData
: public SimpleBehaviorTest
{
public:
Replica_DontSendDataSets_WithNoDiffFromCtorData()
: m_replicaIdDefault(InvalidReplicaId), m_replicaIdModified(InvalidReplicaId)
{
}
enum
{
sHost,
s2,
nSessions
};
int GetNumSessions() override { return nSessions; }
void PreConnect() override
{
m_driller.BusConnect();
{
ReplicaPtr replica = Replica::CreateReplica(nullptr);
auto chunk = CreateAndAttachReplicaChunk<LargeChunkWithDefaults>(replica);
AZ_TEST_ASSERT(chunk);
AZ_TEST_ASSERT(chunk->Data1.IsDefaultValue());
AZ_TEST_ASSERT(chunk->Data2.IsDefaultValue());
m_replicaIdDefault = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica);
}
}
const int ExpectedReplicaSizeWithDefaults = 37;
const int ExpectedReplicaSizeWithNonDefaults = 46;
TestStatus Tick(int tick) override
{
switch (tick)
{
case 20:
{
{
ReplicaPtr rep = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaIdDefault);
AZ_TEST_ASSERT(rep);
auto chunk = rep->FindReplicaChunk<LargeChunkWithDefaults>();
AZ_TEST_ASSERT(chunk);
auto replicaSize = m_driller.m_replicaLengths[0];
AZ_TEST_ASSERT(replicaSize == ExpectedReplicaSizeWithDefaults);
m_driller.ResetCounts();
}
// create another replica with non-default values
{
ReplicaPtr replica = Replica::CreateReplica(nullptr);
auto chunk = CreateAndAttachReplicaChunk<LargeChunkWithDefaults>(replica);
AZ_TEST_ASSERT(chunk);
AZ_TEST_ASSERT(chunk->Data1.IsDefaultValue());
AZ_TEST_ASSERT(chunk->Data2.IsDefaultValue());
chunk->Data1.Set(4242);
chunk->Data2.Set(4242);
AZ_TEST_ASSERT(!chunk->Data1.IsDefaultValue());
AZ_TEST_ASSERT(!chunk->Data2.IsDefaultValue());
m_replicaIdModified = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica);
}
break;
}
case 40:
{
{
ReplicaPtr rep = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaIdModified);
AZ_TEST_ASSERT(rep);
auto chunk = rep->FindReplicaChunk<LargeChunkWithDefaults>();
AZ_TEST_ASSERT(chunk);
auto replicaSize = m_driller.m_replicaLengths[0];
AZ_TEST_ASSERT(replicaSize == ExpectedReplicaSizeWithNonDefaults);
m_driller.ResetCounts();
// check that non-default values are set for the dataset
{
AZ_TEST_ASSERT(!chunk->Data1.IsDefaultValue());
auto value = chunk->Data1.Get();
AZ_TEST_ASSERT(value == 4242);
}
{
AZ_TEST_ASSERT(!chunk->Data2.IsDefaultValue());
auto value = chunk->Data2.Get();
AZ_TEST_ASSERT(value == 4242);
}
}
m_driller.ResetCounts(true);
break;
}
case 45:
{
{
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaIdDefault)->Destroy();
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaIdModified)->Destroy();
}
break;
}
case 50:
return TestStatus::Completed;
default:
break;
}
return TestStatus::Running;
}
ReplicaId m_replicaIdDefault;
ReplicaId m_replicaIdModified;
FilteredHook<LargeChunkWithDefaults> m_driller;
};
TEST(Replica_DontSendDataSets_WithNoDiffFromCtorData, DISABLED_Replica_DontSendDataSets_WithNoDiffFromCtorData)
{
Replica_DontSendDataSets_WithNoDiffFromCtorData tester;
tester.run();
}
/*
* This test checks the actual size of the replica as marshalled in the binary payload.
* The assessment of the payload size is done using driller EBus.
*/
class ReplicaDefaultDataSetDriller
: public SimpleBehaviorTest
{
public:
ReplicaDefaultDataSetDriller()
: m_replicaId(InvalidReplicaId)
{
}
enum
{
sHost,
s2,
nSessions
};
int GetNumSessions() override { return nSessions; }
static const int NonDefaultValue = 4242;
void PreConnect() override
{
m_driller.BusConnect();
ReplicaPtr replica = Replica::CreateReplica(nullptr);
LargeChunkWithDefaults* chunk = CreateAndAttachReplicaChunk<LargeChunkWithDefaults>(replica);
AZ_TEST_ASSERT(chunk);
m_replicaId = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica);
}
~ReplicaDefaultDataSetDriller() override
{
m_driller.BusDisconnect();
}
TestStatus Tick(int tick) override
{
switch (tick)
{
case 10:
{
auto rep = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaId);
AZ_TEST_ASSERT(rep);
m_driller.ResetCounts();
break;
}
case 15:
{
ReplicaPtr replica = m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId);
auto chunk = replica->FindReplicaChunk<LargeChunkWithDefaults>();
int nonDefaultValue = NonDefaultValue;
auto touch = [nonDefaultValue](DataSet<int>& dataSet) { dataSet.Set(nonDefaultValue); };
touch(chunk->Data1);
touch(chunk->Data2);
touch(chunk->Data3);
m_driller.ResetCounts();
break;
}
case 20:
{
auto repLengths = m_driller.m_replicaLengths;
m_driller.ResetCounts();
// check exact expected sizes
const auto countUnreliable = 4;
const auto countReliable = 1;
const auto expectedReplicaSize = 22;
AZ_TEST_ASSERT(repLengths.size() == countUnreliable + countReliable);
for (auto length : repLengths)
{
AZ_TEST_ASSERT(length == expectedReplicaSize);
}
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId)->Destroy();
break;
}
case 25:
{
return TestStatus::Completed;
}
default:
break;
}
return TestStatus::Running;
}
ReplicaDrillerHook m_driller;
ReplicaId m_replicaId;
};
const int ReplicaDefaultDataSetDriller::NonDefaultValue;
TEST(ReplicaDefaultDataSetDriller, DISABLED_ReplicaDefaultDataSetDriller)
{
ReplicaDefaultDataSetDriller tester;
tester.run();
}
/*
* This test checks the actual size of the replica as marshalled in the binary payload.
* The assessment of the payload size is done using driller EBus.
*/
class Replica_ComparePackingBoolsVsU8
: public SimpleBehaviorTest
{
public:
Replica_ComparePackingBoolsVsU8()
: m_replicaBoolsId(InvalidReplicaId)
, m_replicaU8Id(InvalidReplicaId)
{
}
enum
{
sHost,
s2,
nSessions
};
int GetNumSessions() override { return nSessions; }
void PreConnect() override
{
m_driller.BusConnect();
ReplicaPtr replica1 = Replica::CreateReplica(nullptr);
ChunkWithBools* chunk1 = CreateAndAttachReplicaChunk<ChunkWithBools>(replica1);
AZ_TEST_ASSERT(chunk1);
m_replicaBoolsId = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica1);
ReplicaPtr replica2 = Replica::CreateReplica(nullptr);
ChunkWithShortInts* chunk2 = CreateAndAttachReplicaChunk<ChunkWithShortInts>(replica2);
AZ_TEST_ASSERT(chunk2);
m_replicaU8Id = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica2);
}
~Replica_ComparePackingBoolsVsU8() override
{
m_driller.BusDisconnect();
}
TestStatus Tick(int tick) override
{
switch (tick)
{
case 10:
{
auto rep1 = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaBoolsId);
AZ_TEST_ASSERT(rep1);
auto rep2 = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaU8Id);
AZ_TEST_ASSERT(rep2);
break;
}
case 15:
{
// we have to poke the values so that they become non-default
{
ReplicaPtr replica = m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaBoolsId);
auto chunk = replica->FindReplicaChunk<ChunkWithBools>();
auto touch = [](DataSet<bool>& dataSet) { dataSet.Set(true); };
touch(chunk->Data1);
touch(chunk->Data2);
touch(chunk->Data3);
touch(chunk->Data4);
touch(chunk->Data5);
touch(chunk->Data6);
touch(chunk->Data7);
touch(chunk->Data8);
touch(chunk->Data9);
touch(chunk->Data10);
}
{
ReplicaPtr replica = m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaU8Id);
auto chunk = replica->FindReplicaChunk<ChunkWithShortInts>();
auto touch = [](DataSet<AZ::u8>& dataSet) { dataSet.Set(42); };
touch(chunk->Data1);
touch(chunk->Data2);
touch(chunk->Data3);
touch(chunk->Data4);
touch(chunk->Data5);
touch(chunk->Data6);
touch(chunk->Data7);
touch(chunk->Data8);
touch(chunk->Data9);
touch(chunk->Data10);
}
m_driller.ResetCounts();
break;
}
case 30:
{
auto repLengths = m_driller.m_replicaLengths;
m_driller.ResetCounts();
// check exact expected sizes
const auto expectedReplicaSizeWithBools = 12;
const auto expectedReplicaSizeWithShortInts = 20;
AZ_TEST_ASSERT(repLengths.size() >= 2);
AZ_TEST_ASSERT(AZStd::find(repLengths.begin(), repLengths.end(), expectedReplicaSizeWithBools));
AZ_TEST_ASSERT(AZStd::find(repLengths.begin(), repLengths.end(), expectedReplicaSizeWithShortInts));
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaBoolsId)->Destroy();
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaU8Id)->Destroy();
break;
}
case 35:
{
//auto boolDatasetSize = m_driller.m_boolChunkLengths[1];
//auto u8DatasetSize = m_driller.m_u8ChunkLengths[1];
//AZ_TEST_ASSERT(boolDatasetSize < u8DatasetSize); // Observed example: 5bytes < 13bytes
return TestStatus::Completed;
}
default:
break;
}
return TestStatus::Running;
}
ReplicaDrillerHook m_driller;
ReplicaId m_replicaBoolsId;
ReplicaId m_replicaU8Id;
};
TEST(Replica_ComparePackingBoolsVsU8, DISABLED_Replica_ComparePackingBoolsVsU8)
{
Replica_ComparePackingBoolsVsU8 tester;
tester.run();
}
class CheckDataSetStreamIsntWrittenMoreThanNecessary
: public SimpleBehaviorTest
{
public:
CheckDataSetStreamIsntWrittenMoreThanNecessary()
: m_replicaId(InvalidReplicaId)
{
}
enum
{
sHost,
s2,
nSessions
};
int GetNumSessions() override { return nSessions; }
static const int NonDefaultValue = 4242;
void PreConnect() override
{
m_driller.BusConnect();
ReplicaPtr replica = Replica::CreateReplica(nullptr);
auto chunk = CreateAndAttachReplicaChunk<CustomMarshalerTestChunk>(replica);
AZ_TEST_ASSERT(chunk);
m_replicaId = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica);
}
~CheckDataSetStreamIsntWrittenMoreThanNecessary() override
{
m_driller.BusDisconnect();
}
CustomMarshalerTestChunk::Ptr GetHostChunk()
{
ReplicaPtr replica = m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId);
auto chunk = replica->FindReplicaChunk<CustomMarshalerTestChunk>();
return chunk;
}
TestStatus Tick(int tick) override
{
switch (tick)
{
case 10:
{
auto rep = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaId);
AZ_TEST_ASSERT(rep);
break;
}
case 15:
{
auto chunk = GetHostChunk();
//chunk->Data1.Set(CustomInt(41));
const auto& m = chunk->Data1.GetMarshaler();
// Only the initial setup call should have occurred
AZ_TEST_ASSERT(m.m_marshalCalls == 1);
m.m_marshalCalls = 0;
m_driller.ResetCounts();
break;
}
case 42:
{
auto chunk = GetHostChunk();
const auto& m = chunk->Data1.GetMarshaler();
// No reason for any new calls to occur
AZ_TEST_ASSERT(m.m_marshalCalls == 0);
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId)->Destroy();
break;
}
case 45:
{
return TestStatus::Completed;
}
default:
break;
}
return TestStatus::Running;
}
ReplicaDrillerHook m_driller;
ReplicaId m_replicaId;
};
TEST(CheckDataSetStreamIsntWrittenMoreThanNecessary, DISABLED_CheckDataSetStreamIsntWrittenMoreThanNecessary)
{
CheckDataSetStreamIsntWrittenMoreThanNecessary tester;
tester.run();
}
class CheckDataSetStreamIsntWrittenMoreThanNecessaryOnceDirty
: public SimpleBehaviorTest
{
public:
CheckDataSetStreamIsntWrittenMoreThanNecessaryOnceDirty()
: m_replicaId(InvalidReplicaId)
{
}
enum
{
sHost,
s2,
nSessions
};
int GetNumSessions() override { return nSessions; }
static const int NonDefaultValue = 4242;
void PreConnect() override
{
m_driller.BusConnect();
ReplicaPtr replica = Replica::CreateReplica(nullptr);
auto chunk = CreateAndAttachReplicaChunk<CustomMarshalerTestChunk>(replica);
AZ_TEST_ASSERT(chunk);
m_replicaId = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica);
}
~CheckDataSetStreamIsntWrittenMoreThanNecessaryOnceDirty() override
{
m_driller.BusDisconnect();
}
CustomMarshalerTestChunk::Ptr GetHostChunk()
{
ReplicaPtr replica = m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId);
auto chunk = replica->FindReplicaChunk<CustomMarshalerTestChunk>();
return chunk;
}
TestStatus Tick(int tick) override
{
switch (tick)
{
case 10:
{
auto rep = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaId);
AZ_TEST_ASSERT(rep);
break;
}
case 15:
{
auto chunk = GetHostChunk();
chunk->Data1.Set(CustomInt(41));
const auto& m = chunk->Data1.GetMarshaler();
// Only the initial setup call
AZ_TEST_ASSERT(m.m_marshalCalls == 1);
m.m_marshalCalls = 0;
m_driller.ResetCounts();
break;
}
case 42:
{
auto chunk = GetHostChunk();
const auto& m = chunk->Data1.GetMarshaler();
AZ_TEST_ASSERT(m.m_marshalCalls == 6 /* 5 unreliables + 1 reliable */);
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId)->Destroy();
break;
}
case 45:
{
return TestStatus::Completed;
}
default:
break;
}
return TestStatus::Running;
}
ReplicaDrillerHook m_driller;
ReplicaId m_replicaId;
};
TEST(CheckDataSetStreamIsntWrittenMoreThanNecessaryOnceDirty, DISABLED_CheckDataSetStreamIsntWrittenMoreThanNecessaryOnceDirty)
{
CheckDataSetStreamIsntWrittenMoreThanNecessaryOnceDirty tester;
tester.run();
}
class CheckReplicaIsntSentWithNoChanges
: public SimpleBehaviorTest
{
public:
CheckReplicaIsntSentWithNoChanges()
: m_replicaId(InvalidReplicaId)
{
}
enum
{
sHost,
s2,
nSessions
};
int GetNumSessions() override { return nSessions; }
void PreConnect() override
{
m_driller.BusConnect();
ReplicaPtr replica = Replica::CreateReplica(nullptr);
ForcingDirtyTestChunk* chunk = CreateAndAttachReplicaChunk<ForcingDirtyTestChunk>(replica);
AZ_TEST_ASSERT(chunk);
m_replicaId = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica);
}
~CheckReplicaIsntSentWithNoChanges() override
{
m_driller.BusDisconnect();
}
const int NewValue = 999;
const int MomentaryValue = 1;
const int ExpectedNumberReplicasSent = 6;
ReplicaPtr GetHostReplica()
{
return m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId);
}
TestStatus Tick(int tick) override
{
switch (tick)
{
case 9:
{
auto rep = GetHostReplica();
AZ_TEST_ASSERT(rep);
m_driller.ResetCounts();
auto chunk = rep->FindReplicaChunk<ForcingDirtyTestChunk>();
chunk->Data1.Set(NewValue);
break;
}
case 15:
{
auto rep = GetHostReplica();
AZ_TEST_ASSERT(rep);
auto counts = m_driller.m_replicaLengths.size();
AZ_TEST_ASSERT(counts == ExpectedNumberReplicasSent);
m_driller.ResetCounts();
auto chunk = rep->FindReplicaChunk<ForcingDirtyTestChunk>();
chunk->Data1.Set(MomentaryValue);
break;
}
case 16:
{
auto rep = GetHostReplica();
AZ_TEST_ASSERT(rep);
auto chunk = rep->FindReplicaChunk<ForcingDirtyTestChunk>();
chunk->Data1.Set(NewValue);
auto counts = m_driller.m_replicaLengths.size();
AZ_TEST_ASSERT(counts == 1);
m_driller.ResetCounts();
break;
}
case 100:
{
auto counts = m_driller.m_replicaLengths.size();
AZ_TEST_ASSERT(counts == ExpectedNumberReplicasSent);
m_driller.ResetCounts();
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId)->Destroy();
return TestStatus::Completed;
}
default:
break;
}
return TestStatus::Running;
}
FilteredHook<ForcingDirtyTestChunk> m_driller;
ReplicaId m_replicaId;
};
TEST(CheckReplicaIsntSentWithNoChanges, DISABLED_CheckReplicaIsntSentWithNoChanges)
{
CheckReplicaIsntSentWithNoChanges tester;
tester.run();
}
class CheckEntityScriptReplicaIsntSentWithNoChanges
: public SimpleBehaviorTest
{
public:
CheckEntityScriptReplicaIsntSentWithNoChanges()
: m_replicaId(InvalidReplicaId)
{
}
enum
{
sHost,
s2,
nSessions
};
int GetNumSessions() override { return nSessions; }
void PreConnect() override
{
m_driller.BusConnect();
ReplicaPtr replica = Replica::CreateReplica(nullptr);
auto chunk = CreateAndAttachReplicaChunk<EntityLikeScriptReplicaChunk>(replica);
AZ_TEST_ASSERT(chunk);
m_replicaId = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica);
}
~CheckEntityScriptReplicaIsntSentWithNoChanges() override
{
m_driller.BusDisconnect();
}
const int NewValue = 999;
const int MomentaryValue = 1;
const int ExpectedNumberReplicasSent = 6;
ReplicaPtr GetHostReplica()
{
return m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId);
}
TestStatus Tick(int tick) override
{
switch (tick)
{
case 10:
{
auto rep = GetHostReplica();
AZ_TEST_ASSERT(rep);
m_driller.ResetCounts();
auto chunk = rep->FindReplicaChunk<EntityLikeScriptReplicaChunk>();
// mimicing behavior of entity script chunk
chunk->m_scriptDataSets[0].SetIsEnabled(true);
chunk->m_scriptDataSets[0].Set(NewValue);
break;
}
case 60:
{
auto counts = m_driller.m_replicaLengths.size();
AZ_TEST_ASSERT(counts == ExpectedNumberReplicasSent);
m_driller.ResetCounts();
m_sessions[sHost].GetReplicaMgr().FindReplica(m_replicaId)->Destroy();
return TestStatus::Completed;
}
default:
break;
}
return TestStatus::Running;
}
ReplicaDrillerHook m_driller;
ReplicaId m_replicaId;
};
TEST(CheckEntityScriptReplicaIsntSentWithNoChanges, DISABLED_CheckEntityScriptReplicaIsntSentWithNoChanges)
{
CheckEntityScriptReplicaIsntSentWithNoChanges tester;
tester.run();
}
} // namespace ReplicaBehavior
} // namespace UnitTest