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

Linux build fixes

Browse Source 
Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
This commit is contained in:
Esteban Papp
2021-12-02 18:50:51 -08:00
parent bb685ee40b
commit 2dd2e53a29
4 changed files with 3 additions and 477 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Framework/AzFramework/Platform/Common/Xcb/AzFramework/XcbInputDeviceKeyboard.h
+2
View File
@@ -6,6 +6,8 @@
*
*/
#pragma once
#include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
#include <AzFramework/XcbEventHandler.h>
#include <AzFramework/XcbInterface.h>
Code/Framework/AzToolsFramework/Tests/SliceUpgradeTests.cpp
+1
View File
@@ -16,6 +16,7 @@ AZ_PUSH_DISABLE_WARNING(,"-Wdelete-non-virtual-dtor")
#include <AzCore/IO/FileIO.h>
#include <AzCore/IO/Streamer/Streamer.h>
#include <AzCore/IO/Streamer/StreamerComponent.h>
#include <AzCore/IO/SystemFile.h>
#include <AzCore/Serialization/Utils.h>
#include <AzCore/Slice/SliceComponent.h>
#include <AzCore/Slice/SliceMetadataInfoComponent.h>
Code/Framework/GridMate/GridMate/Replica/Replica.cpp
-1
View File
@@ -579,7 +579,6 @@ namespace GridMate
chunkInfo.m_payload.Init(128);
mc.m_outBuffer = &chunkInfo.m_payload;
PackedSize writeOffset = mc.m_outBuffer->GetExactSize();
// Write the ctor data if we need to
if (mc.m_marshalFlags & ReplicaMarshalFlags::IncludeCtorData)
{
Code/Framework/GridMate/Tests/Replica.cpp
-476
View File
@@ -1399,484 +1399,8 @@ public:
}
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class MPSession
: public CarrierEventBus::Handler
{
public:
ReplicaManager& GetReplicaMgr() { return m_rm; }
void SetTransport(Carrier* transport) { m_pTransport = transport; CarrierEventBus::Handler::BusConnect(transport->GetGridMate()); }
Carrier* GetTransport() { return m_pTransport; }
void SetClient(bool isClient) { m_client = isClient; }
void AcceptConn(bool accept) { m_acceptConn = accept; }
~MPSession()
{
CarrierEventBus::Handler::BusDisconnect();
}
void Update()
{
char buf[1500];
for (ConnectionSet::iterator iConn = m_connections.begin(); iConn != m_connections.end(); ++iConn)
{
ConnectionID conn = *iConn;
Carrier::ReceiveResult result = m_pTransport->Receive(buf, 1500, conn, GM_REPLICA_TEST_SESSION_CHANNEL);
if (result.m_state == Carrier::ReceiveResult::RECEIVED)
{
if (strcmp(buf, "IM_A_CLIENT") == 0)
{
m_rm.AddPeer(conn, Mode_Client);
}
else if (strcmp(buf, "IM_A_PEER") == 0)
{
m_rm.AddPeer(conn, Mode_Peer);
}
}
}
}
template<typename T>
typename T::Ptr GetChunkFromReplica(ReplicaId id)
{
ReplicaPtr replica = GetReplicaMgr().FindReplica(id);
if (!replica)
{
return nullptr;
}
return replica->FindReplicaChunk<T>();
}
//////////////////////////////////////////////////////////////////////////
// CarrierEventBus
void OnConnectionEstablished(Carrier* carrier, ConnectionID id) override
{
if (carrier != m_pTransport)
{
return; // not for us
}
m_connections.insert(id);
if (m_client)
{
m_pTransport->Send("IM_A_CLIENT", 12, id, Carrier::SEND_RELIABLE, Carrier::PRIORITY_NORMAL, GM_REPLICA_TEST_SESSION_CHANNEL);
}
else
{
m_pTransport->Send("IM_A_PEER", 10, id, Carrier::SEND_RELIABLE, Carrier::PRIORITY_NORMAL, GM_REPLICA_TEST_SESSION_CHANNEL);
}
}
void OnDisconnect(Carrier* carrier, ConnectionID id, CarrierDisconnectReason /*reason*/) override
{
if (carrier != m_pTransport)
{
return; // not for us
}
m_rm.RemovePeer(id);
m_connections.erase(id);
}
void OnDriverError(Carrier* carrier, ConnectionID id, const DriverError& error) override
{
(void)error;
if (carrier != m_pTransport)
{
return; // not for us
}
m_pTransport->Disconnect(id);
}
void OnSecurityError(Carrier* carrier, ConnectionID id, const SecurityError& error) override
{
(void)carrier;
(void)id;
(void)error;
//Ignore security warnings in unit tests
}
//////////////////////////////////////////////////////////////////////////
ReplicaManager m_rm;
Carrier* m_pTransport;
typedef unordered_set<ConnectionID> ConnectionSet;
ConnectionSet m_connections;
bool m_client;
bool m_acceptConn;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class MyObj
{
public:
GM_CLASS_ALLOCATOR(MyObj);
MyObj()
: m_f1(0.f)
, m_b1(false)
, m_i1(0) {}
float m_f1;
bool m_b1;
int m_i1;
};
//-----------------------------------------------------------------------------
class MyCtorContext
: public CtorContextBase
{
public:
CtorDataSet<float, Float16Marshaler> m_f;
MyCtorContext()
: m_f(Float16Marshaler(0.f, 1.f))
{}
};
//-----------------------------------------------------------------------------
class MigratableReplica
: public ReplicaChunk
{
public:
class Descriptor
: public ReplicaChunkDescriptor
{
public:
Descriptor()
: ReplicaChunkDescriptor(MigratableReplica::GetChunkName(), sizeof(MigratableReplica))
{
}
ReplicaChunkBase* CreateFromStream(UnmarshalContext& mc) override
{
MyCtorContext cc;
cc.Unmarshal(*mc.m_iBuf);
// Important hooks. Pre/Post construct allows us to detect all datasets.
if (mc.m_rm->GetUserContext(12345))
{
AZ_TracePrintf("GridMate", "Create with UserData:%p\n", mc.m_rm->GetUserContext(12345));
}
ReplicaChunk* chunk = aznew MigratableReplica;
return chunk;
}
void DiscardCtorStream(UnmarshalContext& mc) override
{
MyCtorContext cc;
cc.Unmarshal(*mc.m_iBuf);
}
void DeleteReplicaChunk(ReplicaChunkBase* chunkInstance) override { delete chunkInstance; }
void MarshalCtorData(ReplicaChunkBase*, WriteBuffer& wb) override
{
MyCtorContext cc;
cc.m_f.Set(0.5f);
cc.Marshal(wb);
}
};
typedef AZStd::intrusive_ptr<MigratableReplica> Ptr;
GM_CLASS_ALLOCATOR(MigratableReplica);
static const char* GetChunkName() {return "MigratableReplica"; }
MigratableReplica(MyObj* pObj = nullptr)
: MyHandler123Rpc("MyHandler123Rpc")
, m_data1("Data1")
, m_data2("Data2")
, m_data3("Data3", 3.0f, Float16Marshaler(0.0f, 10.0f))
, m_data4("Data4")
{
Bind(pObj);
}
bool IsReplicaMigratable() override
{
return true;
}
bool MyHandler123(const float& f, const RpcContext& rc)
{
(void)f;
(void)rc;
AZ_TracePrintf("GridMate", "Executed MyHandler123 requested at %u with %g on %s at %u.\n", rc.m_timestamp, f, GetReplica()->IsPrimary() ? "Primary" : "Proxy", rc.m_realTime);
return true;
}
Rpc<RpcArg<const float&> >::BindInterface<MigratableReplica, & MigratableReplica::MyHandler123> MyHandler123Rpc;
void UpdateChunk(const ReplicaContext& rc) override
{
if (m_pLocalObj)
{
m_data1.Set(m_pLocalObj->m_f1);
m_data1Interpolated.AddSample(m_pLocalObj->m_f1, rc.m_localTime);
m_data2.Set(m_pLocalObj->m_i1);
m_data3.Set(m_pLocalObj->m_f1);
}
AZStd::bitset<25> bits = m_data4.Get();
m_data4.Set(bits.flip());
}
void UpdateFromChunk(const ReplicaContext& rc) override
{
// AZ_TracePrintf("GridMate", "Updating proxy 0x%x on peer %d coming from peer %d %s\n", GetRepId(), rc.rm->GetLocalPeerId(), rc.myPeer->GetId(), rc.myPeer->GetConnectionId() == InvalidConnectionID ? "(orphan)" : "");
if (m_pLocalObj)
{
m_data1Interpolated.AddSample(m_data1.Get(), m_data1.GetLastUpdateTime());
m_pLocalObj->m_f1 = m_data1Interpolated.GetInterpolatedValue(rc.m_localTime);
m_pLocalObj->m_i1 = m_data2.Get();
}
m_dummy = m_data3.Get();
}
void OnReplicaActivate(const ReplicaContext& rc) override
{
(void)rc;
if (rc.m_rm->GetUserContext(12345))
{
AZ_TracePrintf("GridMate", "Activate %s with UserData:%p\n", GetReplica()->IsPrimary() ? "primary" : "proxy", rc.m_rm->GetUserContext(12345));
}
if (IsProxy())
{
Bind(aznew MyObj());
}
}
void OnReplicaDeactivate(const ReplicaContext& rc) override
{
(void)rc;
if (m_pLocalObj)
{
delete m_pLocalObj;
m_pLocalObj = NULL;
}
}
void OnReplicaChangeOwnership(const ReplicaContext& rc) override
{
(void)rc;
AZ_TracePrintf("GridMate", "Migratable replica 0x%x became %s on Peer %d\n", (int) GetReplicaId(), IsPrimary() ? "primary" : "proxy", (int) rc.m_rm->GetLocalPeerId());
}
void Bind(MyObj* pObj)
{
m_pLocalObj = pObj;
}
private:
DataSet<float> m_data1;
LinearInterpExtrap<float> m_data1Interpolated;
DataSet<int> m_data2;
DataSet<float, Float16Marshaler> m_data3;
DataSet<AZStd::bitset<25> > m_data4;
MyObj* m_pLocalObj;
float m_dummy;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class NonMigratableReplica
: public ReplicaChunk
{
public:
enum EBla : AZ::u8
{
e_Bla0,
e_Bla1,
};
typedef vector<int> IntVectorType;
bool m_unreliableCheck;
protected:
MyObj* m_pLocalObj;
int m_prevUnreliableValue;
bool MyHandler123(const float& f, const RpcContext& rc)
{
(void)f;
(void)rc;
AZ_TracePrintf("GridMate", "Executed MyHandler123 requested at %u with %g on %s at %u.\n", rc.m_timestamp, f, IsPrimary() ? "Primary" : "Proxy", rc.m_realTime);
return true;
}
bool MyHandler2(const float& f, int p2, const RpcContext& rc)
{
(void)f;
(void)p2;
(void)rc;
AZ_TracePrintf("GridMate", "Executed MyHandler2 requested at %u with %g,%d on %s at %u.\n", rc.m_timestamp, f, p2, IsPrimary() ? "Primary" : "Proxy", rc.m_realTime);
return true;
}
bool MyHandler3(const float& f, int p2, EBla p3, const RpcContext& rc)
{
(void)f;
(void)p2;
(void)p3;
(void)rc;
AZ_TracePrintf("GridMate", "Executed MyHandler3 requested at %u with %g,%d,%d on %s at %u.\n", rc.m_timestamp, f, p2, p3, IsPrimary() ? "Primary" : "Proxy", rc.m_realTime);
return true;
}
bool MyHandler4(const float& f, int p2, EBla p3, const IntVectorType& p4, const RpcContext& rc)
{
(void)f;
(void)p2;
(void)p3;
(void)p4;
(void)rc;
AZ_TracePrintf("GridMate", "Executed MyHandler4 requested at %u with %g,%d,%d,%d,%d on %s at %u.\n", rc.m_timestamp, f, p2, p3, p4[0], p4[1], IsPrimary() ? "Primary" : "Proxy", rc.m_realTime);
return true;
}
bool MyHandlerUnreliable(const int& i, const RpcContext& rc)
{
(void)rc;
AZ_TracePrintf("GridMate", "Executed MyHandlerUnreliable requested at %u with %d on %s at %u.\n", rc.m_timestamp, i, IsPrimary() ? "Primary" : "Proxy", rc.m_realTime);
AZ_TEST_ASSERT(i > m_prevUnreliableValue);
if ((i - m_prevUnreliableValue) > 1)
{
m_unreliableCheck = true;
}
m_prevUnreliableValue = i;
return true;
}
public:
GM_CLASS_ALLOCATOR(NonMigratableReplica);
typedef AZStd::intrusive_ptr<NonMigratableReplica> Ptr;
static const char* GetChunkName() { return "NonMigratableReplica"; }
Rpc<RpcArg<const float&> >::BindInterface<NonMigratableReplica, & NonMigratableReplica::MyHandler123> MyHandler123Rpc;
Rpc<RpcArg<const float&>, RpcArg<int> >::BindInterface<NonMigratableReplica, & NonMigratableReplica::MyHandler2> MyHandler2Rpc;
Rpc<RpcArg<const float&>, RpcArg<int>, RpcArg<EBla> >::BindInterface<NonMigratableReplica, & NonMigratableReplica::MyHandler3> MyHandler3Rpc;
Rpc<RpcArg<const float&>, RpcArg<int>, RpcArg<EBla>, RpcArg<const IntVectorType&> >::BindInterface<NonMigratableReplica, & NonMigratableReplica::MyHandler4> MyHandler4Rpc;
Rpc<RpcArg<const int&> >::BindInterface<NonMigratableReplica, & NonMigratableReplica::MyHandlerUnreliable, RpcUnreliable> MyHandlerUnreliableRpc;
NonMigratableReplica(MyObj* pObj = NULL)
: m_unreliableCheck(false)
, m_prevUnreliableValue(0)
, MyHandler123Rpc("MyHandler123Rpc")
, MyHandler2Rpc("MyHandler2Rpc")
, MyHandler3Rpc("MyHandler3Rpc")
, MyHandler4Rpc("MyHandler4Rpc")
, MyHandlerUnreliableRpc("MyHandlerUnreliableRpc")
, m_data1("Data1")
, m_data2("Data2")
{
Bind(pObj);
}
bool IsReplicaMigratable() override
{
return false;
}
~NonMigratableReplica()
{
AZ_Assert(!m_pLocalObj, "Local object should be cleared");
}
void UpdateChunk(const ReplicaContext& rc) override
{
m_data1.Set(m_pLocalObj->m_f1);
m_data1Interpolated.AddSample(m_pLocalObj->m_f1, rc.m_localTime);
m_data2.Set(m_pLocalObj->m_i1);
}
void UpdateFromChunk(const ReplicaContext& rc) override
{
m_data1Interpolated.AddSample(m_data1.Get(), m_data1.GetLastUpdateTime());
m_pLocalObj->m_f1 = m_data1Interpolated.GetInterpolatedValue(rc.m_localTime);
m_pLocalObj->m_i1 = m_data2.Get();
}
void OnReplicaActivate(const ReplicaContext& rc) override
{
(void)rc;
if (rc.m_rm->GetUserContext(12345))
{
AZ_TracePrintf("GridMate", "Activate %s with UserData:%p\n", IsPrimary() ? "primary" : "proxy", rc.m_rm->GetUserContext(12345));
}
if (IsProxy())
{
Bind(aznew MyObj());
}
}
void OnReplicaDeactivate(const ReplicaContext& rc) override
{
(void)rc;
if (m_pLocalObj)
{
delete m_pLocalObj;
m_pLocalObj = NULL;
}
}
void OnReplicaChangeOwnership(const ReplicaContext& rc) override
{
(void)rc;
AZ_TracePrintf("GridMate", "NonMigratable replica 0x%x became %s on Peer %d\n", (int) GetReplicaId(), IsPrimary() ? "primary" : "proxy", (int) rc.m_rm->GetLocalPeerId());
}
void Bind(MyObj* pObj)
{
m_pLocalObj = pObj;
}
protected:
DataSet<float> m_data1;
LinearInterpExtrap<float> m_data1Interpolated;
DataSet<int> m_data2;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class MyDerivedReplica
: public NonMigratableReplica
{
public:
GM_CLASS_ALLOCATOR(MyDerivedReplica);
MyDerivedReplica()
: m_data3("Data3") { }
typedef AZStd::intrusive_ptr<MyDerivedReplica> Ptr;
static const char* GetChunkName() { return "MyDerivedReplica"; }
virtual void UpdateChunk(const ReplicaContext& rc) override
{
NonMigratableReplica::UpdateChunk(rc);
m_data3.Set(m_pLocalObj->m_b1);
}
virtual void UpdateFromChunk(const ReplicaContext& rc) override
{
NonMigratableReplica::UpdateFromChunk(rc);
m_pLocalObj->m_b1 = m_data3.Get();
}
protected:
DataSet<bool> m_data3;
};
} // namespace UnitTest
GM_TEST_SUITE(ReplicaSuite)
GM_TEST(InterpolatorTest)
#if !defined(AZ_DEBUG_BUILD) // these tests are a little slow for debug
GM_TEST(DISABLED_ReplicaBandiwdthTest)
GM_TEST(DISABLED_ReplicaStressTest)
GM_TEST(DISABLED_ReplicaStableStressTest)
#endif
GM_TEST_SUITE_END()