visualdebugserver.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/


#pragma once

#include "gwnavruntime/kernel/SF_Threads.h"
#include "gwnavruntime/kernel/SF_Types.h"
#include "gwnavruntime/kernel/SF_String.h"
#include "gwnavruntime/kernel/SF_Log.h"
#include "gwnavruntime/blob/baseblobbuilder.h"
#include "gwnavruntime/visualdebug/messagereceiverregistry.h"
#include "gwnavruntime/base/memory.h"
#include "gwnavruntime/visualdebug/visualdebugattributes.h"
#include "gwnavruntime/visualdebug/visualdebugblobcategory.h"
#include "gwnavruntime/visualdebug/visualdebugunknownblobtypehandling.h"
#include "gwnavruntime/visualsystem/idisplaylistbuilder.h"


namespace Kaim
{

class FileOpenerBase;
class File;

class ServerStatusChangedCallback;
class MessageBlob;
class MessageAggregatedBlob;
class MessageBlobHandler;
class BlobFieldsStore;

class Profiler;
class FloatStat;
class IQuery;

class Vec3f;

class VisualDebugAttributesManager;

class VisualDebugServerConfig
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_WorldFwk)
public:
    static KyUInt32 DefaultServerPort() { return 4888; }
    static KyUInt32 DefaultBroadcastPort() { return 4887; }

public:
    enum Mode {
        Mode_UseNavigationLab, 
        Mode_UseLocalFile      
    };

    enum WaitOnStart {
        DoNotWaitOnStart, 
        DoWaitOnStart     
    };

    enum DisconnectionMode {
        UseSocketErrors, 
        UseHeartbeat     
    };

    enum RunMode {
        RunSynchronously, 
        RunAsynchronously 
    };

public:
    VisualDebugServerConfig()
        : m_mode(Mode_UseNavigationLab)
        , m_serverPort(0)
        , m_broadcastPort(0)
        , m_waitOnStart(DoNotWaitOnStart)
        , m_navigationLabCommandHandlers(nullptr)
        , m_localFileName(nullptr)
        , m_localFileOpener(nullptr)
        , m_localFileMegaBytesLimit(100)
        , m_maximumMegaBytes(1)
        , m_expectedKiloBytesPerFrame(256)
        , m_disconnectionMode(UseSocketErrors)
        , m_runMode(RunSynchronously)
    {}

    void UseNavigationLab(KyUInt32 serverPort = DefaultServerPort(), KyUInt32 broadcastPort = DefaultBroadcastPort(), MessageReceiverRegistry* navigationLabCommandHandlers = nullptr)
    {
        m_mode                         = Mode_UseNavigationLab;
        m_navigationLabCommandHandlers = navigationLabCommandHandlers;
        m_serverPort                   = serverPort;
        m_broadcastPort                = broadcastPort;
        m_localFileName                = nullptr;
        m_localFileOpener              = nullptr;
    }

    void UseLocalFile(const char* localFileName, FileOpenerBase* localFileOpener = nullptr)
    {
        m_mode                         = Mode_UseLocalFile;
        m_navigationLabCommandHandlers = nullptr;
        m_serverPort                   = 0;
        m_localFileName                = localFileName;
        m_localFileOpener              = localFileOpener;
    }

    void SetLocalFileSizeLimit(KyInt32 localFileMegaBytesLimit) { m_localFileMegaBytesLimit = localFileMegaBytesLimit; }

    void SetWaitOnStart(WaitOnStart waitOnStart) { m_waitOnStart = waitOnStart; }

    void SetMemoryConsumption(KyUInt32 expectedKiloBytesPerFrame, KyUInt32 maximumMegaBytesToUse)
    {
        m_expectedKiloBytesPerFrame = expectedKiloBytesPerFrame;
        m_maximumMegaBytes = maximumMegaBytesToUse;
    }

    void SetDisconnectionMode(DisconnectionMode disconnectionMode) { m_disconnectionMode = disconnectionMode; }

    void SetRunMode(RunMode runMode) { m_runMode = runMode; }

    void SetServerName(const char* serverName) { m_serverName = String(serverName); }

public: // internal
    Mode m_mode;

    // ------------- Relevant attributes if #m_mode = Mode_UseNavigationLab. -----------

    KyUInt32 m_serverPort;

    KyUInt32 m_broadcastPort;

    WaitOnStart m_waitOnStart;

    MessageReceiverRegistry* m_navigationLabCommandHandlers;

    // ------------- Relevant attributes if #m_mode = Mode_UseLocalFile. -----------

    const char* m_localFileName;

    FileOpenerBase* m_localFileOpener;

    KyInt32 m_localFileMegaBytesLimit;

    // ------------- Memory allocations of messages -----------

    KyUInt32 m_maximumMegaBytes;
    KyUInt32 m_expectedKiloBytesPerFrame;

    // ------------- Various attributes -----------

    DisconnectionMode m_disconnectionMode;

    RunMode m_runMode;

    String m_serverName;
};

}

// Define KY_DISABLE_VISUALDEBUGSERVER to disable VisualDebugServer
// In that case, it will be replaced by fully inlined classe, DisabledVisualDebugServer,
// thanks to the define at the end of this file.
// If VisualDebugServer is modified, please apply the changes into disabledvisualdebugserver.inl as well.
#if defined(KY_CONFIG_RELEASE) || !defined(KY_ENABLE_SOCKETS)
# define KY_DISABLE_VISUALDEBUGSERVER
#endif

#ifndef KY_DISABLE_VISUALDEBUGSERVER

#include "gwnavruntime/visualdebug/amp/Amp_ThreadMgr.h"
#include "gwnavruntime/visualdebug/internal/socketdispatcher.h"
#include "gwnavruntime/visualdebug/internal/visualdebugstat.h"
#include "gwnavruntime/blob/blobfieldarray.h"
#include "gwnavruntime/blob/blobhandler.h"


namespace Kaim
{

class VisualDebugServer
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_VisualDebug)

public:
    // --------------- Server Status ----------------

    void NewFrame(KyUInt32 gameFrameIndex = KyUInt32MAXVAL);

    bool IsStarted() const { return m_isStarted; }

    bool IsReadyToSend() { return m_isReadyToSend && IsConnectionEstablished(); }

    // ------------------ Send Statistics ------------------

    void SendStats(const char* statName, const KyFloat32 value, const KyFloat32 average, const KyFloat32 max, const KyFloat32 min, const char* groupName);
    void SendStats(const FloatStat& timeStat, const char* groupName);
    void SendStats(const char* statName, const FloatStat& timeStat, const char* groupName);

    // ------------------ Send Single Value ------------------

    void SendUInt32(const char* statName, const KyUInt32 value, const char* groupName);
    void SendInt32(const char* statName, const KyInt32 value, const char* groupName);
    void SendFloat32(const char* statName, const KyFloat32 value, const char* groupName);
    void SendString(const char* statName, const char* value, const char* groupName);

    // --------------- Send Game-Specific info ---------------

    void SendGameCamera(const Vec3f& cameraPos, const Vec3f& cameraLookAtPos, const Vec3f& cameraUp, KyFloat32 fovInDegrees);
    void SendGameCameraAttitude(const Vec3f& cameraPos, const Vec3f& cameraRight, const Vec3f& cameraUp, const Vec3f& cameraFront, KyFloat32 fovInDegrees);

    // --------------- Advanced usage : Handling Received Blob Messages ----------------

    void PauseMessageProcessing()  { m_messageProcessingIsPaused = true;  }
    void ResumeMessageProcessing() { m_messageProcessingIsPaused = false; }

private:
    KyResult OpenNavigationLabConnection();
    KyResult OpenFileConnection();

    KyResult AggregateMessage(Ptr<BaseBlobHandler> handlerPtr);
    KyResult CreateAggregateMessage(KyUInt32 deepBlobSize);
    KyResult SendAggregateMessage();

    KyResult SetupMessageRegistry(MessageReceiverRegistry* receiverRegistry, VisualDebugUnknownBlobTypeHandling unknownBlobTypeHandling = VisualDebugUnknownBlobTypeHandling::Log);
    KyResult OpenConnection(SocketDispatchMode mode, KyUInt32 port, KyUInt32 broadcastPort, bool initSocketConnection);

    void AddToStats(KyUInt32 blobtypeId, KyUInt32 deepBlobSize);
    void ClearStatistics();
    void SendInternalStatistics();

    void SendStatGroups();
    VisualDebugStatGroup* GetStatGroup(const char* groupName);
    VisualDebugStatGroup* GetOrCreateStatGroup(const char* groupName);

    void ClearSession(); // clear stats, message, timer, gameFrameIndex
    void OnDisconnection(); // called in VisualDebugServer's operatingThread to clear the session if OnDisconnectionUnsafeCallback() was called from the socketThread
    void MakeReadyToSend(); // set m_isConnected to true and apply what has to be done in VisualDebugServer's operatingThread on connection

    KyResult OnConnectionUnsafeCallback();    // called from the socketThread when connection is established
    KyResult OnDisconnectionUnsafeCallback(); // called from the socketThread when disconnected

    void UpdateThreadMgr(bool& out_needToWait);

    // Checks if there is enough memory before creating a new message
    void CheckMemory();

    void InitAttributesManager();
    void CreateProfilingAttributes();
    void CreateAdvancedProfilingAttributes();
    void UpdateProfilingAttributes();
    void UpdateAdvancedProfilingAttributes();

    // Used internally. true for NavigationLab, false for LocalFile.
    void EnableSynchronization(bool enabled) { m_synchronizationEnabled = enabled; }

    // \return true if synchronization is done
    bool Synchronize();

public: // internal

    // --------------- For internal use only ----------------

    VisualDebugServer();
    ~VisualDebugServer();

    KyResult Start(const VisualDebugServerConfig& config);
    KyResult ReStart() { return Start(m_config); }
    void Stop();

    static KyUInt32 GetInfiniteWaitDelay() { return KY_WAIT_INFINITE; }

    bool WaitWhileEstablishingConnection(KyUInt32 maxDelayMilliseconds);

    void Flush();

    void SetSimulationTime(KyFloat32 simulationTimeInSeconds) { m_simulationTimeInSeconds = simulationTimeInSeconds; }

    template <class T>
    KyResult Send(BaseBlobBuilder<T>& blobBuilder)
    {
        const KyUInt32 blobType = T::GetBlobTypeId();
        Ptr<BaseBlobHandler> blobHandler = m_handlerRegistry.Get(blobType);
        if (blobHandler == nullptr)
        {
            blobHandler = *KY_NEW BlobHandler<T>;
            m_handlerRegistry.SetVal(blobType, blobHandler);
        }

        blobBuilder.Build((BlobHandler<T>&)*blobHandler);
        return this->AggregateMessage(blobHandler);
    }

    KyResult Send(BaseBlobHandler& blobHandler);

    // Send a IQuery if the inheriting query supports it
    // _NOTE_: Currently, only used in order to send back the result of a query requested by the NavigationLab.
    KyResult Send(IQuery* query);

    // SendLog
    KyResult SendLog(Kaim::LogMessageId messageId, const char* message);

    KyResult HandleAllReceivedMessages();

    KyResult HandleNextReceivedMessage();

    Ptr<Net::AMP::Message> GetNextReceivedMessage();

    KyResult HandleMessage(Ptr<Net::AMP::Message> msg);

    void SetAdvancedInternalStatistics(bool enable) { m_enableAdvancedInternalStatistics = enable; }

    void SetThreadId(ThreadId threadId) { m_operatingThreadId = threadId; }

    ThreadId GetThreadId() const  { return m_operatingThreadId; }

    bool CanSafelyOperate() const { return (m_operatingThreadId == GetCurrentThreadId()); }

    bool IsConnectionEstablished() const;

    bool IsSynchronizing() { return (m_isReadyToSend == false && IsConnectionEstablished() == true); }

    // Wait until all messages are sent (or if connection is lost or ended client-side).
    void WaitForEmptiedSendQueue();

    // Called when the EndOfSynchronizationBlob Message is received from the NavigationLab
    void EndOfSynchronizationMessageReceived() { m_endOfSynchronizationMessageReceived = true; }

    Net::AMP::ThreadMgr* GetThreadMgr()             { return m_socketThreadMgr.GetPtr(); } 
    const Net::AMP::ThreadMgr* GetThreadMgr() const { return m_socketThreadMgr.GetPtr(); } 

    MemoryHeap* GetHeap() { return Memory::GetHeapByAddress(m_socketThreadMgr.GetPtr()); }

    // return a pointer because it allows DisabledVisualDebugServer::GetConfig() to return nullptr
    const VisualDebugServerConfig* GetConfig() const { return &m_config; }

    UserBlobRegistry<IDisplayListBuilder>* GetDisplayListBuilderRegistry() { return m_displayListBuilderRegistry; }

public: // Deprecated
    KY_DEPRECATED(bool IsConnected()) { return IsReadyToSend(); }

private:
    // Config
    VisualDebugServerConfig m_config; // The config passed to Start()
    KyUInt32  m_defaultGameFrameIndex; // The current frame index
    KyFloat32 m_simulationTimeInSeconds;
    Profiler* m_gameFrameTimeProfiler;
    bool m_synchronizationEnabled;

    // Status
    bool m_isStarted;  // Set to true between calls to Start and Stop
    bool m_isConnectionEstablished;
    bool m_endOfSynchronizationMessageReceived; // Set to true when EndOfSynchronization is received y the client, not though m_isConnected is not yet set to true, NewFrame needs to be called.
    bool m_isReadyToSend;
    bool m_wasDisconnected; // Used to cancel previous m_aggregatedBlobMsg
    ThreadId m_operatingThreadId; // ThreadId of the thread that Send functions and Update are supposed to be called from

    // Socket/Thread management
    Ptr<Net::AMP::ThreadMgr> m_socketThreadMgr;
    Ptr<Net::AMP::DiscardMessageHandler> m_msgDiscarder; // used to discard messages we are not interested in
    Ptr<MessageBlobHandler> m_msgBlobHandler;            // used to handle received MessageBlob
    SocketDispatcherFactory* m_socketFactory;            // in charge of creating the socket depending on VisualDebugServerConfig::Mode
    Ptr<File> m_file;                                    // used when mode is Mode_UseLocalFile

    friend class ServerStatusChangedCallback;
    Ptr<ServerStatusChangedCallback> m_statusCallback; // Callback for connection status change
    Event m_connectedEvent;

    // Message construction
    typedef UserPtrBlobRegistry<BaseBlobHandler> BlobHandlerRegistry;
    BlobHandlerRegistry m_handlerRegistry;
    MessageAggregatedBlob* m_aggregatedBlobMsg;

    // Message reception
    List<Net::AMP::Message> m_msgList;
    Kaim::UInt32 m_msgListSize;

    // Stats
    KyUInt32 m_messagesNotSentOnWait;
    KyUInt32 m_memoryLimitReached; // Records if the memory limit was reached during this frame
    KyFloat32 m_totalFlushTimeMs; // Time spend waiting for the Send queue to be emptied (either in NewFrame or in Flush, or even in CheckMemory)

    KyUInt32 m_sentBlobCountInFrame;
    KyUInt32 m_sentBlobSizeInFrame;
    KyUInt32 m_sentMessageCountInFrame;
    KyUInt32 m_receivedMessageCountInFrame;

    UserBlobRegistry<SentBlobTypeStats> m_sentBlobTypeStatsRegistry;

    KyArray<VisualDebugStatGroup> m_statGroups;
    bool m_enableAdvancedInternalStatistics;

    VisualDebugAttributesManager* m_visualDebugAttributesManager;
    VisualDebugAttributeGroup* m_profilingVisualDebug;
    VisualDebugAttributeGroup* m_advancedProfilingVisualDebug;

    bool m_messageProcessingIsPaused;

    // displayListBuilderRegistry, to verify that QueryBlobs have a DisplayListBuilder before sending them to the NavLab
    Ptr<UserBlobRegistry<IDisplayListBuilder> > m_displayListBuilderRegistry;
};

} // namespace Kaim

#else
// Here we use a separated file in order to easily maintain both versions by comparing the two files (visualdebugserver.h and disabledvisualdebugserver.inl)
# include "gwnavruntime/visualdebug/disabledvisualdebugserver.inl"

// This allows to forward declare VisualDebugServer
// and to use DisabledVisualDebugServer separately in unit tests
namespace Kaim
{

class VisualDebugServer : public DisabledVisualDebugServer
{
};

}
#endif