queryqueue.h

Go to the documentation of this file.

/*
* Copyright 2015 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.
*/

// primary contact: JAPA - secondary contact: GUAL
#ifndef Navigation_QueryQueue_H
#define Navigation_QueryQueue_H

#include "gwnavruntime/containers/circulararray.h"
#include "gwnavruntime/base/memory.h"
#include "gwnavruntime/querysystem/workingmemory.h"
#include "gwnavruntime/kernel/SF_String.h"
#include "gwnavruntime/kernel/SF_RefCount.h"
#include "gwnavruntime/world/floatstat.h"
#include "gwnavruntime/world/worldelement.h"


namespace Kaim
{

class VisualDebugServer;
class World;
class Database;
class IQuery;

class QueryQueueStats
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_QuerySystem)
public:
    QueryQueueStats()
        : m_msSpentInProcessStat("Spent in Process (ms)")
        , m_nbQueriesPopped(0)
    {}

    FloatStat m_msSpentInProcessStat; // ms spent in Process(), in the last frame
    KyUInt32  m_nbQueriesPopped;  // nb queries done or cancelled in the last frame
};

class QueryQueueConfig
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_QuerySystem)
public:
    QueryQueueConfig() :
        m_budgetInMilliseconds(1.0f),
        m_workingMemoryMaxSize(4 * 1024 * 1024), // 4MB
        m_workingMemoryReallocSize(5 * 1024) // 5KB
    {}

    String m_name;
    KyFloat32 m_budgetInMilliseconds;    
    KyUInt32 m_workingMemoryMaxSize;     
    KyUInt32 m_workingMemoryReallocSize; 
};

class QueryQueueCommand
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_QuerySystem)
public:
    enum Type { Push = 0, Cancel };
    QueryQueueCommand(Type type, IQuery* query) : m_type(type), m_query(query) {}
    Type m_type;
    Ptr<IQuery> m_query;
};


class QueryQueue : public RefCountBase<QueryQueue, MemStat_QuerySystem>
{
    KY_CLASS_WITHOUT_COPY(QueryQueue)

public:
    QueryQueue();
    virtual ~QueryQueue();

    void Init(const QueryQueueConfig& config);

    void PushBack(IQuery* query); 

    void Cancel(IQuery* query);

    void Process();

    void FlushCommands();

    void FlushQueries();

    void SetBudgetMs(KyFloat32 budgetMs);
    KyFloat32 GetBudgetMs() const;

    void SetWorkingMemoryMaxSizeInBytes(KyUInt32 sizeInBytes);
    KyUInt32 GetWorkingMemoryMaxSizeInBytes() const;
    KyUInt32 GetWorkingMemoryCurrentSize() const;

    // Get pending Commands
    KyUInt32 GetCommandCount() const;
    QueryQueueCommand& GetCommand(KyUInt32 index);
    const QueryQueueCommand& GetCommand(KyUInt32 index) const;
    
    // Get pending Queries
    KyUInt32 GetQueryCount() const;
    IQuery* GetQuery(KyUInt32 index) const;

    KyUInt32 GetPendingOperationCount() const; 

    const QueryQueueStats& GetStats() const; 

    const String& GetName() const { return m_name; }

    // Call only in WorldUpdate()
    void Clear();
    void CancelAllQueriesAndClearCommands(); // O(GetCount())

    void DoSendVisualDebug(VisualDebugServer& visualDebugServer, VisualDebugSendChangeEvent changeEvent, KyUInt32 queueIndex, KyUInt32 elementId, KyUInt32 queueArrayProcessMode);

protected:
    void ClearCommandForThisQuery(IQuery* query);  // O(GetCommandCount())
    void CancelQuery(IQuery* query);               // O(GetQueryCount())
    void YieldProcess(KyFloat64 msSpent);
    IQuery* FindFirstNonNullQuery();
    IQuery* FindNextNonNullQuery();

protected:
    CircularArray<QueryQueueCommand, MemStat_QuerySystem> m_commands; 
    CircularArray<Ptr<IQuery>, MemStat_QuerySystem > m_queries;       
    KyUInt32 m_firstQueryToProcessIndex;                              
    WorkingMemory m_workingMemory;                                    
    KyFloat32 m_msProcessBudget;                                      
    KyFloat32 m_msSpentInProcess;                                     
    QueryQueueStats m_stats;                                          
    String m_name;                                                    
};


KY_INLINE QueryQueue::QueryQueue()
    : m_firstQueryToProcessIndex(0)
    , m_msProcessBudget(1.0f)
    , m_msSpentInProcess(0.0f)
{}

KY_INLINE QueryQueue::~QueryQueue() { Clear(); }

KY_INLINE void                     QueryQueue::SetBudgetMs(KyFloat32 budgetMs)  { m_msProcessBudget = budgetMs;               }
KY_INLINE void                     QueryQueue::YieldProcess(KyFloat64 msSpent)  { m_msSpentInProcess += (KyFloat32)msSpent;   }
KY_INLINE KyFloat32                QueryQueue::GetBudgetMs()              const { return m_msProcessBudget;                   }
KY_INLINE const QueryQueueStats&   QueryQueue::GetStats()                 const { return m_stats;                             }
KY_INLINE KyUInt32                 QueryQueue::GetCommandCount()          const { return m_commands.GetCount();               }
KY_INLINE QueryQueueCommand&       QueryQueue::GetCommand(KyUInt32 index)       { return m_commands[index];                   }
KY_INLINE const QueryQueueCommand& QueryQueue::GetCommand(KyUInt32 index) const { return m_commands[index];                   }
KY_INLINE KyUInt32                 QueryQueue::GetQueryCount()            const { return m_queries.GetCount();                }
KY_INLINE IQuery*                  QueryQueue::GetQuery(KyUInt32 index)   const { return m_queries[index];                    }
KY_INLINE KyUInt32                 QueryQueue::GetPendingOperationCount() const { return GetQueryCount() + GetCommandCount(); }

} // namespace Kaim

#endif // Navigation_QueryQueue_H