diff --git a/Code/Framework/GridMate/GridMate/Carrier/Carrier.cpp b/Code/Framework/GridMate/GridMate/Carrier/Carrier.cpp index 2922cc2891..0fcb2e6ba3 100644 --- a/Code/Framework/GridMate/GridMate/Carrier/Carrier.cpp +++ b/Code/Framework/GridMate/GridMate/Carrier/Carrier.cpp @@ -3820,10 +3820,8 @@ CarrierImpl::DisconnectRequest(ConnectionID id, CarrierDisconnectReason reason) case Carrier::CST_CONNECTED: { conn->m_state = Carrier::CST_DISCONNECTING; - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionStateChanged, this, conn, conn->m_state); m_handshake->OnDisconnect(conn); EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnDisconnect, this, id, reason); - EBUS_EVENT(Debug::CarrierDrillerBus, OnDisconnect, this, id, reason); ThreadMessage* ctm = aznew ThreadMessage(CTM_DISCONNECT); ctm->m_connection = conn; @@ -3836,10 +3834,8 @@ CarrierImpl::DisconnectRequest(ConnectionID id, CarrierDisconnectReason reason) case Carrier::CST_CONNECTING: { conn->m_state = Carrier::CST_DISCONNECTING; - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionStateChanged, this, id, conn->m_state); m_handshake->OnDisconnect(conn); EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnFailedToConnect, this, id, reason); - EBUS_EVENT(Debug::CarrierDrillerBus, OnFailedToConnect, this, id, reason); ThreadMessage* ctm = aznew ThreadMessage(CTM_DISCONNECT); ctm->m_connection = conn; @@ -3873,13 +3869,11 @@ CarrierImpl::DeleteConnection(Connection* conn, CarrierDisconnectReason reason) { m_handshake->OnDisconnect(conn); EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnDisconnect, this, conn, reason); - EBUS_EVENT(Debug::CarrierDrillerBus, OnDisconnect, this, conn, reason); } break; case Carrier::CST_CONNECTING: { m_handshake->OnDisconnect(conn); EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnFailedToConnect, this, conn, reason); - EBUS_EVENT(Debug::CarrierDrillerBus, OnFailedToConnect, this, conn, reason); } break; case Carrier::CST_DISCONNECTED: case Carrier::CST_DISCONNECTING: @@ -4271,7 +4265,6 @@ CarrierImpl::ProcessMainThreadMessages() m_connections.insert(conn); EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnIncomingConnection, this, conn); - EBUS_EVENT(Debug::CarrierDrillerBus, OnIncomingConnection, this, conn); ThreadMessage* ctm = aznew ThreadMessage(CTM_CONNECT); ctm->m_connection = conn; @@ -4306,7 +4299,6 @@ CarrierImpl::ProcessMainThreadMessages() ctm->m_threadConnection = threadConn; ctm->m_disconnectReason = msg->m_disconnectReason; m_thread->PushCarrierThreadMessage(ctm); - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionStateChanged, this, msg->m_connection, msg->m_connection->m_state); } } break; case MTM_DELETE_CONNECTION: @@ -4333,7 +4325,6 @@ CarrierImpl::ProcessMainThreadMessages() if (msg->m_errorCode == CarrierErrorCode::EC_DRIVER) { EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnDriverError, this, msg->m_connection, msg->m_error.m_driverError); - EBUS_EVENT(Debug::CarrierDrillerBus, OnDriverError, this, msg->m_connection, msg->m_error.m_driverError); if (msg->m_connection) { @@ -4344,7 +4335,6 @@ CarrierImpl::ProcessMainThreadMessages() else { EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnSecurityError, this, msg->m_connection, msg->m_error.m_securityError); - EBUS_EVENT(Debug::CarrierDrillerBus, OnSecurityError, this, msg->m_connection, msg->m_error.m_securityError); } } break; case MTM_RATE_UPDATE: @@ -4443,13 +4433,11 @@ CarrierImpl::ProcessSystemMessages() if (requestError == HandshakeErrorCode::OK) { conn->m_state = Carrier::CST_CONNECTED; - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionStateChanged, this, conn, conn->m_state); SendSyncTime(); // send time first if we have the clock. SendSystemMessage(SM_CONNECT_ACK, wb, conn, SEND_RELIABLE); EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnConnectionEstablished, this, conn); - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionEstablished, this, conn); ThreadMessage* ctm = aznew ThreadMessage(CTM_HANDSHAKE_COMPLETE); ctm->m_connection = conn; @@ -4494,9 +4482,7 @@ CarrierImpl::ProcessSystemMessages() m_pendingHandshakes.erase(PendingHandshake(conn)); // Connected -> no need to retry handshake anymore conn->m_state = Carrier::CST_CONNECTED; - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionStateChanged, this, conn, conn->m_state); EBUS_EVENT_ID(m_gridMate, CarrierEventBus, OnConnectionEstablished, this, conn); - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionEstablished, this, conn); ThreadMessage* ctm = aznew ThreadMessage(CTM_HANDSHAKE_COMPLETE); ctm->m_connection = conn; @@ -4540,7 +4526,6 @@ CarrierImpl::ProcessSystemMessages() ctm->m_threadConnection = threadConn; ctm->m_disconnectReason = reason; m_thread->PushCarrierThreadMessage(ctm); - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionStateChanged, this, conn, conn->m_state); ////////////////////////////////////////////////////////////////////////// } break; case SM_CLOCK_SYNC: @@ -4850,7 +4835,6 @@ CarrierImpl::DebugDeleteConnection(ConnectionID id) ctm->m_threadConnection = threadConn; ctm->m_disconnectReason = reason; m_thread->PushCarrierThreadMessage(ctm); - EBUS_EVENT(Debug::CarrierDrillerBus, OnConnectionStateChanged, this, conn, conn->m_state); ////////////////////////////////////////////////////////////////////////// } diff --git a/Code/Framework/GridMate/GridMate/Carrier/Carrier.h b/Code/Framework/GridMate/GridMate/Carrier/Carrier.h index 94c31ed6d2..9255bb4016 100644 --- a/Code/Framework/GridMate/GridMate/Carrier/Carrier.h +++ b/Code/Framework/GridMate/GridMate/Carrier/Carrier.h @@ -14,8 +14,6 @@ #include #include -#include -#include #include "AzCore/std/smart_ptr/weak_ptr.h" namespace GridMate @@ -485,60 +483,6 @@ namespace GridMate }; typedef AZ::EBus CarrierEventBus; - - namespace Debug - { - class CarrierDrillerEvents - : public CarrierEventsBase - , public AZ::Debug::DrillerEBusTraits - { - public: - virtual void OnIncomingConnection(Carrier* carrier, ConnectionID id) = 0; - - virtual void OnFailedToConnect(Carrier* carrier, ConnectionID id, CarrierDisconnectReason reason) = 0; - - virtual void OnConnectionEstablished(Carrier* carrier, ConnectionID id) = 0; - - virtual void OnDisconnect(Carrier* carrier, ConnectionID id, CarrierDisconnectReason reason) = 0; - - /// Report all carrier and driver errors! id == InvalidConnectionID if the error is not connection related! - virtual void OnDriverError(Carrier* carrier, ConnectionID id, const DriverError& error) = 0; - virtual void OnSecurityError(Carrier* carrier, ConnectionID id, const SecurityError& error) = 0; - - ////////////////////////////////////////////////////////////////////////// - // Executed from NETWORK thread - - // Driver - /// SendTo - /// ReceiveFrom - /// Errors - - // Traffic control - - /// Called every second when you update last second statistics - virtual void OnUpdateStatistics(const AZStd::string& address, const TrafficControl::Statistics& lastSecond, const TrafficControl::Statistics& lifeTime, const TrafficControl::Statistics& effectiveLastSecond, const TrafficControl::Statistics& effectiveLifeTime) = 0; - - // Simulator - /// Enable/Disable - /// Change Simulator parameters - - // Carrier - virtual void OnConnectionStateChanged(Carrier* carrier, ConnectionID id, Carrier::ConnectionStates newState) = 0; - - ////////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////////// - // Executed from GAME/MAIN thread - - // Handshake low level (we drill the handshake on session level too) - - // Carrier - in addition to carrier events - - ////////////////////////////////////////////////////////////////////////// - }; - - typedef AZ::EBus CarrierDrillerBus; - } } #endif // GM_CARRIER_H diff --git a/Code/Framework/GridMate/GridMate/Carrier/DefaultTrafficControl.cpp b/Code/Framework/GridMate/GridMate/Carrier/DefaultTrafficControl.cpp index 8743e50e83..107dfe839b 100644 --- a/Code/Framework/GridMate/GridMate/Carrier/DefaultTrafficControl.cpp +++ b/Code/Framework/GridMate/GridMate/Carrier/DefaultTrafficControl.cpp @@ -591,9 +591,6 @@ DefaultTrafficControl::Update() //AZ_TracePrintf("GridMate","Traffic control: Connection %s LifeTime(rtt %.2f packetLoss %.2f) LastSecond(rtt %.2f packetLoss %.2f)\n", // cd.m_address.c_str(),cd.m_sdLifetime.m_rtt,cd.m_sdLifetime.m_packetLoss,cd.m_sdLastSecond.m_rtt,cd.m_sdLastSecond.m_packetLoss); - // send new statistics event - EBUS_EVENT(Debug::CarrierDrillerBus, OnUpdateStatistics, cd.m_address, cd.m_sdLastSecond, cd.m_sdLifetime, cd.m_sdEffectiveLastSecond, cd.m_sdEffectiveLifetime); - cd.m_sdCurrentSecond.Reset(); cd.m_sdCurrentSecond.m_rtt = cd.m_sdLastSecond.m_rtt; //cd.sdCurrentSecond.flow = 1.0f; // Good diff --git a/Code/Framework/GridMate/GridMate/Drillers/CarrierDriller.cpp b/Code/Framework/GridMate/GridMate/Drillers/CarrierDriller.cpp deleted file mode 100644 index 38f029f0f5..0000000000 --- a/Code/Framework/GridMate/GridMate/Drillers/CarrierDriller.cpp +++ /dev/null @@ -1,224 +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 -#include - -using namespace AZ::Debug; - -namespace GridMate -{ - namespace Debug - { - //========================================================================= - // CarrierDriller - // [4/14/2011] - //========================================================================= - CarrierDriller::CarrierDriller() - { - m_drillerTag = AZ_CRC("CarrierDriller", 0x72a37d06); - } - - //========================================================================= - // Start - // [4/14/2011] - //========================================================================= - void CarrierDriller::Start(const Param* params, int numParams) - { - (void)params; - (void)numParams; - CarrierDrillerBus::Handler::BusConnect(); - - /* get carriers and output all the data - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("CarrierId"),carrier); - m_output->BeginTag(AZ_CRC("StartDrill")); - for(unsigned int iConn = 0; iConn < carrier->GetNumConnections(); ++iConn ) - { - ConnectionID connId = carrier->GetConnectionId(iConn); - m_output->BeginTag(AZ_CRC("Connection")); - m_output->Write(AZ_CRC("Id"),connId); - m_output->Write(AZ_CRC("Address"),carrier->ConnectionToAddress(connId)); - m_output->Write(AZ_CRC("State"),static_cast(carrier->GetConnectionState(connId))); - m_output->EndTag(AZ_CRC("Connection")); - } - m_output->EndTag(AZ_CRC("StartDrill")); - m_output->EndTag(m_drillerTag);*/ - } - - //========================================================================= - // Stop - // [4/14/2011] - //========================================================================= - void CarrierDriller::Stop() - { - CarrierDrillerBus::Handler::BusDisconnect(); - } - - //========================================================================= - // OnUpdateStatistics - // [4/14/2011] - //========================================================================= - void CarrierDriller::OnUpdateStatistics(const AZStd::string& address, const TrafficControl::Statistics& lastSecond, const TrafficControl::Statistics& lifeTime, const TrafficControl::Statistics& effectiveLastSecond, const TrafficControl::Statistics& effectiveLifeTime) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("Statistics", 0xe2d38b22)); - m_output->Write(AZ_CRC("Address", 0x0d4e6f81), address); - m_output->BeginTag(AZ_CRC("LastSecond", 0x5e6ccbee)); - m_output->Write(AZ_CRC("DataSend", 0xae94c282), lastSecond.m_dataSend); - m_output->Write(AZ_CRC("DataReceived", 0xd92f8e4b), lastSecond.m_dataReceived); - m_output->Write(AZ_CRC("DataResend", 0xe44a3086), lastSecond.m_dataResend); - m_output->Write(AZ_CRC("DataAcked", 0xbb5e5496), lastSecond.m_dataAcked); - m_output->Write(AZ_CRC("PacketSend", 0x5b52fa79), lastSecond.m_packetSend); - m_output->Write(AZ_CRC("PacketReceived", 0xf247dd9e), lastSecond.m_packetReceived); - m_output->Write(AZ_CRC("PacketLost", 0xbc64441e), lastSecond.m_packetLost); - m_output->Write(AZ_CRC("PacketAcked", 0x91c4b93a), lastSecond.m_packetAcked); - m_output->Write(AZ_CRC("PacketLoss", 0x2200d1bd), lastSecond.m_packetLoss); - m_output->Write(AZ_CRC("rtt", 0xb40f6cfb), lastSecond.m_rtt); - //m_output->Write(AZ_CRC("flow"),lastSecond.m_flow); - m_output->EndTag(AZ_CRC("LastSecond", 0x5e6ccbee)); - m_output->BeginTag(AZ_CRC("LifeTime", 0x3de73088)); - m_output->Write(AZ_CRC("DataSend", 0xae94c282), lifeTime.m_dataSend); - m_output->Write(AZ_CRC("DataReceived", 0xd92f8e4b), lifeTime.m_dataReceived); - m_output->Write(AZ_CRC("DataResend", 0xe44a3086), lifeTime.m_dataResend); - m_output->Write(AZ_CRC("DataAcked", 0xbb5e5496), lifeTime.m_dataAcked); - m_output->Write(AZ_CRC("PacketSend", 0x5b52fa79), lifeTime.m_packetSend); - m_output->Write(AZ_CRC("PacketReceived", 0xf247dd9e), lifeTime.m_packetReceived); - m_output->Write(AZ_CRC("PacketLost", 0xbc64441e), lifeTime.m_packetLost); - m_output->Write(AZ_CRC("PacketAcked", 0x91c4b93a), lifeTime.m_packetAcked); - m_output->Write(AZ_CRC("PacketLoss", 0x2200d1bd), lifeTime.m_packetLoss); - m_output->Write(AZ_CRC("rtt", 0xb40f6cfb), lifeTime.m_rtt); - //m_output->Write(AZ_CRC("flow"),lifeTime.m_flow); - m_output->EndTag(AZ_CRC("LifeTime", 0x3de73088)); - m_output->BeginTag(AZ_CRC("EffectiveLastSecond", 0x8f84642f)); - m_output->Write(AZ_CRC("DataSend", 0xae94c282), effectiveLastSecond.m_dataSend); - m_output->Write(AZ_CRC("DataReceived", 0xd92f8e4b), effectiveLastSecond.m_dataReceived); - m_output->Write(AZ_CRC("DataResend", 0xe44a3086), effectiveLastSecond.m_dataResend); - m_output->Write(AZ_CRC("DataAcked", 0xbb5e5496), effectiveLastSecond.m_dataAcked); - m_output->Write(AZ_CRC("PacketSend", 0x5b52fa79), effectiveLastSecond.m_packetSend); - m_output->Write(AZ_CRC("PacketReceived", 0xf247dd9e), effectiveLastSecond.m_packetReceived); - m_output->Write(AZ_CRC("PacketLost", 0xbc64441e), effectiveLastSecond.m_packetLost); - m_output->Write(AZ_CRC("PacketAcked", 0x91c4b93a), effectiveLastSecond.m_packetAcked); - m_output->Write(AZ_CRC("PacketLoss", 0x2200d1bd), effectiveLastSecond.m_packetLoss); - m_output->Write(AZ_CRC("rtt", 0xb40f6cfb), effectiveLastSecond.m_rtt); - //m_output->Write(AZ_CRC("flow"),effectiveLastSecond.m_flow); - m_output->EndTag(AZ_CRC("EffectiveLastSecond", 0x8f84642f)); - m_output->BeginTag(AZ_CRC("EffectiveLifeTime", 0x4644a47a)); - m_output->Write(AZ_CRC("DataSend", 0xae94c282), effectiveLifeTime.m_dataSend); - m_output->Write(AZ_CRC("DataReceived", 0xd92f8e4b), effectiveLifeTime.m_dataReceived); - m_output->Write(AZ_CRC("DataResend", 0xe44a3086), effectiveLifeTime.m_dataResend); - m_output->Write(AZ_CRC("DataAcked", 0xbb5e5496), effectiveLifeTime.m_dataAcked); - m_output->Write(AZ_CRC("PacketSend", 0x5b52fa79), effectiveLifeTime.m_packetSend); - m_output->Write(AZ_CRC("PacketReceived", 0xf247dd9e), effectiveLifeTime.m_packetReceived); - m_output->Write(AZ_CRC("PacketLost", 0xbc64441e), effectiveLifeTime.m_packetLost); - m_output->Write(AZ_CRC("PacketAcked", 0x91c4b93a), effectiveLifeTime.m_packetAcked); - m_output->Write(AZ_CRC("PacketLoss", 0x2200d1bd), effectiveLifeTime.m_packetLoss); - m_output->Write(AZ_CRC("rtt", 0xb40f6cfb), effectiveLifeTime.m_rtt); - //m_output->Write(AZ_CRC("flow"),effectiveLifeTime.m_flow); - m_output->EndTag(AZ_CRC("EffectiveLifeTime", 0x4644a47a)); - m_output->EndTag(AZ_CRC("Statistics", 0xe2d38b22)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnConnectionStateChanged - // [4/14/2011] - //========================================================================= - void CarrierDriller::OnConnectionStateChanged(Carrier* carrier, ConnectionID id, Carrier::ConnectionStates newState) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("CarrierId", 0x93f4bfbe), carrier); - m_output->BeginTag(AZ_CRC("ConnectionState", 0x38a6a5da)); - m_output->Write(AZ_CRC("Id", 0xbf396750), id); - m_output->Write(AZ_CRC("State", 0xa393d2fb), static_cast(newState)); - m_output->EndTag(AZ_CRC("ConnectionState", 0x38a6a5da)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnIncomingConnection - // [4/14/2011] - //========================================================================= - void CarrierDriller::OnIncomingConnection(Carrier* carrier, ConnectionID id) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("CarrierId", 0x93f4bfbe), carrier); - m_output->BeginTag(AZ_CRC("IncomingConnection", 0x8c9d071a)); - m_output->Write(AZ_CRC("Id", 0xbf396750), id); - m_output->Write(AZ_CRC("Address", 0x0d4e6f81), carrier->ConnectionToAddress(id)); - m_output->EndTag(AZ_CRC("IncomingConnection", 0x8c9d071a)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnFailedToConnect - // [4/14/2011] - //========================================================================= - void CarrierDriller::OnFailedToConnect(Carrier* carrier, ConnectionID id, CarrierDisconnectReason reason) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("CarrierId", 0x93f4bfbe), carrier); - m_output->BeginTag(AZ_CRC("FailedToConnect", 0xb6539549)); - m_output->Write(AZ_CRC("Id", 0xbf396750), id); - m_output->Write(AZ_CRC("Reason", 0x3bb8880c), ReasonToString(reason)); - m_output->EndTag(AZ_CRC("FailedToConnect", 0xb6539549)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnConnectionEstablished - // [4/14/2011] - //========================================================================= - void CarrierDriller::OnConnectionEstablished(Carrier* carrier, ConnectionID id) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("CarrierId", 0x93f4bfbe), carrier); - m_output->BeginTag(AZ_CRC("ConnectionEstablished", 0xcde31aa7)); - m_output->Write(AZ_CRC("Id", 0xbf396750), id); - m_output->EndTag(AZ_CRC("ConnectionEstablished", 0xcde31aa7)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnDisconnect - // [4/14/2011] - //========================================================================= - void CarrierDriller::OnDisconnect(Carrier* carrier, ConnectionID id, CarrierDisconnectReason reason) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("CarrierId", 0x93f4bfbe), carrier); - m_output->BeginTag(AZ_CRC("Disconnect", 0x003a4b91)); - m_output->Write(AZ_CRC("Id", 0xbf396750), id); - m_output->Write(AZ_CRC("Reason", 0x3bb8880c), ReasonToString(reason)); - m_output->EndTag(AZ_CRC("Disconnect", 0x003a4b91)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnDriverError - // [12/14/2016] - //========================================================================= - void CarrierDriller::OnDriverError(Carrier* carrier, ConnectionID id, const DriverError& error) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("CarrierId", 0x93f4bfbe), carrier); - m_output->BeginTag(AZ_CRC("DriverError", 0xe7522aff)); - m_output->Write(AZ_CRC("Id", 0xbf396750), id); - m_output->Write(AZ_CRC("ErrorCode", 0x499e660e), static_cast(error.m_errorCode)); - m_output->EndTag(AZ_CRC("DriverError", 0xe7522aff)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnSecurityError - //========================================================================= - void CarrierDriller::OnSecurityError(Carrier* carrier, ConnectionID id, const SecurityError& error) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("CarrierId", 0x93f4bfbe), carrier); - m_output->BeginTag(AZ_CRC("SecurityError", 0xdfe940ab)); - m_output->Write(AZ_CRC("Id", 0xbf396750), id); - m_output->Write(AZ_CRC("ErrorCode", 0x499e660e), static_cast(error.m_errorCode)); - m_output->EndTag(AZ_CRC("SecurityError", 0xdfe940ab)); - m_output->EndTag(m_drillerTag); - } - } // namespace Debug -} // namespace GridMate diff --git a/Code/Framework/GridMate/GridMate/Drillers/CarrierDriller.h b/Code/Framework/GridMate/GridMate/Drillers/CarrierDriller.h deleted file mode 100644 index b12441e6fa..0000000000 --- a/Code/Framework/GridMate/GridMate/Drillers/CarrierDriller.h +++ /dev/null @@ -1,62 +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 - * - */ -#ifndef GM_CARRIER_DRILLER_H -#define GM_CARRIER_DRILLER_H - -#include -#include -#include - -namespace GridMate -{ - namespace Debug - { - /** - * Carrier driller - * \note Be careful which buses you attach. The drillers work in Multi threaded environment and expect that - * a driller mutex (DrillerManager::DrillerManager) will be automatically locked on every write. - * Otherwise in output stream corruption will happen (even is the stream is thread safe). - */ - class CarrierDriller - : public AZ::Debug::Driller - , public CarrierDrillerBus::Handler - { - int m_drillerTag; - public: - AZ_CLASS_ALLOCATOR(CarrierDriller, AZ::OSAllocator, 0); - CarrierDriller(); - - ////////////////////////////////////////////////////////////////////////// - // Driller - const char* GroupName() const override { return "GridMate"; } - const char* GetName() const override { return "CarrierDriller"; } - const char* GetDescription() const override { return "Drills Carrier/transport layer,traffic control, driver,etc."; } - void Start(const Param* params = nullptr, int numParams = 0) override; - void Stop() override; - ////////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////////// - // Carrier Driller Bus - void OnUpdateStatistics(const AZStd::string& address, const TrafficControl::Statistics& lastSecond, const TrafficControl::Statistics& lifeTime, const TrafficControl::Statistics& effectiveLastSecond, const TrafficControl::Statistics& effectiveLifeTime) override; - void OnConnectionStateChanged(Carrier* carrier, ConnectionID id, Carrier::ConnectionStates newState) override; - ////////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////////// - // Carrier Event Bus - void OnIncomingConnection(Carrier* carrier, ConnectionID id) override; - void OnFailedToConnect(Carrier* carrier, ConnectionID id, CarrierDisconnectReason reason) override; - void OnConnectionEstablished(Carrier* carrier, ConnectionID id) override; - void OnDisconnect(Carrier* carrier, ConnectionID id, CarrierDisconnectReason reason) override; - void OnDriverError(Carrier* carrier, ConnectionID id, const DriverError& error) override; - void OnSecurityError(Carrier* carrier, ConnectionID id, const SecurityError& error) override; - ////////////////////////////////////////////////////////////////////////// - }; - } -} - -#endif // GM_CARRIER_DRILLER_H diff --git a/Code/Framework/GridMate/GridMate/Drillers/ReplicaDriller.cpp b/Code/Framework/GridMate/GridMate/Drillers/ReplicaDriller.cpp deleted file mode 100644 index cb48578255..0000000000 --- a/Code/Framework/GridMate/GridMate/Drillers/ReplicaDriller.cpp +++ /dev/null @@ -1,140 +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 -#include -#include -#include - -using namespace AZ::Debug; - -namespace GridMate -{ - namespace Debug - { - const AZ::Crc32 ReplicaDriller::Tags::REPLICA_DRILLER = AZ_CRC("ReplicaDriller", 0xd832f49a); - - // Event Types - const AZ::Crc32 ReplicaDriller::Tags::CHUNK_SEND_DATASET = AZ_CRC("ChunkSendDataSet", 0x085ea99b); - const AZ::Crc32 ReplicaDriller::Tags::CHUNK_RECEIVE_DATASET = AZ_CRC("ChunkReceiveDataSet", 0x8d4536db); - const AZ::Crc32 ReplicaDriller::Tags::CHUNK_SEND_RPC = AZ_CRC("ChunkSendRPC", 0x7c40afe0); - const AZ::Crc32 ReplicaDriller::Tags::CHUNK_RECEIVE_RPC = AZ_CRC("ChunkReceiveRPC", 0xb49b302d); - - // Data Fields - const AZ::Crc32 ReplicaDriller::Tags::REPLICA_NAME = AZ_CRC("ReplicaName", 0xc69b68ee); - const AZ::Crc32 ReplicaDriller::Tags::REPLICA_ID = AZ_CRC("ReplicaID", 0x394dd741); - const AZ::Crc32 ReplicaDriller::Tags::CHUNK_TYPE = AZ_CRC("TypeName", 0x115f811d); - const AZ::Crc32 ReplicaDriller::Tags::CHUNK_INDEX = AZ_CRC("ChunkIndex", 0x25ba3370); - const AZ::Crc32 ReplicaDriller::Tags::DATA_SET_NAME = AZ_CRC("DataSetName", 0xf22dbaae); - const AZ::Crc32 ReplicaDriller::Tags::DATA_SET_INDEX = AZ_CRC("DataSetIndex", 0x58d2421f); - const AZ::Crc32 ReplicaDriller::Tags::RPC_NAME = AZ_CRC("RPCName", 0x4c4cbf3a); - const AZ::Crc32 ReplicaDriller::Tags::RPC_INDEX = AZ_CRC("RPCIndex", 0xaf0e7447); - const AZ::Crc32 ReplicaDriller::Tags::SIZE = AZ_CRC("Size", 0xf7c0246a); - const AZ::Crc32 ReplicaDriller::Tags::TIME_PROCESSED_MILLISEC = AZ_CRC("Time", 0x6f949845); - - ReplicaDriller::ReplicaDriller() - { - } - - void ReplicaDriller::Start(const Param* params, int numParams) - { - (void)params; - (void)numParams; - ReplicaDrillerBus::Handler::BusConnect(); - } - - void ReplicaDriller::Stop() - { - ReplicaDrillerBus::Handler::BusDisconnect(); - } - - void ReplicaDriller::OnSendDataSet(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, DataSetBase* dataSet, PeerId from, PeerId to, const void* data, size_t len) - { - (void)from; - (void)to; - (void)data; - - const char* dataSetName = chunk->GetDescriptor()->GetDataSetName(chunk, dataSet); - size_t dataSetIndex = chunk->GetDescriptor()->GetDataSetIndex(chunk, dataSet); - - m_output->BeginTag(Tags::REPLICA_DRILLER); - m_output->BeginTag(Tags::CHUNK_SEND_DATASET); - OutputBaseReplicaChunkTags(chunk, chunkIndex, len); - m_output->Write(Tags::DATA_SET_NAME, dataSetName); - m_output->Write(Tags::DATA_SET_INDEX, dataSetIndex); - m_output->EndTag(Tags::CHUNK_SEND_DATASET); - m_output->EndTag(Tags::REPLICA_DRILLER); - } - - void ReplicaDriller::OnReceiveDataSet(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, DataSetBase* dataSet, PeerId from, PeerId to, const void* data, size_t len) - { - (void)from; - (void)to; - (void)data; - - const char* dataSetName = chunk->GetDescriptor()->GetDataSetName(chunk, dataSet); - size_t dataSetIndex = chunk->GetDescriptor()->GetDataSetIndex(chunk, dataSet); - - m_output->BeginTag(Tags::REPLICA_DRILLER); - m_output->BeginTag(Tags::CHUNK_RECEIVE_DATASET); - OutputBaseReplicaChunkTags(chunk, chunkIndex, len); - m_output->Write(Tags::DATA_SET_NAME, dataSetName); - m_output->Write(Tags::DATA_SET_INDEX, dataSetIndex); - m_output->EndTag(Tags::CHUNK_RECEIVE_DATASET); - m_output->EndTag(Tags::REPLICA_DRILLER); - } - - void ReplicaDriller::OnSendRpc(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, Internal::RpcRequest* rpc, PeerId from, PeerId to, const void* data, size_t len) - { - (void)from; - (void)to; - (void)data; - - const char* rpcName = chunk->GetDescriptor()->GetRpcName(chunk, rpc->m_rpc); - size_t rpcIndex = chunk->GetDescriptor()->GetRpcIndex(chunk, rpc->m_rpc); - - - m_output->BeginTag(Tags::REPLICA_DRILLER); - m_output->BeginTag(Tags::CHUNK_SEND_RPC); - OutputBaseReplicaChunkTags(chunk, chunkIndex, len); - m_output->Write(Tags::RPC_NAME, rpcName); - m_output->Write(Tags::RPC_INDEX, rpcIndex); - m_output->EndTag(Tags::CHUNK_SEND_RPC); - m_output->EndTag(Tags::REPLICA_DRILLER); - } - void ReplicaDriller::OnReceiveRpc(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, Internal::RpcRequest* rpc, PeerId from, PeerId to, const void* data, size_t len) - { - (void)from; - (void)to; - (void)data; - - const char* rpcName = chunk->GetDescriptor()->GetRpcName(chunk, rpc->m_rpc); - size_t rpcIndex = chunk->GetDescriptor()->GetRpcIndex(chunk, rpc->m_rpc); - - m_output->BeginTag(Tags::REPLICA_DRILLER); - m_output->BeginTag(Tags::CHUNK_RECEIVE_RPC); - OutputBaseReplicaChunkTags(chunk, chunkIndex, len); - m_output->Write(Tags::RPC_NAME, rpcName); - m_output->Write(Tags::RPC_INDEX, rpcIndex); - m_output->EndTag(Tags::CHUNK_RECEIVE_RPC); - m_output->EndTag(Tags::REPLICA_DRILLER); - } - - void ReplicaDriller::OutputBaseReplicaChunkTags(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, size_t len) - { - const char* chunkTypeName = chunk->GetDescriptor()->GetChunkName(); - const char* replicaName = chunk->GetReplica()->GetDebugName(); - - m_output->Write(Tags::REPLICA_NAME, replicaName); - m_output->Write(Tags::REPLICA_ID, chunk->GetReplicaId()); - m_output->Write(Tags::CHUNK_TYPE, chunkTypeName); - m_output->Write(Tags::CHUNK_INDEX, chunkIndex); - m_output->Write(Tags::SIZE, len); - m_output->Write(Tags::TIME_PROCESSED_MILLISEC, AZStd::chrono::milliseconds(AZStd::chrono::system_clock::now().time_since_epoch()).count()); - } - } -} diff --git a/Code/Framework/GridMate/GridMate/Drillers/ReplicaDriller.h b/Code/Framework/GridMate/GridMate/Drillers/ReplicaDriller.h deleted file mode 100644 index e2b7213926..0000000000 --- a/Code/Framework/GridMate/GridMate/Drillers/ReplicaDriller.h +++ /dev/null @@ -1,77 +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 - * - */ -#ifndef GM_REPLICA_DRILLER_H -#define GM_REPLICA_DRILLER_H - -#include -#include -#include -#include - -namespace GridMate -{ - namespace Debug - { - class ReplicaDriller - : public AZ::Debug::Driller - , public GridMate::Debug::ReplicaDrillerBus::Handler - { - public: - struct Tags - { - // Driller - static const AZ::Crc32 REPLICA_DRILLER; - - // Event Types - static const AZ::Crc32 CHUNK_SEND_DATASET; - static const AZ::Crc32 CHUNK_RECEIVE_DATASET; - static const AZ::Crc32 CHUNK_SEND_RPC; - static const AZ::Crc32 CHUNK_RECEIVE_RPC; - - // Data Fields - static const AZ::Crc32 REPLICA_NAME; - static const AZ::Crc32 REPLICA_ID; - static const AZ::Crc32 CHUNK_TYPE; - static const AZ::Crc32 CHUNK_INDEX; - static const AZ::Crc32 DATA_SET_NAME; - static const AZ::Crc32 DATA_SET_INDEX; - static const AZ::Crc32 RPC_NAME; - static const AZ::Crc32 RPC_INDEX; - static const AZ::Crc32 SIZE; - static const AZ::Crc32 TIME_PROCESSED_MILLISEC; - }; - - AZ_CLASS_ALLOCATOR(ReplicaDriller, AZ::OSAllocator, 0); - ReplicaDriller(); - - ////////////////////////////////////////////////////////////////////////// - // Driller - const char* GroupName() const override { return "GridMate"; } - const char* GetName() const override { return "ReplicaDriller"; } - const char* GetDescription() const override { return "Drills replicas."; } - void Start(const Param* params = NULL, int numParams = 0) override; - void Stop() override; - ////////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////////// - // ReplicaDrillerEvents - void OnSendDataSet(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, DataSetBase* dataSet, PeerId from, PeerId to, const void* data, size_t len) override; - void OnReceiveDataSet(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, DataSetBase* dataSet, PeerId from, PeerId to, const void* data, size_t len) override; - - void OnSendRpc(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, Internal::RpcRequest* rpc, PeerId from, PeerId to, const void* data, size_t len) override; - void OnReceiveRpc(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, Internal::RpcRequest* rpc, PeerId from, PeerId to, const void* data, size_t len) override; - ////////////////////////////////////////////////////////////////////////// - - private: - - void OutputBaseReplicaChunkTags(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, size_t len); - }; - } -} - -#endif diff --git a/Code/Framework/GridMate/GridMate/Drillers/SessionDriller.cpp b/Code/Framework/GridMate/GridMate/Drillers/SessionDriller.cpp deleted file mode 100644 index a7130218f8..0000000000 --- a/Code/Framework/GridMate/GridMate/Drillers/SessionDriller.cpp +++ /dev/null @@ -1,275 +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 - -using namespace AZ::Debug; - -namespace GridMate -{ - namespace Debug - { - //========================================================================= - // SessionDriller - // [4/14/2011] - //========================================================================= - SessionDriller::SessionDriller() - { - m_drillerTag = AZ_CRC("SessionDriller", 0x30b916a9); - } - - //========================================================================= - // Start - // [4/14/2011] - //========================================================================= - void SessionDriller::Start(const Param* params, int numParams) - { - (void)params; - (void)numParams; - // Collect current session information ? - SessionDrillerBus::Handler::BusConnect(); - - // - //m_output->BeginTag(m_drillerTag); - //m_output->BeginTag(AZ_CRC("StartDrill")); - //if(sessionMgr->m_activeSession) - //{ - // GridSession* gs = sessionMgr->m_activeSession; - // // store the current session state - // m_output->BeginTag(AZ_CRC("Session")); - // m_output->Write(AZ_CRC("SessionId"),gs->GetId()); - // m_output->Write(AZ_CRC("Carrier"),gs->GetCarrier()); - // m_output->Write(AZ_CRC("ReplicaMgr"),gs->GetReplicaMgr()); - // m_output->Write(AZ_CRC("Topology"),(char)gs->GetTopology()); - // m_output->Write(AZ_CRC("Time"),gs->GetTime()); - // m_output->Write(AZ_CRC("State"),(char)gs->m_sm.GetCurrentState()); - // m_output->Write(AZ_CRC("IsHost"),gs->IsHost()); - // // There are endless params add as needed - - // for(unsigned int i = 0; i < gs->GetNumberOfMembers(); ++i ) - // { - // GridMember* gm = gs->GetMember(i); - // m_output->BeginTag(AZ_CRC("Member")); - // m_output->Write(AZ_CRC("Id"),gm->GetId().ToString()); - // m_output->Write(AZ_CRC("Name"),gm->GetName()); - // m_output->Write(AZ_CRC("ConnectionId"),gm->GetConnectionId()); - // m_output->Write(AZ_CRC("NAT"),(char)gm->GetNatType()); - // m_output->Write(AZ_CRC("CommFilter"),gm->GetCommFilter()); - // m_output->Write(AZ_CRC("IsHost"),gm->IsHost()); - // m_output->Write(AZ_CRC("IsLocal"),gm->IsLocal()); - // m_output->Write(AZ_CRC("IsInvited"),gm->IsInvited()); - // m_output->EndTag(AZ_CRC("Member")); - // } - - // m_output->EndTag(AZ_CRC("Session")); - //} - //else if(sessionMgr->m_activeSearch) - //{ - // GridSearch* gs = sessionMgr->m_activeSearch; - // m_output->BeginTag(AZ_CRC("GridSearch")); - // m_output->Write(AZ_CRC("SearchId"),gs); - // m_output->Write(AZ_CRC("IsDone"),gs->IsDone()); - // m_output->Write(AZ_CRC("NumResults"),gs->GetNumResults()); - // // add platform specific drill or just generic reporting - // m_output->EndTag(AZ_CRC("GridSearch")); - //} - //m_output->EndTag(AZ_CRC("StartDrill")); - //m_output->EndTag(m_drillerTag); - } - - //========================================================================= - // Stop - // [4/14/2011] - //========================================================================= - void SessionDriller::Stop() - { - SessionDrillerBus::Handler::BusDisconnect(); - } - - //========================================================================= - // OnSessionServiceReady - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnSessionServiceReady() - { - // m_output->BeginTag(m_drillerTag); - // m_output->EndTag(m_drillerTag); - } - - //========================================================================= - // OnGridSearchComplete - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnGridSearchComplete(GridSearch* gridSearch) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("GridSearchComplete", 0x974b5717)); - m_output->Write(AZ_CRC("SearchId", 0x4f7ef2d2), gridSearch); - m_output->Write(AZ_CRC("NumResults", 0xdfb1542f), gridSearch->GetNumResults()); - // add platform specific drill or just generic reporting - m_output->EndTag(AZ_CRC("GridSearchComplete", 0x974b5717)); - m_output->EndTag(m_drillerTag); - } - - //========================================================================= - // OnMemberJoined - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnMemberJoined(GridSession* session, GridMember* member) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("MemberJoined", 0xbde4706c)); - m_output->Write(AZ_CRC("SessionId", 0xacd49154), session->GetId()); - m_output->Write(AZ_CRC("Id", 0xbf396750), member->GetId().ToString()); - m_output->Write(AZ_CRC("Name", 0x5e237e06), member->GetName()); - m_output->Write(AZ_CRC("ConnectionId", 0x4592a200), member->GetConnectionId()); - m_output->Write(AZ_CRC("NAT", 0x9686d0fb), (char)member->GetNatType()); - //m_output->Write(AZ_CRC("MuteList"),member->GetMuteList()); - m_output->Write(AZ_CRC("IsHost", 0xce28a9cf), member->IsHost()); - m_output->Write(AZ_CRC("IsLocal", 0x4300d6d2), member->IsLocal()); - m_output->Write(AZ_CRC("IsInvited", 0x29d785f7), member->IsInvited()); - m_output->EndTag(AZ_CRC("MemberJoined", 0xbde4706c)); - m_output->EndTag(m_drillerTag); - } - - //========================================================================= - // OnMemberLeaving - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnMemberLeaving(GridSession* session, GridMember* member) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("MemberLeaving", 0xd10ee176)); - m_output->Write(AZ_CRC("SessionId", 0xacd49154), session->GetId()); - m_output->Write(AZ_CRC("Id", 0xbf396750), member->GetId().ToString()); - m_output->EndTag(AZ_CRC("MemberLeaving", 0xd10ee176)); - m_output->EndTag(m_drillerTag); - } - - //========================================================================= - // OnMemberKicked - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnMemberKicked(GridSession* session, GridMember* member) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("MemberKicked", 0x908e74e6)); - m_output->Write(AZ_CRC("SessionId", 0xacd49154), session->GetId()); - m_output->Write(AZ_CRC("Id", 0xbf396750), member->GetId().ToString()); - m_output->EndTag(AZ_CRC("MemberKicked", 0x908e74e6)); - m_output->EndTag(m_drillerTag); - } - - //========================================================================= - // OnSessionCreated - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnSessionCreated(GridSession* session) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("SessionCreated", 0x24655a62)); - m_output->Write(AZ_CRC("SessionId", 0xacd49154), session->GetId()); - m_output->Write(AZ_CRC("Carrier", 0x4739f11c), session->GetCarrier()); - m_output->Write(AZ_CRC("ReplicaMgr", 0x41cf3853), session->GetReplicaMgr()); - m_output->Write(AZ_CRC("Topology", 0x1198610c), (char)session->GetTopology()); - m_output->Write(AZ_CRC("Time", 0x6f949845), session->GetTime()); - m_output->Write(AZ_CRC("State", 0xa393d2fb), (char)session->m_sm.GetCurrentState()); - m_output->Write(AZ_CRC("IsHost", 0xce28a9cf), session->IsHost()); - m_output->EndTag(AZ_CRC("SessionCreated", 0x24655a62)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnSessionJoined - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnSessionJoined(GridSession* session) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("SessionJoined", 0x04b85d49)); - m_output->Write(AZ_CRC("SessionId", 0xacd49154), session->GetId()); - m_output->Write(AZ_CRC("Carrier", 0x4739f11c), session->GetCarrier()); - m_output->Write(AZ_CRC("ReplicaMgr", 0x41cf3853), session->GetReplicaMgr()); - m_output->Write(AZ_CRC("Topology", 0x1198610c), (char)session->GetTopology()); - m_output->Write(AZ_CRC("Time", 0x6f949845), session->GetTime()); - m_output->Write(AZ_CRC("State", 0xa393d2fb), (char)session->m_sm.GetCurrentState()); - m_output->Write(AZ_CRC("IsHost", 0xce28a9cf), session->IsHost()); - m_output->EndTag(AZ_CRC("SessionJoined", 0x04b85d49)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnSessionDelete - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnSessionDelete(GridSession* session) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("SessionDelete", 0x6b5728cd), session->GetId()); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnSessionError - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnSessionError(GridSession* session, const AZStd::string& errorMsg) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("SessionError", 0xc689cc40)); - m_output->Write(AZ_CRC("SessionId", 0xacd49154), session ? session->GetId() : "NoId"); - m_output->Write(AZ_CRC("Error", 0x5dddbc71), errorMsg); - m_output->EndTag(AZ_CRC("SessionError", 0xc689cc40)); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnSessionStart - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnSessionStart(GridSession* session) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("SessionStart", 0x042d25be), session->GetId()); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnSessionEnd - // [4/15/2011] - //========================================================================= - void - SessionDriller::OnSessionEnd(GridSession* session) - { - m_output->BeginTag(m_drillerTag); - m_output->Write(AZ_CRC("SessionEnd", 0x07821a5e), session->GetId()); - m_output->EndTag(m_drillerTag); - } - //========================================================================= - // OnWriteStatistics - // [6/8/2011] - //========================================================================= - void - SessionDriller::OnWriteStatistics(GridSession* session, GridMember* member, StatisticsData& data) - { - m_output->BeginTag(m_drillerTag); - m_output->BeginTag(AZ_CRC("WriteStatistics", 0xcf7f12aa)); - m_output->Write(AZ_CRC("SessionId", 0xacd49154), session->GetId()); - m_output->Write(AZ_CRC("Id", 0xbf396750), member->GetId().ToString()); - // data... - (void)data; - m_output->EndTag(AZ_CRC("WriteStatistics", 0xcf7f12aa)); - m_output->EndTag(m_drillerTag); - } - } // namespace Debug -} // namespace GridMate diff --git a/Code/Framework/GridMate/GridMate/Drillers/SessionDriller.h b/Code/Framework/GridMate/GridMate/Drillers/SessionDriller.h deleted file mode 100644 index 7af318287a..0000000000 --- a/Code/Framework/GridMate/GridMate/Drillers/SessionDriller.h +++ /dev/null @@ -1,77 +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 - * - */ -#ifndef GM_SESSION_DRILLER_H -#define GM_SESSION_DRILLER_H - -#include -#include -#include - -namespace GridMate -{ - namespace Debug - { - /** - * Session Driller - * \note Be careful which buses you attach. The drillers work in Multi threaded environment and expect that - * a driller mutex (DrillerManager::DrillerManager) will be automatically locked on every write. - * Otherwise in output stream corruption will happen (even is the stream is thread safe). - */ - class SessionDriller - : public AZ::Debug::Driller - , public SessionDrillerBus::Handler - { - int m_drillerTag; - public: - AZ_CLASS_ALLOCATOR(SessionDriller, AZ::OSAllocator, 0); - SessionDriller(); - - ////////////////////////////////////////////////////////////////////////// - // Driller - const char* GroupName() const override { return "GridMate"; } - const char* GetName() const override { return "SessionDriller"; } - const char* GetDescription() const override { return "Drills GridSession, Search, etc."; } - void Start(const Param* params = NULL, int numParams = 0) override; - void Stop() override; - ////////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////////// - // Session Event Bus - /// Callback that is called when the Session service is ready to process sessions. - void OnSessionServiceReady() override; - //virtual OnCommucationChanged() = 0 Callback that notifies the title when a member's communication settings change. - /// Callback that notifies the title when a game search query have completed. - void OnGridSearchComplete(GridSearch* gridSearch) override; - /// Callback that notifies the title when a new member joins the game session. - void OnMemberJoined(GridSession* session, GridMember* member) override; - /// Callback that notifies the title that a member is leaving the game session. member pointer is NOT valid after the callback returns. - void OnMemberLeaving(GridSession* session, GridMember* member) override; - // \todo a better way will be (after we solve migration) is to supply a reason to OnMemberLeaving... like the member was kicked. - // this will require that we actually remove the replica at the same moment. - /// Callback that host decided to kick a member. You will receive a OnMemberLeaving when the actual member leaves the session. - void OnMemberKicked(GridSession* session, GridMember* member) override; - /// After this callback it is safe to access session features. If host session is fully operational if client wait for OnSessionJoined. - void OnSessionCreated(GridSession* session) override; - /// Called on client machines to indicate that we join successfully. - void OnSessionJoined(GridSession* session) override; - /// Callback that notifies the title when a session will be left. session pointer is NOT valid after the callback returns. - void OnSessionDelete(GridSession* session) override; - /// Called when a session error occurs. - void OnSessionError(GridSession* session, const AZStd::string& errorMsg) override; - /// Called when the actual game(match) starts - void OnSessionStart(GridSession* session) override; - /// Called when the actual game(match) ends - void OnSessionEnd(GridSession* session) override; - /// Called when we have our last chance to write statistics data for member in the session. - void OnWriteStatistics(GridSession* session, GridMember* member, StatisticsData& data) override; - ////////////////////////////////////////////////////////////////////////// - }; - } -} - -#endif // GM_SESSION_DRILLER_H diff --git a/Code/Framework/GridMate/GridMate/Replica/RemoteProcedureCall.cpp b/Code/Framework/GridMate/GridMate/Replica/RemoteProcedureCall.cpp index 3feef708be..7f96638cf5 100644 --- a/Code/Framework/GridMate/GridMate/Replica/RemoteProcedureCall.cpp +++ b/Code/Framework/GridMate/GridMate/Replica/RemoteProcedureCall.cpp @@ -11,7 +11,6 @@ #include #include #include -#include #include #include @@ -32,14 +31,12 @@ namespace GridMate m_replicaChunk->QueueRPCRequest(rpc); } - void RpcBase::OnRpcRequest(GridMate::Internal::RpcRequest* rpc) const + void RpcBase::OnRpcRequest(GridMate::Internal::RpcRequest*) const { - EBUS_EVENT(Debug::ReplicaDrillerBus, OnRequestRpc, m_replicaChunk, rpc); } - void RpcBase::OnRpcInvoke(GridMate::Internal::RpcRequest* rpc) const + void RpcBase::OnRpcInvoke(GridMate::Internal::RpcRequest*) const { - EBUS_EVENT(Debug::ReplicaDrillerBus, OnInvokeRpc, m_replicaChunk, rpc); } PeerId RpcBase::GetSourcePeerId() diff --git a/Code/Framework/GridMate/GridMate/Replica/Replica.cpp b/Code/Framework/GridMate/GridMate/Replica/Replica.cpp index a05b92a7a0..1caeb7c6e6 100644 --- a/Code/Framework/GridMate/GridMate/Replica/Replica.cpp +++ b/Code/Framework/GridMate/GridMate/Replica/Replica.cpp @@ -14,7 +14,6 @@ #include #include #include -#include #include #include #include @@ -49,8 +48,6 @@ namespace GridMate replicaName = nullptr; #endif InternalCreateInitialChunks(replicaName); - - EBUS_EVENT(Debug::ReplicaDrillerBus, OnCreateReplica, this); } //----------------------------------------------------------------------------- Replica::~Replica() @@ -96,8 +93,6 @@ namespace GridMate } } m_chunks.clear(); - - EBUS_EVENT(Debug::ReplicaDrillerBus, OnDestroyReplica, this); } //----------------------------------------------------------------------------- void Replica::Destroy() @@ -257,17 +252,12 @@ namespace GridMate //----------------------------------------------------------------------------- void Replica::OnActivate(const ReplicaContext& rc) { - EBUS_EVENT(Debug::ReplicaDrillerBus, OnActivateReplica, this); - for (auto chunk : m_chunks) { if (chunk) { - { - GM_PROFILE_USER_CALLBACK("OnReplicaActivate"); - chunk->OnReplicaActivate(rc); - } - EBUS_EVENT(Debug::ReplicaDrillerBus, OnActivateReplicaChunk, chunk.get()); + GM_PROFILE_USER_CALLBACK("OnReplicaActivate"); + chunk->OnReplicaActivate(rc); } } } @@ -277,17 +267,13 @@ namespace GridMate AZ_PROFILE_FUNCTION(GridMate); EBUS_EVENT_ID(rc.m_rm->GetGridMate(), ReplicaMgrCallbackBus, OnDeactivateReplica, GetRepId(), rc.m_rm); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnDeactivateReplica, this); for (auto chunk : m_chunks) { if (chunk) { - { - GM_PROFILE_USER_CALLBACK("OnReplicaDeactivate"); - chunk->OnReplicaDeactivate(rc); - } - EBUS_EVENT(Debug::ReplicaDrillerBus, OnDeactivateReplicaChunk, chunk.get()); + GM_PROFILE_USER_CALLBACK("OnReplicaDeactivate"); + chunk->OnReplicaDeactivate(rc); } } } @@ -325,8 +311,6 @@ namespace GridMate { if (IsPrimary()) { - EBUS_EVENT(Debug::ReplicaDrillerBus, OnRequestReplicaChangeOwnership, this, requestor); - if (IsMigratable() && requestor != m_manager->GetLocalPeerId()) { bool accepted; @@ -595,7 +579,6 @@ namespace GridMate chunkInfo.m_payload.Init(128); mc.m_outBuffer = &chunkInfo.m_payload; - EBUS_EVENT(Debug::ReplicaDrillerBus, OnSendReplicaChunkBegin, chunk.get(), static_cast(iChunk), mc.m_rm->GetLocalPeerId(), mc.m_peer->GetId()); PackedSize writeOffset = mc.m_outBuffer->GetExactSize(); // Write the ctor data if we need to if (mc.m_marshalFlags & ReplicaMarshalFlags::IncludeCtorData) @@ -606,7 +589,6 @@ namespace GridMate // Marshal the chunk data chunk->Marshal(mc, static_cast(iChunk)); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnSendReplicaChunkEnd, chunk.get(), static_cast(iChunk), mc.m_outBuffer->Get() + writeOffset.GetBytes(), mc.m_outBuffer->Size() - writeOffset.GetBytes()); // Precompute the chunk payload length and add to overall replica payload length PackedSize chunkLen = chunkInfo.m_payload.GetExactSize(); @@ -696,9 +678,7 @@ namespace GridMate if (chunk) { - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveReplicaChunkBegin, chunk.get(), static_cast(iChunk), chunkContext.m_peer->GetId(), chunkContext.m_rm->GetLocalPeerId(), innerBuffer.Get(), chunkSize.GetSizeInBytesRoundUp()); chunk->Unmarshal(chunkContext, static_cast(iChunk)); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveReplicaChunkEnd, chunk.get(), static_cast(iChunk)); } else { diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaChunk.cpp b/Code/Framework/GridMate/GridMate/Replica/ReplicaChunk.cpp index d3db481ccd..2ded895be0 100644 --- a/Code/Framework/GridMate/GridMate/Replica/ReplicaChunk.cpp +++ b/Code/Framework/GridMate/GridMate/Replica/ReplicaChunk.cpp @@ -15,7 +15,6 @@ #include #include #include -#include #include namespace GridMate @@ -41,13 +40,11 @@ namespace GridMate ReplicaChunkInitContext* initContext = ReplicaChunkDescriptorTable::Get().GetCurrentReplicaChunkInitContext(); AZ_Assert(initContext, "Replica's descriptor is NOT pushed on the stack! Call Replica::Desriptor::Push() before construction!"); initContext->m_chunk = this; - EBUS_EVENT(Debug::ReplicaDrillerBus, OnCreateReplicaChunk, this); } //----------------------------------------------------------------------------- ReplicaChunkBase::~ReplicaChunkBase() { AZ_Assert(m_refCount == 0, "Attempting to free replica with non-zero refCount(%d)!", m_refCount); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnDestroyReplicaChunk, this); } //----------------------------------------------------------------------------- void ReplicaChunkBase::Init(ReplicaChunkClassId chunkTypeId) @@ -332,7 +329,7 @@ namespace GridMate return dataSetMask; } //----------------------------------------------------------------------------- - void ReplicaChunkBase::MarshalDataSets(MarshalContext& mc, AZ::u32 chunkIndex) + void ReplicaChunkBase::MarshalDataSets(MarshalContext& mc, [[maybe_unused]] AZ::u32 chunkIndex) { //AZ_PROFILE_SCOPE("GridMate"); AZ::u32 dirtyDataSetMask = CalculateDirtyDataSetMask(mc); @@ -358,15 +355,6 @@ namespace GridMate ReadBuffer data = dataset->GetMarshalData(); mc.m_outBuffer->WriteRaw(data.Get(), data.Size()); wroteDataSet = true; - - EBUS_EVENT(Debug::ReplicaDrillerBus, OnSendDataSet, - this, - chunkIndex, - dataset, - mc.m_rm->GetLocalPeerId(), - mc.m_peer->GetId(), - data.Get(), - data.Size().GetSizeInBytesRoundUp()); } } if(wroteDataSet) @@ -380,7 +368,7 @@ namespace GridMate } } //----------------------------------------------------------------------------- - void ReplicaChunkBase::UnmarshalDataSets(UnmarshalContext& mc, AZ::u32 chunkIndex) + void ReplicaChunkBase::UnmarshalDataSets(UnmarshalContext& mc, [[maybe_unused]] AZ::u32 chunkIndex) { AZ_PROFILE_FUNCTION(GridMate); @@ -421,22 +409,12 @@ namespace GridMate dataset->MarkAsNonDefaultValue(); m_nonDefaultValueBits.set(i); - const char* readPtr = mc.m_iBuf->GetCurrent(); dataset->Unmarshal(mc); - - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveDataSet, - this, - chunkIndex, - dataset, - mc.m_peer->GetId(), - mc.m_rm->GetLocalPeerId(), - readPtr, - mc.m_iBuf->GetCurrent() - readPtr); } } } //----------------------------------------------------------------------------- - void ReplicaChunkBase::MarshalRpcs(MarshalContext& mc, AZ::u32 chunkIndex) + void ReplicaChunkBase::MarshalRpcs(MarshalContext& mc, [[maybe_unused]] AZ::u32 chunkIndex) { //AZ_PROFILE_SCOPE("GridMate"); @@ -467,22 +445,12 @@ namespace GridMate AZ::u8 rpcIndex = static_cast(GetDescriptor()->GetRpcIndex(this, rpc->m_rpc)); - auto bufferSize = mc.m_outBuffer->Size(); - SafeGuardWrite(mc.m_outBuffer, [rpc, rpcIndex, &mc]() { mc.m_outBuffer->Write(rpcIndex); rpc->m_rpc->Marshal(*mc.m_outBuffer, rpc); }); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnSendRpc, - this, - chunkIndex, - rpc, - mc.m_rm->GetLocalPeerId(), - mc.m_peer->GetId(), - mc.m_outBuffer->Get() + bufferSize, - mc.m_outBuffer->Size() - bufferSize); rpc->m_relayed = !(mc.m_marshalFlags & ReplicaMarshalFlags::Authoritative); // marking upstream rpcs relayed, for downstream rpcs - replicamgr marks them relayed after marshaling is finished rpcsSent++; } @@ -494,7 +462,7 @@ namespace GridMate } } //----------------------------------------------------------------------------- - void ReplicaChunkBase::UnmarshalRpcs(UnmarshalContext& mc, AZ::u32 chunkIndex) + void ReplicaChunkBase::UnmarshalRpcs(UnmarshalContext& mc, [[maybe_unused]] AZ::u32 chunkIndex) { AZ_PROFILE_FUNCTION(GridMate); @@ -504,7 +472,7 @@ namespace GridMate { for (AZ::u32 rpcsRead = 0; rpcsRead < rpcCount; ++rpcsRead) { - SafeGuardRead(mc.m_iBuf, [this, &mc, &chunkIndex]() + SafeGuardRead(mc.m_iBuf, [this, &mc]() { unsigned char rpcIndex; if (!mc.m_iBuf->Read(rpcIndex)) @@ -519,7 +487,6 @@ namespace GridMate return; } - const char* dataPtr = mc.m_iBuf->GetCurrent(); Internal::RpcRequest* request = rpc->Unmarshal(*mc.m_iBuf); if (!request) { @@ -565,15 +532,6 @@ namespace GridMate request->m_sourcePeer = mc.m_peer->GetId(); } - size_t dataSize = mc.m_iBuf->GetCurrent() - dataPtr; - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveRpc, - this, - chunkIndex, - request, - mc.m_peer->GetId(), - mc.m_rm->GetLocalPeerId(), - dataPtr, - dataSize); m_rpcQueue.push_back(request); } else @@ -739,7 +697,6 @@ namespace GridMate m_replica = replica; - EBUS_EVENT(Debug::ReplicaDrillerBus, OnAttachReplicaChunk, this); { GM_PROFILE_USER_CALLBACK("OnAttachedToReplica"); OnAttachedToReplica(replica); @@ -751,7 +708,6 @@ namespace GridMate AZ_PROFILE_FUNCTION(GridMate); AZ_Assert(m_replica, "Should be attached to a replica"); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnDetachReplicaChunk, this); { GM_PROFILE_USER_CALLBACK("OnDetachedFromReplica"); OnDetachedFromReplica(m_replica); diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaDrillerEvents.h b/Code/Framework/GridMate/GridMate/Replica/ReplicaDrillerEvents.h deleted file mode 100644 index 9ee2785f09..0000000000 --- a/Code/Framework/GridMate/GridMate/Replica/ReplicaDrillerEvents.h +++ /dev/null @@ -1,116 +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 - * - */ -#ifndef GM_REPLICA_DRILLER_EVENTS_H -#define GM_REPLICA_DRILLER_EVENTS_H - -#include - -/*! -* The replica system emits debugging EBus events via the ReplicaDrillerEvents interface. -* To listen for these events, derive from ReplicaDrillerBus::Handler and implement all -* the functions declared in the ReplicaDrillerEvents interface. -*/ - -namespace GridMate -{ - class Replica; - class ReplicaChunk; - class ReplicaChunkBase; - class DataSetBase; - typedef AZ::u32 PeerId; - - namespace Internal - { - struct RpcRequest; - } - - namespace Debug - { - /*! - * These are the driller events that the replica system will emit. - * All functions in this interface should be implemented by the user. - */ - class ReplicaDrillerEvents - : public AZ::Debug::DrillerEBusTraits - { - public: - //! Called when a replica is instantiated. It doesn't mean it will be added to the system. - virtual void OnCreateReplica(Replica* replica) { (void)replica; } - //! Called when a replica is actually destroyed. - virtual void OnDestroyReplica(Replica* replica) { (void)replica; } - //! Called when a replica is added to the system. - virtual void OnActivateReplica(Replica* replica) { (void)replica; } - //! Called when a replica is removed from the system. - virtual void OnDeactivateReplica(Replica* replica) { (void)replica; } - //! Called every time the replica data is sent to a peer. - virtual void OnSendReplicaBegin(Replica* replica) { (void)replica; } - //! Called every time the replica data is sent to a peer. - virtual void OnSendReplicaEnd(Replica* replica, const void* data, size_t len) { (void)replica; (void)data; (void)len; } - //! Called when data is received for a replica. Called with nullptr replica pointer when data for unknown replica received. - virtual void OnReceiveReplicaBegin(Replica* replica, const void* data, size_t len) { (void)replica; (void)data; (void)len; } - //! Called when data is received for a replica. Called with nullptr replica pointer when data for unknown replica received. - virtual void OnReceiveReplicaEnd(Replica* replica) { (void)replica; } - //! Called when an ownership transfer request is received. - virtual void OnRequestReplicaChangeOwnership(Replica* replica, PeerId requestor) { (void)replica; (void)requestor; } - //! Called when a replica changes ownership, not necessarily to or from the local node. - virtual void OnReplicaChangeOwnership(Replica* replica, bool wasPrimary) { (void)replica; (void)wasPrimary; } - - //! Called when a chunk has been created. It doesn't mean it will be added to the system. - //! Object will be partially constructed at this point if you inherit from ReplicaChunk - virtual void OnCreateReplicaChunk(ReplicaChunkBase* chunk) { (void)chunk; } - //! Called when a chuck is actually destroyed. - virtual void OnDestroyReplicaChunk(ReplicaChunkBase* chunk) { (void)chunk; } - //! Called when a chunk is added to the system. - virtual void OnActivateReplicaChunk(ReplicaChunkBase* chunk) { (void)chunk; } - //! Called when a chunk is removed from the system. - virtual void OnDeactivateReplicaChunk(ReplicaChunkBase* chunk) { (void)chunk; } - //! Called when a chunk is attached to a replica. - virtual void OnAttachReplicaChunk(ReplicaChunkBase* chunk) { (void)chunk; } - //! Called when a chunk is detached from a replica. - virtual void OnDetachReplicaChunk(ReplicaChunkBase* chunk) { (void)chunk; } - //! Called every time the chunk data is sent to a peer. - virtual void OnSendReplicaChunkBegin(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, PeerId from, PeerId to) { (void)chunk; (void)chunkIndex; (void)from; (void)to; } - //! Called every time the chunk data is sent to a peer. - virtual void OnSendReplicaChunkEnd(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, const void* data, size_t len) { (void)chunk; (void)chunkIndex; (void)data; (void)len; } - //! Called when data is received for a chunk. - virtual void OnReceiveReplicaChunkBegin(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, PeerId from, PeerId to, const void* data, size_t len) { (void)chunk; (void)chunkIndex; (void)from; (void)to; (void)data; (void)len; } - //! Called when data is received for a chunk. - virtual void OnReceiveReplicaChunkEnd(ReplicaChunkBase* chunk, AZ::u32 chunkIndex) { (void)chunk; (void)chunkIndex; } - - //! Called every time a dataset is sent to a peer. - virtual void OnSendDataSet(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, DataSetBase* dataSet, PeerId from, PeerId to, const void* data, size_t len) { (void)chunk; (void)chunkIndex; (void)dataSet; (void)from; (void)to; (void)data; (void)len; } - //! Called when data is received for a dataset. - virtual void OnReceiveDataSet(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, DataSetBase* dataSet, PeerId from, PeerId to, const void* data, size_t len) { (void)chunk; (void)chunkIndex; (void)dataSet; (void)from; (void)to; (void)data; (void)len; } - - //! Called when an rpc request is received. RpcRequest pointer will be null if rpc is called on primary replica. - virtual void OnRequestRpc(ReplicaChunkBase* chunk, Internal::RpcRequest* rpc) { (void)chunk; (void)rpc; } - //! Called when an rpc is invoked. RpcRequest pointer will be null if rpc is called on primary replica. - virtual void OnInvokeRpc(ReplicaChunkBase* chunk, Internal::RpcRequest* rpc) { (void)chunk; (void)rpc; } - //! Called every time an rpc is sent to a peer. - virtual void OnSendRpc(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, Internal::RpcRequest* rpc, PeerId from, PeerId to, const void* data, size_t len) { (void)chunk; (void)chunkIndex; (void)rpc; (void)from; (void)to; (void)data; (void)len; } - //! Called when an rpc is received. - virtual void OnReceiveRpc(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, Internal::RpcRequest* rpc, PeerId from, PeerId to, const void* data, size_t len) { (void)chunk; (void)chunkIndex; (void)rpc; (void)from; (void)to; (void)data; (void)len; } - - //! Called when a replica packet is sent. - virtual void OnSend(PeerId to, const void* data, size_t len, bool isReliable) { (void)to; (void)data; (void)len; (void)isReliable; } - //! Called when a replica packet is received. - virtual void OnReceive(PeerId from, const void* data, size_t len) { (void)from; (void)data; (void)len; } - }; - - /*! - * Replica driller events are sent are sent via this the ReplicaDrillerBus. - * To receive events, derive a handler from ReplicaDrillerBus::Handler and - * attach it to the bus. - */ - typedef AZ::EBus ReplicaDrillerBus; - } // namespace Debug -} // namespace GridMate - -#endif // GM_REPLICA_DRILLER_EVENTS_H - -#pragma once diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp index 7a56393bd5..1331e08bd6 100644 --- a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp +++ b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp @@ -17,7 +17,6 @@ #include #include #include -#include #include #include @@ -147,8 +146,6 @@ namespace GridMate auto callback = AZStd::make_unique((m_reliableCallbacks)); carrier->SendWithCallback(m_reliableOutBuffer.Get(), static_cast(m_reliableOutBuffer.Size()), AZStd::move(callback), GetConnectionId(), Carrier::SEND_RELIABLE, Carrier::PRIORITY_NORMAL, commChannel); - - EBUS_EVENT(Debug::ReplicaDrillerBus, OnSend, GetId(), m_reliableOutBuffer.Get(), m_reliableOutBuffer.Size(), true); } if (hasUnreliableData) @@ -164,8 +161,6 @@ namespace GridMate auto callback = AZStd::make_unique((m_unreliableCallbacks)); carrier->SendWithCallback(m_unreliableOutBuffer.Get(), static_cast(m_unreliableOutBuffer.Size()), AZStd::move(callback), GetConnectionId(), Carrier::SEND_UNRELIABLE, Carrier::PRIORITY_NORMAL, commChannel); - - EBUS_EVENT(Debug::ReplicaDrillerBus, OnSend, GetId(), m_unreliableOutBuffer.Get(), m_unreliableOutBuffer.Size(), false); } // prepare for next cycle ResetBuffer(); @@ -1024,9 +1019,6 @@ namespace GridMate */ while (!rb.IsEmptyIgnoreTrailingBits()) { - // This is used later to report the buffer information to driller. - const char* cmdBufferBegin = rb.GetCurrent(); - CmdId cmdhdr; if (!rb.Read(cmdhdr)) { @@ -1179,10 +1171,8 @@ namespace GridMate return; } - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveReplicaBegin, pReplica.get(), cmdBufferBegin, rb.GetCurrent() - cmdBufferBegin); pReplica->Unmarshal(mc); OnReplicaUnmarshaled(pReplica); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveReplicaEnd, pReplica.get()); } else { @@ -1195,12 +1185,10 @@ namespace GridMate pReplica->SetSyncStage(isSyncStage); pReplica->SetMigratable(isMigratable); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveReplicaBegin, pReplica.get(), cmdBufferBegin, rb.GetCurrent() - cmdBufferBegin); pReplica->Unmarshal(mc); ReplicaContext rc(this, GetTime(), pFrom); RegisterReplica(pReplica, false, rc); OnReplicaUnmarshaled(pReplica); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveReplicaEnd, pReplica.get()); } break; } @@ -1268,11 +1256,9 @@ namespace GridMate } if (pObj->m_upstreamHop) { - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveReplicaBegin, pObj.get(), cmdBufferBegin, rb.GetCurrent() - cmdBufferBegin); mc.m_peer = pFrom; pObj->Unmarshal(mc); OnReplicaUnmarshaled(pObj); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceiveReplicaEnd, pObj.get()); } else { @@ -1332,7 +1318,6 @@ namespace GridMate } ReadBuffer rb(GetGridMate()->GetDefaultEndianType(), m_receiveBuffer.data(), result.m_numBytes); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReceive, peer->GetId(), rb.Get(), rb.Size().GetSizeInBytesRoundUp()); _Unmarshal(rb, peer); AZ_Assert(rb.IsEmptyIgnoreTrailingBits(), "We did not process the whole message!"); } @@ -1655,7 +1640,6 @@ namespace GridMate { replica->SetPrimary(isPrimary); replica->OnChangeOwnership(rc); - EBUS_EVENT(Debug::ReplicaDrillerBus, OnReplicaChangeOwnership, replica.get(), wasPrimary); } } //----------------------------------------------------------------------------- diff --git a/Code/Framework/GridMate/GridMate/Replica/Tasks/ReplicaMarshalTasks.cpp b/Code/Framework/GridMate/GridMate/Replica/Tasks/ReplicaMarshalTasks.cpp index c1d6905e14..cab40e18ca 100644 --- a/Code/Framework/GridMate/GridMate/Replica/Tasks/ReplicaMarshalTasks.cpp +++ b/Code/Framework/GridMate/GridMate/Replica/Tasks/ReplicaMarshalTasks.cpp @@ -8,7 +8,6 @@ #include #include -#include #include #include #include @@ -72,12 +71,10 @@ namespace GridMate //----------------------------------------------------------------------------- void ReplicaMarshalTaskBase::OnSendReplicaBegin() { - EBUS_EVENT(Debug::ReplicaDrillerBus, OnSendReplicaBegin, m_replica.get()); } //----------------------------------------------------------------------------- - void ReplicaMarshalTaskBase::OnSendReplicaEnd(ReplicaPeer* to, const void* data, size_t len) + void ReplicaMarshalTaskBase::OnSendReplicaEnd(ReplicaPeer* to, const void*, size_t len) { - EBUS_EVENT(Debug::ReplicaDrillerBus, OnSendReplicaEnd, m_replica.get(), data, len); to->m_sentBytes += static_cast(len); } //----------------------------------------------------------------------------- diff --git a/Code/Framework/GridMate/GridMate/Session/LANSession.cpp b/Code/Framework/GridMate/GridMate/Session/LANSession.cpp index 223085cf13..ae1e674cf2 100644 --- a/Code/Framework/GridMate/GridMate/Session/LANSession.cpp +++ b/Code/Framework/GridMate/GridMate/Session/LANSession.cpp @@ -882,7 +882,6 @@ LANSession::OnStateHostMigrateSession(AZ::HSM& sm, const AZ::HSM::Event& e) { // check the output for more info AZStd::string errorMsg = AZStd::string::format("Failed to initialize socket at port %d!", hostPort); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionError, this, errorMsg); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionError, this, errorMsg); // We can't be a real host if we failed to provide matching services. Leave(false); @@ -1146,7 +1145,6 @@ void LANSessionService::OnServiceRegistered(IGridMate* gridMate) LANSessionServiceBus::Handler::BusConnect(gridMate); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionServiceReady); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionServiceReady); } diff --git a/Code/Framework/GridMate/GridMate/Session/Session.cpp b/Code/Framework/GridMate/GridMate/Session/Session.cpp index 3dcb16b08d..54e1e1dfe6 100644 --- a/Code/Framework/GridMate/GridMate/Session/Session.cpp +++ b/Code/Framework/GridMate/GridMate/Session/Session.cpp @@ -316,7 +316,6 @@ GridSession::Shutdown() m_carrier->Shutdown(); } - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionDelete, this); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionDelete, this); m_state = nullptr; @@ -438,7 +437,6 @@ GridSession::Update() memberStateIter = m_unboundMemberStates.erase(memberStateIter); // Both member and client state are valid! send member joined message - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnMemberJoined, this, member); EBUS_EVENT_ID(GetGridMate(), SessionEventBus, OnMemberJoined, this, member); } else @@ -1221,7 +1219,6 @@ GridSession::OnDriverError(Carrier* carrier, ConnectionID id, const DriverError& } uintptr_t idInt = reinterpret_cast(static_cast(id)); AZStd::string errorMsg = AZStd::string::format("Carrier driver error ConnectionID: %" PRIuPTR "ErrorCode: 0x%08x", idInt, error.m_errorCode); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionError, this, errorMsg); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionError, this, errorMsg); if (id != InvalidConnectionID) @@ -1249,7 +1246,6 @@ GridSession::OnSecurityError(Carrier* carrier, ConnectionID id, const SecurityEr } uintptr_t idInt = reinterpret_cast(static_cast(id)); AZStd::string errorMsg = AZStd::string::format("Carrier security error ConnectionID: %" PRIuPTR " ErrorCode: 0x%08x", idInt, error.m_errorCode); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionError, this, errorMsg); } //========================================================================= @@ -1276,7 +1272,6 @@ GridSession::ElectNewHost() // AZ_Assert(m_sm.IsInState(SS_HOST_MIGRATE_ELECTION),"We should be in host migrate election state to call this function!"); GridMember* newHost = nullptr; // Allow the user to choose - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnMigrationElectHost, this, newHost); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnMigrationElectHost, this, newHost); if (newHost == nullptr || newHost->GetConnectionId() == InvalidConnectionID || newHost->IsHost()) @@ -1497,7 +1492,6 @@ GridSession::OnStateJoin(HSM& sm, const HSM::Event& e) { case SE_JOINED: { - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionJoined, this); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionJoined, this); sm.Transition(SS_IDLE); } return true; @@ -1591,7 +1585,6 @@ GridSession::OnStateCreate(HSM& sm, const HSM::Event& e) } sm.Transition(SS_IDLE); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionCreated, this); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionCreated, this); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionHosted, this); } @@ -1616,7 +1609,6 @@ GridSession::OnStateCreate(HSM& sm, const HSM::Event& e) m_carrier->Connect(m_hostAddress); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionCreated, this); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionCreated, this); } @@ -1639,7 +1631,6 @@ GridSession::OnStateStart(HSM& sm, const HSM::Event& e) { case HSM::EnterEventId: { - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionStart, this); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionStart, this); } return true; } @@ -1660,7 +1651,6 @@ GridSession::OnStateEnd(HSM& sm, const HSM::Event& e) { case HSM::EnterEventId: { - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnSessionEnd, this); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnSessionEnd, this); } return true; } @@ -1710,7 +1700,6 @@ GridSession::OnStateHostMigrateElection(AZ::HSM& sm, const AZ::HSM::Event& e) m_hostMigrationInProcess = true; m_handshake->SetHostMigration(true); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnMigrationStart, this); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnMigrationStart, this); m_hostMigrationTimeOut = m_state ? m_state->m_hostMigrationTimeout.Get() : 0; @@ -1890,7 +1879,6 @@ GridSession::OnStateHostMigrateSession(AZ::HSM& sm, const AZ::HSM::Event& e) GridMember* host = GetHost(); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnMigrationEnd, this, host); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnMigrationEnd, this, host); m_myMember->m_clientState->m_newHostVote.Set(0); @@ -2004,7 +1992,6 @@ GridMember::OnReplicaActivate(const ReplicaContext& rc) rc.m_rm->AddPrimary(m_clientState->GetReplica()); // Both member and client state are valid! send member joined message - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnMemberJoined, m_session, this); EBUS_EVENT_ID(m_session->GetGridMate(), SessionEventBus, OnMemberJoined, m_session, this); } } @@ -2021,7 +2008,6 @@ GridMember::OnReplicaDeactivate(const ReplicaContext& rc) if (m_clientState) { // We are deleting the member so send leave message (we are always keeping member <-> state together). - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnMemberLeaving, m_session, this); EBUS_EVENT_ID(m_session->GetGridMate(), SessionEventBus, OnMemberLeaving, m_session, this); m_clientState->m_member = nullptr; @@ -2072,7 +2058,6 @@ GridMember::OnKick(AZ::u8 reason, const RpcContext& rc) // 2 Kick messages in quick succession can cause this to crash otherwise. if (m_session && m_session->GetHost() && rc.m_sourcePeer == m_session->GetHost()->GetIdCompact()) //Only the host can kick { - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnMemberKicked, m_session, this); EBUS_EVENT_ID(m_session->GetGridMate(), SessionEventBus, OnMemberKicked, m_session, this, reason); if (IsLocal()) @@ -2325,7 +2310,6 @@ GridMemberStateReplica::OnReplicaDeactivate(const ReplicaContext& rc) if (m_member) { // client state is gone send leave message - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnMemberLeaving, m_member->m_session, m_member); EBUS_EVENT_ID(m_member->GetSession()->GetGridMate(), SessionEventBus, OnMemberLeaving, m_member->m_session, m_member); m_member->m_clientState = nullptr; @@ -2519,7 +2503,6 @@ SessionService::Update() it = m_activeSearches.erase(it); m_completedSearches.push_back(search); - EBUS_DBG_EVENT(Debug::SessionDrillerBus, OnGridSearchComplete, search); EBUS_EVENT_ID(m_gridMate, SessionEventBus, OnGridSearchComplete, search); } else diff --git a/Code/Framework/GridMate/GridMate/Session/Session.h b/Code/Framework/GridMate/GridMate/Session/Session.h index e075a0aa48..4ab978a713 100644 --- a/Code/Framework/GridMate/GridMate/Session/Session.h +++ b/Code/Framework/GridMate/GridMate/Session/Session.h @@ -28,10 +28,6 @@ namespace GridMate extern const EndianType kSessionEndian; - namespace Debug { - class SessionDriller; - } - typedef AZ::u32 MemberIDCompact; /** * MemberID interface class. @@ -403,7 +399,6 @@ namespace GridMate friend class Internal::GridSessionReplica; friend class Internal::GridMemberStateReplica; friend class SessionService; - friend class Debug::SessionDriller; public: enum CarrierChannels { @@ -742,7 +737,6 @@ namespace GridMate : public GridMateService { friend class GridSession; - friend class Debug::SessionDriller; friend class GridSearch; public: typedef vector SessionArrayType; @@ -936,62 +930,6 @@ namespace GridMate }; } - namespace Debug - { - /** - * Session driller events, - * this events are in addition to the session event bus - */ - class SessionDrillerEvents - : public AZ::Debug::DrillerEBusTraits - { - public: - virtual ~SessionDrillerEvents() {} - - /// Callback that is called when the Session service is ready to process sessions. - virtual void OnSessionServiceReady() {} - - //virtual OnCommucationChanged() = 0 Callback that notifies the title when a member's communication settings change. - - /// Callback when we start a grid search. - virtual void OnGridSearchStart(GridSearch* gridSearch) { (void)gridSearch; } - /// Callback that notifies the title when a game search query have completed. - virtual void OnGridSearchComplete(GridSearch* gridSearch) { (void)gridSearch; } - /// Callback when we release (delete) a grid search. It's not safe to hold the grid pointer after this. - virtual void OnGridSearchRelease(GridSearch* gridSearch) { (void)gridSearch; } - - /// Callback that notifies the title when a new member joins the game session. - virtual void OnMemberJoined(GridSession* session, GridMember* member) { (void)session; (void)member; } - /// Callback that notifies the title that a member is leaving the game session. member pointer is NOT valid after the callback returns. - virtual void OnMemberLeaving(GridSession* session, GridMember* member) { (void)session; (void)member; } - // \todo a better way will be (after we solve migration) is to supply a reason to OnMemberLeaving... like the member was kicked. - // this will require that we actually remove the replica at the same moment. - /// Callback that host decided to kick a member. You will receive a OnMemberLeaving when the actual member leaves the session. - virtual void OnMemberKicked(GridSession* session, GridMember* member) { (void)session; (void)member; } - /// After this callback it is safe to access session features. If host session is fully operational if client wait for OnSessionJoined. - virtual void OnSessionCreated(GridSession* session) { (void)session; } - /// Called on client machines to indicate that we join successfully. - virtual void OnSessionJoined(GridSession* session) { (void)session; } - /// Callback that notifies the title when a session will be left. session pointer is NOT valid after the callback returns. - virtual void OnSessionDelete(GridSession* session) { (void)session; } - /// Called when a session error occurs. - virtual void OnSessionError(GridSession* session, const AZStd::string& errorMsg) { (void)session; (void)errorMsg; } - /// Called when the actual game(match) starts - virtual void OnSessionStart(GridSession* session) { (void)session; } - /// Called when the actual game(match) ends - virtual void OnSessionEnd(GridSession* session) { (void)session; } - /// Called when we start a host migration. - virtual void OnMigrationStart(GridSession* session) { (void)session; } - /// Called so the user can select a member that should be the new Host. Value will be ignored if NULL, current host or the member has invalid connection id. - virtual void OnMigrationElectHost(GridSession* session, GridMember*& newHost) { (void)session; (void)newHost; } - /// Called when the host migration has completed. - virtual void OnMigrationEnd(GridSession* session, GridMember* newHost) { (void)session; (void)newHost; } - /// Called when we have our last chance to write statistics data for member in the session. - virtual void OnWriteStatistics(GridSession* session, GridMember* member, StatisticsData& data) { (void)session; (void)member; (void)data; } - }; - - typedef AZ::EBus SessionDrillerBus; - } } // namespace GridMate #endif // GM_SESSION_H diff --git a/Code/Framework/GridMate/GridMate/gridmate_files.cmake b/Code/Framework/GridMate/GridMate/gridmate_files.cmake index e318a8adcd..99dc4257f6 100644 --- a/Code/Framework/GridMate/GridMate/gridmate_files.cmake +++ b/Code/Framework/GridMate/GridMate/gridmate_files.cmake @@ -45,12 +45,6 @@ set(FILES Containers/unordered_map.h Containers/unordered_set.h Containers/vector.h - Drillers/CarrierDriller.cpp - Drillers/CarrierDriller.h - Drillers/ReplicaDriller.cpp - Drillers/ReplicaDriller.h - Drillers/SessionDriller.cpp - Drillers/SessionDriller.h Online/OnlineUtilityThread.h Online/UserServiceTypes.h Replica/BasicHostChunkDescriptor.h @@ -71,7 +65,6 @@ set(FILES Replica/ReplicaChunkInterface.h Replica/ReplicaCommon.h Replica/ReplicaDefs.h - Replica/ReplicaDrillerEvents.h Replica/ReplicaFunctions.h Replica/ReplicaFunctions.inl Replica/ReplicaInline.inl diff --git a/Code/Framework/GridMate/Tests/Replica.cpp b/Code/Framework/GridMate/Tests/Replica.cpp index 5fef135347..776b8d0a2d 100644 --- a/Code/Framework/GridMate/Tests/Replica.cpp +++ b/Code/Framework/GridMate/Tests/Replica.cpp @@ -1576,14 +1576,6 @@ public: } }; - class MigratableReplicaDebugMsgs - : public AZ::Debug::DrillerEBusTraits - { - public: - typedef AZ::EBus EBus; - - virtual void OnNewOwner(ReplicaId repId, ReplicaManager* repMgr) = 0; - }; typedef AZStd::intrusive_ptr Ptr; @@ -1654,11 +1646,6 @@ public: { Bind(aznew MyObj()); } - - if (IsPrimary()) - { - EBUS_EVENT(MigratableReplicaDebugMsgs::EBus, OnNewOwner, GetReplicaId(), rc.m_rm); - } } void OnReplicaDeactivate(const ReplicaContext& rc) override @@ -1675,11 +1662,6 @@ public: { (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()); - - if (IsPrimary()) - { - EBUS_EVENT(MigratableReplicaDebugMsgs::EBus, OnNewOwner, GetReplicaId(), rc.m_rm); - } } void Bind(MyObj* pObj) @@ -1885,2057 +1867,6 @@ public: protected: DataSet m_data3; }; -//----------------------------------------------------------------------------- - -class ReplicaGMTest - : public UnitTest::GridMateMPTestFixture - , public ::testing::Test -{}; - -TEST_F(ReplicaGMTest, DISABLED_ReplicaTest) - { - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - - AZ_TracePrintf("GridMate", "\n"); - enum - { - s1, - s2, - s3, - nSessions - }; - const int k_delay = 100; - - // Setting up simulator with outgoing packet loss - DefaultSimulator clientSimulator; - clientSimulator.SetOutgoingPacketLoss(1, 1); - - MPSession sessions[nSessions]; - - MyObj* s1obj1 = NULL, * s1obj2 = NULL, * s2obj1 = NULL, * s3obj1 = NULL; - MigratableReplica::Ptr s1rep1, s3rep1; - NonMigratableReplica::Ptr s1rep2; - MyDerivedReplica::Ptr s2rep1; - ReplicaId s1rep1id = 0, s1rep2id = 0, s2rep1id = 0, s3rep1id = 0; - - // initialize transport - int basePort = 4427; - for (int i = 0; i < nSessions; ++i) - { - TestCarrierDesc desc; - desc.m_port = basePort + i; - desc.m_enableDisconnectDetection = false; - if (i == s2) - { - desc.m_simulator = &clientSimulator; - } - - // initialize replica managers - // s2(p)<-->(p)s1(p)<-->(c)s3 - sessions[i].SetTransport(DefaultCarrier::Create(desc, m_gridMate)); - sessions[i].AcceptConn(true); - sessions[i].SetClient(i == s3); - sessions[i].GetReplicaMgr().Init(ReplicaMgrDesc(i + 1, sessions[i].GetTransport(), 0, i == 0 ? ReplicaMgrDesc::Role_SyncHost : 0)); - sessions[i].GetReplicaMgr().RegisterUserContext(12345, reinterpret_cast(static_cast(i + 1))); - } - sessions[0].GetReplicaMgr().SetLocalLagAmt(50); - - // put something on s1 to get it going - auto rep = Replica::CreateReplica(nullptr); - s1rep1 = CreateAndAttachReplicaChunk(rep); - s1rep1id = sessions[s1].GetReplicaMgr().AddPrimary(rep); - s1rep1->Bind(s1obj1 = aznew MyObj()); - - // connect s2 to s1 - sessions[s2].GetTransport()->Connect("127.0.0.1", basePort); - - // main test loop - static bool keepRunning = true; - int tick = 0; - while (keepRunning) - { - // perform some random actions on a timeline - switch (tick) - { - case 5: - { - // connect s3 to s1 - sessions[s3].GetTransport()->Connect("127.0.0.1", basePort); - break; - } - case 25: - // remove s1rep1 - AZ_TEST_ASSERT(s1rep1id); - s1rep1->GetReplica()->Destroy(); - s1obj1 = NULL; - break; - case 35: - //AZ_TracePrintf("GridMate", "No more updates.\n"); - break; - case 70: - //AZ_TracePrintf("GridMate", "Restart updates.\n"); - break; - case 90: - keepRunning = false; - } - - // add an object on s2 - if (sessions[s2].GetReplicaMgr().IsReady()) - { - if (!s2rep1id) - { - auto newReplica = Replica::CreateReplica(nullptr); - s2rep1 = CreateAndAttachReplicaChunk(newReplica); - s2rep1id = sessions[s2].GetReplicaMgr().AddPrimary(newReplica); - s2rep1->Bind(s2obj1 = aznew MyObj()); - } - else - { - static bool sends2rep1rpc = true; - if (sends2rep1rpc && tick >= 20) - { - s2rep1->MyHandler123Rpc(5.f); - s2rep1->MyHandler2Rpc(6.0f, 1); - s2rep1->MyHandler3Rpc(7.0f, 2, NonMigratableReplica::e_Bla0); - NonMigratableReplica::IntVectorType v; - v.push_back(10); - v.push_back(13); - s2rep1->MyHandler4Rpc(8.0f, 3, NonMigratableReplica::e_Bla1, v); - sends2rep1rpc = false; - } - } - } - - // add object on s1 - if (sessions[s1].GetReplicaMgr().IsReady()) - { - if (!s1rep2) - { - auto newReplica = Replica::CreateReplica(nullptr); - s1rep2 = CreateAndAttachReplicaChunk(newReplica); - s1rep2id = sessions[s1].GetReplicaMgr().AddPrimary(newReplica); - s1rep2->Bind(s1obj2 = aznew MyObj); - } - else - { - if (s1rep2id && tick >= 40) - { - s1rep2->GetReplica()->Destroy(); - s1obj2 = NULL; - s1rep2id = 0; - } - } - } - - // add object on s3 - if (sessions[s3].GetReplicaMgr().IsReady()) - { - if (!s3rep1) - { - auto newReplica = Replica::CreateReplica(nullptr); - s3rep1 = CreateAndAttachReplicaChunk(newReplica); - s3rep1id = sessions[s3].GetReplicaMgr().AddPrimary(newReplica); - s3rep1->Bind(s3obj1 = aznew MyObj()); - } - else - { - if (s3rep1id && tick >= 45) - { - s3rep1->MyHandler123Rpc(-1.f); - s3rep1->GetReplica()->Destroy(); - s3obj1 = NULL; - s3rep1id = 0; - } - } - } - - { // Testing unreliable rpcs: enabling network simulator with outgoing packetloss, - // calling 10 rpcs with 1..10 int argument, checking if replicas got rpcs in an order, and have missing calls - static bool requestrpc = true; - if (s3rep1id && requestrpc) - { - if (ReplicaPtr pObj = sessions[s2].GetReplicaMgr().FindReplica(s3rep1id)) - { - pObj->FindReplicaChunk()->MyHandler123Rpc(2.0f); - requestrpc = false; - } - } - - static bool unreliableRequest = true; - static int numUnreliableRequests = 0; - if (sessions[s2].GetReplicaMgr().IsReady() && s2rep1 && tick > 15 && unreliableRequest) - { - // Starting packet loss - unreliableRequest = false; - } - - if (!unreliableRequest && numUnreliableRequests < 10) - { - if (numUnreliableRequests == 4) - { - clientSimulator.Enable(); - } - else if (numUnreliableRequests == 5) - { - clientSimulator.Disable(); - } - s2rep1->MyHandlerUnreliableRpc(++numUnreliableRequests); - } - - static bool checkUnreliableDelivery = true; - if (checkUnreliableDelivery && tick >= 25) - { - // Stopping packet loss - ReplicaPtr rep1 = sessions[s1].GetReplicaMgr().FindReplica(s2rep1->GetReplicaId()); - ReplicaPtr rep3 = sessions[s3].GetReplicaMgr().FindReplica(s2rep1->GetReplicaId()); - AZ_TEST_ASSERT(rep1); - AZ_TEST_ASSERT(rep3); - AZ_TEST_ASSERT(rep1->FindReplicaChunk()->m_unreliableCheck); - AZ_TEST_ASSERT(rep3->FindReplicaChunk()->m_unreliableCheck); - checkUnreliableDelivery = false; - } - } - - // modify local objects - if (tick < 20 || tick > 70) - { - if (s1obj1) - { - s1obj1->m_f1 += 0.5f; - s1obj1->m_i1 += 1; - s1obj1->m_b1 = !s1obj1->m_b1; - } - if (s1obj2) - { - s1obj2->m_f1 += 1.0f; - s1obj2->m_i1 -= 1; - s1obj2->m_b1 = !s1obj2->m_b1; - } - if (s2obj1) - { - s2obj1->m_f1 += 0.1f; - s2obj1->m_i1 += 2; - s2obj1->m_b1 = !s2obj1->m_b1; - } - if (s3obj1) - { - s3obj1->m_f1 += 0.3f; - s3obj1->m_i1 += 3; - s3obj1->m_b1 = !s3obj1->m_b1; - } - } - ++tick; - // tick everything - for (int i = 0; i < nSessions; ++i) - { - sessions[i].Update(); - sessions[i].GetReplicaMgr().Unmarshal(); - } - for (int i = 0; i < nSessions; ++i) - { - sessions[i].GetReplicaMgr().UpdateReplicas(); - } - for (int i = 0; i < nSessions; ++i) - { - sessions[i].GetReplicaMgr().UpdateFromReplicas(); - sessions[i].GetReplicaMgr().Marshal(); - } - for (int i = 0; i < nSessions; ++i) - { - sessions[i].GetTransport()->Update(); - } - AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(k_delay)); - } - - for (int i = 0; i < nSessions; ++i) - { - sessions[i].GetReplicaMgr().Shutdown(); - DefaultCarrier::Destroy(sessions[i].GetTransport()); - } - } - -class ForcedReplicaMigrationTest - : public UnitTest::GridMateMPTestFixture - , public ReplicaMgrCallbackBus::Handler - , public MigratableReplica::MigratableReplicaDebugMsgs::EBus::Handler - , public ::testing::Test -{ - void OnNewHost(bool isHost, ReplicaManager* pMgr) override - { - if (isHost) - { - AZ_TracePrintf("GridMate", "Peer %d has completed host migration and is now the host.\n", (int)pMgr->GetLocalPeerId()); - pMgr->SetSendTimeInterval(k_hostSendRateMs); - m_newHostEventOnNewHostCount++; - } - else - { - AZ_TracePrintf("GridMate", "Peer %d has has received notification that host migration is complete.\n", (int)pMgr->GetLocalPeerId()); - pMgr->SetSendTimeInterval(0); - m_newHostEventOnPeersCount++; - } - } - - void OnNewOwner(ReplicaId repId, ReplicaManager* repMgr) override - { - AZ_TracePrintf("GridMate", "Replica 0x%08x got new owner %d on frame %d.\n", repId, (int)repMgr->GetLocalPeerId(), m_frameCount); - m_replicaOwnership[repId] = repMgr; - } - -public: - ForcedReplicaMigrationTest() { ReplicaMgrCallbackBus::Handler::BusConnect(m_gridMate); } - ~ForcedReplicaMigrationTest() { ReplicaMgrCallbackBus::Handler::BusDisconnect(); } - - - enum - { - p1, p2, p3, p4, p5, nPeers - }; - - static const int k_frameTimePerNodeMs = 10; - static const int k_numFramesToRun = 300; - static const int k_hostSendRateMs = k_frameTimePerNodeMs * nPeers * 2; // limiting host send rate x2 times - - int m_frameCount; - int m_newHostEventOnNewHostCount; - int m_newHostEventOnPeersCount; - AZStd::unordered_map m_replicaOwnership; -}; - -const int ForcedReplicaMigrationTest::k_frameTimePerNodeMs; -const int ForcedReplicaMigrationTest::k_numFramesToRun; -const int ForcedReplicaMigrationTest::k_hostSendRateMs; - -TEST_F(ForcedReplicaMigrationTest, DISABLED_ForcedReplicaMigrationTest) - { - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - - MPSession peers[nPeers]; - MigratableReplica::Ptr migrRep[nPeers]; - NonMigratableReplica::Ptr nonMigrRep[nPeers]; - - m_newHostEventOnNewHostCount = 0; - m_newHostEventOnPeersCount = 0; - - MigratableReplica::MigratableReplicaDebugMsgs::EBus::Handler::BusConnect(); - - // initialize full-mesh P2P session - int basePort = 4427; - for (int i = 0; i < nPeers; ++i) - { - TestCarrierDesc desc; - desc.m_port = basePort + i; - desc.m_enableDisconnectDetection = /*false*/ true; - desc.m_threadUpdateTimeMS = k_frameTimePerNodeMs / 2; - - // initialize replica managers - peers[i].SetTransport(DefaultCarrier::Create(desc, m_gridMate)); - peers[i].AcceptConn(true); - peers[i].SetClient(false); - peers[i].GetReplicaMgr().Init(ReplicaMgrDesc(i + 1 - , peers[i].GetTransport() - , 0 - , i == 0 ? ReplicaMgrDesc::Role_SyncHost : 0 - , i == 0 ? k_hostSendRateMs : 0)); - } - - AZ_TracePrintf("GridMate", "\n"); - m_frameCount = 0; - while (m_frameCount < k_numFramesToRun) - { - static bool allReady = false; - // establish all connections - if (m_frameCount < nPeers) - { - for (int i = 0; i < m_frameCount; ++i) - { - peers[m_frameCount].GetTransport()->Connect("127.0.0.1", basePort + i); - } - } - - if (!allReady) - { - allReady = true; - for (int i = 0; i < nPeers; ++i) - { - if (!peers[i].GetReplicaMgr().IsReady()) - { - allReady = false; - } - } - if (allReady) - { - AZ_TracePrintf("GridMate", "All peers ready at frame %d\n", m_frameCount); - } - } - - // perform tests - if (allReady) - { - // add replicas - static bool addReplicas = true; - if (addReplicas) - { - for (int i = 0; i < nPeers; ++i) - { - { - auto rep = Replica::CreateReplica(nullptr); - migrRep[i] = CreateAndAttachReplicaChunk(rep, aznew MyObj()); - peers[i].GetReplicaMgr().AddPrimary(rep); - AZ_TEST_ASSERT(m_replicaOwnership[migrRep[i]->GetReplicaId()] == &peers[i].GetReplicaMgr()); - } - { - auto rep = Replica::CreateReplica(nullptr); - nonMigrRep[i] = CreateAndAttachReplicaChunk(rep, aznew MyObj()); - peers[i].GetReplicaMgr().AddPrimary(rep); - } - } - addReplicas = false; - AZ_TracePrintf("GridMate", "Replicas added at frame %d\n", m_frameCount); - } - - // disconnect p3 and trigger peer migration - static bool dropP3 = true; - if (m_frameCount > 50 && dropP3) - { - peers[p3].GetTransport()->Disconnect(AllConnections); - dropP3 = false; - AZ_TracePrintf("GridMate", "Dropped P3 at frame %d\n", m_frameCount); - } - - // Check that p3's MigratableReplica has migrated to p1 (host) - if (m_frameCount == 85) - { - AZ_TEST_ASSERT(m_replicaOwnership[migrRep[p3]->GetReplicaId()] == &peers[p1].GetReplicaMgr()); - } - - // disconnect p1 and trigger host loss - static bool dropP1 = true; - if (m_frameCount > 100 && dropP1) - { - peers[p1].GetTransport()->Disconnect(AllConnections); - dropP1 = false; - AZ_TracePrintf("GridMate", "Dropped P1 at frame %d\n", m_frameCount); - } - - // promote p2 to host - static bool promoteP2 = true; - if (m_frameCount > 150 && promoteP2) - { - peers[p2].GetReplicaMgr().Promote(); - promoteP2 = false; - AZ_TracePrintf("GridMate", "Promoted P2 at frame %d\n", m_frameCount); - } - } - - // tick - int tickPeer = m_frameCount++ % nPeers; - peers[tickPeer].Update(); - peers[tickPeer].GetReplicaMgr().Unmarshal(); - peers[tickPeer].GetReplicaMgr().UpdateReplicas(); - peers[tickPeer].GetReplicaMgr().UpdateFromReplicas(); - peers[tickPeer].GetReplicaMgr().Marshal(); - peers[tickPeer].GetTransport()->Update(); - AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(k_frameTimePerNodeMs)); - } - - // Check that p1's MigratableReplicas (including the one from p3) have migrated to p2 (host) - AZ_TEST_ASSERT(m_replicaOwnership[migrRep[p1]->GetReplicaId()] == &peers[p2].GetReplicaMgr()); - AZ_TEST_ASSERT(m_replicaOwnership[migrRep[p3]->GetReplicaId()] == &peers[p2].GetReplicaMgr()); - - AZ_TEST_ASSERT(m_newHostEventOnNewHostCount == 1); // New host should have received OnNewHost event - AZ_TEST_ASSERT(m_newHostEventOnPeersCount == 2); // 2 peers remaining should have received OnNewHost event - - // clean up - for (int i = 0; i < nPeers; ++i) - { - peers[i].GetReplicaMgr().Shutdown(); - DefaultCarrier::Destroy(peers[i].GetTransport()); - } - - MigratableReplica::MigratableReplicaDebugMsgs::EBus::Handler::BusDisconnect(); - } - -class ReplicaMigrationRequestTest - : public UnitTest::GridMateMPTestFixture - , public ::testing::Test -{ -public: - enum - { - Host, - Peer1, - Peer2, - Client1, - Client2, - TotalNodes - }; - - class AlwaysMigratable - : public ReplicaChunk - { - public: - GM_CLASS_ALLOCATOR(AlwaysMigratable); - typedef AZStd::intrusive_ptr Ptr; - static const char* GetChunkName() { return "AlwaysMigratable"; } - - AlwaysMigratable() - : UpdateControlValue("UpdateControlValue") - , m_requests(0) - , m_accepted(0) - , m_triggerNextTransfer(false) - , m_owner("Owner") - , m_control("Control") - { - } - - bool IsReplicaMigratable() override - { - return true; - } - - bool AcceptChangeOwnership(PeerId requestor, const ReplicaContext& rc) override - { - AZ_TracePrintf("GridMate", "Node %d accepted transfer of AlwaysMigratable 0x%x to node %d.\n", rc.m_rm->GetLocalPeerId() - 1, GetReplicaId(), requestor - 1); - m_requests++; - m_accepted++; - - if (rc.m_rm->GetLocalPeerId() - 1 == Peer2 && requestor - 1 == Host) - { - m_triggerNextTransfer = true; - } - - return true; - } - - void OnReplicaActivate(const ReplicaContext& rc) override - { - if (IsPrimary()) - { - m_owner.Set(rc.m_rm->GetLocalPeerId() - 1); - m_control.Set(rc.m_rm->GetLocalPeerId() - 1); - } - } - - void OnReplicaChangeOwnership(const ReplicaContext& rc) override - { - if (IsPrimary()) - { - AZ_TracePrintf("GridMate", "OnChangeOwnership: 0x%04x Became primary on node %d\n", GetReplicaId(), rc.m_rm->GetLocalPeerId() - 1); - m_owner.Set(rc.m_rm->GetLocalPeerId() - 1); - } - else - { - AZ_TracePrintf("GridMate", "OnChangeOwnership: 0x%04x Became proxy on node %d\n", GetReplicaId(), rc.m_rm->GetLocalPeerId() - 1); - if (m_triggerNextTransfer) - { - GetReplica()->RequestChangeOwnership(Client2 + 1); - m_triggerNextTransfer = false; - } - } - } - - bool UpdateControlValueFn(const RpcContext& rc) - { - (void)rc; - m_control.Set(GetReplicaManager()->GetLocalPeerId() - 1); - return false; - } - Rpc<>::BindInterface UpdateControlValue; - - int m_requests; - int m_accepted; - bool m_triggerNextTransfer; - - DataSet m_owner; - DataSet m_control; - }; - - class NeverMigratable - : public AlwaysMigratable - { - public: - GM_CLASS_ALLOCATOR(NeverMigratable); - typedef AZStd::intrusive_ptr Ptr; - static const char* GetChunkName() { return "NeverMigratable"; } - - NeverMigratable() - { - } - - bool IsReplicaMigratable() override - { - return false; - } - }; - - class SometimesMigratable - : public AlwaysMigratable - { - public: - GM_CLASS_ALLOCATOR(SometimesMigratable); - typedef AZStd::intrusive_ptr Ptr; - static const char* GetChunkName() { return "SometimesMigratable"; } - - SometimesMigratable() - { - m_acceptMigrationRequests = false; - } - - virtual bool AcceptChangeOwnership(PeerId requestor, const ReplicaContext& rc) override - { - (void)requestor; - (void)rc; - m_requests++; - if (m_acceptMigrationRequests) - { - AZ_TracePrintf("GridMate", "Node %d accepted transfer of SometimesMigratable 0x%x to node %d.\n", rc.m_rm->GetLocalPeerId() - 1, GetReplicaId(), requestor - 1); - m_accepted++; - return true; - } - return false; - } - - bool m_acceptMigrationRequests; - }; - - struct Node - { - MPSession m_session; - AlwaysMigratable::Ptr m_always; - NeverMigratable::Ptr m_never; - SometimesMigratable::Ptr m_sometimes; - }; - - - static const int k_frameTimePerNodeMs = 10; - static const int k_hostSendTimeMs = k_frameTimePerNodeMs * TotalNodes * 4; // limiting host send rate to be x4 times slower than tick -}; - -TEST_F(ReplicaMigrationRequestTest, DISABLED_ReplicaMigrationRequestTest) - { - /* - Topology: - P1---P2 - \ / - \ / - H - / \ - / \ - C1 C2 - - Migration pattern: - AlwaysMigratable: - P1 -> P2 - P2 -> Host -> C2 (both at same time, with C2 arriving second) - Host -> C1 - C1 -> C2 -> Host - C2 -> P1 - NeverMigratable: - P1 -> C1 (Forbidden) - C2 -> P2 (Forbidden) - SometimesMigratable: - P1 -> Host - C1 -> P1 - P2 -> C2 (Forbidden) - C2 -> Host (Forbidden) - */ - - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - - Node nodes[TotalNodes]; - int basePort = 4427; - for (int i = 0; i < TotalNodes; ++i) - { - TestCarrierDesc desc; - desc.m_port = basePort + i; - desc.m_connectionTimeoutMS = 15000; - // initialize replica managers - nodes[i].m_session.SetTransport(DefaultCarrier::Create(desc, m_gridMate)); - nodes[i].m_session.AcceptConn(true); - nodes[i].m_session.SetClient(i == Client1 || i == Client2); - nodes[i].m_session.GetReplicaMgr().Init(ReplicaMgrDesc(i + 1 - , nodes[i].m_session.GetTransport() - , 0 - , i == Host ? ReplicaMgrDesc::Role_SyncHost : 0 - , i == Host ? k_hostSendTimeMs : 0)); - } - - // Connect all the nodes - nodes[Peer1].m_session.GetTransport()->Connect("127.0.0.1", basePort + Host); - nodes[Peer2].m_session.GetTransport()->Connect("127.0.0.1", basePort + Host); - nodes[Client1].m_session.GetTransport()->Connect("127.0.0.1", basePort + Host); - nodes[Client2].m_session.GetTransport()->Connect("127.0.0.1", basePort + Host); - nodes[Peer1].m_session.GetTransport()->Connect("127.0.0.1", basePort + Peer2); - - - int framesToRun = 800; - for (int iTick = 0; iTick < framesToRun; ++iTick) - { - for (int iNode = 0; iNode < TotalNodes; ++iNode) - { - if (nodes[iNode].m_session.GetReplicaMgr().IsReady()) - { - if (nodes[iNode].m_always == nullptr) - { - { - auto rep = Replica::CreateReplica(nullptr); - nodes[iNode].m_always = CreateAndAttachReplicaChunk(rep); - nodes[iNode].m_session.GetReplicaMgr().AddPrimary(rep); - } - { - auto rep = Replica::CreateReplica(nullptr); - nodes[iNode].m_never = CreateAndAttachReplicaChunk(rep); - nodes[iNode].m_session.GetReplicaMgr().AddPrimary(rep); - } - { - auto rep = Replica::CreateReplica(nullptr); - nodes[iNode].m_sometimes = CreateAndAttachReplicaChunk(rep); - nodes[iNode].m_sometimes->m_acceptMigrationRequests = iNode == Peer1 || iNode == Client1; - nodes[iNode].m_session.GetReplicaMgr().AddPrimary(rep); - } - } - } - } - - // First round of migrations - if (iTick == 200) - { - // P1 -> P2 - ReplicaPtr aP1onP2 = nodes[Peer2].m_session.GetReplicaMgr().FindReplica(nodes[Peer1].m_always->GetReplicaId()); - AZ_TEST_ASSERT(aP1onP2); - aP1onP2->RequestChangeOwnership(); - - // P2 -> Host -> C2 (both at same time, with C2 arriving second) - ReplicaPtr aP2onH = nodes[Host].m_session.GetReplicaMgr().FindReplica(nodes[Peer2].m_always->GetReplicaId()); - AZ_TEST_ASSERT(aP2onH); - aP2onH->RequestChangeOwnership(); - - // Host -> C1 - ReplicaPtr aHonC1 = nodes[Client1].m_session.GetReplicaMgr().FindReplica(nodes[Host].m_always->GetReplicaId()); - AZ_TEST_ASSERT(aHonC1); - aHonC1->RequestChangeOwnership(); - - // C1 -> C2 -> Host (first migration) - ReplicaPtr aC1onC2 = nodes[Client2].m_session.GetReplicaMgr().FindReplica(nodes[Client1].m_always->GetReplicaId()); - AZ_TEST_ASSERT(aC1onC2); - aC1onC2->RequestChangeOwnership(); - - // C2 -> P1 - ReplicaPtr aC2onP1 = nodes[Peer1].m_session.GetReplicaMgr().FindReplica(nodes[Client2].m_always->GetReplicaId()); - AZ_TEST_ASSERT(aC2onP1); - aC2onP1->RequestChangeOwnership(); - - // P1 -> C1 (Forbidden) - ReplicaPtr nP1onC1 = nodes[Client1].m_session.GetReplicaMgr().FindReplica(nodes[Peer1].m_never->GetReplicaId()); - AZ_TEST_ASSERT(nP1onC1); - nP1onC1->RequestChangeOwnership(); - - // C2 -> P2 (Forbidden) - ReplicaPtr nC2onP2 = nodes[Peer2].m_session.GetReplicaMgr().FindReplica(nodes[Client2].m_never->GetReplicaId()); - AZ_TEST_ASSERT(nC2onP2); - nC2onP2->RequestChangeOwnership(); - - // P1 -> Host - ReplicaPtr sP1onH = nodes[Host].m_session.GetReplicaMgr().FindReplica(nodes[Peer1].m_sometimes->GetReplicaId()); - AZ_TEST_ASSERT(sP1onH); - sP1onH->RequestChangeOwnership(); - - // C1 -> P1 - ReplicaPtr sC1onP1 = nodes[Peer1].m_session.GetReplicaMgr().FindReplica(nodes[Client1].m_sometimes->GetReplicaId()); - AZ_TEST_ASSERT(sC1onP1); - sC1onP1->RequestChangeOwnership(); - - // P2 -> C2 (Forbidden) - ReplicaPtr sP2onC2 = nodes[Client2].m_session.GetReplicaMgr().FindReplica(nodes[Peer2].m_sometimes->GetReplicaId()); - AZ_TEST_ASSERT(sP2onC2); - sP2onC2->RequestChangeOwnership(); - - // C2 -> Host (Forbidden) - ReplicaPtr sC2onH = nodes[Host].m_session.GetReplicaMgr().FindReplica(nodes[Client2].m_sometimes->GetReplicaId()); - AZ_TEST_ASSERT(sC2onH); - sC2onH->RequestChangeOwnership(); - } - - // Second round of migrations - if (iTick == 400) - { - // C1 -> C2 -> Host (1st migration) - AZ_TEST_ASSERT(nodes[Client1].m_always->m_requests == 1); - AZ_TEST_ASSERT(nodes[Client1].m_always->m_accepted == 1); - AZ_TEST_ASSERT(nodes[Client1].m_always->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(nodes[Client1].m_always->m_owner.Get() == Client2); - AZ_TEST_ASSERT(nodes[Client2].m_session.GetReplicaMgr().FindReplica(nodes[Client1].m_always->GetReplicaId())->IsPrimary()); - - // C1 -> C2 -> Host (2nd migration) - ReplicaPtr aHonC1 = nodes[Host].m_session.GetReplicaMgr().FindReplica(nodes[Client1].m_always->GetReplicaId()); - AZ_TEST_ASSERT(aHonC1); - aHonC1->RequestChangeOwnership(); - } - - // Send non-authoritative control RPCs - if (iTick == 600) - { - // P1 -> P2 - AlwaysMigratable::Ptr aP1onH = nodes[Host].m_session.GetChunkFromReplica(nodes[Peer1].m_always->GetReplicaId()); - aP1onH->UpdateControlValue(); - // P2 -> Host -> C2 (both at same time, with C2 arriving second) - AlwaysMigratable::Ptr aP2onC1 = nodes[Client1].m_session.GetChunkFromReplica(nodes[Peer2].m_always->GetReplicaId()); - aP2onC1->UpdateControlValue(); - // Host -> C1 - AlwaysMigratable::Ptr aHonP1 = nodes[Peer1].m_session.GetChunkFromReplica(nodes[Host].m_always->GetReplicaId()); - aHonP1->UpdateControlValue(); - // C1 -> C2 -> Host - AlwaysMigratable::Ptr aC1onP2 = nodes[Peer2].m_session.GetChunkFromReplica(nodes[Client1].m_always->GetReplicaId()); - aC1onP2->UpdateControlValue(); - // C2 -> P1 - AlwaysMigratable::Ptr aC2onP2 = nodes[Peer2].m_session.GetChunkFromReplica(nodes[Client2].m_always->GetReplicaId()); - aC2onP2->UpdateControlValue(); - // P1 -> C1 (Forbidden) - NeverMigratable::Ptr nP1onH = nodes[Host].m_session.GetChunkFromReplica(nodes[Peer1].m_never->GetReplicaId()); - nP1onH->UpdateControlValue(); - // C2 -> P2 (Forbidden) - NeverMigratable::Ptr nC2onP1 = nodes[Peer1].m_session.GetChunkFromReplica(nodes[Client2].m_never->GetReplicaId()); - nC2onP1->UpdateControlValue(); - // P1 -> Host - SometimesMigratable::Ptr sP1onH = nodes[Host].m_session.GetChunkFromReplica(nodes[Peer1].m_sometimes->GetReplicaId()); - sP1onH->UpdateControlValue(); - // C1 -> P1 - SometimesMigratable::Ptr sC1onC2 = nodes[Client2].m_session.GetChunkFromReplica(nodes[Client1].m_sometimes->GetReplicaId()); - sC1onC2->UpdateControlValue(); - // P2 -> C2 (Forbidden) - SometimesMigratable::Ptr sP2onC2 = nodes[Client2].m_session.GetChunkFromReplica(nodes[Peer2].m_sometimes->GetReplicaId()); - sP2onC2->UpdateControlValue(); - // C2 -> Host (Forbidden) - SometimesMigratable::Ptr sC2onP1 = nodes[Peer1].m_session.GetChunkFromReplica(nodes[Client2].m_sometimes->GetReplicaId()); - sC2onP1->UpdateControlValue(); - } - - // tick - int tickNode = iTick % TotalNodes; - nodes[tickNode].m_session.Update(); - nodes[tickNode].m_session.GetReplicaMgr().Unmarshal(); - nodes[tickNode].m_session.GetReplicaMgr().UpdateFromReplicas(); - nodes[tickNode].m_session.GetReplicaMgr().UpdateReplicas(); - nodes[tickNode].m_session.GetReplicaMgr().Marshal(); - nodes[tickNode].m_session.GetTransport()->Update(); - AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(k_frameTimePerNodeMs)); - } - - // P1 -> P2 - AZ_TEST_ASSERT(nodes[Peer1].m_always->m_requests == 1); - AZ_TEST_ASSERT(nodes[Peer1].m_always->m_accepted == 1); - AZ_TEST_ASSERT(nodes[Peer1].m_always->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(nodes[Peer1].m_always->m_owner.Get() == Peer2); - AZ_TEST_ASSERT(nodes[Peer2].m_session.GetReplicaMgr().FindReplica(nodes[Peer1].m_always->GetReplicaId())->IsPrimary()); - AZ_TEST_ASSERT(nodes[Peer1].m_always->m_control.Get() == Peer2); - - // P2 -> Host -> C2 (both at same time, with C2 arriving second) - AZ_TEST_ASSERT(nodes[Peer2].m_always->m_requests == 1); - AZ_TEST_ASSERT(nodes[Peer2].m_always->m_accepted == 1); - AZ_TEST_ASSERT(nodes[Peer2].m_always->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(nodes[Peer2].m_always->m_owner.Get() == Client2); - AlwaysMigratable::Ptr aP2onH = nodes[Host].m_session.GetChunkFromReplica(nodes[Peer2].m_always->GetReplicaId()); - AZ_TEST_ASSERT(aP2onH->m_requests == 1); - AZ_TEST_ASSERT(aP2onH->m_accepted == 1); - AZ_TEST_ASSERT(aP2onH->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(aP2onH->m_owner.Get() == Client2); - AZ_TEST_ASSERT(nodes[Client2].m_session.GetReplicaMgr().FindReplica(nodes[Peer2].m_always->GetReplicaId())->IsPrimary()); - AZ_TEST_ASSERT(nodes[Peer2].m_always->m_control.Get() == Client2); - - // Host -> C1 - AZ_TEST_ASSERT(nodes[Host].m_always->m_requests == 1); - AZ_TEST_ASSERT(nodes[Host].m_always->m_accepted == 1); - AZ_TEST_ASSERT(nodes[Host].m_always->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(nodes[Host].m_always->m_owner.Get() == Client1); - AZ_TEST_ASSERT(nodes[Client1].m_session.GetReplicaMgr().FindReplica(nodes[Host].m_always->GetReplicaId())->IsPrimary()); - AZ_TEST_ASSERT(nodes[Host].m_always->m_control.Get() == Client1); - - // C1 -> C2 -> Host (2nd migration) - AZ_TEST_ASSERT(nodes[Client1].m_always->m_requests == 1); - AZ_TEST_ASSERT(nodes[Client1].m_always->m_accepted == 1); - AZ_TEST_ASSERT(nodes[Client1].m_always->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(nodes[Client1].m_always->m_owner.Get() == Host); - AlwaysMigratable::Ptr aC1onC2 = nodes[Client2].m_session.GetChunkFromReplica(nodes[Client1].m_always->GetReplicaId()); - AZ_TEST_ASSERT(aC1onC2->m_requests == 1); - AZ_TEST_ASSERT(aC1onC2->m_accepted == 1); - AZ_TEST_ASSERT(aC1onC2->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(aC1onC2->m_owner.Get() == Host); - AZ_TEST_ASSERT(nodes[Host].m_session.GetReplicaMgr().FindReplica(nodes[Client1].m_always->GetReplicaId())->IsPrimary()); - AZ_TEST_ASSERT(nodes[Client1].m_always->m_control.Get() == Host); - - // C2 -> P1 - AZ_TEST_ASSERT(nodes[Client2].m_always->m_requests == 1); - AZ_TEST_ASSERT(nodes[Client2].m_always->m_accepted == 1); - AZ_TEST_ASSERT(nodes[Client2].m_always->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(nodes[Client2].m_always->m_owner.Get() == Peer1); - AZ_TEST_ASSERT(nodes[Peer1].m_session.GetReplicaMgr().FindReplica(nodes[Client2].m_always->GetReplicaId())->IsPrimary()); - AZ_TEST_ASSERT(nodes[Client2].m_always->m_control.Get() == Peer1); - - // P1 -> C1 (Forbidden) - AZ_TEST_ASSERT(nodes[Peer1].m_never->m_requests == 0); - AZ_TEST_ASSERT(nodes[Peer1].m_never->m_accepted == 0); - AZ_TEST_ASSERT(nodes[Peer1].m_never->GetReplica()->IsPrimary()); - AZ_TEST_ASSERT(nodes[Peer1].m_never->m_owner.Get() == Peer1); - AZ_TEST_ASSERT(nodes[Client1].m_session.GetReplicaMgr().FindReplica(nodes[Peer1].m_never->GetReplicaId())->IsProxy()); - AZ_TEST_ASSERT(nodes[Peer1].m_never->m_control.Get() == Peer1); - - // C2 -> P2 (Forbidden) - AZ_TEST_ASSERT(nodes[Client2].m_never->m_requests == 0); - AZ_TEST_ASSERT(nodes[Client2].m_never->m_accepted == 0); - AZ_TEST_ASSERT(nodes[Client2].m_never->GetReplica()->IsPrimary()); - AZ_TEST_ASSERT(nodes[Client2].m_never->m_owner.Get() == Client2); - AZ_TEST_ASSERT(nodes[Peer2].m_session.GetReplicaMgr().FindReplica(nodes[Client2].m_never->GetReplicaId())->IsProxy()); - AZ_TEST_ASSERT(nodes[Client2].m_never->m_control.Get() == Client2); - - // P1 -> Host - AZ_TEST_ASSERT(nodes[Peer1].m_sometimes->m_requests == 1); - AZ_TEST_ASSERT(nodes[Peer1].m_sometimes->m_accepted == 1); - AZ_TEST_ASSERT(nodes[Peer1].m_sometimes->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(nodes[Peer1].m_sometimes->m_owner.Get() == Host); - AZ_TEST_ASSERT(nodes[Host].m_session.GetReplicaMgr().FindReplica(nodes[Peer1].m_sometimes->GetReplicaId())->IsPrimary()); - AZ_TEST_ASSERT(nodes[Peer1].m_sometimes->m_control.Get() == Host); - - // C1 -> P1 - AZ_TEST_ASSERT(nodes[Client1].m_sometimes->m_requests == 1); - AZ_TEST_ASSERT(nodes[Client1].m_sometimes->m_accepted == 1); - AZ_TEST_ASSERT(nodes[Client1].m_sometimes->GetReplica()->IsProxy()); - AZ_TEST_ASSERT(nodes[Client1].m_sometimes->m_owner.Get() == Peer1); - AZ_TEST_ASSERT(nodes[Peer1].m_session.GetReplicaMgr().FindReplica(nodes[Client1].m_sometimes->GetReplicaId())->IsPrimary()); - AZ_TEST_ASSERT(nodes[Client1].m_sometimes->m_control.Get() == Peer1); - - // P2 -> C2 (Forbidden) - AZ_TEST_ASSERT(nodes[Peer2].m_sometimes->m_requests == 1); - AZ_TEST_ASSERT(nodes[Peer2].m_sometimes->m_accepted == 0); - AZ_TEST_ASSERT(nodes[Peer2].m_sometimes->GetReplica()->IsPrimary()); - AZ_TEST_ASSERT(nodes[Peer2].m_sometimes->m_owner.Get() == Peer2); - AZ_TEST_ASSERT(nodes[Client2].m_session.GetReplicaMgr().FindReplica(nodes[Peer2].m_never->GetReplicaId())->IsProxy()); - AZ_TEST_ASSERT(nodes[Peer2].m_sometimes->m_control.Get() == Peer2); - - // C2 -> Host (Forbidden) - AZ_TEST_ASSERT(nodes[Client2].m_sometimes->m_requests == 1); - AZ_TEST_ASSERT(nodes[Client2].m_sometimes->m_accepted == 0); - AZ_TEST_ASSERT(nodes[Client2].m_sometimes->GetReplica()->IsPrimary()); - AZ_TEST_ASSERT(nodes[Client2].m_sometimes->m_owner.Get() == Client2); - AZ_TEST_ASSERT(nodes[Host].m_session.GetReplicaMgr().FindReplica(nodes[Client2].m_never->GetReplicaId())->IsProxy()); - AZ_TEST_ASSERT(nodes[Client2].m_sometimes->m_control.Get() == Client2); - - // clean up - for (int i = 0; i < TotalNodes; ++i) - { - nodes[i].m_always = nullptr; - nodes[i].m_never = nullptr; - nodes[i].m_sometimes = nullptr; - nodes[i].m_session.GetReplicaMgr().Shutdown(); - DefaultCarrier::Destroy(nodes[i].m_session.GetTransport()); - } - } - -const int ReplicaMigrationRequestTest::k_frameTimePerNodeMs; -const int ReplicaMigrationRequestTest::k_hostSendTimeMs; - - -class PeerRejoinTest - : public UnitTest::GridMateMPTestFixture - , public ReplicaMgrCallbackBus::Handler - , public ::testing::Test -{ - void OnNewHost(bool isHost, ReplicaManager* pMgr) override - { - (void)pMgr; - if (isHost) - { - AZ_TracePrintf("GridMate", "Peer %d has completed host migration and is now the host.\n", (int)pMgr->GetLocalPeerId()); - } - else - { - AZ_TracePrintf("GridMate", "Peer %d has has received notification that host migration is complete.\n", (int)pMgr->GetLocalPeerId()); - } - } - -public: - PeerRejoinTest() { ReplicaMgrCallbackBus::Handler::BusConnect(m_gridMate); } - ~PeerRejoinTest() { ReplicaMgrCallbackBus::Handler::BusDisconnect(); } -}; - -TEST_F(PeerRejoinTest, DISABLED_PeerRejoinTest) - { - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - - int frameTime = 10; - int framesToRun = 300; - enum - { - p1, p2, nPeers - }; - - MPSession peers[nPeers]; - MigratableReplica::Ptr migrRep[nPeers]; - NonMigratableReplica::Ptr nonMigrRep[nPeers]; - - // initialize full-mesh P2P session - int basePort = 4427; - for (int i = 0; i < nPeers; ++i) - { - TestCarrierDesc desc; - desc.m_port = basePort + i; - desc.m_enableDisconnectDetection = true; - desc.m_threadUpdateTimeMS = frameTime / 2; - - // initialize replica managers - peers[i].SetTransport(DefaultCarrier::Create(desc, m_gridMate)); - peers[i].AcceptConn(true); - peers[i].SetClient(false); - peers[i].GetReplicaMgr().Init(ReplicaMgrDesc(i + 1 - , peers[i].GetTransport() - , 0 - , i == 0 ? ReplicaMgrDesc::Role_SyncHost : 0 - , frameTime / 2)); - } - - AZ_TracePrintf("GridMate", "\n"); - int frameCount = 0; - while (frameCount < framesToRun) - { - static bool allReady = false; - // establish all connections - if (frameCount < nPeers) - { - for (int i = 0; i < frameCount; ++i) - { - peers[frameCount].GetTransport()->Connect("127.0.0.1", basePort + i); - } - } - - if (!allReady) - { - allReady = true; - for (int i = 0; i < nPeers; ++i) - { - if (!peers[i].GetReplicaMgr().IsReady()) - { - allReady = false; - } - } - if (allReady) - { - AZ_TracePrintf("GridMate", "All peers ready at frame %d\n", frameCount); - } - } - - // perform tests - if (allReady) - { - // add replicas - static bool addReplicas = true; - if (addReplicas) - { - for (int i = 0; i < nPeers; ++i) - { - { - auto rep = Replica::CreateReplica(nullptr); - migrRep[i] = CreateAndAttachReplicaChunk(rep, aznew MyObj()); - peers[i].GetReplicaMgr().AddPrimary(rep); - } - { - auto rep = Replica::CreateReplica(nullptr); - nonMigrRep[i] = CreateAndAttachReplicaChunk(rep, aznew MyObj()); - peers[i].GetReplicaMgr().AddPrimary(rep); - } - } - addReplicas = false; - AZ_TracePrintf("GridMate", "Replicas added at frame %d\n", frameCount); - } - - // disconnect p2 and trigger peer migration - static bool dropP2 = true; - if (frameCount > 50 && dropP2) - { - peers[p2].GetTransport()->Disconnect(AllConnections); - peers[p2].GetReplicaMgr().Shutdown(); - dropP2 = false; - AZ_TracePrintf("GridMate", "Dropped P2 at frame %d\n", frameCount); - } - - // reconnect p2 - static bool reconP2 = true; - if (frameCount > 100 && reconP2) - { - peers[p2].GetReplicaMgr().Init(ReplicaMgrDesc(p2 + 1 - , peers[p2].GetTransport() - , 0 - , 0 - , frameTime / 2)); - peers[p1].GetTransport()->Connect("127.0.0.1", basePort + p2); - peers[p2].GetTransport()->Connect("127.0.0.1", basePort + p1); - reconP2 = false; - AZ_TracePrintf("GridMate", "Reconnected P2 at frame %d\n", frameCount); - } - - // disconnect p2 again - static bool redropP2 = true; - if (frameCount > 150 && redropP2) - { - peers[p2].GetTransport()->Disconnect(AllConnections); - redropP2 = false; - AZ_TracePrintf("GridMate", "Re-Dropped P2 at frame %d\n", frameCount); - } - } - - // tick - int tickPeer = frameCount++ % nPeers; - peers[tickPeer].Update(); - if (peers[tickPeer].GetReplicaMgr().IsInitialized()) - { - peers[tickPeer].GetReplicaMgr().Unmarshal(); - peers[tickPeer].GetReplicaMgr().UpdateReplicas(); - peers[tickPeer].GetReplicaMgr().UpdateFromReplicas(); - peers[tickPeer].GetReplicaMgr().Marshal(); - } - peers[tickPeer].GetTransport()->Update(); - AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(frameTime)); - } - - // clean up - for (int i = 0; i < nPeers; ++i) - { - peers[i].GetReplicaMgr().Shutdown(); - DefaultCarrier::Destroy(peers[i].GetTransport()); - } - } - -class ReplicationSecurityOptionsTest - : public UnitTest::GridMateMPTestFixture - , public ::testing::Test -{ -public: - enum - { - s1, - s2, - s3, - nSessions - }; - - class TestChunk : public ReplicaChunk - { - public: - struct ForwardSourcePeerTrait : public RpcDefaultTraits - { - static const bool s_alwaysForwardSourcePeer = true; - static const bool s_allowNonAuthoritativeRequestRelay = false; - }; - - struct DisableNonAuthoritativeRequestTrait : public RpcAuthoritativeTraits - { - static const bool s_alwaysForwardSourcePeer = true; - }; - - GM_CLASS_ALLOCATOR(TestChunk); - - static const char* GetChunkName() { return "ReplicationSecurityOptionsTest::TestChunk"; } - - TestChunk() - : m_nForwardSourcePeerRpcCallsFromS1("m_nForwardSourcePeerRpcCallsFromS1", 0) - , m_nForwardSourcePeerRpcCallsFromS2("m_nForwardSourcePeerRpcCallsFromS2", 0) - , m_nForwardSourcePeerRpcCallsFromS3("m_nForwardSourcePeerRpcCallsFromS3", 0) - , ForwardSourcePeerRpcFromS1("ForwardSourcePeerRpcFromS1") - , ForwardSourcePeerRpcFromS2("ForwardSourcePeerRpcFromS2") - , ForwardSourcePeerRpcFromS3("ForwardSourcePeerRpcFromS3") - , m_nAuthoritativeOnlyRpcCallsFromS1("m_nAuthoritativeOnlyRpcCallsFromS1", 0) - , m_nAuthoritativeOnlyRpcCallsFromS2("m_nAuthoritativeOnlyRpcCallsFromS2", 0) - , m_nAuthoritativeOnlyRpcCallsFromS3("m_nAuthoritativeOnlyRpcCallsFromS3", 0) - , m_nAuthoritativeOnlyProxyRpcCallsFromS1(0) - , m_nAuthoritativeOnlyProxyRpcCallsFromS2(0) - , m_nAuthoritativeOnlyProxyRpcCallsFromS3(0) - , AuthoritativeOnlyRpcFromS1("AuthoritativeOnlyRpcFromS1") - , AuthoritativeOnlyRpcFromS2("AuthoritativeOnlyRpcFromS2") - , AuthoritativeOnlyRpcFromS3("AuthoritativeOnlyRpcFromS3") - { - } - - bool IsReplicaMigratable() override { return false; } - - bool OnForwardSourcePeerRpcFromS1(const RpcContext& rpcContext) - { - // make sure the requestor is set to s1 - AZ_TEST_ASSERT(rpcContext.m_sourcePeer == s1 + 1); - m_nForwardSourcePeerRpcCallsFromS1.Modify([](int& value) { ++value; return true; }); - return false; - } - - bool OnForwardSourcePeerRpcFromS2(const RpcContext& rpcContext) - { - // make sure the requestor is set to s2 - AZ_TEST_ASSERT(rpcContext.m_sourcePeer == s2 + 1); - // requests to s3 should be blocked in this test - AZ_TEST_ASSERT(GetReplicaManager()->GetLocalPeerId() != s3 + 1); - m_nForwardSourcePeerRpcCallsFromS2.Modify([](int& value) { ++value; return true; }); - return false; - } - - bool OnForwardSourcePeerRpcFromS3(const RpcContext& rpcContext) - { - // make sure the requestor is set to s3 - AZ_TEST_ASSERT(rpcContext.m_sourcePeer == s3 + 1); - // requests to s2 should be blocked in this test - AZ_TEST_ASSERT(GetReplicaManager()->GetLocalPeerId() != s2 + 1); - m_nForwardSourcePeerRpcCallsFromS3.Modify([](int& value) { ++value; return true; }); - return false; - } - - bool OnAuthoritativeOnlyRpcFromS1(const RpcContext& rpcContext) - { - // make sure the requestor is set to s1 - AZ_TEST_ASSERT(rpcContext.m_sourcePeer == s1 + 1); - if (IsPrimary()) - { - m_nAuthoritativeOnlyRpcCallsFromS1.Modify([](int& value) { ++value; return true; }); - } - else - { - ++m_nAuthoritativeOnlyProxyRpcCallsFromS1; - } - return true; - } - - bool OnAuthoritativeOnlyRpcFromS2(const RpcContext& rpcContext) - { - // make sure the requestor is set to s2 - AZ_TEST_ASSERT(rpcContext.m_sourcePeer == s2 + 1); - if (IsPrimary()) - { - m_nAuthoritativeOnlyRpcCallsFromS2.Modify([](int& value) { ++value; return true; }); - } - else - { - ++m_nAuthoritativeOnlyProxyRpcCallsFromS2; - } - return true; - } - - bool OnAuthoritativeOnlyRpcFromS3(const RpcContext& rpcContext) - { - // make sure the requestor is set to s3 - AZ_TEST_ASSERT(rpcContext.m_sourcePeer == s3 + 1); - if (IsPrimary()) - { - m_nAuthoritativeOnlyRpcCallsFromS3.Modify([](int& value) { ++value; return true; }); - } - else - { - ++m_nAuthoritativeOnlyProxyRpcCallsFromS3; - } - return true; - } - - DataSet m_nForwardSourcePeerRpcCallsFromS1; - DataSet m_nForwardSourcePeerRpcCallsFromS2; - DataSet m_nForwardSourcePeerRpcCallsFromS3; - Rpc<>::BindInterface ForwardSourcePeerRpcFromS1; - Rpc<>::BindInterface ForwardSourcePeerRpcFromS2; - Rpc<>::BindInterface ForwardSourcePeerRpcFromS3; - - DataSet m_nAuthoritativeOnlyRpcCallsFromS1; - DataSet m_nAuthoritativeOnlyRpcCallsFromS2; - DataSet m_nAuthoritativeOnlyRpcCallsFromS3; - int m_nAuthoritativeOnlyProxyRpcCallsFromS1; - int m_nAuthoritativeOnlyProxyRpcCallsFromS2; - int m_nAuthoritativeOnlyProxyRpcCallsFromS3; - Rpc<>::BindInterface AuthoritativeOnlyRpcFromS1; - Rpc<>::BindInterface AuthoritativeOnlyRpcFromS2; - Rpc<>::BindInterface AuthoritativeOnlyRpcFromS3; - }; - using TestChunkPtr = AZStd::intrusive_ptr ; -}; - -TEST_F(ReplicationSecurityOptionsTest, DISABLED_ReplicationSecurityOptionsTest) - { - AZ_TracePrintf("GridMate", "\n"); - - // Register test chunks - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - - MPSession sessions[nSessions]; - ReplicaPtr primarys[nSessions]; - - // initialize transport - int basePort = 4427; - for (int i = 0; i < nSessions; ++i) - { - TestCarrierDesc desc; - desc.m_port = basePort + i; - // initialize replica managers - // s2(c)<-->(p)s1(p)<-->(c)s3 - sessions[i].SetTransport(DefaultCarrier::Create(desc, m_gridMate)); - sessions[i].AcceptConn(true); - sessions[i].SetClient(i != s1); - sessions[i].GetReplicaMgr().Init(ReplicaMgrDesc(i + 1, sessions[i].GetTransport(), 0, i == 0 ? ReplicaMgrDesc::Role_SyncHost : 0)); - - ReplicationSecurityOptions options; - options.m_enableStrictSourceValidation = true; - sessions[i].GetReplicaMgr().SetSecurityOptions(options); - } - - // connect s2 to s1 - sessions[s2].GetTransport()->Connect("127.0.0.1", basePort); - - // connect s3 to s1 - sessions[s3].GetTransport()->Connect("127.0.0.1", basePort); - - // main test loop - for (int tick = 0; tick < 1000; ++tick) - { - if (tick == 100) - { - for (int i = 0; i < nSessions; ++i) - { - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().IsReady()); - primarys[i] = Replica::CreateReplica("ReplicationSecurityOptionsTest::TestReplica"); - TestChunkPtr chunk = CreateReplicaChunk(); - primarys[i]->AttachReplicaChunk(chunk); - sessions[i].GetReplicaMgr().AddPrimary(primarys[i]); - } - } - - if (tick == 200) - { - AZ_TEST_START_TRACE_SUPPRESSION; - for (int i = 0; i < nSessions; ++i) - { - sessions[s1].GetReplicaMgr().FindReplica(primarys[i]->GetRepId())->FindReplicaChunk()->ForwardSourcePeerRpcFromS1(); - sessions[s2].GetReplicaMgr().FindReplica(primarys[i]->GetRepId())->FindReplicaChunk()->ForwardSourcePeerRpcFromS2(); - sessions[s3].GetReplicaMgr().FindReplica(primarys[i]->GetRepId())->FindReplicaChunk()->ForwardSourcePeerRpcFromS3(); - } - } - - if (tick == 300) - { - // The previous test should have triggered the following assert twice: - // ReplicaChunk.cpp(449): AZ_Assert(false, "Discarding non-authoritative RPC <%s> because s_allowNonAuthoritativeRequestRelay trait is disabled!", GetDescriptor()->GetRpcName(this, rpc)); - AZ_TEST_STOP_TRACE_SUPPRESSION(2); - - // All chunks should have received the call from the host - AZ_TEST_ASSERT(primarys[s1]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1 == 1); - AZ_TEST_ASSERT(primarys[s2]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1 == 1); - AZ_TEST_ASSERT(primarys[s3]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1 == 1); - - // the host chunk should have received calls from both clients - AZ_TEST_ASSERT(primarys[s1]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2 == 1); - AZ_TEST_ASSERT(primarys[s1]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3 == 1); - - // the chunk on s2 should receive its own call but not from s3 - AZ_TEST_ASSERT(primarys[s2]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2 == 1); - AZ_TEST_ASSERT(primarys[s2]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3 == 0); - - // the chunk on s3 should receive its own call but not from s2 - AZ_TEST_ASSERT(primarys[s3]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2 == 0); - AZ_TEST_ASSERT(primarys[s3]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3 == 1); - - // all datasets should have propagated properly - for (int i = 0; i < nSessions; ++i) - { - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s1]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1.Get() == primarys[s1]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s1]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2.Get() == primarys[s1]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s1]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3.Get() == primarys[s1]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3.Get()); - - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s2]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1.Get() == primarys[s2]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s2]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2.Get() == primarys[s2]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s2]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3.Get() == primarys[s2]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3.Get()); - - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s3]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1.Get() == primarys[s3]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS1.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s3]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2.Get() == primarys[s3]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS2.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s3]->GetRepId())->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3.Get() == primarys[s3]->FindReplicaChunk()->m_nForwardSourcePeerRpcCallsFromS3.Get()); - } - } - - if (tick == 400) - { - AZ_TEST_START_TRACE_SUPPRESSION; - for (int i = 0; i < nSessions; ++i) - { - sessions[s1].GetReplicaMgr().FindReplica(primarys[i]->GetRepId())->FindReplicaChunk()->AuthoritativeOnlyRpcFromS1(); - sessions[s2].GetReplicaMgr().FindReplica(primarys[i]->GetRepId())->FindReplicaChunk()->AuthoritativeOnlyRpcFromS2(); - sessions[s3].GetReplicaMgr().FindReplica(primarys[i]->GetRepId())->FindReplicaChunk()->AuthoritativeOnlyRpcFromS3(); - } - } - - if (tick == 500) - { - // The previous test should have triggered the following assert six times: - // ReplicaChunk.cpp(444): AZ_Assert(false, "Discarding non-authoritative RPC <%s> because s_allowNonAuthoritativeRequests trait is disabled!", GetDescriptor()->GetRpcName(this, rpc)); - AZ_TEST_STOP_TRACE_SUPPRESSION(6); - - // Each chunk should have received their own AuthoritativeOnlyRpc once. - AZ_TEST_ASSERT(primarys[s1]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1 == 1); - AZ_TEST_ASSERT(primarys[s2]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2 == 1); - AZ_TEST_ASSERT(primarys[s3]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3 == 1); - - // Calls from other nodes should have been discarded. - AZ_TEST_ASSERT(primarys[s1]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2 == 0); - AZ_TEST_ASSERT(primarys[s1]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3 == 0); - AZ_TEST_ASSERT(primarys[s2]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1 == 0); - AZ_TEST_ASSERT(primarys[s2]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3 == 0); - AZ_TEST_ASSERT(primarys[s3]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1 == 0); - AZ_TEST_ASSERT(primarys[s3]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2 == 0); - - // Calls should have successfully propagated to the other 2 proxies - AZ_TEST_ASSERT(sessions[s1].GetReplicaMgr().FindReplica(primarys[s2]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyProxyRpcCallsFromS2 == 1); - AZ_TEST_ASSERT(sessions[s1].GetReplicaMgr().FindReplica(primarys[s3]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyProxyRpcCallsFromS3 == 1); - AZ_TEST_ASSERT(sessions[s2].GetReplicaMgr().FindReplica(primarys[s1]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyProxyRpcCallsFromS1 == 1); - AZ_TEST_ASSERT(sessions[s2].GetReplicaMgr().FindReplica(primarys[s3]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyProxyRpcCallsFromS3 == 1); - AZ_TEST_ASSERT(sessions[s3].GetReplicaMgr().FindReplica(primarys[s1]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyProxyRpcCallsFromS1 == 1); - AZ_TEST_ASSERT(sessions[s3].GetReplicaMgr().FindReplica(primarys[s2]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyProxyRpcCallsFromS2 == 1); - - // all datasets should have propagated properly - for (int i = 0; i < nSessions; ++i) - { - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s1]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1.Get() == primarys[s1]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s1]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2.Get() == primarys[s1]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s1]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3.Get() == primarys[s1]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3.Get()); - - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s2]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1.Get() == primarys[s2]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s2]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2.Get() == primarys[s2]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s2]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3.Get() == primarys[s2]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3.Get()); - - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s3]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1.Get() == primarys[s3]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS1.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s3]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2.Get() == primarys[s3]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS2.Get()); - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().FindReplica(primarys[s3]->GetRepId())->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3.Get() == primarys[s3]->FindReplicaChunk()->m_nAuthoritativeOnlyRpcCallsFromS3.Get()); - } - } - - // tick everything - for (int i = 0; i < nSessions; ++i) - { - sessions[i].Update(); - sessions[i].GetReplicaMgr().Unmarshal(); - sessions[i].GetReplicaMgr().UpdateReplicas(); - sessions[i].GetReplicaMgr().UpdateFromReplicas(); - sessions[i].GetReplicaMgr().Marshal(); - sessions[i].GetTransport()->Update(); - } - - AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(10)); - } - - - for (int i = 0; i < nSessions; ++i) - { - sessions[i].GetReplicaMgr().Shutdown(); - DefaultCarrier::Destroy(sessions[i].GetTransport()); - } - } - - -/* - *03.25.2015* Typical test results on Core i7 3.4 GHz desktop (with polling): - Release: - Replica update time (msec): avg=2.02, min=2, max=3 (peers=40, replicas=16000, freq=0%, samples=4000) - Replica update time (msec): avg=4.83, min=2, max=12 (peers=40, replicas=16000, freq=10%, samples=4000) - Replica update time (msec): avg=4.73, min=3, max=12 (peers=40, replicas=16000, freq=100%, samples=4000) - DebugOpt: - Replica update time (msec): avg=2.53, min=2, max=5 (peers=40, replicas=16000, freq=0%, samples=4000) - Replica update time (msec): avg=4.21, min=2, max=8 (peers=40, replicas=16000, freq=10%, samples=4000) - Replica update time (msec): avg=5.59, min=3, max=14 (peers=40, replicas=16000, freq=100%, samples=4000) - - - Test results (task based marshaling): - Release: - Replica update time (msec): avg=0.03, min=0, max=1 (peers=40, replicas=16000, freq=0%, samples=4000) - Replica update time (msec): avg=3.94, min=1, max=11 (peers=40, replicas=16000, freq=10%, samples=4000) - Replica update time (msec): avg=5.21, min=4, max=15 (peers=40, replicas=16000, freq=100%, samples=4000) - DebugOpt: - Replica update time (msec): avg=1.00, min=1, max=2 (peers=40, replicas=16000, freq=0%, samples=4000) - Replica update time (msec): avg=4.94, min=1, max=9 (peers=40, replicas=16000, freq=10%, samples=4000) - Replica update time (msec): avg=8.05, min=6, max=15 (peers=40, replicas=16000, freq=100%, samples=4000) -*/ -class DISABLED_ReplicaStressTest - : public UnitTest::GridMateMPTestFixture -{ -public: - class StressTestReplica - : public ReplicaChunk - { - public: - GM_CLASS_ALLOCATOR(StressTestReplica); - typedef AZStd::intrusive_ptr Ptr; - static const char* GetChunkName() { return "StressTestReplica"; } - - StressTestReplica() - : m_data("Data") - { - } - - bool IsReplicaMigratable() override - { - return false; - } - - bool m_changing; - DataSet m_data; - }; - - static const size_t NUM_PEERS = 40; - static const size_t NUM_REPLICAS_PER_PEER = 400; - static const int FRAME_TIME = 5; - static const int BASE_PORT = 44270; - - // TODO: Reduce the size or disable the test for platforms which can't allocate 2 GiB - DISABLED_ReplicaStressTest() - : UnitTest::GridMateMPTestFixture(2000u * 1024u * 1024u) - {} - - void UpdateReplica(MPSession& session) - { - session.GetReplicaMgr().Unmarshal(); - session.GetReplicaMgr().UpdateReplicas(); - - session.GetReplicaMgr().UpdateFromReplicas(); - session.GetReplicaMgr().Marshal(); - } - - void Wait(MPSession* sessions, vector >& replicas, int numFrames, int frameTime) - { - (void)replicas; - while (numFrames--) - { - for (size_t i = 0; i < NUM_PEERS; ++i) - { - sessions[i].Update(); - UpdateReplica(sessions[i]); - } - - for (size_t i = 0; i < NUM_PEERS; ++i) - { - sessions[i].GetTransport()->Update(); - } - - AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(frameTime)); - } - } - - // freq is 0..1, 0.0 - no dirty replicas per tick, 1.0 - all replicas are dirty every tick, 0.5 - 50% of replicas per tick - void TestReplicas(MPSession* sessions, vector >& replicas, int numFrames, int frameTime, double freq) - { - AZStd::chrono::system_clock::duration minUpdateTime(AZStd::chrono::system_clock::duration::max()); - AZStd::chrono::system_clock::duration maxUpdateTime(AZStd::chrono::system_clock::duration::min()); - AZStd::chrono::system_clock::duration sumSamples(AZStd::chrono::system_clock::duration::zero()); - unsigned long long numSamples = 0; - - int count = 0; - while (numFrames--) - { - MarkChanging(replicas, freq); - - for (auto& r : replicas) - { - if (r.second->m_changing) - { - r.second->m_data.Set(count++); - } - } - - for (size_t i = 0; i < NUM_PEERS; ++i) - { - sessions[i].Update(); - AZStd::chrono::system_clock::time_point beforeUpdateTime = AZStd::chrono::system_clock::now(); - UpdateReplica(sessions[i]); - auto updateTime = AZStd::chrono::system_clock::now() - beforeUpdateTime; - minUpdateTime = AZStd::min(updateTime, minUpdateTime); - maxUpdateTime = AZStd::max(updateTime, maxUpdateTime); - sumSamples += updateTime; - ++numSamples; - } - - for (size_t i = 0; i < NUM_PEERS; ++i) - { - sessions[i].GetTransport()->Update(); - } - - AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(frameTime)); - } - - AZ_TEST_ASSERT(numSamples > 0); - - AZ_Printf("GridMate", "\n\n----------------\nReplica update time (msec): avg=%.2f, min=%.2f, max=%.2f (peers=%d, replicas=%d, freq=%d%%, samples=%llu)\n", - static_cast(AZStd::chrono::duration_cast(sumSamples).count()) / static_cast(numSamples), - AZStd::chrono::duration_cast(minUpdateTime).count() / 1000.0, - AZStd::chrono::duration_cast(maxUpdateTime).count() / 1000.0, - NUM_PEERS, - replicas.size(), - static_cast(freq * 100.0), - numSamples); - } - - bool ConnectPeers(MPSession* sessions, int frameTime) - { - size_t frameCount = 0; - bool allReady = false; - size_t maxFramesToReady = NUM_PEERS + 100; // this is to avoid infinite loop waiting for all peers to become ready in case some peer cannot connect - vector > replicas; - - while (!allReady && frameCount < maxFramesToReady) - { - // establish all connections - if (frameCount < NUM_PEERS) - { - for (size_t i = 0; i < frameCount; ++i) - { - sessions[frameCount].GetTransport()->Connect("127.0.0.1", BASE_PORT + static_cast(i)); - } - } - - allReady = true; - for (size_t i = 0; i < NUM_PEERS; ++i) - { - if (!sessions[i].GetReplicaMgr().IsReady()) - { - allReady = false; - break; - } - } - if (allReady) - { - AZ_Printf("GridMate", "All peers ready at frame %d\n", frameCount); - } - - Wait(sessions, replicas, 1, frameTime); - ++frameCount; - } - - return allReady; - } - - virtual void RunStressTests(MPSession* sessions, vector >& replicas) - { - // testing 3 cases & waiting for system to settle in between - //TestProfiler::StartProfiling(); - Wait(sessions, replicas, 50, FRAME_TIME); - //TestProfiler::PrintProfilingTotal("GridMate"); - - Wait(sessions, replicas, 20, FRAME_TIME); - //TestProfiler::StartProfiling(); - TestReplicas(sessions, replicas, 100, FRAME_TIME, 0.0); // no replicas are dirty - //TestProfiler::PrintProfilingTotal("GridMate"); - - Wait(sessions, replicas, 20, FRAME_TIME); - //TestProfiler::StartProfiling(); - TestReplicas(sessions, replicas, 1, FRAME_TIME, 1.0); // single burst dirty replicas - Wait(sessions, replicas, 2, FRAME_TIME); - //TestProfiler::PrintProfilingTotal("GridMate"); - - Wait(sessions, replicas, 20, FRAME_TIME); - //TestProfiler::StartProfiling(); - TestReplicas(sessions, replicas, 100, FRAME_TIME, 0.1); // 10% of replicas are marked dirty every frame - //TestProfiler::PrintProfilingTotal("GridMate"); - - Wait(sessions, replicas, 20, FRAME_TIME); - //TestProfiler::StartProfiling(); - TestReplicas(sessions, replicas, 100, FRAME_TIME, 1.0); // every replica is marked dirty every frame - //TestProfiler::PrintProfilingTotal("GridMate"); - //TestProfiler::PrintProfilingSelf("GridMate"); - - //TestProfiler::StopProfiling(); - } - - virtual void MarkChanging(vector >& replicas, double freq) - { - AZ::Sfmt& sfmt = AZ::Sfmt::GetInstance(); - for (auto& r : replicas) - { - r.second->m_changing = sfmt.RandR32_2() <= freq; - } - } - - void run() - { - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - - MPSession sessions[NUM_PEERS]; - vector > replicas; - - replicas.reserve(NUM_PEERS * NUM_REPLICAS_PER_PEER); - - for (unsigned int i = 0; i < NUM_PEERS; ++i) - { - TestCarrierDesc desc; - desc.m_port = BASE_PORT + i; - desc.m_enableDisconnectDetection = false; - - // initialize replica managers - sessions[i].SetTransport(DefaultCarrier::Create(desc, m_gridMate)); - sessions[i].AcceptConn(true); - sessions[i].SetClient(false); - sessions[i].GetReplicaMgr().Init(ReplicaMgrDesc(i + 1 - , sessions[i].GetTransport() - , 0 - , i == 0 ? ReplicaMgrDesc::Role_SyncHost : 0)); - } - - bool allReady = ConnectPeers(sessions, FRAME_TIME); - - AZ_TEST_ASSERT(allReady); - - for (auto& session : sessions) - { - for (size_t j = 0; j < NUM_REPLICAS_PER_PEER; ++j) - { - auto rep = Replica::CreateReplica(nullptr); - auto chunk = CreateAndAttachReplicaChunk(rep); - replicas.push_back(AZStd::make_pair(rep, chunk)); - session.GetReplicaMgr().AddPrimary(rep); - } - } - - RunStressTests(sessions, replicas); - - // clean up - for (auto& s : sessions) - { - s.GetReplicaMgr().Shutdown(); - DefaultCarrier::Destroy(s.GetTransport()); - } - } -}; - -/* - This test performs updates to the same replicas every frame unlike stress test that picks random replicas every frame - *03.25.2015* Typical test results on Core i7 3.4 GHz desktop (with polling): - Release: - Replica update time (msec): avg=2.54, min=2, max=9 (peers=40, replicas=16000, freq=10%, samples=4000) - Replica update time (msec): avg=3.15, min=2, max=7 (peers=40, replicas=16000, freq=50%, samples=4000) - DebugOpt: - Replica update time (msec): avg=3.35, min=3, max=8 (peers=40, replicas=16000, freq=10%, samples=4000) - Replica update time (msec): avg=4.45, min=3, max=10 (peers=40, replicas=16000, freq=50%, samples=4000) - - Test results (task based marshaling): - Release: - Replica update time (msec): avg=1.62, min=1, max=10 (peers=40, replicas=16000, freq=10%, samples=4000) - Replica update time (msec): avg=4.38, min=2, max=15 (peers=40, replicas=16000, freq=50%, samples=4000) - DebugOpt: - Replica update time (msec): avg=2.01, min=1, max=5 (peers=40, replicas=16000, freq=10%, samples=4000) - Replica update time (msec): avg=4.61, min=3, max=10 (peers=40, replicas=16000, freq=50%, samples=4000) -*/ -class DISABLED_ReplicaStableStressTest - : public DISABLED_ReplicaStressTest -{ -public: - - void MarkChanging(vector >& replicas, double freq) override - { - (void)replicas; - (void)freq; - } - - void RunStressTests(MPSession* sessions, vector >& replicas) override - { - DISABLED_ReplicaStressTest::MarkChanging(replicas, 0.1); // picks 10% of replicas - Wait(sessions, replicas, 20, FRAME_TIME); - //TestProfiler::StartProfiling(); - TestReplicas(sessions, replicas, 100, FRAME_TIME, 0.1); - /*TestProfiler::PrintProfilingTotal("GridMate"); - TestProfiler::PrintProfilingSelf("GridMate");*/ - - DISABLED_ReplicaStressTest::MarkChanging(replicas, 0.5); // picks 50% of replicas - Wait(sessions, replicas, 20, FRAME_TIME); - //TestProfiler::StartProfiling(); - TestReplicas(sessions, replicas, 100, FRAME_TIME, 0.5); - /*TestProfiler::PrintProfilingTotal("GridMate"); - TestProfiler::PrintProfilingSelf("GridMate"); - - TestProfiler::StopProfiling();*/ - } -}; - - -/* -* This test verifies bandwidth limiter. The test takes ~2 minutes. It sends ~7k/s of data with a limit of 4k with the following pattern: -* -* -* time | 10s | 10s | 20s | 20s | 10s | 20s | -* +-----+-----+----------+----------+-----+----------+ -* sendrate | 0k | 7k | 7k | 1.5k | 7k | 7k | -* | | | | | | | -* expected |none |brst | capped |under cap |brst | capped | -* -*/ -class DISABLED_ReplicaBandiwdthTest - : public UnitTest::GridMateMPTestFixture -{ -public: - - class BandwidthTestChunk - : public ReplicaChunk - { - public: - GM_CLASS_ALLOCATOR(BandwidthTestChunk); - typedef AZStd::intrusive_ptr Ptr; - static const char* GetChunkName() { return "BandwidthTestChunk"; } - - BandwidthTestChunk() - : m_value("Value") - { - Touch(); - } - - void Touch() - { - AZStd::string randomStr; - for (unsigned i = 0; i < k_strSize; ++i) - { - randomStr += 'a' + (rand() % 26); - } - m_value.Set(randomStr); - } - - bool IsReplicaMigratable() override { return false; } - - static const unsigned k_strSize = 64; - DataSet m_value; - }; - - void run() - { - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - - MPSession sessions[nSessions]; - // initialize transport - int basePort = 4427; - for (int i = 0; i < nSessions; ++i) - { - TestCarrierDesc desc; - desc.m_port = basePort + i; - desc.m_enableDisconnectDetection = false; - sessions[i].SetClient(i != sHost); - sessions[i].SetTransport(DefaultCarrier::Create(desc, m_gridMate)); - sessions[i].AcceptConn(true); - sessions[i].GetReplicaMgr().Init(ReplicaMgrDesc(i + 1, sessions[i].GetTransport(), 0, i == 0 ? ReplicaMgrDesc::Role_SyncHost : 0)); - } - - // adding replicas for the host - static const size_t k_numReplicas = 10; - BandwidthTestChunk::Ptr chunks[k_numReplicas]; - for (size_t i = 0; i < k_numReplicas; ++i) - { - auto rep = Replica::CreateReplica(nullptr); - chunks[i] = CreateAndAttachReplicaChunk(rep); - sessions[sHost].GetReplicaMgr().AddPrimary(rep); - } - - // connect to host - for (size_t i = 0; i < nSessions; ++i) - { - if (i == sHost) - { - continue; - } - - sessions[i].GetTransport()->Connect("127.0.0.1", basePort); - } - - static const int k_delayMS = 100; // tick time - - bool isDone = false; - size_t numReplicasToChange = 0; - - /* - 10 replicas x ~70 bytes per replica x 10 frames per second =~ 7000 bytes per second - Will try to cutoff it at 4k per sec - */ - static const unsigned k_sendRateLimit = 4000; - - unsigned tickNo = 0; - AZ_Printf("GridMate", "Created %d sessions.\n", nSessions); - while (!isDone) - { - for (size_t i = 0; i < numReplicasToChange; ++i) - { - chunks[i]->Touch(); - } - - for (auto connId : sessions[sHost].m_connections) - { - if (connId == InvalidConnectionID) - { - continue; - } - - TrafficControl::Statistics lastSecEffective; - sessions[sHost].GetTransport()->QueryStatistics(connId, nullptr, nullptr, &lastSecEffective); - m_measurements[connId].m_sendData.push_back(lastSecEffective.m_dataSend); - - if (!(tickNo % 30)) // printout every 3 seconds - { - AZ_Printf("GridMate", " - effective sendRate=%.2f KB\n", lastSecEffective.m_dataSend / 1000.f); - } - //AZ_TracePrintf("GridMate", "%d\n", lastSecEffective.m_dataSend); - } - - - // ======================================================= - // Actual tests - // ======================================================= - if (tickNo == 100) // things should've settle at this point, session is established, initial replicas are sent - { - for (size_t i = 0; i < AZ_ARRAY_SIZE(sessions); ++i) - { - AZ_TEST_ASSERT(sessions[i].GetReplicaMgr().IsReady()); - } - - numReplicasToChange = k_numReplicas; - ResetMeasurements(); - AZ_Printf("GridMate", "Starting replica data send. Unlimited.\n"); - } - else if (tickNo == 200) - { - // test if initial unlimited burst was allowed - for (const auto& m : m_measurements) - { - AZ_TEST_ASSERT(m.second.Max() > k_sendRateLimit * 1.5f); - } - ResetMeasurements(); - sessions[sHost].GetReplicaMgr().SetSendLimit(k_sendRateLimit); - AZ_Printf("GridMate", "Limited by SendLimit=%d Bps.\n", sessions[sHost].GetReplicaMgr().GetSendLimit()); - } - else if (tickNo == 400) - { - // checking if bandwidth was rate limited - for (const auto& m : m_measurements) - { - if (!(m.second.Mean() < k_sendRateLimit * 1.1f)) - { - AZ_Printf("GridMate", "rate mean: %f limit %d\n", m.second.Mean(), sessions[sHost].GetReplicaMgr().GetSendLimit()) - } - AZ_TEST_ASSERT(m.second.Mean() < k_sendRateLimit * 1.1f); // allowing 10% margin of error - } - ResetMeasurements(); - numReplicasToChange = k_numReplicas / 4; // reducing outgoing traffic 1/4 - AZ_Printf("GridMate", "Reduced send rate...\n"); - } - else if (tickNo == 600) - { - // checking if traffic below the limit - for (const auto& m : m_measurements) - { - AZ_TEST_ASSERT(m.second.Mean() < k_sendRateLimit * 0.7f); - } - ResetMeasurements(); - sessions[sHost].GetReplicaMgr().SetSendLimit(0); // returning to unlimited send rate - numReplicasToChange = k_numReplicas; - AZ_Printf("GridMate", "Full send rate...\n"); - } - else if (tickNo == 700) - { - // test if burst allowed - for (const auto& m : m_measurements) - { - AZ_TEST_ASSERT(m.second.Max() > k_sendRateLimit * 1.5f); - } - ResetMeasurements(); - sessions[sHost].GetReplicaMgr().SetSendLimit(k_sendRateLimit); - AZ_Printf("GridMate", "Limited by SendLimit=%d Bps.\n", sessions[sHost].GetReplicaMgr().GetSendLimit()); - } - else if (tickNo == 900) - { - // checking if bandwidth was limited - for (const auto& m : m_measurements) - { - AZ_TEST_ASSERT(m.second.Mean() < k_sendRateLimit * 1.1f); // allowing 10% jerking around limit - } - - isDone = true; - } - - // ======================================================= - // Tick everything - // ======================================================= - for (size_t i = 0; i < nSessions; ++i) - { - sessions[i].Update(); - sessions[i].GetReplicaMgr().Unmarshal(); - } - - for (size_t i = 0; i < nSessions; ++i) - { - sessions[i].GetReplicaMgr().UpdateReplicas(); - } - - for (size_t i = 0; i < nSessions; ++i) - { - sessions[i].GetReplicaMgr().UpdateFromReplicas(); - sessions[i].GetReplicaMgr().Marshal(); - } - - for (size_t i = 0; i < nSessions; ++i) - { - sessions[i].GetTransport()->Update(); - } - - ++tickNo; - AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(k_delayMS)); - } - - - for (int i = 0; i < nSessions; ++i) - { - sessions[i].GetReplicaMgr().Shutdown(); - DefaultCarrier::Destroy(sessions[i].GetTransport()); - } - } - - void ResetMeasurements() - { - for (auto& m : m_measurements) - { - m.second.Reset(); - } - } - - struct Measurement - { - unsigned int Mean() const - { - AZ_Assert(!m_sendData.empty(), "No data!"); - unsigned int sum = 0; - for (auto val : m_sendData) - { - sum += val; - } - - return sum / static_cast(m_sendData.size()); - } - - unsigned int Max() const - { - unsigned int curMax = 0; - for (auto val : m_sendData) - { - curMax = AZStd::GetMax(curMax, val); - } - - return curMax; - } - - void Reset() - { - m_sendData.clear(); - } - - vector m_sendData; // data sent per second - }; - - enum - { - sHost, sClient1, nSessions - }; - unordered_map m_measurements; -}; } // namespace UnitTest diff --git a/Code/Framework/GridMate/Tests/ReplicaBehavior.cpp b/Code/Framework/GridMate/Tests/ReplicaBehavior.cpp index 86f9f4605b..67b5e49df7 100644 --- a/Code/Framework/GridMate/Tests/ReplicaBehavior.cpp +++ b/Code/Framework/GridMate/Tests/ReplicaBehavior.cpp @@ -18,7 +18,6 @@ #include #include #include -#include #include using namespace GridMate; @@ -584,837 +583,5 @@ namespace ReplicaBehavior { AZStd::array 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 m_replicaLengths; - }; - - template - 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(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(); - 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(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(); - 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 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(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(); - int nonDefaultValue = NonDefaultValue; - auto touch = [nonDefaultValue](DataSet& 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(replica1); - AZ_TEST_ASSERT(chunk1); - - m_replicaBoolsId = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica1); - - ReplicaPtr replica2 = Replica::CreateReplica(nullptr); - ChunkWithShortInts* chunk2 = CreateAndAttachReplicaChunk(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(); - - auto touch = [](DataSet& 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(); - - auto touch = [](DataSet& 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(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(); - - 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(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(); - - 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(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(); - 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(); - chunk->Data1.Set(MomentaryValue); - - break; - } - case 16: - { - auto rep = GetHostReplica(); - AZ_TEST_ASSERT(rep); - auto chunk = rep->FindReplicaChunk(); - 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 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(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(); - - // 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 diff --git a/Code/Framework/GridMate/Tests/ReplicaMedium.cpp b/Code/Framework/GridMate/Tests/ReplicaMedium.cpp index 2e8d2a3a73..b258d7d310 100644 --- a/Code/Framework/GridMate/Tests/ReplicaMedium.cpp +++ b/Code/Framework/GridMate/Tests/ReplicaMedium.cpp @@ -20,7 +20,6 @@ #include #include #include -#include #include #include @@ -525,22 +524,6 @@ public: int m_deactivates; }; -class DrillerTestChunk - : public ReplicaChunk -{ -public: - GM_CLASS_ALLOCATOR(DrillerTestChunk); - typedef AZStd::intrusive_ptr Ptr; - static const char* GetChunkName() { return "DrillerTestChunk"; } - - DrillerTestChunk() { } - - bool IsReplicaMigratable() override - { - return true; - } -}; - class NonConstMarshaler { public: @@ -744,10 +727,6 @@ public: { ReplicaChunkDescriptorTable::Get().RegisterChunkType(); } - if (!ReplicaChunkDescriptorTable::Get().FindReplicaChunkDescriptor(ReplicaChunkClassId(DrillerTestChunk::GetChunkName()))) - { - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - } if (!ReplicaChunkDescriptorTable::Get().FindReplicaChunkDescriptor(ReplicaChunkClassId(NonConstMarshalerChunk::GetChunkName()))) { ReplicaChunkDescriptorTable::Get().RegisterChunkType(); @@ -1648,440 +1627,6 @@ TEST_F(ReplicaChunkEventsDeactivate, DISABLED_ReplicaChunkEventsDeactivate) }); } - -class ReplicaDriller - : public SimpleTest -{ -public: - ReplicaDriller() - : m_replicaId(InvalidReplicaId) - { - } - - enum - { - sHost, - s2, - nSessions - }; - - class ReplicaDrillerHook - : public Debug::ReplicaDrillerBus::Handler - { - public: - ReplicaDrillerHook() - : m_createdReplicas(0) - , m_destroyedReplicas(0) - , m_activatedReplicas(0) - , m_deactivatedReplicas(0) - , m_attachedChunks(0) - , m_detachedChunks(0) - , m_numReplicaBytesSent(0) - , m_numReplicaBytesReceived(0) - , m_numRequestChangeOwnership(0) - , m_numChangedOwnership(0) - , m_createdChunks(0) - , m_destroyedChunks(0) - , m_activatedChunks(0) - , m_deactivatedChunks(0) - , m_numChunkBytesSent(0) - , m_numChunkBytesReceived(0) - , m_numOutgoingDatasets(0) - , m_numIncomingDatasets(0) - , m_numRpcRequests(0) - , m_numRpcInvokes(0) - , m_outgoingRpcDataSize(0) - , m_incomingRpcDataSize(0) - , m_totalOutgoingBytes(0) - , m_totalIncomingBytes(0) - , m_curReplicaSend(nullptr) - , m_curReplicaChunkSend(nullptr) - , m_curReplicaChunkIndexSend(GM_MAX_CHUNKS_PER_REPLICA) - , m_curReplicaReceive(nullptr) - , m_curReplicaChunkReceive(nullptr) - , m_curReplicaChunkIndexReceive(GM_MAX_CHUNKS_PER_REPLICA) - { - } - - AZStd::size_t m_createdReplicas; - AZStd::size_t m_destroyedReplicas; - AZStd::size_t m_activatedReplicas; - AZStd::size_t m_deactivatedReplicas; - AZStd::size_t m_attachedChunks; - AZStd::size_t m_detachedChunks; - AZStd::size_t m_numReplicaBytesSent; - AZStd::size_t m_numReplicaBytesReceived; - AZStd::size_t m_numRequestChangeOwnership; - AZStd::size_t m_numChangedOwnership; - - AZStd::size_t m_createdChunks; - AZStd::size_t m_destroyedChunks; - AZStd::size_t m_activatedChunks; - AZStd::size_t m_deactivatedChunks; - AZStd::size_t m_numChunkBytesSent; - AZStd::size_t m_numChunkBytesReceived; - - AZStd::size_t m_numOutgoingDatasets; - AZStd::size_t m_numIncomingDatasets; - - AZStd::size_t m_numRpcRequests; - AZStd::size_t m_numRpcInvokes; - AZStd::size_t m_outgoingRpcDataSize; - AZStd::size_t m_incomingRpcDataSize; - - AZStd::size_t m_totalOutgoingBytes; - AZStd::size_t m_totalIncomingBytes; - - Replica* m_curReplicaSend; - ReplicaChunkBase* m_curReplicaChunkSend; - size_t m_curReplicaChunkIndexSend; - Replica* m_curReplicaReceive; - ReplicaChunkBase* m_curReplicaChunkReceive; - AZ::u32 m_curReplicaChunkIndexReceive; - - void OnCreateReplica(Replica* replica) override - { - AZ_TEST_ASSERT(replica); - ++m_createdReplicas; - } - - void OnDestroyReplica(Replica* replica) override - { - AZ_TEST_ASSERT(replica); - ++m_destroyedReplicas; - } - - void OnActivateReplica(Replica* replica) override - { - AZ_TEST_ASSERT(replica); - ++m_activatedReplicas; - } - - void OnDeactivateReplica(Replica* replica) override - { - AZ_TEST_ASSERT(replica); - ++m_deactivatedReplicas; - } - - void OnAttachReplicaChunk(ReplicaChunkBase* chunk) override - { - AZ_TEST_ASSERT(chunk); - ++m_attachedChunks; - } - - void OnDetachReplicaChunk(ReplicaChunkBase* chunk) override - { - AZ_TEST_ASSERT(chunk); - ++m_detachedChunks; - } - - void OnSendReplicaBegin(Replica* replica) override - { - AZ_TEST_ASSERT(replica); - AZ_TEST_ASSERT(m_curReplicaSend == nullptr); - m_curReplicaSend = replica; - } - - void OnSendReplicaEnd(Replica* replica, const void* data, size_t len) override - { - AZ_TEST_ASSERT(replica); - AZ_TEST_ASSERT(replica == m_curReplicaSend); - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - m_numReplicaBytesSent += len; - m_curReplicaSend = nullptr; - } - - void OnReceiveReplicaBegin(Replica* replica, const void* data, size_t len) override - { - AZ_TEST_ASSERT(replica); - AZ_TEST_ASSERT(m_curReplicaReceive == nullptr); - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - m_curReplicaReceive = replica; - m_numReplicaBytesReceived += len; - } - - void OnReceiveReplicaEnd(Replica* replica) override - { - AZ_TEST_ASSERT(replica); - AZ_TEST_ASSERT(replica == m_curReplicaReceive); - m_curReplicaReceive = nullptr; - } - - void OnRequestReplicaChangeOwnership(Replica* replica, PeerId requestor) override - { - AZ_TEST_ASSERT(replica); - AZ_TEST_ASSERT(requestor == (s2 + 1)); - ++m_numRequestChangeOwnership; - } - - void OnReplicaChangeOwnership(Replica* replica, bool wasPrimary) override - { - AZ_TEST_ASSERT(replica); - switch (m_numChangedOwnership) - { - case 0: // host loses ownership - AZ_TEST_ASSERT(replica->IsProxy() && wasPrimary == true); - break; - case 1: // peer acquires ownership - AZ_TEST_ASSERT(replica->IsPrimary() && wasPrimary == false); - break; - default: - AZ_TEST_ASSERT(0); - } - - ++m_numChangedOwnership; - } - - void OnCreateReplicaChunk(ReplicaChunkBase* chunk) override - { - AZ_TEST_ASSERT(chunk); - ++m_createdChunks; - } - - void OnDestroyReplicaChunk(ReplicaChunkBase* chunk) override - { - AZ_TEST_ASSERT(chunk); - ++m_destroyedChunks; - } - - void OnActivateReplicaChunk(ReplicaChunkBase* chunk) override - { - AZ_TEST_ASSERT(chunk); - ++m_activatedChunks; - } - - void OnDeactivateReplicaChunk(ReplicaChunkBase* chunk) override - { - AZ_TEST_ASSERT(chunk); - ++m_deactivatedChunks; - } - - void OnSendReplicaChunkBegin(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, PeerId from, PeerId to) override - { - (void)from; - (void)to; - - AZ_TEST_ASSERT(chunk); - AZ_TEST_ASSERT(m_curReplicaSend == chunk->GetReplica()); - AZ_TEST_ASSERT(m_curReplicaChunkSend == nullptr); - AZ_TEST_ASSERT(m_curReplicaChunkIndexSend == GM_MAX_CHUNKS_PER_REPLICA); - m_curReplicaChunkSend = chunk; - m_curReplicaChunkIndexSend = chunkIndex; - } - - void OnSendReplicaChunkEnd(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, const void* data, size_t len) override - { - AZ_TEST_ASSERT(chunk); - AZ_TEST_ASSERT(m_curReplicaSend == chunk->GetReplica()); - AZ_TEST_ASSERT(m_curReplicaChunkSend == chunk); - AZ_TEST_ASSERT(m_curReplicaChunkIndexSend == chunkIndex); - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - m_numChunkBytesSent += len; - m_curReplicaChunkSend = nullptr; - m_curReplicaChunkIndexSend = GM_MAX_CHUNKS_PER_REPLICA; - - } - - void OnReceiveReplicaChunkBegin(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, PeerId from, PeerId to, const void* data, size_t len) override - { - AZ_TEST_ASSERT(chunk); - AZ_TEST_ASSERT(m_curReplicaReceive == chunk->GetReplica()); - AZ_TEST_ASSERT(m_curReplicaChunkReceive == nullptr); - AZ_TEST_ASSERT(m_curReplicaChunkIndexReceive == GM_MAX_CHUNKS_PER_REPLICA); - AZ_TEST_ASSERT(from); - AZ_TEST_ASSERT(to); - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - m_curReplicaChunkReceive = chunk; - m_curReplicaChunkIndexReceive = chunkIndex; - m_numChunkBytesReceived += len; - } - - void OnReceiveReplicaChunkEnd(ReplicaChunkBase* chunk, AZ::u32 chunkIndex) override - { - AZ_TEST_ASSERT(chunk); - AZ_TEST_ASSERT(m_curReplicaReceive == chunk->GetReplica()); - AZ_TEST_ASSERT(m_curReplicaChunkReceive == chunk); - AZ_TEST_ASSERT(m_curReplicaChunkIndexReceive == chunkIndex); - m_curReplicaChunkReceive = nullptr; - m_curReplicaChunkIndexReceive = GM_MAX_CHUNKS_PER_REPLICA; - } - - void OnSendDataSet(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, DataSetBase* dataSet, PeerId from, PeerId to, const void* data, size_t len) override - { - AZ_TEST_ASSERT(chunk); - AZ_TEST_ASSERT(m_curReplicaChunkSend == chunk); - AZ_TEST_ASSERT(m_curReplicaChunkIndexSend == chunkIndex); - AZ_TEST_ASSERT(dataSet); - AZ_TEST_ASSERT(from); - AZ_TEST_ASSERT(to); - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - - ++m_numOutgoingDatasets; - } - - void OnReceiveDataSet(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, DataSetBase* dataSet, PeerId from, PeerId to, const void* data, size_t len) override - { - AZ_TEST_ASSERT(chunk); - AZ_TEST_ASSERT(m_curReplicaChunkReceive == chunk); - AZ_TEST_ASSERT(m_curReplicaChunkIndexReceive == chunkIndex); - AZ_TEST_ASSERT(dataSet); - AZ_TEST_ASSERT(from); - AZ_TEST_ASSERT(to); - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - - ++m_numIncomingDatasets; - } - - void OnRequestRpc(ReplicaChunkBase* chunk, Internal::RpcRequest* rpc) override - { - (void)chunk; - (void)rpc; - ++m_numRpcRequests; - } - - void OnInvokeRpc(ReplicaChunkBase* chunk, Internal::RpcRequest* rpc) override - { - (void)chunk; - (void)rpc; - ++m_numRpcInvokes; - } - - void OnSendRpc(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, Internal::RpcRequest* rpc, PeerId from, PeerId to, const void* data, size_t len) override - { - AZ_TEST_ASSERT(chunk); - AZ_TEST_ASSERT(m_curReplicaChunkSend == chunk); - AZ_TEST_ASSERT(m_curReplicaChunkIndexSend == chunkIndex); - AZ_TEST_ASSERT(rpc); - AZ_TEST_ASSERT(from); - AZ_TEST_ASSERT(to); - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - m_outgoingRpcDataSize += len; - } - - void OnReceiveRpc(ReplicaChunkBase* chunk, AZ::u32 chunkIndex, Internal::RpcRequest* rpc, PeerId from, PeerId to, const void* data, size_t len) override - { - AZ_TEST_ASSERT(chunk); - AZ_TEST_ASSERT(m_curReplicaChunkReceive == chunk); - AZ_TEST_ASSERT(m_curReplicaChunkIndexReceive == chunkIndex); - AZ_TEST_ASSERT(rpc); - AZ_TEST_ASSERT(from); - AZ_TEST_ASSERT(to); - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - m_incomingRpcDataSize += len; - } - - void OnSend(PeerId to, const void* data, size_t len, bool isReliable) override - { - (void)to; // peerId might not be valid at this point, e.g. handshake (Cmd_Greetings) did not accomplish yet - (void)isReliable; - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - m_totalOutgoingBytes += len; - } - - void OnReceive(PeerId from, const void* data, size_t len) override - { - (void)from; // peerId might not be valid at this point, e.g. handshake (Cmd_Greetings) did not accomplish yet - AZ_TEST_ASSERT(data); - AZ_TEST_ASSERT(len > 0); - m_totalIncomingBytes += len; - } - }; - - int GetNumSessions() override { return nSessions; } - - void PreConnect() override - { - m_driller.BusConnect(); - - ReplicaPtr replica = Replica::CreateReplica(nullptr); - CreateAndAttachReplicaChunk(replica); - m_replicaId = m_sessions[sHost].GetReplicaMgr().AddPrimary(replica); - } - - ~ReplicaDriller() override - { - m_driller.BusDisconnect(); - } - - ReplicaDrillerHook m_driller; - ReplicaId m_replicaId; -}; - -TEST_F(ReplicaDriller, DISABLED_ReplicaDriller) -{ - RunTickLoop([this](int tick)-> TestStatus - { - switch (tick) - { - case 10: - { - auto rep = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaId); - AZ_TEST_ASSERT(rep); - AZ_TEST_ASSERT(rep->IsProxy()); - rep->RequestChangeOwnership(); - break; - } - case 30: - { - auto rep = m_sessions[s2].GetReplicaMgr().FindReplica(m_replicaId); - AZ_TEST_ASSERT(rep); - AZ_TEST_ASSERT(rep->IsPrimary()); - rep->Destroy(); - break; - } - case 40: - // replicas - AZ_TEST_ASSERT(m_driller.m_createdReplicas > 0); - AZ_TEST_ASSERT(m_driller.m_destroyedReplicas > 0); - AZ_TEST_ASSERT(m_driller.m_activatedReplicas > 0); - AZ_TEST_ASSERT(m_driller.m_deactivatedReplicas > 0); - AZ_TEST_ASSERT(m_driller.m_numReplicaBytesSent > 0); - AZ_TEST_ASSERT(m_driller.m_numReplicaBytesReceived > 0); - AZ_TEST_ASSERT(m_driller.m_numRequestChangeOwnership == 1); - AZ_TEST_ASSERT(m_driller.m_numChangedOwnership == 2); // two because one call for host & one for peer - - // chunks - AZ_TEST_ASSERT(m_driller.m_createdChunks >= m_driller.m_createdReplicas); - AZ_TEST_ASSERT(m_driller.m_destroyedChunks >= m_driller.m_destroyedReplicas); - AZ_TEST_ASSERT(m_driller.m_activatedChunks >= m_driller.m_activatedReplicas); - AZ_TEST_ASSERT(m_driller.m_deactivatedChunks >= m_driller.m_deactivatedReplicas); - AZ_TEST_ASSERT(m_driller.m_attachedChunks > 0); - AZ_TEST_ASSERT(m_driller.m_detachedChunks > 0); - AZ_TEST_ASSERT(m_driller.m_numChunkBytesReceived > 0); - - AZ_TEST_ASSERT(m_driller.m_numChunkBytesSent > 0); - AZ_TEST_ASSERT(m_driller.m_numChunkBytesReceived > 0); - - // datasets - AZ_TEST_ASSERT(m_driller.m_numOutgoingDatasets > 0); - AZ_TEST_ASSERT(m_driller.m_numIncomingDatasets > 0); - - // rpcs - AZ_TEST_ASSERT(m_driller.m_numRpcRequests > 0); - AZ_TEST_ASSERT(m_driller.m_numRpcInvokes > 0); - AZ_TEST_ASSERT(m_driller.m_outgoingRpcDataSize > 0); - AZ_TEST_ASSERT(m_driller.m_incomingRpcDataSize > 0); - - // data - AZ_TEST_ASSERT(m_driller.m_totalOutgoingBytes > 0); - AZ_TEST_ASSERT(m_driller.m_totalIncomingBytes > 0); - return TestStatus::Completed; - default: break; - } - return TestStatus::Running; - }); -} - - class DataSetChangedTest : public SimpleTest { @@ -2403,114 +1948,6 @@ TEST_F(SourcePeerTest, DISABLED_SourcePeerTest) }); } - -class SendWithPriority - : public SimpleTest -{ -public: - enum - { - sHost, - s2, - nSessions - }; - - class PriorityChunk - : public ReplicaChunk - { - public: - GM_CLASS_ALLOCATOR(PriorityChunk); - typedef AZStd::intrusive_ptr Ptr; - static const char* GetChunkName() { return "PriorityChunk"; } - - PriorityChunk() - : m_value("Value") - { - } - - bool IsReplicaMigratable() override { return false; } - - DataSet m_value; - }; - - class ReplicaDrillerHook - : public Debug::ReplicaDrillerBus::Handler - { - public: - ReplicaDrillerHook() - : m_expectedSendValue(SendWithPriority::kNumReplicas) - , m_expectedRecvValue(SendWithPriority::kNumReplicas) - { - } - - void OnReceiveReplicaEnd(Replica* replica) override - { - auto chunk = replica->FindReplicaChunk(); - if (chunk && m_expectedRecvValue > 0) - { - AZ_TEST_ASSERT(chunk->m_value.Get() == m_expectedRecvValue); // checking reverse order - --m_expectedRecvValue; - } - } - - void OnSendReplicaEnd(Replica* replica, const void* data, size_t len) override - { - (void)data; - (void)len; - - auto chunk = replica->FindReplicaChunk(); - if (chunk && m_expectedSendValue > 0) - { - AZ_TEST_ASSERT(chunk->m_value.Get() == m_expectedSendValue); // checking reverse order - --m_expectedSendValue; - } - } - - int m_expectedSendValue; - int m_expectedRecvValue; - }; - - int GetNumSessions() override { return nSessions; } - - void PreConnect() override - { - ReplicaChunkDescriptorTable::Get().RegisterChunkType(); - - m_driller.BusConnect(); - - for (unsigned i = 0; i < kNumReplicas; ++i) - { - ReplicaPtr replica = Replica::CreateReplica(nullptr); - m_chunks[i] = CreateAndAttachReplicaChunk(replica); - m_chunks[i]->m_value.Set(i + 1); // setting dataset values to 1..kNumReplicas - m_chunks[i]->SetPriority(k_replicaPriorityNormal + static_cast(i)); // the later created - the higher priorities, so should be sent in reverse order - m_sessions[sHost].GetReplicaMgr().AddPrimary(replica); - } - } - - - static const size_t kNumReplicas = 5; - - ReplicaDrillerHook m_driller; - PriorityChunk::Ptr m_chunks[kNumReplicas]; -}; - -TEST_F(SendWithPriority, DISABLED_SendWithPriority) -{ - RunTickLoop([this](int tick)-> TestStatus - { - if (tick == 20) - { - AZ_TEST_ASSERT(m_driller.m_expectedSendValue == 0); // sent all the replicas in the right order - AZ_TEST_ASSERT(m_driller.m_expectedRecvValue == 0); // received all the replicas in the right order - return TestStatus::Completed; - } - - return TestStatus::Running; - }); -} - - class SuspendUpdatesTest : public SimpleTest { @@ -2787,75 +2224,6 @@ TEST_F(BasicHostChunkDescriptorTest, DISABLED_BasicHostChunkDescriptorTest) } } -/* - * Create and immedietly destroy primary replica - * Test that it does not result in any network sync -*/ -class CreateDestroyPrimary - : public SimpleTest - , public Debug::ReplicaDrillerBus::Handler -{ -public: - enum - { - sHost, - s2, - nSessions - }; - - int GetNumSessions() override { return nSessions; } - - - // ReplicaDrillerBus - void OnReceive(PeerId from, const void* data, size_t len) override - { - (void)from; - (void)data; - (void)len; - - AZ_TEST_ASSERT(false); // should not receive any replica data - } - - void ConnectDriller() - { - Debug::ReplicaDrillerBus::Handler::BusConnect(); - } - - void DisconnectDriller() - { - Debug::ReplicaDrillerBus::Handler::BusDisconnect(); - } -}; - -TEST_F(CreateDestroyPrimary, DISABLED_CreateDestroyPrimary) -{ - RunTickLoop([this](int tick)-> TestStatus - { - switch (tick) - { - - case 10: - { - ConnectDriller(); - auto replica = Replica::CreateReplica(nullptr); - CreateAndAttachReplicaChunk(replica); - m_sessions[sHost].GetReplicaMgr().AddPrimary(replica); - - // Destroying replica right away - replica->Destroy(); - break; - } - - case 20: - DisconnectDriller(); - return TestStatus::Completed; - default: break; - } - - return TestStatus::Running; - }); -} - /* * This test checks that when the carrier ACKs a message it feeds back to the ReplicaTarget. * The ReplicaTarget will prevent sending more updates. @@ -2884,8 +2252,6 @@ public: void PreConnect() override { - m_driller.BusConnect(); - ReplicaPtr replica = Replica::CreateReplica("ReplicaACKfeedbackTest"); LargeChunkWithDefaultsMedium* chunk = CreateAndAttachReplicaChunk(replica); AZ_TEST_ASSERT(chunk); @@ -2895,12 +2261,9 @@ public: ~ReplicaACKfeedbackTestFixture() override { - m_driller.BusDisconnect(); } - size_t m_replicaBytesSentPrev = 0; ReplicaId m_replicaId; - ReplicaDriller::ReplicaDrillerHook m_driller; }; TEST_F(ReplicaACKfeedbackTestFixture, ReplicaACKfeedbackTest) @@ -2912,7 +2275,6 @@ TEST_F(ReplicaACKfeedbackTestFixture, ReplicaACKfeedbackTest) return TestStatus::Completed; } - //AZ_Printf("GridMateTests", "%d %d\n", tick, m_driller.m_numReplicaBytesSent); // Tests the Revision stamp with Carrier ACK feedback // result is true on the immediate tick after changing, but false on the next and stays false until next change auto CheckHostReplicaChanged = [this](bool result) @@ -2963,12 +2325,10 @@ TEST_F(ReplicaACKfeedbackTestFixture, ReplicaACKfeedbackTest) updateDataSets(chunk, NonDefaultValue); - m_replicaBytesSentPrev = m_driller.m_numReplicaBytesSent; CheckHostReplicaChanged(false); //Changed now, but wont know until next prepareData() }break; case 16: { - AZ_TEST_ASSERT(m_driller.m_numReplicaBytesSent - m_replicaBytesSentPrev == k_updateBytes); CheckHostReplicaChanged(true); //Detected change. ACK feedback on next tick returns to false. }break; case 20: @@ -2978,12 +2338,10 @@ TEST_F(ReplicaACKfeedbackTestFixture, ReplicaACKfeedbackTest) updateDataSets(chunk, NonDefaultValue + 1); - m_replicaBytesSentPrev = m_driller.m_numReplicaBytesSent; CheckHostReplicaChanged(false); //Changed now, but wont know until next prepareData() }break; case 21: { - AZ_TEST_ASSERT(m_driller.m_numReplicaBytesSent - m_replicaBytesSentPrev == k_updateBytes); CheckHostReplicaChanged(true); //Detected change. ACK feedback on next tick returns to false. }break; case 25: diff --git a/Code/Framework/GridMate/Tests/ReplicaSmall.cpp b/Code/Framework/GridMate/Tests/ReplicaSmall.cpp index d71789ae90..7e058d5c6f 100644 --- a/Code/Framework/GridMate/Tests/ReplicaSmall.cpp +++ b/Code/Framework/GridMate/Tests/ReplicaSmall.cpp @@ -453,7 +453,6 @@ public: // replicaHeader += 16; //#endif // const int marshalDataSize = 48; //Data plus length - //Only for Driller ReplicaManager rm; ReplicaPeer peer(&rm); diff --git a/Code/Framework/GridMate/Tests/Tests.h b/Code/Framework/GridMate/Tests/Tests.h index 099c94f284..f3583c22eb 100644 --- a/Code/Framework/GridMate/Tests/Tests.h +++ b/Code/Framework/GridMate/Tests/Tests.h @@ -18,8 +18,6 @@ #include #include -#include - #include #include @@ -42,9 +40,6 @@ namespace UnitTest { protected: GridMate::IGridMate* m_gridMate; - AZ::Debug::DrillerSession* m_drillerSession; - AZ::Debug::DrillerOutputFileStream* m_drillerStream; - AZ::Debug::DrillerManager* m_drillerManager; private: using Platform = GridMateTestFixture_Platform; @@ -52,9 +47,6 @@ namespace UnitTest public: GridMateTestFixture([[maybe_unused]] unsigned int memorySize = 100 * 1024 * 1024) : m_gridMate(nullptr) - , m_drillerSession(nullptr) - , m_drillerStream(nullptr) - , m_drillerManager(nullptr) { GridMate::GridMateDesc desc; AZ::AllocatorInstance::Create(); @@ -63,8 +55,7 @@ namespace UnitTest m_gridMate = GridMateCreate(desc); AZ_TEST_ASSERT(m_gridMate != NULL); - m_drillerSession = NULL; - + AZ::AllocatorManager::Instance().EnterProfilingMode(); AZ::Debug::AllocationRecords* records = AZ::AllocatorInstance::GetAllocator().GetRecords(); if (records) { @@ -85,13 +76,7 @@ namespace UnitTest } AZ::AllocatorInstance::Destroy(); - - if (m_drillerManager) - { - AZ::Debug::DrillerManager::Destroy(m_drillerManager); - AZ::AllocatorManager::Instance().ExitProfilingMode(); - m_drillerManager = nullptr; - } + AZ::AllocatorManager::Instance().ExitProfilingMode(); } void Update()