backups/LCEMP
1
0
Fork 0
mirror of https://github.com/LCEMP/LCEMP.git synced 2026-04-23 15:33:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
LCEMP/Minecraft.Client/Platform_Libs/Dev/Render/microprofile/microprofile.cpp

16191 lines
469 KiB
C++
Raw Permalink Blame History

#include "../Profiler.h"
#ifdef ENABLE_PROFILING
#define MICROPROFILE_IMPL
#include "microprofile.h"
#if MICROPROFILE_ENABLED
#define BREAK_SKIP() __builtin_trap()
#ifdef _WIN32
#if !defined(WIN32_LEAN_AND_MEAN)
#define WIN32_LEAN_AND_MEAN
#endif
#include <malloc.h>
#endif
#ifdef _WIN32
#define MICROPROFILE_MAX_PATH MAX_PATH
#else
#define MICROPROFILE_MAX_PATH 1024
#endif
#include <atomic>
#include <ctype.h>
#include <mutex>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <thread>
#if defined(MICROPROFILE_SYSTEM_STB)
#include <stb_sprintf.h>
#else
#define STB_SPRINTF_IMPLEMENTATION
#include "stb/stb_sprintf.h"
#endif
#if defined(_WIN32) && _MSC_VER == 1700
#define PRIx64 "llx"
#define PRIu64 "llu"
#define PRId64 "lld"
#else
#include <inttypes.h>
#endif
#define MICROPROFILE_MAX_COUNTERS 512
#define MICROPROFILE_MAX_COUNTER_NAME_CHARS (MICROPROFILE_MAX_COUNTERS * 16)
#define MICROPROFILE_MAX_GROUP_INTS (MICROPROFILE_MAX_GROUPS / 32)
#define MICROPROFILE_MAX_CATEGORIES 16
#define MICROPROFILE_MAX_GRAPHS 5
#define MICROPROFILE_GRAPH_HISTORY 128
#define MICROPROFILE_BUFFER_SIZE ((MICROPROFILE_PER_THREAD_BUFFER_SIZE) / sizeof(MicroProfileLogEntry))
#define MICROPROFILE_GPU_BUFFER_SIZE ((MICROPROFILE_PER_THREAD_GPU_BUFFER_SIZE) / sizeof(MicroProfileLogEntry))
#define MICROPROFILE_MAX_CONTEXT_SWITCH_THREADS 256
#define MICROPROFILE_WEBSOCKET_BUFFER_SIZE (64 << 10)
#define MICROPROFILE_INVALID_TICK ((uint64_t) - 1)
#define MICROPROFILE_DROPPED_TICK ((uint64_t) - 2)
#define MICROPROFILE_INVALID_FRAME ((uint32_t) - 1)
#define MICROPROFILE_GROUP_MASK_ALL 0xffffffff
#define MICROPROFILE_MAX_PATCH_ERRORS 32
#define MICROPROFILE_MAX_MODULE_EXEC_REGIONS 16
#define MP_LOG_TICK_MASK 0x0000ffffffffffff
#define MP_LOG_INDEX_MASK 0x3fff000000000000
#define MP_LOG_BEGIN_MASK 0xc000000000000000
#define MP_LOG_CSTR_MASK 0xe000000000000000
#define MP_LOG_CSTR_BIT 0x2000000000000000
#define MP_LOG_PAYLOAD_PTR_MASK (~(MP_LOG_BEGIN_MASK | MP_LOG_CSTR_BIT))
#define MP_LOG_ENTER_LEAVE_MASK 0x8000000000000000
#define MP_LOG_LEAVE 0x0
#define MP_LOG_ENTER 0x1
#define MP_LOG_EXTENDED 0x2
#define MP_LOG_EXTENDED_NO_DATA 0x3
#ifndef MICROPROFILE_SETTINGS_FILE
#define MICROPROFILE_SETTINGS_FILE "mppresets.cfg"
#endif
#ifndef MICROPROFILE_SETTINGS_FILE_BUILTIN
#define MICROPROFILE_SETTINGS_FILE_BUILTIN "mppresets.builtin.cfg"
#endif
#ifndef MICROPROFILE_SETTINGS_FILE_TEMP
#define MICROPROFILE_SETTINGS_FILE_TEMP ".tmp"
#endif
// #define MP_LOG_EXTRA_DATA 0x3
static_assert(0 == (MICROPROFILE_MAX_GROUPS % 32), "MICROPROFILE_MAX_GROUPS must be divisible by 32");
enum EMicroProfileTokenExtended
{
ETOKEN_GPU_CPU_TIMESTAMP = 0x3fff,
ETOKEN_GPU_CPU_SOURCE_THREAD = 0x3ffe,
ETOKEN_META_MARKER = 0x3ffd,
ETOKEN_CUSTOM_NAME = 0x3ffc,
ETOKEN_CUSTOM_COLOR = 0x3ffb,
ETOKEN_CUSTOM_ID = 0x3ffa,
ETOKEN_CSTR_PTR = 0x2000, // note, matches MP_LOG_CSTR_BIT
ETOKEN_MAX = 0x2000,
};
enum
{
MICROPROFILE_WEBSOCKET_DIRTY_MENU,
MICROPROFILE_WEBSOCKET_DIRTY_ENABLED,
};
#ifndef MICROPROFILE_ALLOC // redefine all if overriding
#define MICROPROFILE_ALLOC(nSize, nAlign) MicroProfileAllocAligned(nSize, nAlign);
#define MICROPROFILE_REALLOC(p, s) realloc(p, s)
#define MICROPROFILE_FREE(p) MicroProfileFreeAligned(p)
#define MICROPROFILE_FREE_NON_ALIGNED(p) free(p)
#endif
#define MP_ALLOC(nSize, nAlign) MicroProfileAllocInternal(nSize, nAlign)
#define MP_REALLOC(p, s) MicroProfileReallocInternal(p, s)
#define MP_FREE(p) MicroProfileFreeInternal(p)
#define MP_ALLOC_OBJECT(T) (T*)MP_ALLOC(sizeof(T), alignof(T))
#define MP_ALLOC_OBJECT_ARRAY(T, Count) (T*)MP_ALLOC(sizeof(T) * Count, alignof(T))
#ifndef MICROPROFILE_DEBUG
#define MICROPROFILE_DEBUG 0
#endif
typedef uint64_t MicroProfileLogEntry;
void MicroProfileSleep(uint32_t nMs);
template <typename T>
T MicroProfileMin(T a, T b);
template <typename T>
T MicroProfileMax(T a, T b);
template <typename T>
T MicroProfileClamp(T a, T min_, T max_);
int64_t MicroProfileMsToTick(float fMs, int64_t nTicksPerSecond);
float MicroProfileTickToMsMultiplier(int64_t nTicksPerSecond);
uint32_t MicroProfileLogGetType(MicroProfileLogEntry Index);
uint64_t MicroProfileLogGetTimerIndex(MicroProfileLogEntry Index);
MicroProfileLogEntry MicroProfileMakeLogIndex(uint64_t nBegin, MicroProfileToken nToken, int64_t nTick);
int64_t MicroProfileLogTickDifference(MicroProfileLogEntry Start, MicroProfileLogEntry End);
int64_t MicroProfileLogSetTick(MicroProfileLogEntry e, int64_t nTick);
uint16_t MicroProfileGetTimerIndex(MicroProfileToken t);
uint32_t MicroProfileGetGroupMask(MicroProfileToken t);
MicroProfileToken MicroProfileMakeToken(uint64_t nGroupMask, uint32_t nGroupIndex, uint16_t nTimer);
bool MicroProfileAnyGroupActive();
void MicroProfileWriteFile(void* Handle, size_t nSize, const char* pData);
// defer implementation
#define CONCAT_INTERNAL(x, y) x##y
#define CONCAT(x, y) CONCAT_INTERNAL(x, y)
void IntentionallyNotDefinedFunction__(); // DO NOT DEFINE THIS
template <typename T>
struct MicroProfileExitScope
{
T lambda;
MicroProfileExitScope(T lambda)
: lambda(lambda)
{
}
~MicroProfileExitScope()
{
lambda();
}
MicroProfileExitScope(const MicroProfileExitScope& rhs)
: lambda(rhs.lambda)
{
IntentionallyNotDefinedFunction__(); // this is here to ensure the compiler does not create duplicate copies
}
private:
MicroProfileExitScope& operator=(const MicroProfileExitScope&);
};
class MicroProfileExitScopeHelp
{
public:
template <typename T>
MicroProfileExitScope<T> operator+(T t)
{
return t;
}
};
#define defer const auto& CONCAT(defer__, __LINE__) = MicroProfileExitScopeHelp() + [&]()
//////////////////////////////////////////////////////////////////////////
// platform IMPL
void* MicroProfileAllocInternal(size_t nSize, size_t nAlign);
void MicroProfileFreeInternal(void* pPtr);
void* MicroProfileReallocInternal(void* pPtr, size_t nSize);
void* MicroProfileAllocAligned(size_t nSize, size_t nAlign);
void MicroProfileFreeAligned(void* pMem);
#if defined(__APPLE__)
#include <TargetConditionals.h>
#include <float.h>
#include <libkern/OSAtomic.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <unistd.h>
#if TARGET_OS_IPHONE
#define MICROPROFILE_IOS
#endif
#define MP_TICK() mach_absolute_time()
inline int64_t MicroProfileTicksPerSecondCpu_()
{
static int64_t nTicksPerSecond = 0;
if(nTicksPerSecond == 0)
{
mach_timebase_info_data_t sTimebaseInfo;
mach_timebase_info(&sTimebaseInfo);
nTicksPerSecond = 1000000000ll * sTimebaseInfo.denom / sTimebaseInfo.numer;
}
return nTicksPerSecond;
}
int64_t MicroProfileTicksPerSecondCpu()
{
return MicroProfileTicksPerSecondCpu_();
}
#define MicroProfileTicksPerSecondCpu MicroProfileTicksPerSecondCpu_
inline uint64_t MicroProfileGetCurrentThreadId()
{
uint64_t tid;
pthread_threadid_np(pthread_self(), &tid);
return tid;
}
#include <stdlib.h>
#define MP_BREAK() __builtin_trap()
#define MP_THREAD_LOCAL __thread
#define MP_STRCASECMP strcasecmp
#define MP_GETCURRENTTHREADID() MicroProfileGetCurrentThreadId()
#define MP_STRCASESTR strcasestr
#define MP_THREAD_LOCAL __thread
#define MP_NOINLINE __attribute__((noinline))
void* MicroProfileAllocAligned(size_t nSize, size_t nAlign)
{
void* p;
int result = posix_memalign(&p, nAlign, nSize);
if(result != 0)
{
return nullptr;
}
return p;
}
void MicroProfileFreeAligned(void* pMem)
{
free(pMem);
}
#elif defined(_WIN32)
#include <Shlwapi.h>
#include <winsock2.h>
#include <ws2tcpip.h>
int64_t MicroProfileGetTick();
#define MP_TICK() MicroProfileGetTick()
#define MP_BREAK() __debugbreak()
#define MP_THREAD_LOCAL __declspec(thread)
#define MP_STRCASECMP _stricmp
#define MP_GETCURRENTTHREADID() GetCurrentThreadId()
#define MP_STRCASESTR StrStrI
#define MP_THREAD_LOCAL __declspec(thread)
#define MP_NOINLINE __declspec(noinline)
#ifndef MICROPROFILE_WIN32_TRAP_ALLOCATOR
#define MICROPROFILE_WIN32_TRAP_ALLOCATOR 0
#endif
#if MICROPROFILE_WIN32_TRAP_ALLOCATOR
// minimal trap allocator
#define PAGE_SIZE (4096)
void* MicroProfileAllocAligned(size_t nSize, size_t nAlign)
{
(void)nAlign;
size_t nAlignedSize = (nSize + PAGE_SIZE - 1) & (~(PAGE_SIZE - 1));
size_t nDelta = nAlignedSize - nSize;
size_t nFullSize = nAlignedSize + 2 * PAGE_SIZE;
void* ptr = VirtualAlloc(0, nFullSize, MEM_RESERVE, PAGE_READWRITE);
intptr_t intptr = (intptr_t)ptr;
void* pResult = VirtualAlloc((void*)(intptr + PAGE_SIZE), nAlignedSize, MEM_COMMIT, PAGE_READWRITE);
memset(pResult, 0xf0, nAlignedSize);
intptr_t page = (intptr_t)pResult;
//((char*)page)[-1] = 0x70; //trap test
page += nDelta;
pResult = (void*)page;
memset(pResult, 0xfe, nSize);
//((char*)page)[nSize] = 0x70; //trap test
return (void*)page;
}
void MicroProfileFreeAligned(void* pMem)
{
intptr_t intptr = (intptr_t)pMem;
intptr = (intptr & (~(PAGE_SIZE - 1))) - PAGE_SIZE;
VirtualFree(pMem, 0, MEM_RELEASE);
}
#else
void* MicroProfileAllocAligned(size_t nSize, size_t nAlign)
{
return _aligned_malloc(nSize, nAlign);
}
void MicroProfileFreeAligned(void* pMem)
{
_aligned_free(pMem);
}
#endif
#else
#ifndef MICROPROFILE_CUSTOM_PLATFORM
#include <float.h>
#include <malloc.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
inline int64_t MicroProfileTicksPerSecondCpu_()
{
return 1000000000ll;
}
int64_t MicroProfileTicksPerSecondCpu()
{
return MicroProfileTicksPerSecondCpu_();
}
#define MicroProfileTicksPerSecondCpu MicroProfileTicksPerSecondCpu_
inline int64_t MicroProfileGetTick()
{
timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
return 1000000000ll * ts.tv_sec + ts.tv_nsec;
}
#define MP_TICK() MicroProfileGetTick()
#define MP_BREAK() __builtin_trap()
#define MP_THREAD_LOCAL __thread
#define MP_STRCASECMP strcasecmp
#define MP_GETCURRENTTHREADID() (uint64_t) pthread_self()
#define MP_STRCASESTR strcasestr
#define MP_THREAD_LOCAL __thread
#define MP_NOINLINE __attribute__((noinline))
void* MicroProfileAllocAligned(size_t nSize, size_t nAlign)
{
#if defined(__linux__)
void* p;
int result = posix_memalign(&p, nAlign, nSize);
if(result != 0)
{
return nullptr;
}
return p;
#else
return memalign(nAlign, nSize);
#endif
}
void MicroProfileFreeAligned(void* pMem)
{
free(pMem);
}
#endif
#endif
#ifdef MICROPROFILE_PS4
#define MICROPROFILE_PS4_DECL
#include "microprofile_ps4.h"
#endif
#ifdef MICROPROFILE_XBOXONE
#define MICROPROFILE_XBOXONE_DECL
#include "microprofile_xboxone.h"
#else
#ifdef _WIN32
#include <d3d11_1.h>
#endif
#endif
#ifdef _WIN32
typedef uint32_t MicroProfileThreadIdType;
#else
#ifdef MICROPROFILE_THREADID_SIZE_4BYTE
typedef uint32_t MicroProfileThreadIdType;
#elif MICROPROFILE_THREADID_SIZE_8BYTE
typedef uint64_t MicroProfileThreadIdType;
#else
typedef uint64_t MicroProfileThreadIdType;
#endif
#endif
#define MP_ASSERT(a) \
do \
{ \
if(!(a)) \
{ \
MP_BREAK(); \
} \
} while(0)
#ifdef _WIN32
#include <basetsd.h>
typedef UINT_PTR MpSocket;
#else
typedef int MpSocket;
#endif
#ifndef _WIN32
typedef pthread_t MicroProfileThread;
#elif defined(_WIN32)
#if _MSC_VER == 1900
typedef void* HANDLE;
#endif
typedef HANDLE MicroProfileThread;
#else
typedef std::thread* MicroProfileThread;
#endif
#if MICROPROFILE_DYNAMIC_INSTRUMENT
struct MicroProfileSymbolDesc;
#define MICROPROFILE_SUSPEND_MAX (4 << 10)
struct MicroProfileSuspendState
{
uint32_t SuspendCounter = 0;
uint32_t NumSuspended = 0;
#ifdef _WIN32
HANDLE Suspended[MICROPROFILE_SUSPEND_MAX];
intptr_t SuspendedIP[MICROPROFILE_SUSPEND_MAX];
#endif
};
void MicroProfileSymbolQueryFunctions(MpSocket Connection, const char* pFilter);
bool MicroProfileInstrumentFunction(void* pFunction, const char* pModuleName, const char* pFunctionName, uint32_t nColor);
bool MicroProfileSymbolInitialize(bool bStartLoad, const char* pModuleName = 0);
MicroProfileSymbolDesc* MicroProfileSymbolFindFuction(void* pAddress);
void MicroProfileInstrumentFunctionsCalled(void* pFunction, const char* pModuleName, const char* pFunctionName, int nMinBytes, int nMaxCalls);
void MicroProfileSymbolQuerySendResult(MpSocket Connection);
void MicroProfileSymbolSendFunctionNames(MpSocket Connection);
void MicroProfileSymbolSendErrors(MpSocket Connection);
const char* MicroProfileSymbolModuleGetString(uint32_t nIndex);
void MicroProfileInstrumentWithoutSymbols(const char** pModules, const char** pSymbols, uint32_t nNumSymbols);
void MicroProfileSymbolUpdateModuleList();
bool MicroProfileSymInit();
void MicroProfileSymCleanup();
#endif
struct MicroProfileFunctionQuery;
// hash table functions & declarations
struct MicroProfileHashTable;
struct MicroProfileHashTableIterator;
typedef bool (*MicroProfileHashCompareFunction)(uint64_t l, uint64_t r);
typedef uint64_t (*MicroProfileHashFunction)(uint64_t p);
uint64_t MicroProfileHashTableHashString(uint64_t pString);
bool MicroProfileHashTableCompareString(uint64_t L, uint64_t R);
uint64_t MicroProfileHashTableHashPtr(uint64_t pString);
bool MicroProfileHashTableComparePtr(uint64_t L, uint64_t R);
void MicroProfileHashTableInit(MicroProfileHashTable* pTable, uint32_t nInitialSize, uint32_t nSearchLimit, MicroProfileHashCompareFunction CompareFunc, MicroProfileHashFunction HashFunc);
void MicroProfileHashTableDestroy(MicroProfileHashTable* pTable);
uint64_t MicroProfileHashTableHash(MicroProfileHashTable* pTable, uint64_t K);
bool MicroProfileHashTableSet(MicroProfileHashTable* pTable, uint64_t Key, uintptr_t Value);
MicroProfileHashTableIterator MicroProfileGetHashTableIteratorBegin(MicroProfileHashTable* HashTable);
MicroProfileHashTableIterator MicroProfileGetHashTableIteratorEnd(MicroProfileHashTable* HashTable);
template <typename T>
struct MicroProfileArray
{
T* Data = nullptr;
uint32_t Size = 0;
uint32_t Capacity = 0;
T& operator[](const uint32_t Index);
const T& operator[](const uint32_t Index) const;
T* begin();
T* end();
};
template <typename T>
void MicroProfileArrayInit(MicroProfileArray<T>& Array, uint32_t InitialCapacity);
template <typename T>
void MicroProfileArrayDestroy(MicroProfileArray<T>& Array, uint32_t InitialCapacity);
template <typename T>
void MicroProfileArrayClear(MicroProfileArray<T>& Array);
template <typename T>
void MicroProfileArrayPushBack(MicroProfileArray<T>& Array, const T& v);
struct MicroProfileTimer
{
uint64_t nTicks;
uint32_t nCount;
};
struct MicroProfileCategory
{
char pName[MICROPROFILE_NAME_MAX_LEN];
uint32_t nGroupMask[MICROPROFILE_MAX_GROUP_INTS];
};
struct MicroProfileGroupInfo
{
char pName[MICROPROFILE_NAME_MAX_LEN];
uint32_t nNameLen;
uint32_t nGroupIndex;
uint32_t nNumTimers;
uint32_t nMaxTimerNameLen;
uint32_t nColor;
uint32_t nCategory;
MicroProfileTokenType Type;
int nWSNext;
};
struct MicroProfileTimerInfo
{
MicroProfileToken nToken;
uint32_t nTimerIndex;
uint32_t nGroupIndex;
char pName[MICROPROFILE_NAME_MAX_LEN];
char pNameExt[MICROPROFILE_NAME_MAX_LEN];
uint32_t nNameLen;
uint32_t nColor;
int nWSNext;
bool bGraph;
MicroProfileTokenType Type;
uint32_t Flags;
};
struct MicroProfileCounterInfo
{
int nParent;
int nSibling;
int nFirstChild;
uint16_t nNameLen;
uint8_t nLevel;
const char* pName;
uint32_t nFlags;
int64_t nLimit;
double dLimit;
int nWSNext;
MicroProfileCounterFormat eFormat;
std::atomic<int64_t> ExternalAtomic;
};
struct MicroProfileCounterHistory
{
uint32_t nPut;
uint64_t nHistory[MICROPROFILE_GRAPH_HISTORY];
};
struct MicroProfileCounterSource
{
void* pSource;
uint32_t nSourceSize;
};
struct MicroProfileGraphState
{
int64_t nHistory[MICROPROFILE_GRAPH_HISTORY];
MicroProfileToken nToken;
int32_t nKey;
};
struct MicroProfileContextSwitch
{
MicroProfileThreadIdType nThreadOut;
MicroProfileThreadIdType nThreadIn;
int64_t nCpu : 8;
int64_t nTicks : 56;
};
struct MicroProfileFrameState
{
uint64_t nFrameStartCpu;
uint64_t nFrameStartGpu;
uint64_t nFrameId;
uint32_t nGpuPending;
uint32_t nLogStart[MICROPROFILE_MAX_THREADS];
uint32_t nLogStartTimeline;
uint32_t nTimelineFrameMax;
int32_t nHistoryTimeline;
};
// All frame counter data stored. Used to store the time for all counters/groups for every frame.
// Must be enabled with MicroProfileEnableFrameCounterExtraData()
// Will allocate sizeof(MicroProfileFrameExtraCounterData) * MICROPROFILE_MAX_FRAME_HISTORY bytes
struct MicroProfileFrameExtraCounterData
{
uint16_t NumTimers;
uint16_t NumGroups;
uint64_t Timers[MICROPROFILE_MAX_TIMERS];
uint64_t Groups[MICROPROFILE_MAX_GROUPS];
};
struct MicroProfileCsvConfig
{
enum CsvConfigState
{
INACTIVE = 0,
CONFIG,
ACTIVE,
};
CsvConfigState State;
uint32_t NumTimers;
uint32_t NumGroups;
uint32_t NumCounters;
uint32_t MaxTimers;
uint32_t MaxGroups;
uint32_t MaxCounters;
uint32_t TotalElements;
uint16_t* TimerIndices;
uint16_t* GroupIndices;
uint16_t* CounterIndices;
uint64_t* FrameData;
const char** pTimerNames;
const char** pGroupNames;
const char** pCounterNames;
uint32_t Flags;
};
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4200) // zero-sized struct
#pragma warning(disable : 4201) // nameless struct/union
#pragma warning(disable : 4244) // possible loss of data
#pragma warning(disable : 4100) // unreferenced formal parameter
#pragma warning(disable : 4091)
#pragma warning(disable : 4189) // local variable is initialized but not referenced. (for defer local variables)
#pragma warning(disable : 4456)
#pragma warning(disable : 4702)
#endif
struct MicroProfileStringBlock
{
enum
{
DEFAULT_SIZE = 8192,
};
MicroProfileStringBlock* pNext;
uint32_t nUsed;
uint32_t nSize;
char Memory[];
};
struct MicroProfileHashTableEntry
{
uint64_t Key;
uint64_t Hash;
uintptr_t Value;
};
struct MicroProfileHashTable
{
MicroProfileHashTableEntry* pEntries;
uint32_t nUsed;
uint32_t nAllocated;
uint32_t nSearchLimit;
uint32_t nLim;
MicroProfileHashCompareFunction CompareFunc;
MicroProfileHashFunction HashFunc;
};
struct MicroProfileHashTableIterator
{
MicroProfileHashTableIterator(uint32_t nIndex, MicroProfileHashTable* pTable)
: nIndex(nIndex)
, pTable(pTable)
{
}
MicroProfileHashTableIterator(const MicroProfileHashTableIterator& other)
: nIndex(other.nIndex)
, pTable(other.pTable)
{
}
uint32_t nIndex;
MicroProfileHashTable* pTable;
void AssertValid()
{
MP_ASSERT(nIndex < pTable->nAllocated);
}
MicroProfileHashTableEntry& operator*()
{
AssertValid();
return pTable->pEntries[nIndex];
}
MicroProfileHashTableEntry* operator->()
{
AssertValid();
return &pTable->pEntries[nIndex];
}
bool operator==(const MicroProfileHashTableIterator& rhs)
{
return nIndex == rhs.nIndex && pTable == rhs.pTable;
}
bool operator!=(const MicroProfileHashTableIterator& rhs)
{
return nIndex != rhs.nIndex || pTable != rhs.pTable;
}
void SkipInvalid()
{
while(nIndex < pTable->nAllocated && pTable->pEntries[nIndex].Hash == 0)
nIndex++;
}
MicroProfileHashTableIterator operator++()
{
AssertValid();
nIndex++;
SkipInvalid();
return *this;
}
MicroProfileHashTableIterator operator++(int)
{
MicroProfileHashTableIterator tmp = *this;
++(*this);
return tmp;
}
};
struct MicroProfileStrings
{
MicroProfileHashTable HashTable;
MicroProfileStringBlock* pFirst;
MicroProfileStringBlock* pLast;
};
struct MicroProfileThreadLog
{
std::atomic<uint32_t> nPut;
std::atomic<uint32_t> nGet;
MicroProfileLogEntry Log[MICROPROFILE_BUFFER_SIZE];
uint32_t nStackPut;
uint32_t nStackScope;
#ifdef MICROPROFILE_VERIFY_BALANCED
uint64_t VerifyStack[MICROPROFILE_STACK_MAX];
#endif
MicroProfileScopeStateC ScopeState[MICROPROFILE_STACK_MAX];
uint32_t nActive;
uint32_t nGpu;
MicroProfileThreadIdType nThreadId;
uint32_t nLogIndex;
uint32_t nCustomId;
uint32_t nIdleFrames;
MicroProfileLogEntry nStackLogEntry[MICROPROFILE_STACK_MAX];
uint64_t nChildTickStack[MICROPROFILE_STACK_MAX + 1];
int32_t nStackPos;
uint8_t nGroupStackPos[MICROPROFILE_MAX_GROUPS];
uint64_t nGroupTicks[MICROPROFILE_MAX_GROUPS];
uint64_t nAggregateGroupTicks[MICROPROFILE_MAX_GROUPS];
enum
{
THREAD_MAX_LEN = 64,
};
char ThreadName[64];
int nFreeListNext;
};
struct MicroProfileWebSocketBuffer
{
char* pBufferAllocation;
char* pBuffer;
uint32_t nBufferSize;
uint32_t nPut;
MpSocket Socket;
char SendBuffer[MICROPROFILE_WEBSOCKET_BUFFER_SIZE];
std::atomic<uint32_t> nSendPut;
std::atomic<uint32_t> nSendGet;
};
typedef void (*MicroProfileHookFunc)(int x);
struct MicroProfilePatchError
{
unsigned char Code[32];
char Message[256];
int AlreadyInstrumented;
int nCodeSize;
};
// linear, per-frame per-thread gpu log
struct MicroProfileThreadLogGpu
{
MicroProfileLogEntry Log[MICROPROFILE_GPU_BUFFER_SIZE];
uint32_t nPut;
uint32_t nStart;
uint32_t nId;
void* pContext;
uint32_t nAllocated;
uint32_t nStackScope;
MicroProfileScopeStateC ScopeState[MICROPROFILE_STACK_MAX];
};
#if MICROPROFILE_GPU_TIMERS
static MicroProfileGpuInsertTimeStamp_CB MicroProfileGpuInsertTimeStamp_Callback = 0;
static MicroProfileGpuGetTimeStamp_CB MicroProfileGpuGetTimeStamp_Callback = 0;
static MicroProfileTicksPerSecondGpu_CB MicroProfileTicksPerSecondGpu_Callback = 0;
static MicroProfileGetGpuTickReference_CB MicroProfileGetGpuTickReference_Callback = 0;
static MicroProfileGpuFlip_CB MicroProfileGpuFlip_Callback = 0;
static MicroProfileGpuShutdown_CB MicroProfileGpuShutdown_Callback = 0;
uint32_t MicroProfileGpuInsertTimeStamp(void* pContext)
{
return MicroProfileGpuInsertTimeStamp_Callback ? MicroProfileGpuInsertTimeStamp_Callback(pContext) : 0;
}
uint64_t MicroProfileGpuGetTimeStamp(uint32_t nKey)
{
return MicroProfileGpuGetTimeStamp_Callback ? MicroProfileGpuGetTimeStamp_Callback(nKey) : 1;
}
uint64_t MicroProfileTicksPerSecondGpu()
{
return MicroProfileTicksPerSecondGpu_Callback ? MicroProfileTicksPerSecondGpu_Callback() : 1;
}
int MicroProfileGetGpuTickReference(int64_t* pOutCPU, int64_t* pOutGpu)
{
return MicroProfileGetGpuTickReference_Callback ? MicroProfileGetGpuTickReference_Callback(pOutCPU, pOutGpu) : 0;
}
uint32_t MicroProfileGpuFlip(void* p)
{
return MicroProfileGpuFlip_Callback ? MicroProfileGpuFlip_Callback(p) : 0;
}
void MicroProfileGpuShutdown()
{
if(MicroProfileGpuShutdown_Callback)
MicroProfileGpuShutdown_Callback();
}
#endif
#if MICROPROFILE_GPU_TIMERS_D3D11
//:'######:::'########::'##::::'##::::'########:::'#######::'########:::::'##::::::'##:::
//'##... ##:: ##.... ##: ##:::: ##:::: ##.... ##:'##.... ##: ##.... ##::'####::::'####:::
// ##:::..::: ##:::: ##: ##:::: ##:::: ##:::: ##:..::::: ##: ##:::: ##::.. ##::::.. ##:::
// ##::'####: ########:: ##:::: ##:::: ##:::: ##::'#######:: ##:::: ##:::: ##:::::: ##:::
// ##::: ##:: ##.....::: ##:::: ##:::: ##:::: ##::...... ##: ##:::: ##:::: ##:::::: ##:::
// ##::: ##:: ##:::::::: ##:::: ##:::: ##:::: ##:'##:::: ##: ##:::: ##:::: ##:::::: ##:::
//. ######::: ##::::::::. #######::::: ########::. #######:: ########:::'######::'######:
//:......::::..::::::::::.......::::::........::::.......:::........::::......:::......::
struct MicroProfileD3D11Frame
{
uint32_t m_nQueryStart;
uint32_t m_nQueryCountMax;
std::atomic<uint32_t> m_nQueryCount;
uint32_t m_nRateQueryStarted;
void* m_pRateQuery;
};
struct MicroProfileGpuTimerStateD3D11 : public MicroProfileGpuTimerState
{
uint32_t bInitialized;
void* m_pDevice;
void* m_pImmediateContext;
void* m_pQueries[MICROPROFILE_D3D11_MAX_QUERIES];
int64_t m_nQueryResults[MICROPROFILE_D3D11_MAX_QUERIES];
uint32_t m_nQueryPut;
uint32_t m_nQueryGet;
uint32_t m_nQueryFrame;
int64_t m_nQueryFrequency;
void* pSyncQuery;
MicroProfileD3D11Frame m_QueryFrames[MICROPROFILE_GPU_FRAME_DELAY];
};
uint32_t MicroProfileGpuInsertTimeStampD3D11(void* pContext_);
uint64_t MicroProfileGpuGetTimeStampD3D11(uint32_t nIndex);
bool MicroProfileGpuGetDataD3D11(void* pQuery, void* pData, uint32_t nDataSize);
uint64_t MicroProfileTicksPerSecondGpuD3D11();
uint32_t MicroProfileGpuFlipD3D11(void* pDeviceContext_);
void MicroProfileGpuInitD3D11(void* pDevice_, void* pImmediateContext);
void MicroProfileGpuShutdownD3D11();
int MicroProfileGetGpuTickReferenceD3D11(int64_t* pOutCPU, int64_t* pOutGpu);
MicroProfileGpuTimerStateD3D11* MicroProfileGetGpuTimerStateD3D11();
#endif
#if MICROPROFILE_GPU_TIMERS_D3D12
//:'######:::'########::'##::::'##::::'########:::'#######::'########:::::'##::::'#######::
//'##... ##:: ##.... ##: ##:::: ##:::: ##.... ##:'##.... ##: ##.... ##::'####:::'##.... ##:
// ##:::..::: ##:::: ##: ##:::: ##:::: ##:::: ##:..::::: ##: ##:::: ##::.. ##:::..::::: ##:
// ##::'####: ########:: ##:::: ##:::: ##:::: ##::'#######:: ##:::: ##:::: ##::::'#######::
// ##::: ##:: ##.....::: ##:::: ##:::: ##:::: ##::...... ##: ##:::: ##:::: ##:::'##::::::::
// ##::: ##:: ##:::::::: ##:::: ##:::: ##:::: ##:'##:::: ##: ##:::: ##:::: ##::: ##::::::::
//. ######::: ##::::::::. #######::::: ########::. #######:: ########:::'######: #########:
//:......::::..::::::::::.......::::::........::::.......:::........::::......::.........::
#include <d3d12.h>
#ifndef MICROPROFILE_D3D12_MAX_QUERIES
#define MICROPROFILE_D3D12_MAX_QUERIES (32 << 10)
#endif
#define MICROPROFILE_D3D_MAX_NODE_COUNT 4
#define MICROPROFILE_D3D_INTERNAL_DELAY 8
#define MP_NODE_MASK_ALL(n) ((1u << (n)) - 1u)
#define MP_NODE_MASK_ONE(n) (1u << (n))
struct MicroProfileGpuTimerStateD3D12;
int MicroProfileGetGpuTickReferenceD3D12(int64_t* pOutCPU, int64_t* pOutGpu);
uint32_t MicroProfileGpuInsertTimeStampD3D12(void* pContext);
uint64_t MicroProfileGpuGetTimeStampD3D12(uint32_t nIndex);
uint64_t MicroProfileTicksPerSecondGpuD3D12();
uint32_t MicroProfileGpuFlipD3D12(void* pContext);
void MicroProfileGpuInitD3D12(void* pDevice_, uint32_t nNodeCount, void** pCommandQueues_, void** pCommandQueuesCopy_);
void MicroProfileGpuShutdownD3D12();
void MicroProfileSetCurrentNodeD3D12(uint32_t nNode);
int MicroProfileGetGpuTickReferenceD3D12(int64_t* pOutCPU, int64_t* pOutGpu);
MicroProfileGpuTimerStateD3D12* MicroProfileGetGpuTimerStateD3D12();
struct MicroProfileFrameD3D12
{
uint32_t nTimeStampBegin;
uint32_t nTimeStampCount;
uint32_t nTimeStampBeginCopyQueue;
uint32_t nTimeStampCountCopyQueue;
uint32_t nNode;
ID3D12GraphicsCommandList* pCommandList[MICROPROFILE_D3D_MAX_NODE_COUNT];
ID3D12GraphicsCommandList* pCommandListCopy[MICROPROFILE_D3D_MAX_NODE_COUNT];
ID3D12CommandAllocator* pCommandAllocator;
ID3D12CommandAllocator* pCommandAllocatorCopy;
};
struct MicroProfileGpuTimerStateD3D12 : public MicroProfileGpuTimerState
{
ID3D12Device* pDevice;
uint32_t nNodeCount;
uint32_t nCurrentNode;
uint64_t nFrame;
uint64_t nPendingFrame;
uint32_t nFrameStartTimeStamps;
uint32_t nFrameStartCopyQueueTimeStamps;
std::atomic<uint32_t> nFrameCountTimeStamps;
std::atomic<uint32_t> nFrameCountCopyQueueTimeStamps;
int64_t nFrequency;
ID3D12Resource* pBuffer;
ID3D12Resource* pBufferCopy;
struct
{
ID3D12CommandQueue* pCommandQueue;
ID3D12CommandQueue* pCommandQueueCopy;
ID3D12QueryHeap* pHeap;
ID3D12QueryHeap* pCopyQueueHeap;
ID3D12Fence* pFence;
ID3D12Fence* pFenceCopy;
} NodeState[MICROPROFILE_D3D_MAX_NODE_COUNT];
uint16_t nQueryFrames[MICROPROFILE_D3D12_MAX_QUERIES];
int64_t nResults[MICROPROFILE_D3D12_MAX_QUERIES];
uint16_t nQueryFramesCopy[MICROPROFILE_D3D12_MAX_QUERIES];
int64_t nResultsCopy[MICROPROFILE_D3D12_MAX_QUERIES];
MicroProfileFrameD3D12 Frames[MICROPROFILE_D3D_INTERNAL_DELAY];
};
#endif
#if MICROPROFILE_GPU_TIMERS_GL
//:'######:::'########::'##::::'##:::::'######:::'##:::::::
//'##... ##:: ##.... ##: ##:::: ##::::'##... ##:: ##:::::::
// ##:::..::: ##:::: ##: ##:::: ##:::: ##:::..::: ##:::::::
// ##::'####: ########:: ##:::: ##:::: ##::'####: ##:::::::
// ##::: ##:: ##.....::: ##:::: ##:::: ##::: ##:: ##:::::::
// ##::: ##:: ##:::::::: ##:::: ##:::: ##::: ##:: ##:::::::
//. ######::: ##::::::::. #######:::::. ######::: ########:
//:......::::..::::::::::.......:::::::......::::........::
struct MicroProfileGpuTimerStateGL : public MicroProfileGpuTimerState
{
uint32_t GLTimers[MICROPROFILE_GL_MAX_QUERIES];
uint32_t GLTimerPos;
};
MicroProfileGpuTimerStateGL* MicroProfileGetGpuTimerStateGL();
uint32_t MicroProfileGpuInsertTimeStampGL(void* pContext);
uint64_t MicroProfileGpuGetTimeStampGL(uint32_t nKey);
uint64_t MicroProfileTicksPerSecondGpuGL();
int MicroProfileGetGpuTickReferenceGL(int64_t* pOutCpu, int64_t* pOutGpu);
uint32_t MicroProfileGpuFlipGL(void* pContext);
void MicroProfileGpuShutdownGL();
#endif
#if MICROPROFILE_GPU_TIMERS_VULKAN
//:'######:::'########::'##::::'##::::'##::::'##:'##::::'##:'##:::::::'##:::'##::::'###::::'##::: ##:
//'##... ##:: ##.... ##: ##:::: ##:::: ##:::: ##: ##:::: ##: ##::::::: ##::'##::::'## ##::: ###:: ##:
// ##:::..::: ##:::: ##: ##:::: ##:::: ##:::: ##: ##:::: ##: ##::::::: ##:'##::::'##:. ##:: ####: ##:
// ##::'####: ########:: ##:::: ##:::: ##:::: ##: ##:::: ##: ##::::::: #####::::'##:::. ##: ## ## ##:
// ##::: ##:: ##.....::: ##:::: ##::::. ##:: ##:: ##:::: ##: ##::::::: ##. ##::: #########: ##. ####:
// ##::: ##:: ##:::::::: ##:::: ##:::::. ## ##::: ##:::: ##: ##::::::: ##:. ##:: ##.... ##: ##:. ###:
//. ######::: ##::::::::. #######:::::::. ###::::. #######:: ########: ##::. ##: ##:::: ##: ##::. ##:
//:......::::..::::::::::.......:::::::::...::::::.......:::........::..::::..::..:::::..::..::::..::
struct MicroProfileGpuTimerStateVulkan;
MicroProfileGpuTimerStateVulkan* MicroProfileGetGpuTimerStateVulkan();
uint32_t MicroProfileGpuInsertTimeStampVulkan(void* pContext);
uint64_t MicroProfileGpuGetTimeStampVulkan(uint32_t nKey);
uint64_t MicroProfileTicksPerSecondGpuVulkan();
int MicroProfileGetGpuTickReferenceVulkan(int64_t* pOutCpu, int64_t* pOutGpu);
uint32_t MicroProfileGpuFlipVulkan(void* pContext);
void MicroProfileGpuShutdownVulkan();
#endif
struct MicroProfileSymbolState
{
std::atomic<int> nModuleLoadsFinished;
std::atomic<int> nModuleLoadsRequested;
std::atomic<int64_t> nSymbolsLoaded;
};
struct MicroProfileSymbolModuleRegion
{
intptr_t nBegin;
intptr_t nEnd;
};
struct MicroProfileSymbolModule
{
uint64_t nModuleBase;
uint32_t nMatchOffset;
uint32_t nStringOffset;
const char* pBaseString;
const char* pTrimmedString;
MicroProfileSymbolModuleRegion Regions[MICROPROFILE_MAX_MODULE_EXEC_REGIONS];
int nNumExecutableRegions;
bool bDownloading;
intptr_t nProgress;
intptr_t nProgressTarget;
struct MicroProfileSymbolBlock* pSymbolBlock;
MicroProfileHashTable AddressToSymbol;
int64_t nSymbols;
std::atomic<int64_t> nSymbolsLoaded;
std::atomic<int> nModuleLoadRequested;
std::atomic<int> nModuleLoadFinished;
};
struct MicroProfileInstrumentMemoryRegion
{
intptr_t Start;
intptr_t Size;
uint32_t Protect;
};
struct MicroProfile
{
uint32_t nTotalTimers;
uint32_t nGroupCount;
uint32_t nCategoryCount;
uint32_t nAggregateClear;
uint32_t nAggregateFlip;
uint32_t nAggregateFlipCount;
uint32_t nAggregateFrames;
uint64_t nFlipStartTick;
uint64_t nAggregateFlipTick;
uint32_t nDisplay;
uint32_t nBars;
uint32_t nActiveGroups[MICROPROFILE_MAX_GROUP_INTS];
bool AnyActive;
uint32_t nFrozen;
uint32_t nWasFrozen;
uint32_t nPlatformMarkersEnabled;
uint32_t nForceEnable;
uint32_t nForceGroups[MICROPROFILE_MAX_GROUP_INTS];
uint32_t nActiveGroupsWanted[MICROPROFILE_MAX_GROUP_INTS];
uint32_t nGroupMask[MICROPROFILE_MAX_GROUP_INTS];
uint32_t nStartEnabled;
uint32_t nAllThreadsWanted;
uint32_t nOverflow;
uint32_t nMaxGroupSize;
uint32_t nDumpFileNextFrame;
uint32_t nDumpFileCountDown;
uint32_t nDumpSpikeMask;
uint32_t nAutoClearFrames;
float fDumpCpuSpike;
float fDumpGpuSpike;
char HtmlDumpPath[512];
char CsvDumpPath[512];
uint32_t DumpFrameCount;
int64_t nPauseTicks;
std::atomic<int64_t> nContextSwitchStalledTick;
int64_t nContextSwitchLastPushed;
int64_t nContextSwitchLastIndexPushed;
float fReferenceTime;
float fRcpReferenceTime;
MicroProfileCategory CategoryInfo[MICROPROFILE_MAX_CATEGORIES];
MicroProfileGroupInfo GroupInfo[MICROPROFILE_MAX_GROUPS];
MicroProfileTimerInfo TimerInfo[MICROPROFILE_MAX_TIMERS];
uint32_t TimerToGroup[MICROPROFILE_MAX_TIMERS];
MicroProfileTimer AccumTimers[MICROPROFILE_MAX_TIMERS];
uint64_t AccumMaxTimers[MICROPROFILE_MAX_TIMERS];
uint64_t AccumMinTimers[MICROPROFILE_MAX_TIMERS];
uint64_t AccumTimersExclusive[MICROPROFILE_MAX_TIMERS];
uint64_t AccumMaxTimersExclusive[MICROPROFILE_MAX_TIMERS];
MicroProfileTimer Frame[MICROPROFILE_MAX_TIMERS];
uint64_t FrameExclusive[MICROPROFILE_MAX_TIMERS];
MicroProfileTimer Aggregate[MICROPROFILE_MAX_TIMERS];
uint64_t AggregateMax[MICROPROFILE_MAX_TIMERS];
uint64_t AggregateMin[MICROPROFILE_MAX_TIMERS];
uint64_t AggregateExclusive[MICROPROFILE_MAX_TIMERS];
uint64_t AggregateMaxExclusive[MICROPROFILE_MAX_TIMERS];
uint32_t FrameGroupThreadValid[MICROPROFILE_MAX_THREADS / 32 + 1];
struct GroupTime
{
uint64_t nTicks;
uint64_t nTicksExclusive;
uint32_t nCount;
};
GroupTime FrameGroupThread[MICROPROFILE_MAX_THREADS][MICROPROFILE_MAX_GROUPS];
GroupTime FrameGroup[MICROPROFILE_MAX_GROUPS];
uint64_t AccumGroup[MICROPROFILE_MAX_GROUPS];
uint64_t AccumGroupMax[MICROPROFILE_MAX_GROUPS];
uint64_t AggregateGroup[MICROPROFILE_MAX_GROUPS];
uint64_t AggregateGroupMax[MICROPROFILE_MAX_GROUPS];
MicroProfileGraphState Graph[MICROPROFILE_MAX_GRAPHS];
uint32_t nGraphPut;
uint32_t nThreadActive[MICROPROFILE_MAX_THREADS];
MicroProfileThreadLog* Pool[MICROPROFILE_MAX_THREADS];
MicroProfileThreadLogGpu* PoolGpu[MICROPROFILE_MAX_THREADS];
MicroProfileThreadLog TimelineLog;
uint32_t TimelineTokenFrameEnter[MICROPROFILE_TIMELINE_MAX_TOKENS];
uint32_t TimelineTokenFrameLeave[MICROPROFILE_TIMELINE_MAX_TOKENS];
uint32_t TimelineToken[MICROPROFILE_TIMELINE_MAX_TOKENS];
const char* TimelineTokenStaticString[MICROPROFILE_TIMELINE_MAX_TOKENS];
uint32_t nTimelineFrameMax;
MicroProfileFrameExtraCounterData* FrameExtraCounterData;
MicroProfileCsvConfig CsvConfig;
const char* pSettings;
const char* pSettingsReadOnly;
const char* pSettingsTemp;
uint32_t nNumLogs;
uint32_t nNumLogsGpu;
uint32_t nMemUsage;
int nFreeListHead;
uint32_t nFrameCurrent;
uint32_t nFrameCurrentIndex;
uint32_t nFramePut;
uint32_t nFrameNext;
uint64_t nFramePutIndex;
MicroProfileFrameState Frames[MICROPROFILE_MAX_FRAME_HISTORY];
uint64_t nFlipTicks;
uint64_t nFlipAggregate;
uint64_t nFlipMax;
uint64_t nFlipAggregateDisplay;
uint64_t nFlipMaxDisplay;
MicroProfileThread ContextSwitchThread;
bool bContextSwitchRunning;
bool bContextSwitchStop;
bool bContextSwitchAllThreads;
bool bContextSwitchNoBars;
uint32_t nContextSwitchUsage;
uint32_t nContextSwitchLastPut;
int64_t nContextSwitchHoverTickIn;
int64_t nContextSwitchHoverTickOut;
uint32_t nContextSwitchHoverThread;
uint32_t nContextSwitchHoverThreadBefore;
uint32_t nContextSwitchHoverThreadAfter;
uint8_t nContextSwitchHoverCpu;
uint8_t nContextSwitchHoverCpuNext;
uint32_t CoreCount;
uint8_t CoreEfficiencyClass[MICROPROFILE_MAX_CPU_CORES];
uint32_t nContextSwitchPut;
MicroProfileContextSwitch ContextSwitch[MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE];
MpSocket ListenerSocket;
uint32_t nWebServerPort;
char WebServerBuffer[MICROPROFILE_WEBSERVER_SOCKET_BUFFER_SIZE];
uint32_t WebServerPut;
uint64_t nWebServerDataSent;
int WebSocketTimers;
int WebSocketCounters;
int WebSocketGroups;
uint32_t nWebSocketDirty;
MpSocket WebSockets[1];
int64_t WebSocketFrameLast[1];
uint32_t nNumWebSockets;
uint32_t nSocketFail; // for error propagation.
MicroProfileThread WebSocketSendThread;
bool WebSocketThreadRunning;
bool WebSocketThreadJoined;
uint32_t WSCategoriesSent;
uint32_t WSGroupsSent;
uint32_t WSTimersSent;
uint32_t WSCountersSent;
MicroProfileWebSocketBuffer WSBuf;
char* pJsonSettings;
const char* pJsonSettingsName;
bool bJsonSettingsReadOnly;
uint32_t nJsonSettingsPending;
uint32_t nJsonSettingsBufferSize;
uint32_t nWSWasConnected;
uint32_t nMicroProfileShutdown;
uint32_t nWSViewMode;
char CounterNames[MICROPROFILE_MAX_COUNTER_NAME_CHARS];
MicroProfileCounterInfo CounterInfo[MICROPROFILE_MAX_COUNTERS];
MicroProfileCounterSource CounterSource[MICROPROFILE_MAX_COUNTERS];
uint32_t nNumCounters;
uint32_t nCounterNamePos;
std::atomic<int64_t> Counters[MICROPROFILE_MAX_COUNTERS];
std::atomic<double>* CountersDouble;
#if MICROPROFILE_COUNTER_HISTORY // uses 1kb per allocated counter. 512kb for default counter count
uint32_t nCounterHistoryPut;
int64_t nCounterHistory[MICROPROFILE_GRAPH_HISTORY][MICROPROFILE_MAX_COUNTERS]; // flipped to make swapping cheap, drawing more expensive.
int64_t nCounterMax[MICROPROFILE_MAX_COUNTERS];
int64_t nCounterMin[MICROPROFILE_MAX_COUNTERS];
double* dCounterHistory;
double* dCounterMax;
double* dCounterMin;
#endif
MicroProfileThread AutoFlipThread;
std::atomic<uint32_t> nAutoFlipDelay;
std::atomic<uint32_t> nAutoFlipStop;
MicroProfileStrings Strings;
MicroProfileToken CounterToken_MicroProfile;
MicroProfileToken CounterToken_StringBlock;
MicroProfileToken CounterToken_StringBlock_Count;
MicroProfileToken CounterToken_StringBlock_Waste;
MicroProfileToken CounterToken_StringBlock_Strings;
MicroProfileToken CounterToken_StringBlock_Memory;
MicroProfileToken CounterToken_Alloc;
MicroProfileToken CounterToken_Alloc_Memory;
MicroProfileToken CounterToken_Alloc_Count;
#if MICROPROFILE_DYNAMIC_INSTRUMENT
uint32_t DynamicTokenIndex;
MicroProfileToken DynamicTokens[MICROPROFILE_MAX_DYNAMIC_TOKENS];
void* FunctionsInstrumented[MICROPROFILE_MAX_DYNAMIC_TOKENS];
const char* FunctionsInstrumentedName[MICROPROFILE_MAX_DYNAMIC_TOKENS];
const char* FunctionsInstrumentedModuleNames[MICROPROFILE_MAX_DYNAMIC_TOKENS];
// const char* FunctionsInstrumentedUnmangled[MICROPROFILE_MAX_DYNAMIC_TOKENS];
uint32_t WSFunctionsInstrumentedSent;
MicroProfileSymbolState SymbolState;
MicroProfileSymbolModule SymbolModules[MICROPROFILE_INSTRUMENT_MAX_MODULES];
char SymbolModuleNameBuffer[MICROPROFILE_INSTRUMENT_MAX_MODULE_CHARS];
int SymbolModuleNameOffset;
int SymbolNumModules;
int WSSymbolModulesSent;
std::atomic<int> nSymbolsDirty;
MicroProfileFunctionQuery* pPendingQuery;
MicroProfileFunctionQuery* pFinishedQuery;
MicroProfileFunctionQuery* pQueryFreeList;
uint32_t nQueryProcessed;
uint32_t nNumQueryFree;
uint32_t nNumQueryAllocated;
int SymbolThreadRunning;
int SymbolThreadFinished;
MicroProfileThread SymbolThread;
int nNumPatchErrors;
MicroProfilePatchError PatchErrors[MICROPROFILE_MAX_PATCH_ERRORS];
int nNumPatchErrorFunctions;
const char* PatchErrorFunctionNames[MICROPROFILE_MAX_PATCH_ERRORS];
MicroProfileSuspendState SuspendState;
MicroProfileArray<MicroProfileInstrumentMemoryRegion> MemoryRegions;
#endif
int GpuQueue;
MicroProfileThreadLogGpu* pGpuGlobal;
MicroProfileGpuTimerState* pGPU;
};
inline uint32_t MicroProfileLogGetType(MicroProfileLogEntry Index)
{
return ((MP_LOG_BEGIN_MASK & Index) >> 62) & 0x3;
}
inline uint64_t MicroProfileLogGetTimerIndex(MicroProfileLogEntry Index)
{
return (0x3fff & (Index >> 48));
}
uint32_t MicroProfileLogGetDataSize(MicroProfileLogEntry Index)
{
if(MicroProfileLogGetType(Index) == MP_LOG_EXTENDED)
return 0xffff & (Index >> 32);
else
return 0;
}
inline EMicroProfileTokenExtended MicroProfileLogGetExtendedToken(MicroProfileLogEntry Index)
{
return (EMicroProfileTokenExtended)(0x3fff & (Index >> 48));
}
inline uint32_t MicroProfileLogGetExtendedDataSize(MicroProfileLogEntry Index)
{
return (uint32_t)(0xffff & (Index >> 32));
}
inline uint32_t MicroProfileLogGetExtendedPayload(MicroProfileLogEntry Index)
{
return (uint32_t)(0xffffffff & Index);
}
inline uint64_t MicroProfileLogGetExtendedPayloadNoData(MicroProfileLogEntry Index)
{
return (uint64_t)(MP_LOG_TICK_MASK & Index);
}
inline void* MicroProfileLogGetExtendedPayloadNoDataPtr(MicroProfileLogEntry Index)
{
return (void*)(MP_LOG_PAYLOAD_PTR_MASK & Index);
}
MicroProfileLogEntry MicroProfileMakeLogIndex(uint64_t nBegin, MicroProfileToken nToken, int64_t nTick);
MicroProfileLogEntry MicroProfileMakeLogExtended(EMicroProfileTokenExtended eTokenExt, uint32_t nDataSizeQWords, uint32_t nPayload);
MicroProfileLogEntry MicroProfileMakeLogExtendedNoData(EMicroProfileTokenExtended eTokenExt, uint64_t nTick);
inline MicroProfileLogEntry MicroProfileMakeLogIndex(uint64_t nBegin, MicroProfileToken nToken, int64_t nTick)
{
MicroProfileLogEntry Entry = (nBegin << 62) | ((0x3fff & nToken) << 48) | (MP_LOG_TICK_MASK & nTick);
uint32_t t = MicroProfileLogGetType(Entry);
uint64_t nTimerIndex = MicroProfileLogGetTimerIndex(Entry);
MP_ASSERT(t == nBegin);
MP_ASSERT(nTimerIndex == (nToken & 0x3fff));
return Entry;
}
// extended data, with the option to store 0xfffe * 8 bytes after
inline MicroProfileLogEntry MicroProfileMakeLogExtended(EMicroProfileTokenExtended eTokenExt, uint32_t nDataSizeQWords, uint32_t nPayload)
{
MP_ASSERT(nDataSizeQWords < 0xffff);
MicroProfileLogEntry Entry = (((uint64_t)MP_LOG_EXTENDED) << 62) | ((0x3fff & (uint64_t)eTokenExt) << 48) | ((0xffff & (uint64_t)nDataSizeQWords) << 32) | nPayload;
MP_ASSERT(MicroProfileLogGetExtendedToken(Entry) == eTokenExt);
MP_ASSERT(MicroProfileLogGetExtendedDataSize(Entry) == nDataSizeQWords);
MP_ASSERT(MicroProfileLogGetExtendedPayload(Entry) == nPayload);
return Entry;
}
// extended with no data, but instead 48 bits payload
inline MicroProfileLogEntry MicroProfileMakeLogExtendedNoData(EMicroProfileTokenExtended eTokenExt, uint64_t nPayload)
{
MicroProfileLogEntry Entry = (((uint64_t)MP_LOG_EXTENDED_NO_DATA) << 62) | ((0x3fff & (uint64_t)eTokenExt) << 48) | (MP_LOG_TICK_MASK & nPayload);
MP_ASSERT(MicroProfileLogGetExtendedToken(Entry) == eTokenExt);
MP_ASSERT(MicroProfileLogGetExtendedPayloadNoData(Entry) == nPayload);
return Entry;
}
// extended with no data, but instead 61 bits payload. used to store a pointer.
inline MicroProfileLogEntry MicroProfileMakeLogExtendedNoDataPtr(uint64_t nPayload)
{
uint64_t hest = ETOKEN_CSTR_PTR;
MicroProfileLogEntry Entry = (((uint64_t)MP_LOG_EXTENDED_NO_DATA) << 62) | (hest << 48) | (MP_LOG_PAYLOAD_PTR_MASK & nPayload);
uint64_t v0 = (MP_LOG_PAYLOAD_PTR_MASK & nPayload);
uint64_t v1 = (uint64_t)MicroProfileLogGetExtendedPayloadNoDataPtr(Entry);
MP_ASSERT(v0 == v1);
return Entry;
}
inline uint32_t MicroProfileGetQWordSize(uint32_t nDataSize)
{
uint32_t nSize = (nDataSize + 7) / 8;
MP_ASSERT(nSize < 0xffff); // won't pack...
return nSize;
}
namespace
{
struct MicroProfilePayloadPack
{
union
{
struct
{
#if MICROPROFILE_BIG_ENDIAN /// NOT implemented.
char h;
char message[7];
#else
char message[7];
char h;
#endif
};
uint64_t LogEntry;
};
};
}; // namespace
inline int64_t MicroProfileLogTickDifference(MicroProfileLogEntry Start, MicroProfileLogEntry End)
{
int64_t nStart = Start;
int64_t nEnd = End;
int64_t nDifference = ((nEnd << 16) - (nStart << 16));
return nDifference >> 16;
}
inline int64_t MicroProfileLogTickMax(MicroProfileLogEntry A, MicroProfileLogEntry B)
{
int64_t Diff = MicroProfileLogTickDifference(A, B);
if(Diff < 0)
{
return A;
}
else
{
return B;
}
}
inline int64_t MicroProfileLogTickMin(MicroProfileLogEntry A, MicroProfileLogEntry B)
{
int64_t Diff = MicroProfileLogTickDifference(A, B);
if(Diff < 0)
{
return B;
}
else
{
return A;
}
}
inline int64_t MicroProfileLogTickClamp(uint64_t T, uint64_t min, uint64_t max)
{
return MicroProfileLogTickMin(MicroProfileLogTickMax(T, min), max);
}
inline int64_t MicroProfileLogGetTick(MicroProfileLogEntry e)
{
return MP_LOG_TICK_MASK & e;
}
inline int64_t MicroProfileLogSetTick(MicroProfileLogEntry e, int64_t nTick)
{
return (MP_LOG_TICK_MASK & nTick) | (e & ~MP_LOG_TICK_MASK);
}
inline uint16_t MicroProfileGetTimerIndex(MicroProfileToken t)
{
return (t & 0xffff);
}
inline uint32_t MicroProfileGetGroupMask(MicroProfileToken t)
{
return (uint32_t)((t >> 16) & MICROPROFILE_GROUP_MASK_ALL);
}
inline uint32_t MicroProfileGetGroupMaskIndex(MicroProfileToken t)
{
return (uint32_t)(t >> 48);
}
inline MicroProfileToken MicroProfileMakeToken(uint32_t nGroupMask, uint16_t nGroupIndex, uint16_t nTimer)
{
uint64_t token = ((uint64_t)nGroupIndex << 48llu) | ((uint64_t)nGroupMask << 16llu) | nTimer;
if(0 != (token & MP_LOG_CSTR_MASK))
{
MP_BREAK(); // should never happen
}
return token;
}
template <typename T>
T MicroProfileMin(T a, T b)
{
return a < b ? a : b;
}
template <typename T>
T MicroProfileMax(T a, T b)
{
return a > b ? a : b;
}
template <typename T>
T MicroProfileClamp(T a, T min_, T max_)
{
return MicroProfileMin(max_, MicroProfileMax(min_, a));
}
inline int64_t MicroProfileMsToTick(float fMs, int64_t nTicksPerSecond)
{
return (int64_t)(fMs * 0.001f * nTicksPerSecond);
}
inline float MicroProfileTickToMsMultiplier(int64_t nTicksPerSecond)
{
return 1000.f / (nTicksPerSecond ? nTicksPerSecond : 1);
}
float MicroProfileTickToMsMultiplierCpu()
{
return MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
}
float MicroProfileTickToMsMultiplierGpu()
{
return MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondGpu());
}
uint16_t MicroProfileGetGroupIndex(MicroProfileToken t)
{
return (uint16_t)MicroProfileGet()->TimerToGroup[MicroProfileGetTimerIndex(t)];
}
uint64_t MicroProfileTick()
{
return MP_TICK();
}
#ifdef _WIN32
#include <windows.h>
#define fopen microprofile_fopen_helper
FILE* microprofile_fopen_helper(const char* filename, const char* mode)
{
FILE* F = 0;
if(0 == fopen_s(&F, filename, mode))
{
return F;
}
return 0;
}
int64_t MicroProfileTicksPerSecondCpu()
{
static int64_t nTicksPerSecond = 0;
if(nTicksPerSecond == 0)
{
QueryPerformanceFrequency((LARGE_INTEGER*)&nTicksPerSecond);
}
return nTicksPerSecond;
}
int64_t MicroProfileGetTick()
{
int64_t ticks;
QueryPerformanceCounter((LARGE_INTEGER*)&ticks);
return ticks;
}
#endif
#if 1
typedef void* (*MicroProfileThreadFunc)(void*);
#ifndef _WIN32
typedef pthread_t MicroProfileThread;
void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
{
pthread_attr_t Attr;
int r = pthread_attr_init(&Attr);
MP_ASSERT(r == 0);
pthread_create(pThread, &Attr, Func, 0);
}
void MicroProfileThreadJoin(MicroProfileThread* pThread)
{
int r = pthread_join(*pThread, 0);
MP_ASSERT(r == 0);
}
#elif defined(_WIN32)
typedef HANDLE MicroProfileThread;
DWORD __stdcall ThreadTrampoline(void* pFunc)
{
MicroProfileThreadFunc F = (MicroProfileThreadFunc)pFunc;
return (uint32_t)(uintptr_t)F(0);
}
void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
{
*pThread = CreateThread(0, 0, ThreadTrampoline, Func, 0, 0);
}
void MicroProfileThreadJoin(MicroProfileThread* pThread)
{
WaitForSingleObject(*pThread, INFINITE);
CloseHandle(*pThread);
}
#else
#include <thread>
typedef std::thread* MicroProfileThread;
inline void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
{
*pThread = MP_ALLOC_OBJECT(std::thread);
new(*pThread) std::thread(Func, nullptr);
}
inline void MicroProfileThreadJoin(MicroProfileThread* pThread)
{
(*pThread)->join();
(*pThread)->~thread();
MP_FREE(*pThread);
*pThread = 0;
}
#endif
#endif
#if MICROPROFILE_WEBSERVER
#ifdef _WIN32
#define MP_INVALID_SOCKET(f) (f == INVALID_SOCKET)
#else
#include <fcntl.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define MP_INVALID_SOCKET(f) (f < 0)
#endif
void MicroProfileWebServerStart();
void MicroProfileWebServerStop();
void MicroProfileWebServerJoin();
bool MicroProfileWebServerUpdate();
void MicroProfileDumpToFile();
#else
#define MicroProfileWebServerStart() \
do \
{ \
} while(0)
#define MicroProfileWebServerStop() \
do \
{ \
} while(0)
#define MicroProfileWebServerJoin() \
do \
{ \
} while(0)
#define MicroProfileWebServerUpdate() false
#define MicroProfileDumpToFile() \
do \
{ \
} while(0)
#endif
#include <algorithm>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#if MICROPROFILE_DEBUG
#ifdef _WIN32
void uprintf(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
char buffer[1024];
stbsp_vsnprintf(buffer, sizeof(buffer) - 1, fmt, args);
OutputDebugStringA(buffer);
va_end(args);
}
#else
#define uprintf(...) printf(__VA_ARGS__)
#endif
#else
#define uprintf(...) \
do \
{ \
sizeof(__VA_ARGS__); \
} while(0)
#endif
#define S g_MicroProfile
MicroProfile g_MicroProfile;
#ifdef MICROPROFILE_IOS
// iOS doesn't support __thread
static pthread_key_t g_MicroProfileThreadLogKey;
static pthread_once_t g_MicroProfileThreadLogKeyOnce = PTHREAD_ONCE_INIT;
static void MicroProfileCreateThreadLogKey()
{
pthread_key_create(&g_MicroProfileThreadLogKey, NULL);
}
#else
MP_THREAD_LOCAL MicroProfileThreadLog* g_MicroProfileThreadLogThreadLocal = 0;
#endif
static bool g_bUseLock = false; /// This is used because windows does not support using mutexes under dll init(which is where global initialization is handled)
MICROPROFILE_DEFINE(g_MicroProfileFlip, "MicroProfile", "MicroProfileFlip", MP_GREEN4);
MICROPROFILE_DEFINE(g_MicroProfileThreadLoop, "MicroProfile", "ThreadLoop", MP_GREEN4);
MICROPROFILE_DEFINE(g_MicroProfileClear, "MicroProfile", "Clear", MP_GREEN4);
MICROPROFILE_DEFINE(g_MicroProfileAccumulate, "MicroProfile", "Accumulate", MP_GREEN4);
MICROPROFILE_DEFINE(g_MicroProfileContextSwitchSearch, "MicroProfile", "ContextSwitchSearch", MP_GREEN4);
MICROPROFILE_DEFINE(g_MicroProfileGpuSubmit, "MicroProfile", "MicroProfileGpuSubmit", MP_HOTPINK2);
MICROPROFILE_DEFINE(g_MicroProfileSendLoop, "MicroProfile", "MicroProfileSocketSendLoop", MP_GREEN4);
MICROPROFILE_DEFINE_LOCAL_ATOMIC_COUNTER(g_MicroProfileBytesPerFlip, "microprofile/bytesperflip");
// void MicroProfileHashTableInit(MicroProfileHashTable* pTable, uint32_t nInitialSize, MicroProfileHashCompareFunction CompareFunc, MicroProfileHashFunction HashFunc);
void MicroProfileHashTableDestroy(MicroProfileHashTable* pTable);
uint64_t MicroProfileHashTableHash(MicroProfileHashTable* pTable, uint64_t K);
void MicroProfileHashTableGrow(MicroProfileHashTable* pTable);
bool MicroProfileHashTableSet(MicroProfileHashTable* pTable, uint64_t Key, uintptr_t Value, uint64_t H, bool bAllowGrow);
bool MicroProfileHashTableGet(MicroProfileHashTable* pTable, uint64_t Key, uintptr_t* pValue);
bool MicroProfileHashTableRemove(MicroProfileHashTable* pTable, uint64_t Key);
bool MicroProfileHashTableSetString(MicroProfileHashTable* pTable, const char* pKey, const char* pValue);
bool MicroProfileHashTableGetString(MicroProfileHashTable* pTable, const char* pKey, const char** pValue);
bool MicroProfileHashTableRemoveString(MicroProfileHashTable* pTable, const char* pKey);
bool MicroProfileHashTableSetPtr(MicroProfileHashTable* pTable, const void* pKey, void* pValue);
template <typename T = void>
bool MicroProfileHashTableGetPtr(MicroProfileHashTable* pTable, const void* pKey, T** pValue = nullptr);
bool MicroProfileHashTableRemovePtr(MicroProfileHashTable* pTable, const void* pKey);
enum
{
ESTRINGINTERN_LOWERCASE = 1,
ESTRINGINTERN_FORCEFORWARDSLASH = 0x2,
};
const char* MicroProfileStringIntern(const char* pStr);
const char* MicroProfileStringInternLower(const char* pStr);
const char* MicroProfileStringInternSlash(const char* pStr);
const char* MicroProfileStringIntern(const char* pStr, uint32_t nLen, uint32_t nInternalFlags = 0);
void MicroProfileStringsInit(MicroProfileStrings* pStrings);
void MicroProfileStringsDestroy(MicroProfileStrings* pStrings);
MicroProfileToken MicroProfileCounterTokenInit(int nParent, uint32_t nFlags);
void MicroProfileCounterTokenInitName(MicroProfileToken nToken, const char* pName);
void MicroProfileCounterConfigToken(MicroProfileToken, uint32_t eFormat, int64_t nLimit, uint32_t nFlags);
uint16_t MicroProfileFindGroup(const char* pGroup);
inline std::recursive_mutex& MicroProfileMutex()
{
static std::recursive_mutex Mutex;
return Mutex;
}
std::recursive_mutex& MicroProfileGetMutex()
{
return MicroProfileMutex();
}
inline std::recursive_mutex& MicroProfileTimelineMutex()
{
static std::recursive_mutex Mutex;
return Mutex;
}
MICROPROFILE_API MicroProfile* MicroProfileGet()
{
return &g_MicroProfile;
}
MicroProfileThreadLog* MicroProfileCreateThreadLog(const char* pName);
MicroProfileThreadLogGpu* MicroProfileThreadLogGpuAllocInternal();
void* MicroProfileSocketSenderThread(void*);
void MicroProfileInit()
{
static bool bOnce = true;
if(!bOnce)
{
return;
}
std::recursive_mutex& mutex = MicroProfileMutex();
bool bUseLock = g_bUseLock;
if(bUseLock)
mutex.lock();
if(bOnce)
{
bOnce = false;
memset(&S, 0, sizeof(S));
MicroProfileStringsInit(&S.Strings);
// these strings are used for counter names inside the string
S.CounterToken_MicroProfile = MicroProfileCounterTokenInit(-1, 0);
S.CounterToken_StringBlock = MicroProfileCounterTokenInit(S.CounterToken_MicroProfile, 0);
S.CounterToken_StringBlock_Count = MicroProfileCounterTokenInit(S.CounterToken_StringBlock, 0);
S.CounterToken_StringBlock_Waste = MicroProfileCounterTokenInit(S.CounterToken_StringBlock, 0);
S.CounterToken_StringBlock_Strings = MicroProfileCounterTokenInit(S.CounterToken_StringBlock, 0);
S.CounterToken_StringBlock_Memory = MicroProfileCounterTokenInit(S.CounterToken_StringBlock, 0);
S.CounterToken_Alloc = MicroProfileCounterTokenInit(S.CounterToken_MicroProfile, 0);
S.CounterToken_Alloc_Memory = MicroProfileCounterTokenInit(S.CounterToken_Alloc, 0);
S.CounterToken_Alloc_Count = MicroProfileCounterTokenInit(S.CounterToken_Alloc, 0);
MicroProfileCounterTokenInitName(S.CounterToken_MicroProfile, "microprofile");
MicroProfileCounterTokenInitName(S.CounterToken_StringBlock, "stringblock");
MicroProfileCounterTokenInitName(S.CounterToken_StringBlock_Count, "count");
MicroProfileCounterTokenInitName(S.CounterToken_StringBlock_Waste, "waste");
MicroProfileCounterTokenInitName(S.CounterToken_StringBlock_Strings, "strings");
MicroProfileCounterTokenInitName(S.CounterToken_StringBlock_Memory, "memory");
MicroProfileCounterTokenInitName(S.CounterToken_Alloc, "alloc");
MicroProfileCounterTokenInitName(S.CounterToken_Alloc_Memory, "memory");
MicroProfileCounterTokenInitName(S.CounterToken_Alloc_Count, "count");
S.nMemUsage += sizeof(S);
for(int i = 0; i < MICROPROFILE_MAX_GROUPS; ++i)
{
S.GroupInfo[i].pName[0] = '\0';
}
for(int i = 0; i < MICROPROFILE_MAX_CATEGORIES; ++i)
{
S.CategoryInfo[i].pName[0] = '\0';
memset(S.CategoryInfo[i].nGroupMask, 0, sizeof(S.CategoryInfo[i].nGroupMask));
}
memcpy(&S.CategoryInfo[0].pName[0], "default", sizeof("default"));
S.nCategoryCount = 1;
for(int i = 0; i < MICROPROFILE_MAX_TIMERS; ++i)
{
S.TimerInfo[i].pName[0] = '\0';
}
S.nGroupCount = 0;
S.nFlipStartTick = MP_TICK();
S.nContextSwitchStalledTick = MP_TICK();
S.nAggregateFlipTick = MP_TICK();
memset(S.nActiveGroups, 0, sizeof(S.nActiveGroups));
S.nFrozen = 0;
S.nWasFrozen = 0;
memset(S.nForceGroups, 0, sizeof(S.nForceGroups));
memset(S.nActiveGroupsWanted, 0, sizeof(S.nActiveGroupsWanted));
S.nStartEnabled = 0;
S.nAllThreadsWanted = 1;
S.nAggregateFlip = 0;
S.nTotalTimers = 0;
for(uint32_t i = 0; i < MICROPROFILE_MAX_GRAPHS; ++i)
{
S.Graph[i].nToken = MICROPROFILE_INVALID_TOKEN;
}
S.fReferenceTime = 33.33f;
S.fRcpReferenceTime = 1.f / S.fReferenceTime;
S.nFreeListHead = -1;
int64_t nTick = MP_TICK();
for(int i = 0; i < MICROPROFILE_MAX_FRAME_HISTORY; ++i)
{
S.Frames[i].nFrameStartCpu = nTick;
S.Frames[i].nFrameStartGpu = MICROPROFILE_INVALID_TICK;
}
S.nWebServerPort = MICROPROFILE_WEBSERVER_PORT; // Use defined value as default port
S.nWebServerDataSent = (uint64_t)-1;
S.WebSocketTimers = -1;
S.WebSocketCounters = -1;
S.WebSocketGroups = -1;
S.nSocketFail = 0;
S.DumpFrameCount = MICROPROFILE_WEBSERVER_DEFAULT_FRAMES;
#if MICROPROFILE_COUNTER_HISTORY
S.nCounterHistoryPut = 0;
for(uint32_t i = 0; i < MICROPROFILE_MAX_COUNTERS; ++i)
{
S.nCounterMin[i] = 0x7fffffffffffffff;
S.nCounterMax[i] = 0x8000000000000000;
}
#endif
S.GpuQueue = MICROPROFILE_GPU_INIT_QUEUE("GPU");
S.pGpuGlobal = MicroProfileThreadLogGpuAllocInternal();
MicroProfileGpuBegin(0, S.pGpuGlobal);
S.pJsonSettings = 0;
S.pJsonSettingsName = nullptr;
S.nJsonSettingsPending = 0;
S.nJsonSettingsBufferSize = 0;
S.nWSWasConnected = 0;
for(uint32_t i = 0; i < MICROPROFILE_TIMELINE_MAX_TOKENS; ++i)
{
S.TimelineTokenFrameEnter[i] = MICROPROFILE_INVALID_FRAME;
S.TimelineTokenFrameLeave[i] = MICROPROFILE_INVALID_FRAME;
S.TimelineTokenStaticString[i] = nullptr;
S.TimelineToken[i] = 0;
}
memset(&S.AccumMinTimers[0], 0xFF, sizeof(S.AccumMinTimers));
S.CountersDouble = (std::atomic<double>*)&S.Counters;
#if MICROPROFILE_COUNTER_HISTORY
S.dCounterHistory = (double*)S.nCounterHistory;
S.dCounterMax = (double*)S.nCounterMax;
S.dCounterMin = (double*)S.nCounterMin;
#endif
}
MicroProfileUpdateSettingsPath();
#if MICROPROFILE_FRAME_EXTRA_DATA
S.FrameExtraCounterData = (MicroProfileFrameExtraCounterData*)1;
#endif
MicroProfileCounterConfigToken(S.CounterToken_Alloc_Memory, MICROPROFILE_COUNTER_FORMAT_BYTES, 0, MICROPROFILE_COUNTER_FLAG_DETAILED);
MICROPROFILE_COUNTER_CONFIG("MicroProfile/ThreadLog/Memory", MICROPROFILE_COUNTER_FORMAT_BYTES, 0, MICROPROFILE_COUNTER_FLAG_DETAILED);
if(bUseLock)
{
mutex.unlock();
}
}
void MicroProfileUpdateSettingsPath()
{
if(S.pSettings)
{
MicroProfileFreeInternal((void*)S.pSettings);
S.pSettings = nullptr;
}
if(S.pSettingsReadOnly)
{
MicroProfileFreeInternal((void*)S.pSettingsReadOnly);
S.pSettingsReadOnly = nullptr;
}
if(S.pSettingsTemp)
{
MicroProfileFreeInternal((void*)S.pSettingsTemp);
S.pSettingsTemp = nullptr;
}
auto DupeString = [](const char* BasePath, const char* File) -> const char*
{
size_t BaseLen = strlen(BasePath);
bool TrailingSlash = BaseLen > 1 && (BasePath[BaseLen - 1] == '\\' || BasePath[BaseLen - 1] == '/');
size_t Len = BaseLen + strlen(File) + 2;
char* Data = (char*)MicroProfileAllocInternal(Len + 1, 1);
#ifdef _WIN32
char Slash = '\\';
#else
char Slash = '/';
#endif
if(TrailingSlash)
snprintf(Data, Len, "%s%s", BasePath, File);
else
snprintf(Data, Len, "%s%c%s", BasePath, Slash, File);
return Data;
};
const char* pBaseSettingsPath = MICROPROFILE_GET_SETTINGS_FILE_PATH;
S.pSettings = DupeString(pBaseSettingsPath, MICROPROFILE_SETTINGS_FILE);
S.pSettingsReadOnly = DupeString(pBaseSettingsPath, MICROPROFILE_SETTINGS_FILE_BUILTIN);
S.pSettingsTemp = DupeString(pBaseSettingsPath, MICROPROFILE_SETTINGS_FILE MICROPROFILE_SETTINGS_FILE_TEMP);
}
void MicroProfileJoinContextSwitchTrace();
void MicroProfileShutdown()
{
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
S.nMicroProfileShutdown = 1;
MicroProfileStopContextSwitchTrace();
}
MicroProfileWebServerJoin();
MicroProfileJoinContextSwitchTrace();
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
if(S.pJsonSettings)
{
MP_FREE(S.pJsonSettings);
S.pJsonSettings = 0;
S.pJsonSettingsName = 0;
S.nJsonSettingsBufferSize = 0;
}
if(S.pGPU)
{
MicroProfileGpuShutdownPlatform();
}
MicroProfileHashTableDestroy(&S.Strings.HashTable);
MicroProfileStringsDestroy(&S.Strings);
MICROPROFILE_FREE_NON_ALIGNED(S.WSBuf.pBufferAllocation);
MicroProfileFreeGpuQueue(S.GpuQueue);
MicroProfileThreadLogGpuFree(S.pGpuGlobal);
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
#if MICROPROFILE_ASSERT_LOG_FREED
MP_ASSERT(S.Pool[i]->nActive != 1);
#endif
MP_FREE(S.Pool[i]);
}
for(uint32_t i = 0; i < S.nNumLogsGpu; ++i)
{
#if MICROPROFILE_ASSERT_LOG_FREED
MP_ASSERT(!S.PoolGpu[i]->nAllocated);
#endif
MP_FREE(S.PoolGpu[i]);
}
MicroProfileFreeInternal((void*)S.pSettings);
S.pSettings = nullptr;
MicroProfileFreeInternal((void*)S.pSettingsReadOnly);
S.pSettingsReadOnly = nullptr;
MicroProfileFreeInternal((void*)S.pSettingsTemp);
S.pSettingsTemp = nullptr;
}
}
static void* MicroProfileAutoFlipThread(void*)
{
MicroProfileOnThreadCreate("AutoFlipThread");
while(0 == S.nAutoFlipStop.load())
{
MICROPROFILE_SCOPEI("MICROPROFILE", "AutoFlipThread", 0);
MicroProfileSleep(S.nAutoFlipDelay);
MicroProfileFlip(0);
}
MicroProfileOnThreadExit();
return 0;
}
void MicroProfileStartAutoFlip(uint32_t nMsDelay)
{
S.nAutoFlipDelay = nMsDelay;
S.nAutoFlipStop.store(0);
MicroProfileThreadStart(&S.AutoFlipThread, MicroProfileAutoFlipThread);
}
void MicroProfileStopAutoFlip()
{
S.nAutoFlipStop.store(1);
MicroProfileThreadJoin(&S.AutoFlipThread);
}
void MicroProfileEnableFrameExtraCounterData()
{
// should not be called at the same time as MicroProfileFlip.
if(!S.FrameExtraCounterData)
{
S.FrameExtraCounterData = (MicroProfileFrameExtraCounterData*)1;
}
}
void MicroProfileCsvConfigEnd()
{
MP_ASSERT(S.CsvConfig.State == MicroProfileCsvConfig::CONFIG);
S.CsvConfig.State = MicroProfileCsvConfig::ACTIVE;
}
void MicroProfileCsvConfigBegin(uint32_t MaxTimers, uint32_t MaxGroups, uint32_t MaxCounters, uint32_t Flags)
{
MP_ASSERT(S.CsvConfig.State == MicroProfileCsvConfig::INACTIVE); // right now, only support being configured once.
uint32_t TotalElements = MaxTimers + MaxGroups + MaxCounters;
uint32_t BaseSize = (sizeof(MicroProfileCsvConfig) + 7) & 7;
uint32_t TimerIndexSize = sizeof(uint16_t) * MaxTimers;
uint32_t GroupIndexSize = sizeof(uint16_t) * MaxGroups;
uint32_t CounterIndexSize = sizeof(uint16_t) * MaxCounters;
uint32_t FrameBlockSize = TotalElements * sizeof(uint64_t);
uint32_t FrameDataSize = FrameBlockSize * MICROPROFILE_MAX_FRAME_HISTORY;
S.CsvConfig.NumTimers = 0;
S.CsvConfig.NumGroups = 0;
S.CsvConfig.NumCounters = 0;
S.CsvConfig.MaxTimers = MaxTimers;
S.CsvConfig.MaxGroups = MaxGroups;
S.CsvConfig.MaxCounters = MaxCounters;
S.CsvConfig.TotalElements = TotalElements;
S.CsvConfig.TimerIndices = (uint16_t*)MicroProfileAllocInternal(TimerIndexSize, alignof(uint16_t));
S.CsvConfig.pTimerNames = (const char**)MicroProfileAllocInternal(MaxTimers * sizeof(const char*), alignof(const char*));
memset(S.CsvConfig.pTimerNames, 0, MaxTimers * sizeof(const char*));
for(uint32_t i = 0; i < MaxTimers; ++i)
S.CsvConfig.TimerIndices[i] = UINT16_MAX;
S.CsvConfig.pGroupNames = (const char**)MicroProfileAllocInternal(MaxGroups * sizeof(const char*), alignof(const char*));
memset(S.CsvConfig.pGroupNames, 0, MaxGroups * sizeof(const char*));
S.CsvConfig.GroupIndices = (uint16_t*)MicroProfileAllocInternal(GroupIndexSize, alignof(uint16_t));
for(uint32_t i = 0; i < MaxGroups; ++i)
S.CsvConfig.GroupIndices[i] = UINT16_MAX;
S.CsvConfig.pCounterNames = (const char**)MicroProfileAllocInternal(MaxCounters * sizeof(const char*), alignof(const char*));
memset(S.CsvConfig.pCounterNames, 0, MaxCounters * sizeof(const char*));
S.CsvConfig.CounterIndices = (uint16_t*)MicroProfileAllocInternal(CounterIndexSize, alignof(uint16_t));
for(uint32_t i = 0; i < MaxCounters; ++i)
S.CsvConfig.CounterIndices[i] = UINT16_MAX;
S.CsvConfig.FrameData = (uint64_t*)MicroProfileAllocInternal(FrameDataSize, alignof(uint64_t));
memset(S.CsvConfig.FrameData, 0, FrameDataSize);
S.CsvConfig.State = MicroProfileCsvConfig::CONFIG;
S.CsvConfig.Flags = Flags;
}
void MicroProfileCsvConfigAddTimer(const char* Group, const char* Timer, const char* Name, MicroProfileTokenType Type)
{
MP_ASSERT(S.CsvConfig.State == MicroProfileCsvConfig::CONFIG);
if(S.CsvConfig.State == MicroProfileCsvConfig::CONFIG && S.CsvConfig.NumTimers < S.CsvConfig.MaxTimers)
{
MicroProfileToken ret = MicroProfileGetToken(Group, Timer, MP_AUTO, Type, MICROPROFILE_TIMER_FLAG_PLACEHOLDER);
if(ret != MICROPROFILE_INVALID_TOKEN)
{
MP_ASSERT(S.CsvConfig.NumTimers < S.CsvConfig.MaxTimers);
uint16_t TimerIndex = MicroProfileGetTimerIndex(ret);
for(uint32_t i = 0; i < S.CsvConfig.NumTimers; ++i)
{
if(S.CsvConfig.TimerIndices[i] == TimerIndex)
return;
}
S.CsvConfig.pTimerNames[S.CsvConfig.NumTimers] = Name;
S.CsvConfig.TimerIndices[S.CsvConfig.NumTimers++] = TimerIndex;
}
}
}
void MicroProfileCsvConfigAddGroup(const char* Group, const char* Name)
{
MP_ASSERT(S.CsvConfig.State == MicroProfileCsvConfig::CONFIG);
if(S.CsvConfig.State == MicroProfileCsvConfig::CONFIG && S.CsvConfig.NumGroups < S.CsvConfig.MaxGroups)
{
uint16_t Index = MicroProfileFindGroup(Group);
MP_ASSERT(UINT16_MAX != Index);
if(UINT16_MAX != Index)
{
MP_ASSERT(S.CsvConfig.NumGroups < S.CsvConfig.MaxGroups);
for(uint32_t i = 0; i < S.CsvConfig.NumGroups; ++i)
{
if(S.CsvConfig.GroupIndices[i] == Index)
return;
}
S.CsvConfig.pGroupNames[S.CsvConfig.NumGroups] = Name;
S.CsvConfig.GroupIndices[S.CsvConfig.NumGroups++] = Index;
}
}
}
void MicroProfileCsvConfigAddCounter(const char* CounterName, const char* Name)
{
MP_ASSERT(S.CsvConfig.State == MicroProfileCsvConfig::CONFIG);
if(S.CsvConfig.State == MicroProfileCsvConfig::CONFIG && S.CsvConfig.NumCounters < S.CsvConfig.MaxCounters)
{
MicroProfileToken Token = MicroProfileGetCounterToken(CounterName, 0);
if(MICROPROFILE_INVALID_TOKEN != Token)
{
MP_ASSERT(Token < UINT16_MAX);
MP_ASSERT(S.CsvConfig.NumCounters < S.CsvConfig.MaxCounters);
for(uint32_t i = 0; i < S.CsvConfig.NumCounters; ++i)
{
if(S.CsvConfig.CounterIndices[i] == (uint16_t)Token)
return;
}
S.CsvConfig.pCounterNames[S.CsvConfig.NumCounters] = Name;
S.CsvConfig.CounterIndices[S.CsvConfig.NumCounters++] = (uint16_t)Token;
}
}
}
#ifdef MICROPROFILE_IOS
inline MicroProfileThreadLog* MicroProfileGetThreadLog()
{
pthread_once(&g_MicroProfileThreadLogKeyOnce, MicroProfileCreateThreadLogKey);
return (MicroProfileThreadLog*)pthread_getspecific(g_MicroProfileThreadLogKey);
}
inline void MicroProfileSetThreadLog(MicroProfileThreadLog* pLog)
{
pthread_once(&g_MicroProfileThreadLogKeyOnce, MicroProfileCreateThreadLogKey);
pthread_setspecific(g_MicroProfileThreadLogKey, pLog);
}
#else
MicroProfileThreadLog* MicroProfileGetThreadLog()
{
return g_MicroProfileThreadLogThreadLocal;
}
void MicroProfileSetThreadLog(MicroProfileThreadLog* pLog)
{
g_MicroProfileThreadLogThreadLocal = pLog;
}
#endif
MicroProfileThreadLog* MicroProfileGetThreadLog2()
{
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog();
if(!pLog)
{
MicroProfileInitThreadLog();
pLog = MicroProfileGetThreadLog();
}
return pLog;
}
struct MicroProfileScopeLock
{
bool bUseLock;
int nUnlock;
std::recursive_mutex& m;
MicroProfileScopeLock(std::recursive_mutex& m)
: bUseLock(g_bUseLock)
, nUnlock(0)
, m(m)
{
if(bUseLock)
m.lock();
}
~MicroProfileScopeLock()
{
MP_ASSERT(nUnlock == 0);
if(bUseLock)
m.unlock();
}
void Unlock()
{
MP_ASSERT(bUseLock);
m.unlock();
nUnlock++;
}
void Lock()
{
m.lock();
nUnlock--;
}
};
void MicroProfileLogReset(MicroProfileThreadLog* pLog);
void MicroProfileLogClearInternal(MicroProfileThreadLog* pLog);
MicroProfileThreadLog* MicroProfileCreateThreadLog(const char* pName)
{
MicroProfileScopeLock L(MicroProfileMutex());
if(S.nNumLogs == MICROPROFILE_MAX_THREADS && S.nFreeListHead == -1)
{
uprintf("recycling thread logs\n");
// reuse the oldest.
MicroProfileThreadLog* pOldest = 0;
uint32_t nIdleFrames = 0;
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
MicroProfileThreadLog* pLog = S.Pool[i];
uprintf("tlactive %p, %d. idle:%d\n", pLog, pLog->nActive, pLog->nIdleFrames);
if(pLog->nActive == 2)
{
if(pLog->nIdleFrames >= nIdleFrames)
{
nIdleFrames = pLog->nIdleFrames;
pOldest = pLog;
}
}
}
MP_ASSERT(pOldest);
MicroProfileLogReset(pOldest);
}
MicroProfileThreadLog* pLog = 0;
if(S.nFreeListHead != -1)
{
pLog = S.Pool[S.nFreeListHead];
MP_ASSERT(pLog->nPut.load() == 0);
MP_ASSERT(pLog->nGet.load() == 0);
S.nFreeListHead = S.Pool[S.nFreeListHead]->nFreeListNext;
}
else
{
MICROPROFILE_COUNTER_ADD("MicroProfile/ThreadLog/Allocated", 1);
MICROPROFILE_COUNTER_ADD("MicroProfile/ThreadLog/Memory", sizeof(MicroProfileThreadLog));
pLog = MP_ALLOC_OBJECT(MicroProfileThreadLog);
MicroProfileLogClearInternal(pLog);
S.nMemUsage += sizeof(MicroProfileThreadLog);
pLog->nLogIndex = S.nNumLogs;
MP_ASSERT(S.nNumLogs < MICROPROFILE_MAX_THREADS);
S.Pool[S.nNumLogs++] = pLog;
}
int len = 0;
if(pName)
{
len = (int)strlen(pName);
int maxlen = sizeof(pLog->ThreadName) - 1;
len = len < maxlen ? len : maxlen;
memcpy(&pLog->ThreadName[0], pName, len);
}
else
{
len = snprintf(&pLog->ThreadName[0], sizeof(pLog->ThreadName) - 1, "TID:[%" PRId64 "]", (int64_t)MP_GETCURRENTTHREADID());
}
pLog->ThreadName[len] = '\0';
pLog->nThreadId = MP_GETCURRENTTHREADID();
pLog->nFreeListNext = -1;
pLog->nActive = 1;
return pLog;
}
void MicroProfileOnThreadCreate(const char* pThreadName)
{
char Buffer[64];
g_bUseLock = true;
MicroProfileInit();
MP_ASSERT(MicroProfileGetThreadLog() == 0);
MicroProfileThreadLog* pLog = MicroProfileCreateThreadLog(pThreadName ? pThreadName : MicroProfileGetThreadName(Buffer));
(void)Buffer;
MP_ASSERT(pLog);
MicroProfileSetThreadLog(pLog);
}
void MicroProfileThreadLogGpuReset(MicroProfileThreadLogGpu* pLog)
{
MP_ASSERT(pLog->nAllocated);
pLog->pContext = (void*)-1;
pLog->nStart = (uint32_t)-1;
pLog->nPut = 0;
pLog->nStackScope = 0;
}
MicroProfileThreadLogGpu* MicroProfileThreadLogGpuAllocInternal()
{
MicroProfileThreadLogGpu* pLog = 0;
for(uint32_t i = 0; i < S.nNumLogsGpu; ++i)
{
MicroProfileThreadLogGpu* pNextLog = S.PoolGpu[i];
if(pNextLog && !pNextLog->nAllocated)
{
pLog = pNextLog;
break;
}
}
if(!pLog)
{
pLog = MP_ALLOC_OBJECT(MicroProfileThreadLogGpu);
int nLogIndex = S.nNumLogsGpu++;
MP_ASSERT(nLogIndex < MICROPROFILE_MAX_THREADS);
pLog->nId = nLogIndex;
S.PoolGpu[nLogIndex] = pLog;
}
pLog->nAllocated = 1;
MicroProfileThreadLogGpuReset(pLog);
return pLog;
}
MicroProfileThreadLogGpu* MicroProfileThreadLogGpuAlloc()
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
return MicroProfileThreadLogGpuAllocInternal();
}
void MicroProfileThreadLogGpuFree(MicroProfileThreadLogGpu* pLog)
{
MP_ASSERT(pLog->nAllocated);
pLog->nAllocated = 0;
}
int MicroProfileGetGpuQueue(const char* pQueueName)
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; i++)
{
MicroProfileThreadLog* pLog = S.Pool[i];
if(pLog && pLog->nGpu && pLog->nActive && 0 == MP_STRCASECMP(pQueueName, pLog->ThreadName))
{
return i;
}
}
MP_ASSERT(0); // call MicroProfileInitGpuQueue
return 0;
}
MicroProfileThreadLog* MicroProfileGetGpuQueueLog(const char* pQueueName)
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; i++)
{
MicroProfileThreadLog* pLog = S.Pool[i];
if(pLog && pLog->nGpu && pLog->nActive && 0 == MP_STRCASECMP(pQueueName, pLog->ThreadName))
{
return pLog;
}
}
MP_ASSERT(0); // call MicroProfileInitGpuQueue
return 0;
}
int MicroProfileInitGpuQueue(const char* pQueueName)
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
MicroProfileThreadLog* pLog = S.Pool[i];
if(pLog && 0 == MP_STRCASECMP(pQueueName, pLog->ThreadName))
{
MP_ASSERT(0); // call MicroProfileInitGpuQueue only once per CommandQueue. name must not clash with threadname
}
}
MicroProfileThreadLog* pLog = MicroProfileCreateThreadLog(pQueueName);
pLog->nGpu = 1;
pLog->nThreadId = 0;
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
if(S.Pool[i] == pLog)
{
return i;
}
}
MP_BREAK();
return 0;
}
void MicroProfileFreeGpuQueue(int nQueue)
{
MicroProfileThreadLog* pLog = S.Pool[nQueue];
if(pLog)
{
MP_ASSERT(pLog->nActive == 1);
pLog->nActive = 2;
}
}
MicroProfileThreadLogGpu* MicroProfileGetGlobalGpuThreadLog()
{
return S.pGpuGlobal;
}
MICROPROFILE_API int MicroProfileGetGlobalGpuQueue()
{
return S.GpuQueue;
}
void MicroProfileLogClearInternal(MicroProfileThreadLog* pLog)
{
// can't clear atomics..
void* pStart = (void*)&pLog->Log[0];
void* pEnd = (void*)(pLog + 1);
memset(pStart, 0, (uintptr_t)pEnd - (uintptr_t)pStart);
pLog->nPut.store(0);
pLog->nGet.store(0);
}
void MicroProfileLogReset(MicroProfileThreadLog* pLog)
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
int32_t nLogIndex = -1;
for(int i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
if(pLog == S.Pool[i])
{
nLogIndex = i;
break;
}
}
MP_ASSERT(nLogIndex < MICROPROFILE_MAX_THREADS && nLogIndex > 0);
MicroProfileLogClearInternal(pLog);
pLog->nFreeListNext = S.nFreeListHead;
S.nFreeListHead = nLogIndex;
for(int i = 0; i < MICROPROFILE_MAX_FRAME_HISTORY; ++i)
{
S.Frames[i].nLogStart[nLogIndex] = 0;
}
}
void MicroProfileOnThreadExit()
{
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog();
if(pLog)
{
MP_ASSERT(pLog->nActive == 1);
pLog->nActive = 2;
}
}
void MicroProfileInitThreadLog()
{
MicroProfileOnThreadCreate(nullptr);
}
MicroProfileToken MicroProfileFindTokenInternal(const char* pGroup, const char* pName)
{
MicroProfileInit();
MicroProfileScopeLock L(MicroProfileMutex());
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
if(!MP_STRCASECMP(pName, S.TimerInfo[i].pName) && !MP_STRCASECMP(pGroup, S.GroupInfo[S.TimerToGroup[i]].pName))
{
return S.TimerInfo[i].nToken;
}
}
return MICROPROFILE_INVALID_TOKEN;
}
MicroProfileToken MicroProfileFindToken(const char* pGroup, const char* pName)
{
return MicroProfileGetToken(pGroup, pName, MP_AUTO, MicroProfileTokenTypeCpu, MICROPROFILE_TIMER_FLAG_PLACEHOLDER);
}
uint16_t MicroProfileFindGroup(const char* pGroup)
{
for(uint32_t i = 0; i < S.nGroupCount; ++i)
{
if(!MP_STRCASECMP(pGroup, S.GroupInfo[i].pName))
{
return i;
}
}
return UINT16_MAX;
}
uint16_t MicroProfileGetGroup(const char* pGroup, MicroProfileTokenType Type)
{
for(uint32_t i = 0; i < S.nGroupCount; ++i)
{
if(!MP_STRCASECMP(pGroup, S.GroupInfo[i].pName))
{
return i;
}
}
uint16_t nGroupIndex = 0xffff;
uint32_t nLen = (uint32_t)strlen(pGroup);
if(nLen > MICROPROFILE_NAME_MAX_LEN - 1)
nLen = MICROPROFILE_NAME_MAX_LEN - 1;
memcpy(&S.GroupInfo[S.nGroupCount].pName[0], pGroup, nLen);
S.GroupInfo[S.nGroupCount].pName[nLen] = '\0';
S.GroupInfo[S.nGroupCount].nNameLen = nLen;
S.GroupInfo[S.nGroupCount].nNumTimers = 0;
S.GroupInfo[S.nGroupCount].nGroupIndex = S.nGroupCount;
S.GroupInfo[S.nGroupCount].Type = Type;
S.GroupInfo[S.nGroupCount].nMaxTimerNameLen = 0;
S.GroupInfo[S.nGroupCount].nColor = 0x42;
S.GroupInfo[S.nGroupCount].nCategory = 0;
S.GroupInfo[S.nGroupCount].nWSNext = -2;
uint32_t nIndex = S.nGroupCount / 32;
uint32_t nBit = S.nGroupCount % 32;
{
S.CategoryInfo[0].nGroupMask[nIndex] |= (1 << nBit);
}
if(S.nStartEnabled)
{
S.nActiveGroupsWanted[nIndex] |= (1ll << nBit);
S.nActiveGroups[nIndex] |= (1ll << nBit);
S.AnyActive = true;
}
nGroupIndex = S.nGroupCount++;
S.nGroupMask[nIndex] |= (1 << nBit);
MP_ASSERT(S.nGroupCount < MICROPROFILE_MAX_GROUPS);
return nGroupIndex;
}
void MicroProfileRegisterGroup(const char* pGroup, const char* pCategory, uint32_t nColor)
{
MicroProfileScopeLock L(MicroProfileMutex());
int nCategoryIndex = -1;
for(uint32_t i = 0; i < S.nCategoryCount; ++i)
{
if(!MP_STRCASECMP(pCategory, S.CategoryInfo[i].pName))
{
nCategoryIndex = (int)i;
break;
}
}
if(-1 == nCategoryIndex && S.nCategoryCount < MICROPROFILE_MAX_CATEGORIES)
{
MP_ASSERT(S.CategoryInfo[S.nCategoryCount].pName[0] == '\0');
nCategoryIndex = (int)S.nCategoryCount++;
uint32_t nLen = (uint32_t)strlen(pCategory);
if(nLen > MICROPROFILE_NAME_MAX_LEN - 1)
nLen = MICROPROFILE_NAME_MAX_LEN - 1;
memcpy(&S.CategoryInfo[nCategoryIndex].pName[0], pCategory, nLen);
S.CategoryInfo[nCategoryIndex].pName[nLen] = '\0';
}
uint16_t nGroup = MicroProfileGetGroup(pGroup, 0 != MP_STRCASECMP(pGroup, "gpu") ? MicroProfileTokenTypeCpu : MicroProfileTokenTypeGpu);
S.GroupInfo[nGroup].nColor = nColor;
if(nCategoryIndex >= 0)
{
uint32_t nIndex = nGroup / 32;
uint32_t nBit = nGroup % 32;
nBit = (1 << nBit);
uint32_t nOldCategory = S.GroupInfo[nGroup].nCategory;
S.CategoryInfo[nOldCategory].nGroupMask[nIndex] &= ~nBit;
S.CategoryInfo[nCategoryIndex].nGroupMask[nIndex] |= nBit;
S.GroupInfo[nGroup].nCategory = nCategoryIndex;
}
}
MicroProfileToken MicroProfileGetToken(const char* pGroup, const char* pName, uint32_t nColor, MicroProfileTokenType Type, uint32_t Flags)
{
MicroProfileInit();
MicroProfileScopeLock L(MicroProfileMutex());
MicroProfileToken ret = MicroProfileFindTokenInternal(pGroup, pName);
if(ret != MICROPROFILE_INVALID_TOKEN)
{
int idx = MicroProfileGetTimerIndex(ret);
if(S.TimerInfo[idx].Flags & MICROPROFILE_TIMER_FLAG_PLACEHOLDER)
{
S.TimerInfo[idx].nColor = nColor & 0xffffff;
S.TimerInfo[idx].Flags = Flags;
S.TimerInfo[idx].Type = Type;
}
MP_ASSERT(S.TimerInfo[idx].Flags == Flags || (Flags & MICROPROFILE_TIMER_FLAG_PLACEHOLDER));
return ret;
}
uint16_t nGroupIndex = MicroProfileGetGroup(pGroup, Type);
uint16_t nTimerIndex = (uint16_t)(S.nTotalTimers++);
MP_ASSERT(nTimerIndex < MICROPROFILE_MAX_TIMERS);
uint32_t nBitIndex = nGroupIndex / 32;
uint32_t nBit = nGroupIndex % 32;
uint32_t nGroupMask = 1ll << nBit;
MicroProfileToken nToken = MicroProfileMakeToken(nGroupMask, (uint16_t)nBitIndex, nTimerIndex);
S.GroupInfo[nGroupIndex].nNumTimers++;
S.GroupInfo[nGroupIndex].nMaxTimerNameLen = MicroProfileMax(S.GroupInfo[nGroupIndex].nMaxTimerNameLen, (uint32_t)strlen(pName));
MP_ASSERT(S.GroupInfo[nGroupIndex].Type == Type); // dont mix cpu & gpu timers in the same group
S.nMaxGroupSize = MicroProfileMax(S.nMaxGroupSize, S.GroupInfo[nGroupIndex].nNumTimers);
S.TimerInfo[nTimerIndex].nToken = nToken;
uint32_t nLen = (uint32_t)strlen(pName);
if(nLen > MICROPROFILE_NAME_MAX_LEN - 1)
nLen = MICROPROFILE_NAME_MAX_LEN - 1;
memcpy(&S.TimerInfo[nTimerIndex].pName, pName, nLen);
snprintf(&S.TimerInfo[nTimerIndex].pNameExt[0], sizeof(S.TimerInfo[nTimerIndex].pNameExt) - 1, "%s %s", S.GroupInfo[nGroupIndex].pName, pName);
S.TimerInfo[nTimerIndex].pName[nLen] = '\0';
S.TimerInfo[nTimerIndex].nNameLen = nLen;
S.TimerInfo[nTimerIndex].nColor = nColor & 0xffffff;
S.TimerInfo[nTimerIndex].nGroupIndex = nGroupIndex;
S.TimerInfo[nTimerIndex].nTimerIndex = nTimerIndex;
S.TimerInfo[nTimerIndex].nWSNext = -2;
S.TimerInfo[nTimerIndex].Type = Type;
S.TimerInfo[nTimerIndex].Flags = Flags;
// printf("*** TOKEN %08d %s\\%s .. flags %08x\n", nTimerIndex, pGroup, pName, Flags);
S.TimerToGroup[nTimerIndex] = nGroupIndex;
return nToken;
}
void MicroProfileGetTokenC(MicroProfileToken* pToken, const char* pGroup, const char* pName, uint32_t nColor, MicroProfileTokenType Type, uint32_t flags)
{
if(*pToken == MICROPROFILE_INVALID_TOKEN)
{
MicroProfileInit();
MicroProfileScopeLock L(MicroProfileMutex());
if(*pToken == MICROPROFILE_INVALID_TOKEN)
{
*pToken = MicroProfileGetToken(pGroup, pName, nColor, Type, flags);
}
}
}
const char* MicroProfileNextName(const char* pName, char* pNameOut, uint32_t* nSubNameLen)
{
int nMaxLen = MICROPROFILE_NAME_MAX_LEN - 1;
const char* pRet = 0;
bool bDone = false;
uint32_t nChars = 0;
for(int i = 0; i < nMaxLen && !bDone; ++i)
{
char c = *pName++;
switch(c)
{
case 0:
bDone = true;
break;
case '\\':
case '/':
if(nChars)
{
bDone = true;
pRet = pName;
}
break;
default:
nChars++;
*pNameOut++ = c;
}
}
*nSubNameLen = nChars;
*pNameOut = '\0';
return pRet;
}
const char* MicroProfileCounterFullName(int nCounter)
{
static char Buffer[1024];
int nNodes[32];
int nIndex = 0;
do
{
nNodes[nIndex++] = nCounter;
nCounter = S.CounterInfo[nCounter].nParent;
} while(nCounter >= 0);
int nOffset = 0;
while(nIndex >= 0 && nOffset < (int)sizeof(Buffer) - 2)
{
uint32_t nLen = S.CounterInfo[nNodes[nIndex]].nNameLen + nOffset; // < sizeof(Buffer)-1
nLen = MicroProfileMin((uint32_t)(sizeof(Buffer) - 2 - nOffset), nLen);
memcpy(&Buffer[nOffset], S.CounterInfo[nNodes[nIndex]].pName, nLen);
nOffset += S.CounterInfo[nNodes[nIndex]].nNameLen + 1;
if(nIndex)
{
Buffer[nOffset++] = '/';
}
nIndex--;
}
return &Buffer[0];
}
MicroProfileToken MicroProfileCounterTokenInit(int nParent, uint32_t nFlags)
{
MP_ASSERT(0 == (nFlags & (~MICROPROFILE_COUNTER_FLAG_TYPE_MASK)));
MicroProfileToken nResult = S.nNumCounters++;
S.CounterInfo[nResult].nParent = nParent;
S.CounterInfo[nResult].nSibling = -1;
S.CounterInfo[nResult].nFirstChild = -1;
S.CounterInfo[nResult].nFlags = nFlags;
S.CounterInfo[nResult].eFormat = MICROPROFILE_COUNTER_FORMAT_DEFAULT;
S.CounterInfo[nResult].nLimit = 0;
S.CounterInfo[nResult].ExternalAtomic = 0;
S.CounterSource[nResult].pSource = 0;
S.CounterSource[nResult].nSourceSize = 0;
S.CounterInfo[nResult].nNameLen = 0;
S.CounterInfo[nResult].pName = nullptr;
S.CounterInfo[nResult].nWSNext = -2;
if(nParent >= 0)
{
MP_ASSERT(nParent < (int)S.nNumCounters);
S.CounterInfo[nResult].nSibling = S.CounterInfo[nParent].nFirstChild;
S.CounterInfo[nResult].nLevel = S.CounterInfo[nParent].nLevel + 1;
S.CounterInfo[nParent].nFirstChild = nResult;
}
else
{
S.CounterInfo[nResult].nLevel = 0;
}
return nResult;
}
void MicroProfileCounterTokenInitName(MicroProfileToken nToken, const char* pName)
{
MP_ASSERT(0 == S.CounterInfo[nToken].pName);
S.CounterInfo[nToken].nNameLen = (uint16_t)strlen(pName);
S.CounterInfo[nToken].pName = MicroProfileStringInternLower(pName);
}
MicroProfileToken MicroProfileGetCounterTokenByParent(int nParent, const char* pName, uint32_t nFlags)
{
for(uint32_t i = 0; i < S.nNumCounters; ++i)
{
if(nParent == S.CounterInfo[i].nParent && S.CounterInfo[i].pName == pName)
{
return i;
}
}
if(0 != (MICROPROFILE_COUNTER_FLAG_TOKEN_DONT_CREATE & nFlags))
return MICROPROFILE_INVALID_TOKEN;
MicroProfileToken nResult = MicroProfileCounterTokenInit(nParent, nFlags);
MicroProfileCounterTokenInitName(nResult, pName);
return nResult;
}
// by passing in last token/parent, and a non-changing static string,
// we can quickly return in case the parent is the same as before.
// Note that this doesn't support paths, but instead must be called once per level in the tree
// String must be preinterned.
MicroProfileToken MicroProfileCounterTokenTree(MicroProfileToken* LastToken, MicroProfileToken CurrentParent, const char* pString)
{
MicroProfileToken Token = *LastToken;
if(Token != MICROPROFILE_INVALID_TOKEN)
{
if(S.CounterInfo[Token].pName == pString && S.CounterInfo[Token].nParent == CurrentParent)
{
return Token;
}
}
MicroProfileInit();
MicroProfileScopeLock L(MicroProfileMutex());
Token = MicroProfileGetCounterTokenByParent(CurrentParent, pString, 0);
*LastToken = Token;
return Token;
}
const char* MicroProfileCounterString(const char* pString)
{
MicroProfileInit();
MicroProfileScopeLock L(MicroProfileMutex());
return MicroProfileStringInternLower(pString);
}
// Same as above, but works with non-static strings. always takes a lock, and does a search, so expect this to be not cheap
MicroProfileToken MicroProfileCounterTokenTreeDynamic(MicroProfileToken* LastToken, MicroProfileToken Parent, const char* pString)
{
(void)LastToken;
MicroProfileInit();
MicroProfileScopeLock L(MicroProfileMutex());
const char* pSubNameLower = MicroProfileStringInternLower(pString);
return MicroProfileGetCounterTokenByParent(Parent, pSubNameLower, 0);
}
MicroProfileToken MicroProfileGetCounterToken(const char* pName, uint32_t CounterFlag)
{
MicroProfileInit();
MicroProfileScopeLock L(MicroProfileMutex());
char SubName[MICROPROFILE_NAME_MAX_LEN];
MicroProfileToken nResult = MICROPROFILE_INVALID_TOKEN;
do
{
uint32_t nLen = 0;
pName = MicroProfileNextName(pName, &SubName[0], &nLen);
if(0 == nLen)
{
break;
}
const char* pSubNameLower = MicroProfileStringInternLower(SubName);
nResult = MicroProfileGetCounterTokenByParent(nResult, pSubNameLower, 0);
if(MICROPROFILE_INVALID_TOKEN == nResult)
return nResult;
} while(pName != 0);
S.CounterInfo[nResult].nFlags |= MICROPROFILE_COUNTER_FLAG_LEAF;
#if MICROPROFILE_COUNTER_HISTORY
if(CounterFlag & MICROPROFILE_COUNTER_FLAG_DOUBLE)
{
S.CounterInfo[nResult].nFlags |= MICROPROFILE_COUNTER_FLAG_DOUBLE;
S.dCounterMax[nResult] = -DBL_MAX;
S.dCounterMin[nResult] = DBL_MAX;
}
#endif
MP_ASSERT((int)nResult >= 0);
return nResult;
}
MicroProfileToken MicroProfileGetChildCounterToken(MicroProfileToken Parent, const char* pName)
{
MP_ASSERT(NULL == strpbrk(pName, "\\/")); // delimiters not supported when manually building the tree.
return MicroProfileCounterTokenTreeDynamic(nullptr, Parent, pName);
}
inline void MicroProfileLogPut(MicroProfileLogEntry LE, MicroProfileThreadLog* pLog)
{
MP_ASSERT(pLog != 0); // this assert is hit if MicroProfileOnCreateThread is not called
MP_ASSERT(pLog->nActive == 1); // Dont put after calling thread exit
uint32_t nPut = pLog->nPut.load(std::memory_order_relaxed);
uint32_t nNextPos = (nPut + 1) % MICROPROFILE_BUFFER_SIZE;
uint32_t nGet = pLog->nGet.load(std::memory_order_relaxed);
uint32_t nDistance = (nGet - nNextPos) % MICROPROFILE_BUFFER_SIZE;
MP_ASSERT(nDistance < MICROPROFILE_BUFFER_SIZE);
uint32_t nStackPut = pLog->nStackPut;
if(nDistance < nStackPut + 2)
{
S.nOverflow = 100;
}
else
{
pLog->Log[nPut] = LE;
pLog->nPut.store(nNextPos, std::memory_order_release);
}
}
inline uint64_t MicroProfileLogPutEnter(MicroProfileToken nToken_, uint64_t nTick, MicroProfileThreadLog* pLog)
{
MP_ASSERT(pLog != 0); // this assert is hit if MicroProfileOnCreateThread is not called
MP_ASSERT(pLog->nActive == 1); // Dont put after calling thread exit
uint32_t nStackPut = pLog->nStackPut;
if(nStackPut < MICROPROFILE_STACK_MAX)
{
uint64_t LE = MicroProfileMakeLogIndex(MP_LOG_ENTER, nToken_, nTick);
uint32_t nPut = pLog->nPut.load(std::memory_order_relaxed);
uint32_t nNextPos = (nPut + 1) % MICROPROFILE_BUFFER_SIZE;
uint32_t nGet = pLog->nGet.load(std::memory_order_acquire);
uint32_t nDistance = (nGet - nNextPos) % MICROPROFILE_BUFFER_SIZE;
MP_ASSERT(nDistance < MICROPROFILE_BUFFER_SIZE);
if(nDistance < nStackPut + 4) // 2 for ring buffer, 2 for the actual entries
{
S.nOverflow = 100;
return MICROPROFILE_INVALID_TICK;
}
else
{
#ifdef MICROPROFILE_VERIFY_BALANCED
pLog->VerifyStack[nStackPut] = LE;
#endif
pLog->nStackPut = nStackPut + 1;
pLog->Log[nPut] = LE;
pLog->nPut.store(nNextPos, std::memory_order_release);
return nTick;
}
}
else
{
S.nOverflow = 100;
pLog->nStackPut = nStackPut + 1;
return MICROPROFILE_DROPPED_TICK;
}
}
inline uint64_t MicroProfileLogPutEnterCStr(const char* pStr, uint64_t nTick, MicroProfileThreadLog* pLog)
{
MP_ASSERT(pLog != 0); // this assert is hit if MicroProfileOnCreateThread is not called
MP_ASSERT(pLog->nActive == 1); // Dont put after calling thread exit
uint32_t nStackPut = pLog->nStackPut;
if(nStackPut < MICROPROFILE_STACK_MAX)
{
uint64_t LE = MicroProfileMakeLogIndex(MP_LOG_ENTER, ETOKEN_CSTR_PTR, nTick);
uint64_t LEStr = MicroProfileMakeLogExtendedNoDataPtr((uint64_t)pStr);
MP_ASSERT(ETOKEN_CSTR_PTR == MicroProfileLogGetTimerIndex(LE));
uint32_t nPut = pLog->nPut.load(std::memory_order_relaxed);
uint32_t nNextPos = (nPut + 2) % MICROPROFILE_BUFFER_SIZE;
uint32_t nGet = pLog->nGet.load(std::memory_order_acquire);
uint32_t nDistance = (nGet - nNextPos) % MICROPROFILE_BUFFER_SIZE;
MP_ASSERT(nDistance < MICROPROFILE_BUFFER_SIZE);
if(nDistance < nStackPut + 6) // 2 for ring buffer, 4 for the actual entries
{
S.nOverflow = 100;
return MICROPROFILE_INVALID_TICK;
}
else
{
pLog->nStackPut = nStackPut + 1;
pLog->Log[nPut + 0] = LE;
pLog->Log[(nPut + 1) % MICROPROFILE_BUFFER_SIZE] = LEStr;
pLog->nPut.store(nNextPos, std::memory_order_release);
return nTick;
}
}
else
{
S.nOverflow = 100;
pLog->nStackPut = nStackPut + 1;
return MICROPROFILE_DROPPED_TICK;
}
}
inline void MicroProfileLogPutLeaveCStr(const char* pStr, uint64_t nTick, MicroProfileThreadLog* pLog)
{
MP_ASSERT(pLog != 0); // this assert is hit if MicroProfileOnCreateThread is not called
MP_ASSERT(pLog->nActive);
MP_ASSERT(pLog->nStackPut != 0);
uint32_t nStackPut = --(pLog->nStackPut);
MP_ASSERT(nStackPut < 0xf0000000);
if(nStackPut < MICROPROFILE_STACK_MAX)
{
uint64_t LE = MicroProfileMakeLogIndex(MP_LOG_LEAVE, ETOKEN_CSTR_PTR, nTick);
uint64_t LEStr = MicroProfileMakeLogExtendedNoDataPtr((uint64_t)pStr);
MP_ASSERT(ETOKEN_CSTR_PTR == MicroProfileLogGetTimerIndex(LE));
uint32_t nPos = pLog->nPut.load(std::memory_order_relaxed);
uint32_t nNextPos = (nPos + 2) % MICROPROFILE_BUFFER_SIZE;
uint32_t nGet = pLog->nGet.load(std::memory_order_acquire);
MP_ASSERT(nStackPut < MICROPROFILE_STACK_MAX);
MP_ASSERT(nNextPos != nGet); // should never happen
pLog->Log[nPos + 0] = LE;
pLog->Log[(nPos + 1) % MICROPROFILE_BUFFER_SIZE] = LEStr;
pLog->nPut.store(nNextPos, std::memory_order_release);
}
}
inline void MicroProfileLogPutLeave(MicroProfileToken nToken_, uint64_t nTick, MicroProfileThreadLog* pLog)
{
MP_ASSERT(pLog != 0); // this assert is hit if MicroProfileOnCreateThread is not called
MP_ASSERT(pLog->nActive);
MP_ASSERT(pLog->nStackPut != 0);
uint32_t nStackPut = --(pLog->nStackPut);
if(nStackPut < MICROPROFILE_STACK_MAX)
{
uint64_t LE = MicroProfileMakeLogIndex(MP_LOG_LEAVE, nToken_, nTick);
uint32_t nPos = pLog->nPut.load(std::memory_order_relaxed);
uint32_t nNextPos = (nPos + 1) % MICROPROFILE_BUFFER_SIZE;
uint32_t nGet = pLog->nGet.load(std::memory_order_acquire);
MP_ASSERT(nStackPut < MICROPROFILE_STACK_MAX);
MP_ASSERT(nNextPos != nGet); // should never happen
#ifdef MICROPROFILE_VERIFY_BALANCED
// verify what we pop is what we push.
uint64_t Pushed = pLog->VerifyStack[nStackPut];
uint64_t TimerPopped = MicroProfileLogGetTimerIndex(LE);
uint64_t TimerOnStack = MicroProfileLogGetTimerIndex(Pushed);
if(TimerPopped != TimerOnStack)
{
uprintf("Push/Pop Mismatch %s vs %s\n", S.TimerInfo[TimerPopped].pName, S.TimerInfo[TimerOnStack].pName);
MP_ASSERT(0);
}
#endif
pLog->Log[nPos] = LE;
pLog->nPut.store(nNextPos, std::memory_order_release);
}
}
inline void MicroProfileLogPut(MicroProfileToken nToken_, uint64_t nTick, uint64_t nBegin, MicroProfileThreadLog* pLog)
{
MicroProfileLogPut(MicroProfileMakeLogIndex(nBegin, nToken_, nTick), pLog);
}
inline void MicroProfileLogPutGpu(MicroProfileLogEntry LE, MicroProfileThreadLogGpu* pLog)
{
uint32_t nPos = pLog->nPut;
if(nPos < MICROPROFILE_GPU_BUFFER_SIZE)
{
pLog->Log[nPos] = LE;
pLog->nPut = nPos + 1;
}
}
inline void MicroProfileLogPutGpuTimer(MicroProfileToken nToken_, uint64_t nTick, uint64_t nBegin, MicroProfileThreadLogGpu* pLog)
{
MicroProfileLogPutGpu(MicroProfileMakeLogIndex(nBegin, nToken_, nTick), pLog);
}
inline void MicroProfileLogPutGpuExtended(EMicroProfileTokenExtended eTokenExt, uint32_t nDataSizeQWords, uint32_t nPayload, MicroProfileThreadLogGpu* pLog)
{
MicroProfileLogEntry LE = MicroProfileMakeLogExtended(eTokenExt, nDataSizeQWords, nPayload);
MicroProfileLogPutGpu(LE, pLog);
}
inline void MicroProfileLogPutGpuExtendedNoData(EMicroProfileTokenExtended eTokenExt, uint64_t nPayload, MicroProfileThreadLogGpu* pLog)
{
MicroProfileLogEntry LE = MicroProfileMakeLogExtendedNoData(eTokenExt, nPayload);
MicroProfileLogPutGpu(LE, pLog);
}
uint32_t MicroProfileGroupTokenActive(MicroProfileToken nToken_)
{
uint32_t nMask = MicroProfileGetGroupMask(nToken_);
uint32_t nIndex = MicroProfileGetGroupMaskIndex(nToken_);
return 0 != (S.nActiveGroups[nIndex] & nMask);
}
uint64_t MicroProfileEnterInternal(MicroProfileToken nToken_)
{
if(MicroProfileGroupTokenActive(nToken_))
{
uint64_t nTick = MP_TICK();
if(MICROPROFILE_PLATFORM_MARKERS_ENABLED)
{
uint32_t idx = MicroProfileGetTimerIndex(nToken_);
MicroProfileTimerInfo& TI = S.TimerInfo[idx];
MICROPROFILE_PLATFORM_MARKER_BEGIN(TI.nColor, TI.pNameExt);
return nTick;
}
else
{
return MicroProfileLogPutEnter(nToken_, nTick, MicroProfileGetThreadLog2());
}
}
return MICROPROFILE_INVALID_TICK;
}
uint64_t MicroProfileEnterInternalCStr(const char* pStr)
{
if(S.AnyActive)
{
uint64_t nTick = MP_TICK();
if(MICROPROFILE_PLATFORM_MARKERS_ENABLED)
{
MICROPROFILE_PLATFORM_MARKER_BEGIN(0, pStr);
return nTick;
}
else
{
return MicroProfileLogPutEnterCStr(pStr, nTick, MicroProfileGetThreadLog2());
}
}
return MICROPROFILE_INVALID_TICK;
}
void MicroProfileTimelineLeave(uint32_t id)
{
if(!id)
return;
std::lock_guard<std::recursive_mutex> Lock(MicroProfileTimelineMutex());
MicroProfileThreadLog* pLog = &S.TimelineLog;
uint32_t nPut = pLog->nPut.load(std::memory_order_relaxed);
uint32_t nNextPos = (nPut + 1) % MICROPROFILE_BUFFER_SIZE;
uint32_t nGet = pLog->nGet.load(std::memory_order_acquire);
uint32_t nDistance = (nGet - nNextPos) % MICROPROFILE_BUFFER_SIZE;
{
uint32_t nFrameStart = S.TimelineTokenFrameEnter[id % MICROPROFILE_TIMELINE_MAX_TOKENS];
uint32_t nFrameCurrent = S.nFrameCurrent;
if(nFrameCurrent < nFrameStart)
nFrameCurrent += MICROPROFILE_MAX_FRAME_HISTORY;
uint32_t nFrameDistance = (nFrameCurrent - nFrameStart) % MICROPROFILE_MAX_FRAME_HISTORY;
S.TimelineTokenFrameEnter[id % MICROPROFILE_TIMELINE_MAX_TOKENS] = MICROPROFILE_INVALID_FRAME;
S.TimelineTokenFrameLeave[id % MICROPROFILE_TIMELINE_MAX_TOKENS] = nFrameCurrent;
S.TimelineToken[id % MICROPROFILE_TIMELINE_MAX_TOKENS] = 0;
S.nTimelineFrameMax = MicroProfileMax(S.nTimelineFrameMax, nFrameDistance);
}
if(nDistance < 2 + 4)
{
S.nOverflow = 100;
}
else
{
uint64_t LEEnter = MicroProfileMakeLogIndex(MP_LOG_LEAVE, ETOKEN_CUSTOM_NAME, MP_TICK());
uint64_t LEId = MicroProfileMakeLogExtended(ETOKEN_CUSTOM_ID, 0, id);
pLog->Log[nPut++] = LEEnter;
nPut %= MICROPROFILE_BUFFER_SIZE;
pLog->Log[nPut++] = LEId;
nPut %= MICROPROFILE_BUFFER_SIZE;
pLog->nPut.store(nPut);
}
}
void MicroProfileTimelineEnterStatic(uint32_t nColor, const char* pStr)
{
if(!S.AnyActive)
return;
uint32_t nToken = MicroProfileTimelineEnterInternal(nColor, pStr, (uint32_t)strlen(pStr), true);
(void)nToken;
}
void MicroProfileTimelineLeaveStatic(const char* pStr)
{
if(!S.AnyActive)
return;
for(uint32_t i = 0; i < MICROPROFILE_TIMELINE_MAX_TOKENS; ++i)
{
if(S.TimelineTokenStaticString[i] && 0 == MP_STRCASECMP(pStr, S.TimelineTokenStaticString[i]))
{
MicroProfileTimelineLeave(S.TimelineToken[i]);
}
}
}
uint32_t MicroProfileTimelineEnterInternal(uint32_t nColor, const char* pStr, uint32_t nStrLen, int bIsStaticString)
{
if(!S.AnyActive)
return 0;
std::lock_guard<std::recursive_mutex> Lock(MicroProfileTimelineMutex());
MicroProfileThreadLog* pLog = &S.TimelineLog;
MP_ASSERT(pStr[nStrLen] == '\0');
nStrLen += 1;
uint32_t nStringQwords = MicroProfileGetQWordSize(nStrLen);
uint32_t nNumMessages = nStringQwords;
uint32_t nPut = pLog->nPut.load(std::memory_order_relaxed);
uint32_t nNextPos = (nPut + 1) % MICROPROFILE_BUFFER_SIZE;
uint32_t nGet = pLog->nGet.load(std::memory_order_acquire);
uint32_t nDistance = (nGet - nNextPos) % MICROPROFILE_BUFFER_SIZE;
if(nDistance < nNumMessages + 7)
{
S.nOverflow = 100;
return 0;
}
else
{
uint32_t token = pLog->nCustomId;
uint32_t nFrameLeave = S.TimelineTokenFrameLeave[token % MICROPROFILE_TIMELINE_MAX_TOKENS];
uint32_t nFrameEnter = S.TimelineTokenFrameEnter[token % MICROPROFILE_TIMELINE_MAX_TOKENS];
uint32_t nCounter = 0;
uint32_t nFrameCurrent = S.nFrameCurrent;
{
/// dont reuse tokens until their leave command has been dead for the maximum amount of frames we can generate a capture for.
while(token == 0 || nFrameEnter != MICROPROFILE_INVALID_FRAME || (nFrameCurrent - nFrameLeave < MICROPROFILE_MAX_FRAME_HISTORY + 3 && nFrameLeave != MICROPROFILE_INVALID_FRAME))
{
token = (uint32_t)pLog->nCustomId++;
nFrameLeave = S.TimelineTokenFrameLeave[token % MICROPROFILE_TIMELINE_MAX_TOKENS];
nFrameEnter = S.TimelineTokenFrameEnter[token % MICROPROFILE_TIMELINE_MAX_TOKENS];
if(++nCounter == MICROPROFILE_TIMELINE_MAX_TOKENS)
{
// MP_BREAK();
return 0;
}
}
S.TimelineTokenFrameEnter[token % MICROPROFILE_TIMELINE_MAX_TOKENS] = S.nFrameCurrent;
}
if(bIsStaticString)
{
S.TimelineTokenStaticString[token % MICROPROFILE_TIMELINE_MAX_TOKENS] = pStr;
}
else
{
S.TimelineTokenStaticString[token % MICROPROFILE_TIMELINE_MAX_TOKENS] = nullptr;
}
S.TimelineToken[token % MICROPROFILE_TIMELINE_MAX_TOKENS] = token;
uint64_t LEEnter = MicroProfileMakeLogIndex(MP_LOG_ENTER, ETOKEN_CUSTOM_NAME, MP_TICK());
uint64_t LEColor = MicroProfileMakeLogExtended(ETOKEN_CUSTOM_COLOR, 0, nColor);
uint64_t LEId = MicroProfileMakeLogExtended(ETOKEN_CUSTOM_ID, nStringQwords, token);
pLog->Log[nPut++] = LEEnter;
nPut %= MICROPROFILE_BUFFER_SIZE;
pLog->Log[nPut++] = LEColor;
nPut %= MICROPROFILE_BUFFER_SIZE;
pLog->Log[nPut++] = LEId;
nPut %= MICROPROFILE_BUFFER_SIZE;
// copy if we dont wrap
if(nPut + nStringQwords <= MICROPROFILE_BUFFER_SIZE)
{
memcpy(&pLog->Log[nPut], pStr, nStrLen + 1);
nPut += nStringQwords;
}
else
{
int nCharsLeft = (int)nStrLen;
while(nCharsLeft > 0)
{
int nCount = MicroProfileMin(nCharsLeft, 8);
memcpy(&pLog->Log[nPut++], pStr, nCount);
// uint64_t LEPayload = MicroProfileMakeLogPayload(pStr, nCount);
// pLog->Log[nPut++] = LEPayload; nPut %= MICROPROFILE_BUFFER_SIZE;
pStr += nCount;
nCharsLeft -= nCount;
}
}
pLog->nPut.store(nPut);
return token;
}
}
uint32_t MicroProfileTimelineEnter(uint32_t nColor, const char* pStr)
{
return MicroProfileTimelineEnterInternal(nColor, pStr, (uint32_t)strlen(pStr), false);
}
uint32_t MicroProfileTimelineEnterf(uint32_t nColor, const char* pStr, ...)
{
if(!S.AnyActive)
return 0;
char buffer[MICROPROFILE_MAX_STRING + 1];
va_list args;
va_start(args, pStr);
#ifdef _WIN32
size_t size = vsprintf_s(buffer, pStr, args);
#else
size_t size = vsnprintf(buffer, sizeof(buffer) - 1, pStr, args);
#endif
va_end(args);
MP_ASSERT(size < sizeof(buffer));
buffer[size] = '\0';
return MicroProfileTimelineEnterInternal(nColor, buffer, (uint32_t)size, false);
}
void MicroProfileLocalCounterAdd(int64_t* pCounter, int64_t nCount)
{
*pCounter += nCount;
}
int64_t MicroProfileLocalCounterSet(int64_t* pCounter, int64_t nCount)
{
int64_t r = *pCounter;
*pCounter = nCount;
return r;
}
void MicroProfileLocalCounterAddAtomic(MicroProfileToken nToken, int64_t nCount)
{
std::atomic<int64_t>* pCounter = &S.CounterInfo[nToken].ExternalAtomic;
pCounter->fetch_add(nCount);
}
int64_t MicroProfileLocalCounterSetAtomic(MicroProfileToken nToken, int64_t nCount)
{
std::atomic<int64_t>* pCounter = &S.CounterInfo[nToken].ExternalAtomic;
return pCounter->exchange(nCount);
}
void MicroProfileCounterAdd(MicroProfileToken nToken, int64_t nCount)
{
MP_ASSERT(nToken < S.nNumCounters);
S.Counters[nToken].fetch_add(nCount);
}
void MicroProfileCounterSet(MicroProfileToken nToken, int64_t nCount)
{
MP_ASSERT(nToken < S.nNumCounters);
S.Counters[nToken].store(nCount);
}
int64_t MicroProfileCounterGet(MicroProfileToken nToken)
{
MP_ASSERT(nToken < S.nNumCounters);
return S.Counters[nToken].load();
}
void MicroProfileCounterSetDouble(MicroProfileToken nToken, double nCount)
{
MP_ASSERT(nToken < S.nNumCounters);
MP_ASSERT((S.CounterInfo[nToken].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) == MICROPROFILE_COUNTER_FLAG_DOUBLE);
S.CountersDouble[nToken].store(nCount);
}
double MicroProfileCounterGetDouble(MicroProfileToken nToken)
{
MP_ASSERT(nToken < S.nNumCounters);
MP_ASSERT((S.CounterInfo[nToken].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) == MICROPROFILE_COUNTER_FLAG_DOUBLE);
return S.CountersDouble[nToken].load();
}
void MicroProfileCounterSetLimit(MicroProfileToken nToken, int64_t nCount)
{
MP_ASSERT(nToken < S.nNumCounters);
S.CounterInfo[nToken].nLimit = nCount;
}
void MicroProfileCounterSetLimitDouble(MicroProfileToken nToken, double dCount)
{
MP_ASSERT(nToken < S.nNumCounters);
MP_ASSERT((S.CounterInfo[nToken].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) == MICROPROFILE_COUNTER_FLAG_DOUBLE);
S.CounterInfo[nToken].dLimit = dCount;
}
void MicroProfileCounterConfigToken(MicroProfileToken nToken, uint32_t eFormat, int64_t nLimit, uint32_t nFlags)
{
S.CounterInfo[nToken].eFormat = (MicroProfileCounterFormat)eFormat;
S.CounterInfo[nToken].nLimit = nLimit;
S.CounterInfo[nToken].nFlags |= (nFlags & ~MICROPROFILE_COUNTER_FLAG_INTERNAL_MASK);
}
void MicroProfileCounterConfig(const char* pName, uint32_t eFormat, int64_t nLimit, uint32_t nFlags)
{
MicroProfileToken nToken = MicroProfileGetCounterToken(pName, 0);
MicroProfileCounterConfigToken(nToken, eFormat, nLimit, nFlags);
}
void MicroProfileCounterSetPtr(const char* pCounterName, void* pSource, uint32_t nSize)
{
MicroProfileToken nToken = MicroProfileGetCounterToken(pCounterName, 0);
S.CounterSource[nToken].pSource = pSource;
S.CounterSource[nToken].nSourceSize = nSize;
}
inline void MicroProfileFetchCounter(uint32_t i)
{
MP_ASSERT(0 == S.CounterSource[i].nSourceSize || (S.CounterInfo[i].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) == MICROPROFILE_COUNTER_FLAG_DOUBLE);
switch(S.CounterSource[i].nSourceSize)
{
case sizeof(int32_t):
S.Counters[i] = *(int32_t*)S.CounterSource[i].pSource;
break;
case sizeof(int64_t):
S.Counters[i] = *(int64_t*)S.CounterSource[i].pSource;
break;
default:
break;
}
}
void MicroProfileCounterFetchCounters()
{
for(uint32_t i = 0; i < S.nNumCounters; ++i)
{
MicroProfileFetchCounter(i);
}
}
void MicroProfileLeaveInternal(MicroProfileToken nToken_, uint64_t nTickStart)
{
if(MICROPROFILE_INVALID_TICK != nTickStart)
{
if(MICROPROFILE_PLATFORM_MARKERS_ENABLED)
{
MICROPROFILE_PLATFORM_MARKER_END();
}
else
{
uint64_t nTick = MP_TICK();
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog2();
MicroProfileLogPutLeave(nToken_, nTick, pLog);
}
}
}
void MicroProfileLeaveInternalCStr(const char* pStr, uint64_t nTickStart)
{
if(MICROPROFILE_INVALID_TICK != nTickStart)
{
if(MICROPROFILE_PLATFORM_MARKERS_ENABLED)
{
MICROPROFILE_PLATFORM_MARKER_END();
}
else
{
uint64_t nTick = MP_TICK();
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog2();
MicroProfileLogPutLeaveCStr(pStr, nTick, pLog);
}
}
}
void MicroProfileEnter(MicroProfileToken nToken)
{
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog2();
MP_ASSERT(pLog->nStackScope < MICROPROFILE_STACK_MAX); // if youre hitting this assert you probably have mismatched _ENTER/_LEAVE markers
uint32_t nStackPos = pLog->nStackScope++;
if(nStackPos < MICROPROFILE_STACK_MAX)
{
MicroProfileScopeStateC* pScopeState = &pLog->ScopeState[nStackPos];
pScopeState->Token = nToken;
pScopeState->nTick = MicroProfileEnterInternal(nToken);
}
else
{
S.nOverflow = 100;
}
}
void MicroProfileLeave()
{
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog2();
MP_ASSERT(pLog->nStackScope > 0); // if youre hitting this assert you probably have mismatched _ENTER/_LEAVE markers
uint32_t nStackPos = --pLog->nStackScope;
if(nStackPos < MICROPROFILE_STACK_MAX)
{
MicroProfileScopeStateC* pScopeState = &pLog->ScopeState[nStackPos];
MicroProfileLeaveInternal(pScopeState->Token, pScopeState->nTick);
}
else
{
S.nOverflow = 100;
}
}
void MicroProfileEnterGpu(MicroProfileToken nToken, MicroProfileThreadLogGpu* pLog)
{
// MP_ASSERT(pLog->nStackScope < MICROPROFILE_STACK_MAX); // if youre hitting this assert you probably have mismatched _ENTER/_LEAVE markers
uint32_t nStackPos = pLog->nStackScope++;
if(nStackPos < MICROPROFILE_STACK_MAX)
{
MicroProfileScopeStateC* pScopeState = &pLog->ScopeState[nStackPos];
pScopeState->Token = nToken;
pScopeState->nTick = MicroProfileGpuEnterInternal(pLog, nToken);
}
else
{
S.nOverflow = 100;
}
}
void MicroProfileLeaveGpu(MicroProfileThreadLogGpu* pLog)
{
uint32_t nStackPos = --pLog->nStackScope;
if(nStackPos < MICROPROFILE_STACK_MAX)
{
MicroProfileScopeStateC* pScopeState = &pLog->ScopeState[nStackPos];
MicroProfileGpuLeaveInternal(pLog, pScopeState->Token, pScopeState->nTick);
}
}
void MicroProfileGpuBegin(void* pContext, MicroProfileThreadLogGpu* pLog)
{
MP_ASSERT(pLog->pContext == (void*)-1); // dont call begin without calling end
MP_ASSERT(pLog->nStart == (uint32_t)-1);
MP_ASSERT(pContext != (void*)-1);
pLog->pContext = pContext;
pLog->nStart = pLog->nPut;
MicroProfileLogPutGpu(0, pLog);
}
void MicroProfileGpuSetContext(void* pContext, MicroProfileThreadLogGpu* pLog)
{
MP_ASSERT(pLog->pContext != (void*)-1); // dont call begin without calling end
MP_ASSERT(pLog->nStart != (uint32_t)-1);
pLog->pContext = pContext;
}
uint64_t MicroProfileGpuEnd(MicroProfileThreadLogGpu* pLog)
{
uint64_t nStart = pLog->nStart;
uint32_t nEnd = pLog->nPut;
uint64_t nId = pLog->nId;
if(nStart < MICROPROFILE_GPU_BUFFER_SIZE)
{
pLog->Log[nStart] = nEnd - nStart - 1;
}
pLog->pContext = (void*)-1;
pLog->nStart = (uint32_t)-1;
return nStart | (nId << 32);
}
void MicroProfileGpuSubmit(int nQueue, uint64_t nWork)
{
MP_ASSERT(nQueue >= 0 && nQueue < MICROPROFILE_MAX_THREADS);
MICROPROFILE_SCOPE(g_MicroProfileGpuSubmit);
uint32_t nStart = (uint32_t)nWork;
uint32_t nThreadLog = uint32_t(nWork >> 32);
MicroProfileThreadLog* pQueueLog = S.Pool[nQueue];
MP_ASSERT(nQueue < MICROPROFILE_MAX_THREADS);
MicroProfileThreadLogGpu* pGpuLog = S.PoolGpu[nThreadLog];
MP_ASSERT(pGpuLog);
int64_t nCount = 0;
if(nStart < MICROPROFILE_GPU_BUFFER_SIZE)
{
nCount = pGpuLog->Log[nStart];
}
MP_ASSERT(nCount < (int64_t)MICROPROFILE_GPU_BUFFER_SIZE);
nStart++;
for(int32_t i = 0; i < nCount; ++i)
{
MP_ASSERT(nStart < MICROPROFILE_GPU_BUFFER_SIZE);
MicroProfileLogEntry LE = pGpuLog->Log[nStart++];
MicroProfileLogPut(LE, pQueueLog);
}
}
uint64_t MicroProfileGpuEnterInternal(MicroProfileThreadLogGpu* pGpuLog, MicroProfileToken nToken_)
{
if(MicroProfileGroupTokenActive(nToken_))
{
if(!MicroProfileGetThreadLog())
{
MicroProfileInitThreadLog();
}
MP_ASSERT(pGpuLog->pContext != (void*)-1); // must be called between GpuBegin/GpuEnd
uint64_t nTimer = MicroProfileGpuInsertTimeStamp(pGpuLog->pContext);
MicroProfileLogPutGpuTimer(nToken_, nTimer, MP_LOG_ENTER, pGpuLog);
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog();
MicroProfileLogPutGpuExtendedNoData(ETOKEN_GPU_CPU_TIMESTAMP, MP_TICK(), pGpuLog);
MicroProfileLogPutGpuExtendedNoData(ETOKEN_GPU_CPU_SOURCE_THREAD, pLog->nLogIndex, pGpuLog);
// MP_ASSERT(pGpuLog->pContext != (void*)-1); // must be called between GpuBegin/GpuEnd
// uint64_t nTimer = MicroProfileGpuInsertTimeStamp(pGpuLog->pContext);
// MicroProfileLogPutGpu(nToken_, nTimer, MP_LOG_ENTER, pGpuLog);
// MicroProfileThreadLog* pLog = MicroProfileGetThreadLog();
// MicroProfileLogPutGpu(ETOKEN_GPU_CPU_TIMESTAMP, MP_TICK(), MP_LOG_EXTRA_DATA, pGpuLog);
// MicroProfileLogPutGpu(ETOKEN_GPU_CPU_SOURCE_THREAD, pLog->nLogIndex, MP_LOG_EXTRA_DATA, pGpuLog);
return 1;
}
return 0;
}
uint64_t MicroProfileGpuEnterInternalCStr(MicroProfileThreadLogGpu* pGpuLog, const char* pStr)
{
MP_BREAK(); // not implemented
return 0;
// if(S.AnyGpuActive)
// {
// if(!MicroProfileGetThreadLog())
// {
// MicroProfileInitThreadLog();
// }
// MP_ASSERT(pGpuLog->pContext != (void*)-1); // must be called between GpuBegin/GpuEnd
// uint64_t nTimer = MicroProfileGpuInsertTimeStamp(pGpuLog->pContext);
// MicroProfileLogPutGpuTimer(nToken_, nTimer, MP_LOG_ENTER, pGpuLog);
// MicroProfileThreadLog* pLog = MicroProfileGetThreadLog();
// MicroProfileLogPutGpuExtendedNoData(ETOKEN_GPU_CPU_TIMESTAMP, MP_TICK(), pGpuLog);
// MicroProfileLogPutGpuExtendedNoData(ETOKEN_GPU_CPU_SOURCE_THREAD, pLog->nLogIndex, pGpuLog);
// // MP_ASSERT(pGpuLog->pContext != (void*)-1); // must be called between GpuBegin/GpuEnd
// // uint64_t nTimer = MicroProfileGpuInsertTimeStamp(pGpuLog->pContext);
// // MicroProfileLogPutGpu(nToken_, nTimer, MP_LOG_ENTER, pGpuLog);
// // MicroProfileThreadLog* pLog = MicroProfileGetThreadLog();
// // MicroProfileLogPutGpu(ETOKEN_GPU_CPU_TIMESTAMP, MP_TICK(), MP_LOG_EXTRA_DATA, pGpuLog);
// // MicroProfileLogPutGpu(ETOKEN_GPU_CPU_SOURCE_THREAD, pLog->nLogIndex, MP_LOG_EXTRA_DATA, pGpuLog);
// return 1;
// }
// return 0;
}
void MicroProfileGpuLeaveInternal(MicroProfileThreadLogGpu* pGpuLog, MicroProfileToken nToken_, uint64_t nTickStart)
{
if(nTickStart)
{
if(!MicroProfileGetThreadLog())
{
MicroProfileInitThreadLog();
}
MP_ASSERT(pGpuLog->pContext != (void*)-1); // must be called between GpuBegin/GpuEnd
uint64_t nTimer = MicroProfileGpuInsertTimeStamp(pGpuLog->pContext);
MicroProfileLogPutGpuTimer(nToken_, nTimer, MP_LOG_LEAVE, pGpuLog);
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog();
MicroProfileLogPutGpuExtendedNoData(ETOKEN_GPU_CPU_TIMESTAMP, MP_TICK(), pGpuLog);
MicroProfileLogPutGpuExtendedNoData(ETOKEN_GPU_CPU_SOURCE_THREAD, pLog->nLogIndex, pGpuLog);
}
}
void MicroProfileGpuLeaveInternalCStr(MicroProfileThreadLogGpu* pGpuLog, uint64_t nTickStart)
{
MP_BREAK(); // not implemented
return;
// if(nTickStart)
// {
// if(!MicroProfileGetThreadLog())
// {
// MicroProfileInitThreadLog();
// }
// MP_ASSERT(pGpuLog->pContext != (void*)-1); // must be called between GpuBegin/GpuEnd
// uint64_t nTimer = MicroProfileGpuInsertTimeStamp(pGpuLog->pContext);
// MicroProfileLogPutGpuTimer(nToken_, nTimer, MP_LOG_LEAVE, pGpuLog);
// MicroProfileThreadLog* pLog = MicroProfileGetThreadLog();
// MicroProfileLogPutGpuExtendedNoData(ETOKEN_GPU_CPU_TIMESTAMP, MP_TICK(), pGpuLog);
// MicroProfileLogPutGpuExtendedNoData(ETOKEN_GPU_CPU_SOURCE_THREAD, pLog->nLogIndex, pGpuLog);
// }
}
void MicroProfileContextSwitchPut(MicroProfileContextSwitch* pContextSwitch)
{
if(0 == S.nPauseTicks || (S.nPauseTicks - pContextSwitch->nTicks) > 0)
{
uint32_t nPut = S.nContextSwitchPut;
S.ContextSwitch[nPut] = *pContextSwitch;
S.nContextSwitchPut = (S.nContextSwitchPut + 1) % MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE;
// if(S.nContextSwitchPut < nPut)
//{
// float fMsDelay = MicroProfileTickToMsMultiplierCpu() * ((int64_t)S.nFlipStartTick - pContextSwitch->nTicks);
// uprintf("context switch wrap .. %7.3fms\n", fMsDelay);
// }
// if(S.nContextSwitchPut % 1024 == 0)
//{
// float fMsDelay = MicroProfileTickToMsMultiplierCpu() * ((int64_t)S.nFlipStartTick - pContextSwitch->nTicks);
// uprintf("cswitch tick %x ... %7.3fms\n", S.nContextSwitchPut, fMsDelay);
// }
S.nContextSwitchLastPushed = pContextSwitch->nTicks;
}
else
{
S.nContextSwitchStalledTick = MP_TICK();
}
}
void MicroProfileGetRange(uint32_t nPut, uint32_t nGet, uint32_t nRange[2][2])
{
if(nPut > nGet)
{
nRange[0][0] = nGet;
nRange[0][1] = nPut;
nRange[1][0] = nRange[1][1] = 0;
}
else if(nPut != nGet)
{
MP_ASSERT(nGet != MICROPROFILE_BUFFER_SIZE);
uint32_t nCountEnd = MICROPROFILE_BUFFER_SIZE - nGet;
nRange[0][0] = nGet;
nRange[0][1] = nGet + nCountEnd;
nRange[1][0] = 0;
nRange[1][1] = nPut;
}
}
void MicroProfileToggleFrozen()
{
S.nFrozen = !S.nFrozen;
}
int MicroProfileIsFrozen()
{
return S.nFrozen != 0 ? 1 : 0;
}
int MicroProfileEnabled()
{
return MicroProfileAnyGroupActive();
}
void* MicroProfileAllocInternal(size_t nSize, size_t nAlign)
{
nAlign = MicroProfileMax(4 * sizeof(uint32_t), nAlign);
nSize += nAlign;
intptr_t nPtr = (intptr_t)MICROPROFILE_ALLOC(nSize, nAlign);
nPtr += nAlign;
uint32_t* pVal = (uint32_t*)nPtr;
MP_ASSERT(nSize < 0xffffffff);
MP_ASSERT(nAlign < 0xffffffff);
pVal[-1] = (uint32_t)nSize;
pVal[-2] = (uint32_t)nAlign;
pVal[-3] = (uint32_t)0x28586813;
MicroProfileCounterAdd(S.CounterToken_Alloc_Memory, nSize);
MicroProfileCounterAdd(S.CounterToken_Alloc_Count, 1);
return (void*)nPtr;
}
void MicroProfileFreeInternal(void* pPtr)
{
intptr_t p = (intptr_t)pPtr;
uint32_t* p4 = (uint32_t*)pPtr;
uint32_t nSize = p4[-1];
uint32_t nAlign = p4[-2];
uint32_t nMagic = p4[-3];
MP_ASSERT(nMagic == 0x28586813);
MICROPROFILE_FREE((void*)(p - nAlign));
MicroProfileCounterAdd(S.CounterToken_Alloc_Memory, -(int)nSize);
MicroProfileCounterAdd(S.CounterToken_Alloc_Count, -1);
}
void* MicroProfileReallocInternal(void* pPtr, size_t nSize)
{
intptr_t p = (intptr_t)pPtr;
uint32_t nAlignBase;
if(p)
{
uint32_t* p4 = (uint32_t*)pPtr;
uint32_t nSizeBase = p4[-1];
nAlignBase = p4[-2];
uint32_t nMagicBase = p4[-3];
MP_ASSERT(nMagicBase == 0x28586813);
MicroProfileCounterAdd(S.CounterToken_Alloc_Memory, nSize - nSizeBase);
}
else
{
nAlignBase = 4 * sizeof(uint32_t);
MicroProfileCounterAdd(S.CounterToken_Alloc_Memory, nSize + nAlignBase);
MicroProfileCounterAdd(S.CounterToken_Alloc_Count, 1);
}
nSize += nAlignBase;
MP_ASSERT(nAlignBase >= 4 * sizeof(uint32_t));
if(p)
{
p = (intptr_t)MICROPROFILE_REALLOC((void*)(p - nAlignBase), nSize);
}
else
{
p = (intptr_t)MICROPROFILE_REALLOC((void*)(p), nSize);
}
p += nAlignBase;
uint32_t* pVal = (uint32_t*)p;
MP_ASSERT(nSize < 0xffffffff);
MP_ASSERT(nAlignBase < 0xffffffff);
pVal[-1] = (uint32_t)nSize;
pVal[-2] = (uint32_t)nAlignBase;
pVal[-3] = (uint32_t)0x28586813;
return (void*)p;
}
static void MicroProfileFlipEnabled()
{
if(S.nFrozen)
{
memset(S.nActiveGroups, 0, sizeof(S.nActiveGroups));
S.AnyActive = false;
}
else
{
bool AnyActive = false;
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
uint32_t nNew = S.nActiveGroupsWanted[i];
nNew |= S.nForceGroups[i];
if(nNew)
AnyActive = true;
if(S.nActiveGroups[i] != nNew)
{
S.nActiveGroups[i] = nNew;
}
}
S.AnyActive = AnyActive;
}
}
void MicroProfileFlip(void* pContext, uint32_t FlipFlag)
{
MicroProfileFlip_CB(pContext, nullptr, FlipFlag);
}
#define MICROPROFILE_TICK_VALIDATE_FRAME_TIME 0
void MicroProfileFlip_CB(void* pContext, MicroProfileOnFreeze FreezeCB, uint32_t FlipFlag)
{
MICROPROFILE_COUNTER_LOCAL_UPDATE_SET_ATOMIC(g_MicroProfileBytesPerFlip);
#if 0
//verify LogEntry wraps correctly
MicroProfileLogEntry c = MP_LOG_TICK_MASK-5000;
for(int i = 0; i < 10000; ++i, c += 1)
{
MicroProfileLogEntry l2 = (c+2500) & MP_LOG_TICK_MASK;
MP_ASSERT(2500 == MicroProfileLogTickDifference(c, l2));
}
#endif
MICROPROFILE_SCOPE(g_MicroProfileFlip);
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
if(S.nDumpFileNextFrame)
{
if(0 == S.nDumpFileCountDown)
{
MicroProfileDumpToFile();
S.nDumpFileNextFrame = 0;
S.nAutoClearFrames = MICROPROFILE_GPU_FRAME_DELAY + 3; // hide spike from dumping webpage
}
else
{
S.nDumpFileCountDown--;
}
}
#if MICROPROFILE_WEBSERVER
if(MICROPROFILE_FLIP_FLAG_START_WEBSERVER == (MICROPROFILE_FLIP_FLAG_START_WEBSERVER & FlipFlag) && S.nWebServerDataSent == (uint64_t)-1)
{
MicroProfileWebServerStart();
S.nWebServerDataSent = 0;
if(!S.WebSocketThreadRunning)
{
S.WebSocketThreadRunning = 1;
MicroProfileThreadStart(&S.WebSocketSendThread, MicroProfileSocketSenderThread);
}
}
#endif
int nLoop = 0;
do
{
#if MICROPROFILE_WEBSERVER
if(MicroProfileWebServerUpdate())
{
S.nAutoClearFrames = MICROPROFILE_GPU_FRAME_DELAY + 3; // hide spike from dumping webpage
}
#endif
if(nLoop++)
{
MicroProfileSleep(100);
if((nLoop % 10) == 0)
{
uprintf("microprofile frozen %d\n", nLoop);
}
}
} while(S.nFrozen);
uint32_t nAggregateClear = S.nAggregateClear || S.nAutoClearFrames, nAggregateFlip = 0;
if(S.nAutoClearFrames)
{
nAggregateClear = 1;
nAggregateFlip = 1;
S.nAutoClearFrames -= 1;
}
bool nRunning = MicroProfileAnyGroupActive();
if(nRunning)
{
S.nFlipStartTick = MP_TICK();
int64_t nGpuWork = MicroProfileGpuEnd(S.pGpuGlobal);
MicroProfileGpuSubmit(S.GpuQueue, nGpuWork);
MicroProfileThreadLogGpuReset(S.pGpuGlobal);
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
if(S.PoolGpu[i])
{
S.PoolGpu[i]->nPut = 0;
}
}
MicroProfileGpuBegin(pContext, S.pGpuGlobal);
uint32_t nGpuTimeStamp = MicroProfileGpuFlip(pContext);
uint64_t nFrameIdx = S.nFramePutIndex++;
S.nFramePut = (S.nFramePut + 1) % MICROPROFILE_MAX_FRAME_HISTORY;
S.Frames[S.nFramePut].nFrameId = nFrameIdx;
MP_ASSERT((S.nFramePutIndex % MICROPROFILE_MAX_FRAME_HISTORY) == S.nFramePut);
S.nFrameCurrent = (S.nFramePut + MICROPROFILE_MAX_FRAME_HISTORY - MICROPROFILE_GPU_FRAME_DELAY - 1) % MICROPROFILE_MAX_FRAME_HISTORY;
S.nFrameCurrentIndex++;
uint32_t nFrameNext = (S.nFrameCurrent + 1) % MICROPROFILE_MAX_FRAME_HISTORY;
S.nFrameNext = nFrameNext;
uint32_t nContextSwitchPut = S.nContextSwitchPut;
if(S.nContextSwitchLastPut < nContextSwitchPut)
{
S.nContextSwitchUsage = (nContextSwitchPut - S.nContextSwitchLastPut);
}
else
{
S.nContextSwitchUsage = MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE - S.nContextSwitchLastPut + nContextSwitchPut;
}
S.nContextSwitchLastPut = nContextSwitchPut;
MicroProfileFrameState* pFramePut = &S.Frames[S.nFramePut];
MicroProfileFrameState* pFrameCurrent = &S.Frames[S.nFrameCurrent];
MicroProfileFrameState* pFrameNext = &S.Frames[nFrameNext];
const int64_t nTickStartFrame = pFrameCurrent->nFrameStartCpu;
const int64_t nTickEndFrame = pFrameNext->nFrameStartCpu;
pFrameCurrent->nGpuPending = 0;
pFramePut->nGpuPending = 1;
pFramePut->nFrameStartCpu = MP_TICK();
pFramePut->nFrameStartGpu = nGpuTimeStamp;
{
const float fDumpTimeThreshold = 1000.f * 60 * 60 * 24 * 365.f; // if time above this, then we're handling uninitialized counters
int nDumpNextFrame = 0;
float fTimeGpu = 0.f;
if(pFrameNext->nFrameStartGpu != MICROPROFILE_INVALID_TICK)
{
uint64_t nTickCurrent = pFrameCurrent->nFrameStartGpu;
uint64_t nTickNext = pFrameNext->nFrameStartGpu = MicroProfileGpuGetTimeStamp((uint32_t)pFrameNext->nFrameStartGpu);
nTickCurrent = MicroProfileLogTickMin(nTickCurrent, nTickNext);
float fTime = 1000.f * (nTickNext - nTickCurrent) / (MicroProfileTicksPerSecondGpu());
fTime = fTimeGpu;
if(S.fDumpGpuSpike > 0.f && fTime > S.fDumpGpuSpike && fTime < fDumpTimeThreshold)
{
nDumpNextFrame = 1;
}
}
float fTimeCpu = 1000.f * (pFrameNext->nFrameStartCpu - pFrameCurrent->nFrameStartCpu) / MicroProfileTicksPerSecondCpu();
if(S.fDumpCpuSpike > 0.f && fTimeCpu > S.fDumpCpuSpike && fTimeCpu < fDumpTimeThreshold)
{
nDumpNextFrame = 1;
}
if(nDumpNextFrame)
{
S.nDumpFileNextFrame = S.nDumpSpikeMask;
S.nDumpSpikeMask = 0;
S.nDumpFileCountDown = 5;
}
}
const uint64_t nTickEndFrameGpu_ = pFrameNext->nFrameStartGpu;
const uint64_t nTickStartFrameGpu_ = pFrameCurrent->nFrameStartGpu;
const bool bGpuFrameInvalid = nTickEndFrameGpu_ == MICROPROFILE_INVALID_TICK || nTickStartFrameGpu_ == MICROPROFILE_INVALID_TICK;
const uint64_t nTickEndFrameGpu = bGpuFrameInvalid ? 1 : nTickEndFrameGpu_;
const uint64_t nTickStartFrameGpu = bGpuFrameInvalid ? 2 : nTickStartFrameGpu_;
MicroProfileFrameExtraCounterData* ExtraData = S.FrameExtraCounterData;
bool UsingExtraData = false;
if(ExtraData)
{
if((intptr_t)ExtraData == 1)
{
size_t Bytes = sizeof(MicroProfileFrameExtraCounterData) * MICROPROFILE_MAX_FRAME_HISTORY;
printf(" allocating %d bytes %f\n", (int)Bytes, Bytes / (1024.0 * 1024.0));
ExtraData = S.FrameExtraCounterData = (MicroProfileFrameExtraCounterData*)MicroProfileAllocInternal(Bytes, alignof(uint64_t));
memset(ExtraData, 0, Bytes);
}
ExtraData = ExtraData + S.nFrameCurrent;
UsingExtraData = true;
}
#define MP_ASSERT_LE_WRAP(l, g) MP_ASSERT(uint64_t(g - l) < 0x8000000000000000)
{
MP_ASSERT_LE_WRAP(nTickStartFrame, nTickEndFrame);
uint64_t nTick = nTickEndFrame - nTickStartFrame;
S.nFlipTicks = nTick;
S.nFlipAggregate += nTick;
S.nFlipMax = MicroProfileMax(S.nFlipMax, nTick);
}
uint32_t* pTimerToGroup = &S.TimerToGroup[0];
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
MicroProfileThreadLog* pLog = S.Pool[i];
if(!pLog)
{
pFramePut->nLogStart[i] = 0;
}
else
{
uint32_t nPut = pLog->nPut.load(std::memory_order_acquire);
pFramePut->nLogStart[i] = nPut;
if(!pLog->nGpu)
{
uint32_t nStart = pFrameCurrent->nLogStart[i];
while(nStart != nPut)
{
int64_t LE = pLog->Log[nStart];
int64_t nDifference = MicroProfileLogTickDifference(LE, nTickEndFrame);
uint32_t Ext = MicroProfileLogGetType(LE);
if(nDifference > 0 || 0 != (0x2 & Ext))
{
nStart = (nStart + 1) % MICROPROFILE_BUFFER_SIZE;
}
else
{
break;
}
}
pFrameNext->nLogStart[i] = nStart;
}
}
}
{
pFramePut->nLogStartTimeline = S.TimelineLog.nPut.load(std::memory_order_acquire);
uint32_t nFrameCurrent = S.nFrameCurrent;
uint32_t nTimelineFrameDeltaMax = S.nTimelineFrameMax;
for(uint32_t i = 0; i != MICROPROFILE_TIMELINE_MAX_TOKENS; ++i)
{
uint32_t nFrameStart = S.TimelineTokenFrameEnter[i];
if(nFrameStart != MICROPROFILE_INVALID_FRAME)
{
uint32_t nCur = nFrameCurrent;
if(nCur < nFrameStart)
nCur += MICROPROFILE_MAX_FRAME_HISTORY;
if(nCur >= nFrameStart)
{
uint32_t D = nCur - nFrameStart;
nTimelineFrameDeltaMax = MicroProfileMax(nTimelineFrameDeltaMax, D);
}
}
}
pFramePut->nTimelineFrameMax = nTimelineFrameDeltaMax;
S.nTimelineFrameMax = 0;
}
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
MicroProfileThreadLog* pLog = S.Pool[i];
if(!pLog)
continue;
if(pLog->nGpu)
{
uint32_t nPut = pFrameNext->nLogStart[i];
uint32_t nGet = pFrameCurrent->nLogStart[i];
uint32_t nRange[2][2] = {
{ 0, 0 },
{ 0, 0 },
};
MicroProfileGetRange(nPut, nGet, nRange);
for(uint32_t j = 0; j < 2; ++j)
{
uint32_t nStart = nRange[j][0];
uint32_t nEnd = nRange[j][1];
for(uint32_t k = nStart; k < nEnd; ++k)
{
MicroProfileLogEntry L = pLog->Log[k];
if(MicroProfileLogGetType(L) < MP_LOG_EXTENDED)
{
pLog->Log[k] = MicroProfileLogSetTick(L, MicroProfileGpuGetTimeStamp((uint32_t)MicroProfileLogGetTick(L)));
}
k += MicroProfileLogGetDataSize(L);
}
}
}
}
}
{
MicroProfile::GroupTime* pFrameGroup = &S.FrameGroup[0];
{
MICROPROFILE_SCOPE(g_MicroProfileClear);
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
S.Frame[i].nTicks = 0;
S.Frame[i].nCount = 0;
S.FrameExclusive[i] = 0;
}
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUPS; ++i)
{
pFrameGroup[i].nTicks = 0;
pFrameGroup[i].nTicksExclusive = 0;
pFrameGroup[i].nCount = 0;
}
}
{
MICROPROFILE_SCOPE(g_MicroProfileThreadLoop);
memset(S.FrameGroupThreadValid, 0, sizeof(S.FrameGroupThreadValid));
for(uint32_t idx_thread = 0; idx_thread < MICROPROFILE_MAX_THREADS; ++idx_thread)
{
MicroProfileThreadLog* pLog = S.Pool[idx_thread];
if(!pLog)
continue;
bool bGpu = pLog->nGpu != 0;
int64_t nTickStartLog = bGpu ? nTickStartFrameGpu : nTickStartFrame;
int64_t nTickEndLog = bGpu ? nTickEndFrameGpu : nTickEndFrame;
float fToMs = bGpu ? MicroProfileTickToMsMultiplierGpu() : MicroProfileTickToMsMultiplierCpu();
float fFrameTime = fToMs * (nTickEndLog - nTickStartLog);
MicroProfile::GroupTime* pFrameGroupThread = &S.FrameGroupThread[idx_thread][0];
uint32_t nPut = pFrameNext->nLogStart[idx_thread];
uint32_t nGet = pFrameCurrent->nLogStart[idx_thread];
uint32_t nRange[2][2] = {
{ 0, 0 },
{ 0, 0 },
};
MicroProfileGetRange(nPut, nGet, nRange);
if(nPut != nGet)
{
S.FrameGroupThreadValid[idx_thread / 32] |= 1 << (idx_thread % 32);
memset(pFrameGroupThread, 0, sizeof(S.FrameGroupThread[idx_thread]));
}
uint64_t* pStackLog = &pLog->nStackLogEntry[0];
uint64_t* pChildTickStack = &pLog->nChildTickStack[1];
int32_t nStackPos = pLog->nStackPos;
uint8_t TimerStackPos[MICROPROFILE_MAX_TIMERS];
uint8_t GroupStackPos[MICROPROFILE_MAX_GROUPS];
memset(TimerStackPos, 0, sizeof(TimerStackPos));
memset(GroupStackPos, 0, sizeof(GroupStackPos));
// restore group and timer stack pos.
for(int32_t i = 0; i < nStackPos; ++i)
{
uint64_t nTimer = MicroProfileLogGetTimerIndex(pStackLog[i]);
uint32_t nGroup = pTimerToGroup[nTimer];
MP_ASSERT(nTimer < MICROPROFILE_MAX_TIMERS);
MP_ASSERT(nGroup < MICROPROFILE_MAX_GROUPS);
TimerStackPos[nTimer]++;
GroupStackPos[nGroup]++;
}
for(uint32_t j = 0; j < 2; ++j)
{
uint32_t nStart = nRange[j][0];
uint32_t nEnd = nRange[j][1];
for(uint32_t k = nStart; k < nEnd; ++k)
{
MicroProfileLogEntry LE = pLog->Log[k];
uint32_t nType = MicroProfileLogGetType(LE);
switch(nType)
{
case MP_LOG_ENTER:
{
uint64_t nTimer = MicroProfileLogGetTimerIndex(LE);
if(nTimer != ETOKEN_CSTR_PTR)
{
MP_ASSERT(nTimer < S.nTotalTimers);
uint32_t nGroup = pTimerToGroup[nTimer];
MP_ASSERT(nStackPos < MICROPROFILE_STACK_MAX);
MP_ASSERT(nGroup < MICROPROFILE_MAX_GROUPS);
// When we aggretate the total time, we have to count if the timers & groups are layered, to avoid summing them twice when calculating the total time.
// Averages become nonsense regardless.
TimerStackPos[nTimer]++;
GroupStackPos[nGroup]++;
pStackLog[nStackPos] = LE;
pChildTickStack[nStackPos] = 0;
nStackPos++;
}
break;
}
case MP_LOG_LEAVE:
{
uint64_t nTimer = MicroProfileLogGetTimerIndex(LE);
if(nTimer != ETOKEN_CSTR_PTR)
{
MP_ASSERT(nTimer < S.nTotalTimers);
uint32_t nGroup = pTimerToGroup[nTimer];
MP_ASSERT(nGroup < MICROPROFILE_MAX_GROUPS);
MP_ASSERT(nStackPos);
uint64_t nTicks;
bool bGroupRoot = 0 == GroupStackPos[nGroup] || 0 == --GroupStackPos[nGroup];
bool bTimerRoot = 0 == TimerStackPos[nTimer] || 0 == --TimerStackPos[nTimer];
{
nStackPos--;
MicroProfileLogEntry LEStack = pStackLog[nStackPos];
MP_ASSERT(MicroProfileLogGetTimerIndex(LEStack) == nTimer); // unbalanced timers are not supported
uint64_t nTickStart = MicroProfileLogTickClamp(LEStack, nTickStartLog, nTickEndLog);
uint64_t nClamped = MicroProfileLogTickClamp(LE, nTickStartLog, nTickEndLog);
nTicks = MicroProfileLogTickDifference(nTickStart, nClamped);
MP_ASSERT(nTicks < 0x8000000000000000);
uint64_t nChildTicks = pChildTickStack[nStackPos];
MP_ASSERT(nStackPos < MICROPROFILE_STACK_MAX);
if(nStackPos)
{
pChildTickStack[nStackPos - 1] += nTicks;
}
MP_ASSERT(nTicks >= nChildTicks);
uint64_t nTicksExclusive = (nTicks - nChildTicks);
S.FrameExclusive[nTimer] += nTicksExclusive;
pFrameGroupThread[nGroup].nTicksExclusive += nTicksExclusive;
if(bTimerRoot) // dont count this if its below another instance of the same timer.
{
S.Frame[nTimer].nTicks += nTicks;
S.Frame[nTimer].nCount += 1;
MP_ASSERT(nGroup < MICROPROFILE_MAX_GROUPS);
if(bGroupRoot)
{
pFrameGroupThread[nGroup].nTicks += nTicks;
pFrameGroupThread[nGroup].nCount += 1;
}
}
}
}
break;
}
case MP_LOG_EXTENDED:
{
k += MicroProfileLogGetDataSize(LE);
break;
}
case MP_LOG_EXTENDED_NO_DATA:
break;
}
}
}
for(int32_t i = nStackPos - 1; i >= 0; --i)
{
MicroProfileLogEntry LE = pStackLog[i];
uint64_t nTickStart = MicroProfileLogTickClamp(LE, nTickStartLog, nTickEndLog);
uint64_t nTicks = MicroProfileLogTickDifference(nTickStart, nTickEndLog);
int64_t nChildTicks = pChildTickStack[i];
pChildTickStack[i] = 0; // consume..
MP_ASSERT(i < MICROPROFILE_STACK_MAX && i >= 0);
if(i)
{
pChildTickStack[i - 1] += nTicks;
}
MP_ASSERT(nTicks >= (uint64_t)nChildTicks);
uint32_t nTimer = (uint32_t)MicroProfileLogGetTimerIndex(LE);
uint32_t nGroup = pTimerToGroup[nTimer];
bool bGroupRoot = 0 == GroupStackPos[nGroup] || 0 == --GroupStackPos[nGroup];
bool bTimerRoot = 0 == TimerStackPos[nTimer] || 0 == --TimerStackPos[nTimer];
uint64_t nTicksExclusive = (nTicks - nChildTicks);
S.FrameExclusive[nTimer] += nTicksExclusive;
pFrameGroupThread[nGroup].nTicksExclusive += nTicksExclusive;
if(bTimerRoot)
{
S.Frame[nTimer].nTicks += nTicks;
S.Frame[nTimer].nCount += 1;
MP_ASSERT(nGroup < MICROPROFILE_MAX_GROUPS);
if(bGroupRoot)
{
pFrameGroupThread[nGroup].nTicks += nTicks;
pFrameGroupThread[nGroup].nCount += 1;
}
}
}
#ifdef MP_ASSERT
for(uint8_t& g : GroupStackPos)
{
MP_ASSERT(g == 0);
}
for(uint8_t& g : TimerStackPos)
{
MP_ASSERT(g == 0);
}
#endif
pLog->nStackPos = nStackPos;
for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
{
pLog->nGroupTicks[j] += pFrameGroupThread[j].nTicks;
if((S.FrameGroupThreadValid[idx_thread / 32] & (1 << (idx_thread % 32))) != 0)
{
pFrameGroup[j].nTicks += pFrameGroupThread[j].nTicks;
pFrameGroup[j].nTicksExclusive += pFrameGroupThread[j].nTicksExclusive;
pFrameGroup[j].nCount += pFrameGroupThread[j].nCount;
}
}
if(pLog->nPut == pLog->nGet && pLog->nActive == 2)
{
pLog->nIdleFrames++;
}
else
{
pLog->nIdleFrames = 0;
}
if(pLog->nActive == 2 && pLog->nIdleFrames > MICROPROFILE_THREAD_LOG_FRAMES_REUSE)
{
MicroProfileLogReset(pLog);
}
}
}
{
MICROPROFILE_SCOPE(g_MicroProfileAccumulate);
uint64_t* ExtraPut = nullptr;
if(UsingExtraData)
{
ExtraPut = &ExtraData->Timers[0];
ExtraData->NumTimers = S.nTotalTimers;
}
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
S.AccumTimers[i].nTicks += S.Frame[i].nTicks;
S.AccumTimers[i].nCount += S.Frame[i].nCount;
S.AccumMaxTimers[i] = MicroProfileMax(S.AccumMaxTimers[i], S.Frame[i].nTicks);
S.AccumMinTimers[i] = MicroProfileMin(S.AccumMinTimers[i], S.Frame[i].nTicks);
S.AccumTimersExclusive[i] += S.FrameExclusive[i];
S.AccumMaxTimersExclusive[i] = MicroProfileMax(S.AccumMaxTimersExclusive[i], S.FrameExclusive[i]);
if(ExtraPut)
*ExtraPut++ = S.Frame[i].nTicks;
}
ExtraPut = nullptr;
if(UsingExtraData)
{
ExtraPut = &ExtraData->Groups[0];
ExtraData->NumGroups = S.nGroupCount;
}
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUPS; ++i)
{
S.AccumGroup[i] += pFrameGroup[i].nTicks;
S.AccumGroupMax[i] = MicroProfileMax(S.AccumGroupMax[i], pFrameGroup[i].nTicks);
if(ExtraPut)
*ExtraPut++ = pFrameGroup[i].nTicks;
}
#if MICROPROFILE_IMGUI
void MicroProfileImguiGather();
MicroProfileImguiGather();
#endif
if(S.CsvConfig.State == MicroProfileCsvConfig::ACTIVE)
{
uint32_t FrameIndex = S.nFrameCurrent % MICROPROFILE_MAX_FRAME_HISTORY;
uint64_t* FrameData = S.CsvConfig.FrameData + S.CsvConfig.TotalElements * FrameIndex;
{
uint16_t* TimerIndices = S.CsvConfig.TimerIndices;
for(uint32_t i = 0; i < S.CsvConfig.NumTimers; ++i)
{
uint16_t Index = TimerIndices[i];
if(Index != UINT16_MAX)
{
*FrameData = S.Frame[Index].nTicks;
}
else
{
*FrameData = 0;
}
FrameData++;
}
}
{
uint16_t* GroupIndices = S.CsvConfig.GroupIndices;
for(uint32_t i = 0; i < S.CsvConfig.NumGroups; ++i)
{
uint16_t Index = GroupIndices[i];
if(Index != UINT16_MAX)
{
*FrameData = pFrameGroup[Index].nTicks;
}
else
{
*FrameData = 0;
}
FrameData++;
}
}
{
uint16_t* CounterIndices = S.CsvConfig.CounterIndices;
for(uint32_t i = 0; i < S.CsvConfig.NumCounters; ++i)
{
uint16_t Index = CounterIndices[i];
if(Index != UINT16_MAX)
{
if(S.CounterInfo[Index].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE)
{
double d = S.CountersDouble[Index].load();
memcpy(FrameData, &d, sizeof(d));
}
else
{
*FrameData = S.Counters[Index].load();
}
}
else
{
*FrameData = 0;
}
FrameData++;
}
}
}
}
for(uint32_t i = 0; i < MICROPROFILE_MAX_GRAPHS; ++i)
{
if(S.Graph[i].nToken != MICROPROFILE_INVALID_TOKEN)
{
MicroProfileToken nToken = S.Graph[i].nToken;
S.Graph[i].nHistory[S.nGraphPut] = S.Frame[MicroProfileGetTimerIndex(nToken)].nTicks;
}
}
S.nGraphPut = (S.nGraphPut + 1) % MICROPROFILE_GRAPH_HISTORY;
}
if(S.nAggregateFlip <= ++S.nAggregateFlipCount)
{
nAggregateFlip = 1;
if(S.nAggregateFlip) // if 0 accumulate indefinitely
{
nAggregateClear = 1;
}
}
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
MicroProfileThreadLog* pLog = S.Pool[i];
uint32_t nNewGet = pFrameNext->nLogStart[i];
if(pLog && nNewGet != (uint32_t)-1)
{
pLog->nGet.store(nNewGet);
}
}
if(pFrameNext->nLogStartTimeline != (uint32_t)-1)
{
S.TimelineLog.nGet.store(pFrameNext->nLogStartTimeline);
}
}
if(nAggregateFlip)
{
memcpy(&S.Aggregate[0], &S.AccumTimers[0], sizeof(S.Aggregate[0]) * S.nTotalTimers);
memcpy(&S.AggregateMax[0], &S.AccumMaxTimers[0], sizeof(S.AggregateMax[0]) * S.nTotalTimers);
memcpy(&S.AggregateMin[0], &S.AccumMinTimers[0], sizeof(S.AggregateMin[0]) * S.nTotalTimers);
memcpy(&S.AggregateExclusive[0], &S.AccumTimersExclusive[0], sizeof(S.AggregateExclusive[0]) * S.nTotalTimers);
memcpy(&S.AggregateMaxExclusive[0], &S.AccumMaxTimersExclusive[0], sizeof(S.AggregateMaxExclusive[0]) * S.nTotalTimers);
memcpy(&S.AggregateGroup[0], &S.AccumGroup[0], sizeof(S.AggregateGroup));
memcpy(&S.AggregateGroupMax[0], &S.AccumGroupMax[0], sizeof(S.AggregateGroup));
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
MicroProfileThreadLog* pLog = S.Pool[i];
if(!pLog)
continue;
memcpy(&pLog->nAggregateGroupTicks[0], &pLog->nGroupTicks[0], sizeof(pLog->nAggregateGroupTicks));
if(nAggregateClear)
{
memset(&pLog->nGroupTicks[0], 0, sizeof(pLog->nGroupTicks));
}
}
S.nAggregateFrames = S.nAggregateFlipCount;
S.nFlipAggregateDisplay = S.nFlipAggregate;
S.nFlipMaxDisplay = S.nFlipMax;
if(nAggregateClear)
{
memset(&S.AccumTimers[0], 0, sizeof(S.Aggregate[0]) * S.nTotalTimers);
memset(&S.AccumMaxTimers[0], 0, sizeof(S.AccumMaxTimers[0]) * S.nTotalTimers);
memset(&S.AccumMinTimers[0], 0xFF, sizeof(S.AccumMinTimers[0]) * S.nTotalTimers);
memset(&S.AccumTimersExclusive[0], 0, sizeof(S.AggregateExclusive[0]) * S.nTotalTimers);
memset(&S.AccumMaxTimersExclusive[0], 0, sizeof(S.AccumMaxTimersExclusive[0]) * S.nTotalTimers);
memset(&S.AccumGroup[0], 0, sizeof(S.AggregateGroup));
memset(&S.AccumGroupMax[0], 0, sizeof(S.AggregateGroup));
S.nAggregateFlipCount = 0;
S.nFlipAggregate = 0;
S.nFlipMax = 0;
S.nAggregateFlipTick = MP_TICK();
}
#if MICROPROFILE_COUNTER_HISTORY
int64_t* pDest = &S.nCounterHistory[S.nCounterHistoryPut][0];
S.nCounterHistoryPut = (S.nCounterHistoryPut + 1) % MICROPROFILE_GRAPH_HISTORY;
for(uint32_t i = 0; i < S.nNumCounters; ++i)
{
if(0 != (S.CounterInfo[i].nFlags & MICROPROFILE_COUNTER_FLAG_DETAILED))
{
MicroProfileFetchCounter(i);
bool IsDouble = (S.CounterInfo[i].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) != 0;
if(IsDouble)
{
double dValue = S.CountersDouble[i].load(std::memory_order_relaxed);
memcpy(&pDest[i], &dValue, sizeof(dValue));
S.dCounterMin[i] = MicroProfileMin(S.dCounterMin[i], dValue);
S.dCounterMax[i] = MicroProfileMax(S.dCounterMax[i], dValue);
}
else
{
uint64_t nValue = S.Counters[i].load(std::memory_order_relaxed);
pDest[i] = nValue;
S.nCounterMin[i] = MicroProfileMin(S.nCounterMin[i], (int64_t)nValue);
S.nCounterMax[i] = MicroProfileMax(S.nCounterMax[i], (int64_t)nValue);
}
}
}
#endif
}
S.nAggregateClear = 0;
MicroProfileFlipEnabled();
}
void MicroProfileSetEnableAllGroups(int bEnable)
{
if(bEnable)
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
S.nActiveGroupsWanted[i] = S.nGroupMask[i];
}
S.nStartEnabled = 1;
MicroProfileFlipEnabled();
}
else
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
S.nActiveGroupsWanted[i] = 0;
}
S.nStartEnabled = 0;
MicroProfileFlipEnabled();
}
}
void MicroProfileEnableCategory(const char* pCategory, int bEnabled)
{
int nCategoryIndex = -1;
for(uint32_t i = 0; i < S.nCategoryCount; ++i)
{
if(!MP_STRCASECMP(pCategory, S.CategoryInfo[i].pName))
{
nCategoryIndex = (int)i;
break;
}
}
if(nCategoryIndex >= 0)
{
if(bEnabled)
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
S.nActiveGroupsWanted[i] |= S.CategoryInfo[nCategoryIndex].nGroupMask[i];
}
}
else
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
S.nActiveGroupsWanted[i] &= ~S.CategoryInfo[nCategoryIndex].nGroupMask[i];
}
}
}
}
void MicroProfileEnableCategory(const char* pCategory)
{
MicroProfileEnableCategory(pCategory, true);
}
void MicroProfileDisableCategory(const char* pCategory)
{
MicroProfileEnableCategory(pCategory, false);
}
int MicroProfileGetEnableAllGroups()
{
return 0 == memcmp(S.nGroupMask, S.nActiveGroupsWanted, sizeof(S.nGroupMask));
}
void MicroProfileSetForceMetaCounters(int bForce)
{
}
int MicroProfileGetForceMetaCounters()
{
return 0;
}
void MicroProfileEnableMetaCounter(const char* pMeta)
{
}
void MicroProfileDisableMetaCounter(const char* pMeta)
{
}
void MicroProfileSetAggregateFrames(int nFrames)
{
S.nAggregateFlip = (uint32_t)nFrames;
if(0 == nFrames)
{
S.nAggregateClear = 1;
}
}
int MicroProfileGetAggregateFrames()
{
return S.nAggregateFlip;
}
int MicroProfileGetCurrentAggregateFrames()
{
return int(S.nAggregateFlip ? S.nAggregateFlip : S.nAggregateFlipCount);
}
void MicroProfileForceEnableGroup(const char* pGroup, MicroProfileTokenType Type)
{
MicroProfileInit();
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
uint16_t nGroup = MicroProfileGetGroup(pGroup, Type);
uint32_t nIndex = nGroup / 32;
uint32_t nBit = nGroup % 32;
S.nForceGroups[nIndex] |= (1ll << nBit);
}
void MicroProfileForceDisableGroup(const char* pGroup, MicroProfileTokenType Type)
{
MicroProfileInit();
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
uint16_t nGroup = MicroProfileGetGroup(pGroup, Type);
uint32_t nIndex = nGroup / 32;
uint32_t nBit = nGroup % 32;
S.nForceGroups[nIndex] &= ~(1ll << nBit);
}
struct MicroProfileTimerValues
{
float TimeMs;
float AverageMs;
float MaxMs;
float MinMs;
float CallAverageMs;
float ExclusiveMs;
float AverageExclusiveMs;
float MaxExclusiveMs;
float TotalMs;
uint32_t nCount;
};
void MicroProfileCalcTimers(int nTimer, MicroProfileTimerValues& Out)
{
const uint32_t nGroupId = S.TimerInfo[nTimer].nGroupIndex;
const float fToMs = MicroProfileTickToMsMultiplier(S.GroupInfo[nGroupId].Type == MicroProfileTokenTypeGpu ? MicroProfileTicksPerSecondGpu() : MicroProfileTicksPerSecondCpu());
uint32_t nAggregateFrames = S.nAggregateFrames ? S.nAggregateFrames : 1;
uint32_t nAggregateCount = S.Aggregate[nTimer].nCount ? S.Aggregate[nTimer].nCount : 1;
Out.nCount = S.Aggregate[nTimer].nCount;
float fToPrc = S.fRcpReferenceTime;
float fMs = fToMs * (S.Frame[nTimer].nTicks);
float fAverageMs = fToMs * (S.Aggregate[nTimer].nTicks / nAggregateFrames);
float fMaxMs = fToMs * (S.AggregateMax[nTimer]);
float fMinMs = fToMs * (S.AggregateMin[nTimer] != uint64_t(-1) ? S.AggregateMin[nTimer] : 0);
float fCallAverageMs = fToMs * (S.Aggregate[nTimer].nTicks / nAggregateCount);
float fMsExclusive = fToMs * (S.FrameExclusive[nTimer]);
float fAverageMsExclusive = fToMs * (S.AggregateExclusive[nTimer] / nAggregateFrames);
float fMaxMsExclusive = fToMs * (S.AggregateMaxExclusive[nTimer]);
float fTotalMs = fToMs * S.Aggregate[nTimer].nTicks;
Out.TimeMs = fMs;
Out.AverageMs = fAverageMs;
Out.MaxMs = fMaxMs;
Out.MinMs = fMinMs;
Out.CallAverageMs = fCallAverageMs;
Out.ExclusiveMs = fMsExclusive;
Out.AverageExclusiveMs = fAverageMsExclusive;
Out.MaxExclusiveMs = fMaxMsExclusive;
Out.TotalMs = fTotalMs;
}
void MicroProfileCalcAllTimers(
float* pTimers, float* pAverage, float* pMax, float* pMin, float* pCallAverage, float* pExclusive, float* pAverageExclusive, float* pMaxExclusive, float* pTotal, uint32_t nSize)
{
for(uint32_t i = 0; i < S.nTotalTimers && i < nSize; ++i)
{
const uint32_t nGroupId = S.TimerInfo[i].nGroupIndex;
const float fToMs = MicroProfileTickToMsMultiplier(S.GroupInfo[nGroupId].Type == MicroProfileTokenTypeGpu ? MicroProfileTicksPerSecondGpu() : MicroProfileTicksPerSecondCpu());
uint32_t nTimer = i;
uint32_t nIdx = i * 2;
uint32_t nAggregateFrames = S.nAggregateFrames ? S.nAggregateFrames : 1;
uint32_t nAggregateCount = S.Aggregate[nTimer].nCount ? S.Aggregate[nTimer].nCount : 1;
float fToPrc = S.fRcpReferenceTime;
float fMs = fToMs * (S.Frame[nTimer].nTicks);
float fPrc = MicroProfileMin(fMs * fToPrc, 1.f);
float fAverageMs = fToMs * (S.Aggregate[nTimer].nTicks / nAggregateFrames);
float fAveragePrc = MicroProfileMin(fAverageMs * fToPrc, 1.f);
float fMaxMs = fToMs * (S.AggregateMax[nTimer]);
float fMaxPrc = MicroProfileMin(fMaxMs * fToPrc, 1.f);
float fMinMs = fToMs * (S.AggregateMin[nTimer] != uint64_t(-1) ? S.AggregateMin[nTimer] : 0);
float fMinPrc = MicroProfileMin(fMinMs * fToPrc, 1.f);
float fCallAverageMs = fToMs * (S.Aggregate[nTimer].nTicks / nAggregateCount);
float fCallAveragePrc = MicroProfileMin(fCallAverageMs * fToPrc, 1.f);
float fMsExclusive = fToMs * (S.FrameExclusive[nTimer]);
float fPrcExclusive = MicroProfileMin(fMsExclusive * fToPrc, 1.f);
float fAverageMsExclusive = fToMs * (S.AggregateExclusive[nTimer] / nAggregateFrames);
float fAveragePrcExclusive = MicroProfileMin(fAverageMsExclusive * fToPrc, 1.f);
float fMaxMsExclusive = fToMs * (S.AggregateMaxExclusive[nTimer]);
float fMaxPrcExclusive = MicroProfileMin(fMaxMsExclusive * fToPrc, 1.f);
float fTotalMs = fToMs * S.Aggregate[nTimer].nTicks;
pTimers[nIdx] = fMs;
pTimers[nIdx + 1] = fPrc;
pAverage[nIdx] = fAverageMs;
pAverage[nIdx + 1] = fAveragePrc;
pMax[nIdx] = fMaxMs;
pMax[nIdx + 1] = fMaxPrc;
pMin[nIdx] = fMinMs;
pMin[nIdx + 1] = fMinPrc;
pCallAverage[nIdx] = fCallAverageMs;
pCallAverage[nIdx + 1] = fCallAveragePrc;
pExclusive[nIdx] = fMsExclusive;
pExclusive[nIdx + 1] = fPrcExclusive;
pAverageExclusive[nIdx] = fAverageMsExclusive;
pAverageExclusive[nIdx + 1] = fAveragePrcExclusive;
pMaxExclusive[nIdx] = fMaxMsExclusive;
pMaxExclusive[nIdx + 1] = fMaxPrcExclusive;
pTotal[nIdx] = fTotalMs;
pTotal[nIdx + 1] = 0.f;
}
}
float MicroProfileGetTime(const char* pGroup, const char* pName)
{
MicroProfileToken nToken = MicroProfileFindTokenInternal(pGroup, pName);
if(nToken == MICROPROFILE_INVALID_TOKEN)
{
return 0.f;
}
uint32_t nTimerIndex = MicroProfileGetTimerIndex(nToken);
uint32_t nGroupIndex = MicroProfileGetGroupIndex(nToken);
float fToMs = MicroProfileTickToMsMultiplier(S.GroupInfo[nGroupIndex].Type == MicroProfileTokenTypeGpu ? MicroProfileTicksPerSecondGpu() : MicroProfileTicksPerSecondCpu());
return S.Frame[nTimerIndex].nTicks * fToMs;
}
int MicroProfilePlatformMarkersGetEnabled()
{
return S.nPlatformMarkersEnabled != 0 ? 1 : 0;
}
void MicroProfilePlatformMarkersSetEnabled(int bEnabled)
{
S.nPlatformMarkersEnabled = bEnabled ? 1 : 0;
}
#define MICROPROFILE_CONTEXT_SWITCH_SEARCH_DEBUG MICROPROFILE_DEBUG
void MicroProfileContextSwitchSearch(uint32_t* pContextSwitchStart, uint32_t* pContextSwitchEnd, uint64_t nBaseTicksCpu, uint64_t nBaseTicksEndCpu)
{
MICROPROFILE_SCOPE(g_MicroProfileContextSwitchSearch);
uint32_t nContextSwitchPut = S.nContextSwitchPut;
uint64_t nContextSwitchStart, nContextSwitchEnd;
nContextSwitchStart = nContextSwitchEnd = (nContextSwitchPut + MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE - 1) % MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE;
int64_t nSearchEnd = nBaseTicksEndCpu + MicroProfileMsToTick(30.f, MicroProfileTicksPerSecondCpu());
int64_t nSearchBegin = nBaseTicksCpu - MicroProfileMsToTick(30.f, MicroProfileTicksPerSecondCpu());
#if MICROPROFILE_CONTEXT_SWITCH_SEARCH_DEBUG
int64_t lp = S.nContextSwitchLastPushed;
uprintf("cswitch-search\n");
uprintf("Begin %" PRId64 " End %" PRId64 " Last %" PRId64 "\n", nSearchBegin, nSearchEnd, lp);
float fToMs = MicroProfileTickToMsMultiplierCpu();
uprintf("E %6.2fms\n", fToMs * (nSearchEnd - nSearchBegin));
uprintf("LAST %6.2fms\n", fToMs * (lp - nSearchBegin));
#endif
int64_t nMax = INT64_MIN;
int64_t nMin = INT64_MAX;
for(uint32_t i = 0; i < MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE; ++i)
{
uint32_t nIndex = (nContextSwitchPut + MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE - (i + 1)) % MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE;
MicroProfileContextSwitch& CS = S.ContextSwitch[nIndex];
if(nMax < CS.nTicks)
nMax = CS.nTicks;
if(nMin > CS.nTicks && CS.nTicks != 0)
nMin = CS.nTicks;
if(CS.nTicks > nSearchEnd)
{
nContextSwitchEnd = nIndex;
}
if(CS.nTicks > nSearchBegin)
{
nContextSwitchStart = nIndex;
}
}
*pContextSwitchStart = nContextSwitchStart;
*pContextSwitchEnd = nContextSwitchEnd;
#if MICROPROFILE_CONTEXT_SWITCH_SEARCH_DEBUG
{
uprintf("contextswitch start %" PRId64 " %" PRId64 "\n", nContextSwitchStart, nContextSwitchEnd);
MicroProfileContextSwitch& CS0 = S.ContextSwitch[0];
int64_t nMax = CS0.nTicks;
int64_t nMin = CS0.nTicks;
int64_t nBegin = 0;
int64_t nEnd = 0;
int nRanges = 0;
for(uint32_t i = 0; i < MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE; i += 1024)
{
int64_t MinTick = INT64_MAX;
int64_t MaxTick = INT64_MIN;
for(int j = 0; j < 1024; ++j)
{
MicroProfileContextSwitch& CS = S.ContextSwitch[i + j];
int64_t nTicks = CS.nTicks;
MinTick = MicroProfileMin(nTicks, MinTick);
MaxTick = MicroProfileMax(nTicks, MaxTick);
}
uprintf("XX range [%5" PRIx64 ":%5" PRIx64 "] :: [%6.2f:%6.2f] [%p :: %p] .. ref %p\n",
i,
i + 1024,
fToMs * (MinTick - nSearchBegin),
fToMs * (MaxTick - nSearchBegin),
(void*)MinTick,
(void*)MaxTick,
(void*)nSearchBegin
);
}
uprintf("\n\n");
for(uint32_t i = 0; i < MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE; ++i)
{
MicroProfileContextSwitch& CS = S.ContextSwitch[i];
int64_t nTicks = CS.nTicks;
float fMs = (nTicks - nMax) * fToMs;
if(fMs < 0 || fMs > 50)
{
// dump range here
uprintf("range [%5" PRId64 ":%5" PRId64 "] :: [%6.2f:%6.2f] [%p :: %p] .. ref %p\n",
nBegin,
nEnd,
fToMs * (nMin - nSearchBegin),
fToMs * (nMax - nSearchBegin),
(void*)nMin,
(void*)nMax,
(void*)nSearchBegin
);
nEnd = nBegin = i;
nMax = nMin = CS.nTicks;
nRanges++;
}
else
{
nEnd = i;
nMax = MicroProfileMax(nTicks, nMax);
}
}
}
lp = S.nContextSwitchLastPushed;
uprintf("E %6.2fms\n", fToMs * (nSearchEnd - nSearchBegin));
uprintf("LP2 %6.2fms\n", fToMs * (lp - nSearchBegin));
#endif
}
int MicroProfileFormatCounter(int eFormat, int64_t nCounter, char* pOut, uint32_t nBufferSize)
{
if(!nCounter)
{
pOut[0] = '0';
pOut[1] = '\0';
return 1;
}
int nLen = 0;
char* pBase = pOut;
char* pTmp = pOut;
char* pEnd = pOut + nBufferSize;
int nNegative = 0;
if(nCounter < 0)
{
nCounter = -nCounter;
nNegative = 1;
if(nCounter < 0) // handle INT_MIN
{
nCounter = -(nCounter + 1);
}
}
switch(eFormat)
{
case MICROPROFILE_COUNTER_FORMAT_DEFAULT:
{
int nSeperate = 0;
while(nCounter)
{
if(nSeperate)
{
*pTmp++ = '.';
}
nSeperate = 1;
for(uint32_t i = 0; nCounter && i < 3; ++i)
{
int nDigit = nCounter % 10;
nCounter /= 10;
*pTmp++ = '0' + nDigit;
}
}
if(nNegative)
{
*pTmp++ = '-';
}
nLen = pTmp - pOut;
--pTmp;
MP_ASSERT(pTmp <= pEnd);
while(pTmp > pOut) // reverse string
{
char c = *pTmp;
*pTmp = *pOut;
*pOut = c;
pTmp--;
pOut++;
}
}
break;
case MICROPROFILE_COUNTER_FORMAT_BYTES:
{
const char* pExt[] = { "b", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb" };
size_t nNumExt = sizeof(pExt) / sizeof(pExt[0]);
int64_t nShift = 0;
int64_t nDivisor = 1;
int64_t nCountShifted = nCounter >> 10;
while(nCountShifted)
{
nDivisor <<= 10;
nCountShifted >>= 10;
nShift++;
}
MP_ASSERT(nShift < (int64_t)nNumExt);
if(nShift)
{
nLen = snprintf(pOut, nBufferSize - 1, "%c%3.2f%s", nNegative ? '-' : ' ', (double)nCounter / nDivisor, pExt[nShift]);
}
else
{
nLen = snprintf(pOut, nBufferSize - 1, "%c%" PRId64 "%s", nNegative ? '-' : ' ', nCounter, pExt[nShift]);
}
}
break;
}
pBase[nLen] = '\0';
return nLen;
}
int MicroProfileFormatCounterDouble(int eFormat, double dCounter, char* pOut, uint32_t nBufferSize)
{
int nLen = 0;
switch(eFormat)
{
case MICROPROFILE_COUNTER_FORMAT_DEFAULT:
{
nLen = stbsp_snprintf(pOut, nBufferSize - 1, "%f", dCounter);
}
break;
case MICROPROFILE_COUNTER_FORMAT_BYTES:
{
const char* pExt[] = { "b", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb" };
double scale = 1.f;
int offset = 0;
int end = sizeof(pExt) / sizeof(pExt[0]);
double d = dCounter;
while(d / scale > 1024.f && offset + 1 < end)
{
scale *= 1024.f;
offset += 1;
}
nLen = stbsp_snprintf(pOut, nBufferSize - 1, "%.3f%s", d / scale, pExt[offset]);
}
break;
}
pOut[nLen] = '\0';
return nLen;
}
bool MicroProfileAnyGroupActive()
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
if(S.nActiveGroups[i] != 0)
return true;
}
return false;
}
bool MicroProfileGroupActive(uint32_t nGroupIndex)
{
MP_ASSERT(nGroupIndex < MICROPROFILE_MAX_GROUPS);
uint32_t nIndex = nGroupIndex / 32;
uint32_t nBit = nGroupIndex % 32;
return ((S.nActiveGroups[nIndex] >> nBit) & 1) == 1;
}
void MicroProfileToggleGroup(uint32_t nGroup)
{
if(nGroup < S.nGroupCount)
{
uint32_t nIndex = nGroup / 32;
uint32_t nBit = nGroup % 32;
S.nActiveGroupsWanted[nIndex] ^= (1ll << nBit);
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
}
}
void MicroProfileGroupSetEnabled(uint32_t nGroup)
{
if(nGroup < S.nGroupCount)
{
uint32_t nIndex = nGroup / 32;
uint32_t nBit = nGroup % 32;
S.nActiveGroupsWanted[nIndex] |= (1ll << nBit);
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
}
}
bool MicroProfileGroupEnabled(uint32_t nGroup)
{
if(nGroup < S.nGroupCount)
{
uint32_t nIndex = nGroup / 32;
uint32_t nBit = nGroup % 32;
return 0 != (S.nActiveGroupsWanted[nIndex] & (1ll << nBit));
}
return false;
}
bool MicroProfileCategoryEnabled(uint32_t nCategory)
{
if(nCategory < S.nCategoryCount)
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
if(S.CategoryInfo[nCategory].nGroupMask[i] != (S.CategoryInfo[nCategory].nGroupMask[i] & S.nActiveGroupsWanted[i]))
{
return false;
}
}
return true;
}
return false;
}
bool MicroProfileCategoryDisabled(uint32_t nCategory)
{
if(nCategory < S.nCategoryCount)
{
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
uint32_t ActiveMask = S.nActiveGroupsWanted[i];
uint32_t CategoryMask = S.CategoryInfo[nCategory].nGroupMask[i];
if(0 != (ActiveMask & CategoryMask))
{
return false;
}
}
return true;
}
return false;
}
void MicroProfileToggleCategory(uint32_t nCategory)
{
if(nCategory < S.nCategoryCount)
{
bool bAllSet = true;
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
bAllSet = bAllSet && S.CategoryInfo[nCategory].nGroupMask[i] == (S.CategoryInfo[nCategory].nGroupMask[i] & S.nActiveGroupsWanted[i]);
}
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUP_INTS; ++i)
{
if(bAllSet)
{
S.nActiveGroupsWanted[i] &= ~S.CategoryInfo[nCategory].nGroupMask[i];
}
else
{
S.nActiveGroupsWanted[i] |= S.CategoryInfo[nCategory].nGroupMask[i];
}
}
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
}
}
void MicroProfileSleep(uint32_t nMs)
{
#ifdef _WIN32
Sleep(nMs);
#else
usleep(nMs * 1000);
#endif
}
#if MICROPROFILE_WEBSERVER
#define MICROPROFILE_EMBED_HTML
extern const char* g_MicroProfileHtml_begin[];
extern size_t g_MicroProfileHtml_begin_sizes[];
extern size_t g_MicroProfileHtml_begin_count;
extern const char* g_MicroProfileHtml_end[];
extern size_t g_MicroProfileHtml_end_sizes[];
extern size_t g_MicroProfileHtml_end_count;
extern const char* g_MicroProfileHtmlLive_begin[];
extern size_t g_MicroProfileHtmlLive_begin_sizes[];
extern size_t g_MicroProfileHtmlLive_begin_count;
extern const char* g_MicroProfileHtmlLive_end[];
extern size_t g_MicroProfileHtmlLive_end_sizes[];
extern size_t g_MicroProfileHtmlLive_end_count;
extern const uint32_t uprof_16[];
extern const uint32_t uprof_16_len;
extern const uint32_t uprof_32[];
extern const uint32_t uprof_32_len;
extern const uint32_t uprof_192[];
extern const uint32_t uprof_192_len;
extern const uint32_t uprof_512[];
extern const uint32_t uprof_512_len;
typedef void (*MicroProfileWriteCallback)(void* Handle, size_t size, const char* pData);
uint32_t MicroProfileWebServerPort()
{
return S.nWebServerPort;
}
void MicroProfileSetWebServerPort(uint32_t nPort)
{
if(S.nWebServerPort != nPort)
{
MicroProfileWebServerJoin();
MicroProfileWebServerStop();
S.nWebServerPort = nPort;
S.nWebServerDataSent = (uint64_t)-1; // Will cause the web server and its thread to be restarted next time MicroProfileFlip() is called.
}
}
void MicroProfileDumpFileImmediately(const char* pHtml, const char* pCsv, void* pGpuContext, uint32_t FrameCount)
{
for(uint32_t i = 0; i < 2; ++i)
{
MicroProfileFlip(pGpuContext);
}
for(uint32_t i = 0; i < MICROPROFILE_GPU_FRAME_DELAY + 1; ++i)
{
MicroProfileFlip(pGpuContext);
}
uint32_t nDumpMask = 0;
if(pHtml)
{
size_t nLen = strlen(pHtml);
if(nLen > sizeof(S.HtmlDumpPath) - 1)
{
return;
}
const size_t ExtSize = sizeof(".html") - 1;
if(nLen > ExtSize && 0 == memcmp(".html", pHtml + nLen - ExtSize, ExtSize))
nLen -= ExtSize;
memcpy(S.HtmlDumpPath, pHtml, nLen);
S.HtmlDumpPath[nLen] = '\0';
nDumpMask |= 1;
}
if(pCsv)
{
size_t nLen = strlen(pCsv);
if(nLen > sizeof(S.CsvDumpPath) - 1)
{
return;
}
const size_t ExtSize = sizeof(".csv") - 1;
if(nLen > ExtSize && 0 == memcmp(".csv", pCsv + nLen - ExtSize, ExtSize))
nLen -= ExtSize;
memcpy(S.CsvDumpPath, pCsv, nLen + 1);
S.CsvDumpPath[nLen] = '\0';
nDumpMask |= 2;
}
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
S.nDumpFileNextFrame = nDumpMask;
S.nDumpSpikeMask = 0;
S.nDumpFileCountDown = 0;
S.DumpFrameCount = FrameCount;
MicroProfileDumpToFile();
}
void MicroProfileDumpFile(const char* pHtml, const char* pCsv, float fCpuSpike, float fGpuSpike, uint32_t FrameCount)
{
S.fDumpCpuSpike = fCpuSpike;
S.fDumpGpuSpike = fGpuSpike;
S.DumpFrameCount = FrameCount;
uint32_t nDumpMask = 0;
if(pHtml)
{
size_t nLen = strlen(pHtml);
if(nLen > sizeof(S.HtmlDumpPath) - 1)
{
return;
}
const size_t ExtSize = sizeof(".html") - 1;
if(nLen > ExtSize && 0 == memcmp(".html", pHtml + nLen - ExtSize, ExtSize))
nLen -= ExtSize;
memcpy(S.HtmlDumpPath, pHtml, nLen);
S.HtmlDumpPath[nLen] = '\0';
nDumpMask |= 1;
}
if(pCsv)
{
size_t nLen = strlen(pCsv);
if(nLen > sizeof(S.CsvDumpPath) - 1)
{
return;
}
const size_t ExtSize = sizeof(".csv") - 1;
if(nLen > ExtSize && 0 == memcmp(".csv", pCsv + nLen - ExtSize, ExtSize))
nLen -= ExtSize;
memcpy(S.CsvDumpPath, pCsv, nLen);
S.CsvDumpPath[nLen] = '\0';
nDumpMask |= 2;
}
if(fCpuSpike > 0.f || fGpuSpike > 0.f)
{
S.nDumpFileNextFrame = 0;
S.nDumpSpikeMask = nDumpMask;
}
else
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
S.nDumpFileNextFrame = nDumpMask;
S.nDumpSpikeMask = 0;
S.nDumpFileCountDown = 0;
MicroProfileDumpToFile();
}
}
struct MicroProfilePrintfArgs
{
MicroProfileWriteCallback CB;
void* Handle;
};
char* MicroProfilePrintfCallback(const char* buf, void* user, int len)
{
MicroProfilePrintfArgs* A = (MicroProfilePrintfArgs*)user;
(A->CB)(A->Handle, len, buf);
return const_cast<char*>(buf);
};
void MicroProfilePrintf(MicroProfileWriteCallback CB, void* Handle, const char* pFmt, ...)
{
va_list args;
va_start(args, pFmt);
MicroProfilePrintfArgs A;
A.CB = CB;
A.Handle = Handle;
char Buffer[STB_SPRINTF_MIN];
int size = stbsp_vsprintfcb(MicroProfilePrintfCallback, (void*)&A, Buffer, pFmt, args);
(void)size;
va_end(args);
}
void MicroProfileGetFramesToDump(uint64_t nStartFrameId, uint32_t nMaxFrames, uint32_t& nFirstFrame, uint32_t& nLastFrame, uint32_t& nNumFrames)
{
nFirstFrame = (uint32_t)-1;
nNumFrames = 0;
if(nStartFrameId != (uint64_t)-1)
{
// search for the frane
for(uint32_t i = 0; i < MICROPROFILE_MAX_FRAME_HISTORY; ++i)
{
if(S.Frames[i].nFrameId == nStartFrameId)
{
nFirstFrame = i;
break;
}
}
if(nFirstFrame != (uint32_t)-1)
{
nLastFrame = S.nFrameCurrent;
uint32_t nDistance = (MICROPROFILE_MAX_FRAME_HISTORY + nFirstFrame - nLastFrame) % MICROPROFILE_MAX_FRAME_HISTORY;
nNumFrames = MicroProfileMin(nDistance, (uint32_t)nMaxFrames);
}
}
if(nNumFrames == 0)
{
nNumFrames = (MICROPROFILE_MAX_FRAME_HISTORY - MICROPROFILE_GPU_FRAME_DELAY - 3); // leave a few to not overwrite
nNumFrames = MicroProfileMin(nNumFrames, (uint32_t)nMaxFrames);
nFirstFrame = (S.nFrameCurrent + MICROPROFILE_MAX_FRAME_HISTORY - nNumFrames) % MICROPROFILE_MAX_FRAME_HISTORY;
}
nLastFrame = (nFirstFrame + nNumFrames) % MICROPROFILE_MAX_FRAME_HISTORY;
}
#define printf(...) MicroProfilePrintf(CB, Handle, __VA_ARGS__)
void MicroProfileDumpCsvWithConfig(MicroProfileWriteCallback CB, void* Handle, uint32_t nFirstFrame, uint32_t nLastFrame, uint32_t nNumFrames)
{
uint32_t NumTimers = S.CsvConfig.NumTimers;
uint32_t NumGroups = S.CsvConfig.NumGroups;
uint32_t NumCounters = S.CsvConfig.NumCounters;
uint16_t* TimerIndices = S.CsvConfig.TimerIndices;
uint16_t* GroupIndices = S.CsvConfig.GroupIndices;
uint64_t* FrameData = S.CsvConfig.FrameData;
uint16_t* CounterIndices = S.CsvConfig.CounterIndices;
uint32_t TotalElements = S.CsvConfig.TotalElements;
uint32_t Offset = 0;
bool UseFrameTime = 0 != (MICROPROFILE_CSV_FLAG_FRAME_TIME & S.CsvConfig.Flags);
const char** pTimerNames = S.CsvConfig.pTimerNames;
const char** pGroupNames = S.CsvConfig.pGroupNames;
const char** pCounterNames = S.CsvConfig.pCounterNames;
if(UseFrameTime)
printf("Time");
else
printf("FrameNumber");
for(uint32_t i = 0; i < NumTimers; ++i, ++Offset)
printf(", %s", pTimerNames[i] ? pTimerNames[i] : S.TimerInfo[TimerIndices[i]].pName);
for(uint32_t i = 0; i < NumGroups; ++i, ++Offset)
printf(", %s", pGroupNames[i] ? pGroupNames[i] : S.GroupInfo[GroupIndices[i]].pName);
for(uint32_t i = 0; i < NumCounters; ++i, ++Offset)
printf(", %s", pCounterNames[i] ? pCounterNames[i] : S.CounterInfo[CounterIndices[i]].pName);
printf("\n");
float* fToMsTimer = (float*)alloca(sizeof(float) * NumTimers);
float* fToMsGroup = (float*)alloca(sizeof(float) * NumGroups);
float fToMsCPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
float fToMsGPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondGpu());
for(uint32_t i = 0; i < NumTimers; ++i)
fToMsTimer[i] = S.TimerInfo[TimerIndices[i]].Type == MicroProfileTokenTypeGpu ? fToMsGPU : fToMsCPU;
for(uint32_t i = 0; i < NumGroups; ++i)
fToMsGroup[i] = S.GroupInfo[GroupIndices[i]].Type == MicroProfileTokenTypeGpu ? fToMsGPU : fToMsCPU;
uint64_t TickStart = S.Frames[nFirstFrame % MICROPROFILE_MAX_FRAME_HISTORY].nFrameStartCpu;
for(uint32_t i = 0; i < nNumFrames; ++i)
{
uint32_t FrameIndex = ((nFirstFrame + i) % MICROPROFILE_MAX_FRAME_HISTORY);
uint64_t TickFrame = S.Frames[FrameIndex].nFrameStartCpu;
uint64_t* Data = FrameData + TotalElements * FrameIndex;
if(UseFrameTime)
printf("%f", (TickFrame - TickStart) * fToMsCPU);
else
printf("%d", i);
Offset = 0;
for(uint32_t j = 0; j < NumTimers; ++j)
printf(", %f", Data[Offset++] * fToMsTimer[j]);
for(uint32_t j = 0; j < NumGroups; ++j)
printf(", %f", Data[Offset++] * fToMsGroup[j]);
for(uint32_t j = 0; j < NumCounters; ++j)
{
if(S.CounterInfo[CounterIndices[j]].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE)
{
printf(", %f", ((double*)Data)[Offset++]);
}
else
{
printf(", %lld", Data[Offset++]);
}
}
printf("\n");
}
}
void MicroProfileDumpCsvTimerFrames(MicroProfileWriteCallback CB, void* Handle, uint32_t nFirstFrame, uint32_t nLastFrame, uint32_t nNumFrames)
{
MP_ASSERT(S.FrameExtraCounterData);
uint32_t TotalTimers = S.nTotalTimers;
float* fToMs = (float*)alloca(sizeof(float) * TotalTimers);
float fToMsCPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
float fToMsGPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondGpu());
for(uint32_t i = 0; i < TotalTimers; ++i)
fToMs[i] = S.TimerInfo[i].Type == MicroProfileTokenTypeGpu ? fToMsGPU : fToMsCPU;
for(uint32_t i = 0; i < TotalTimers; ++i)
{
printf(i == 0 ? "FrameNumber, \"%s\"" : ",\"%s\"", S.TimerInfo[i].pName);
}
printf("\n");
for(uint32_t i = 0; i < nNumFrames; ++i)
{
// printf("%d", i) MicroProfileFrame& F = S.Frames[(i + nFirstFrame) % MICROPROFILE_MAX_FRAME_HISTORY];
MicroProfileFrameExtraCounterData* Data = S.FrameExtraCounterData;
uint32_t NumTimers = 0;
uint32_t j;
printf("%d", i);
Data += ((i + nFirstFrame) % MICROPROFILE_MAX_FRAME_HISTORY);
NumTimers = MicroProfileMin(TotalTimers, (uint32_t)Data->NumTimers);
for(j = 0; j < NumTimers; ++j)
{
printf(",%f", Data->Timers[j] * fToMs[j]);
}
for(; j < TotalTimers; ++j)
printf(",0");
printf("\n");
}
}
void MicroProfileDumpCsvGroupFrames(MicroProfileWriteCallback CB, void* Handle, uint32_t nFirstFrame, uint32_t nLastFrame, uint32_t nNumFrames)
{
MP_ASSERT(S.FrameExtraCounterData);
float fToMsCPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
float fToMsGPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondGpu());
uint32_t nGroupCount = S.nGroupCount;
float* fToMs = (float*)alloca(sizeof(float) * nGroupCount);
for(uint32_t i = 0; i < nGroupCount; ++i)
fToMs[i] = S.GroupInfo[i].Type == MicroProfileTokenTypeGpu ? fToMsGPU : fToMsCPU;
for(uint32_t i = 0; i < nGroupCount; ++i)
{
printf(i == 0 ? "FrameNumber, \"%s\"" : ",\"%s\"", S.GroupInfo[i].pName);
}
printf("\n");
for(uint32_t i = 0; i < nNumFrames; ++i)
{
MicroProfileFrameExtraCounterData* Data = S.FrameExtraCounterData;
uint32_t NumGroups = 0;
uint32_t j;
printf("%d", i);
Data += ((i + nFirstFrame) % MICROPROFILE_MAX_FRAME_HISTORY);
NumGroups = MicroProfileMin(nGroupCount, (uint32_t)Data->NumGroups);
for(j = 0; j < NumGroups; ++j)
{
printf(",%f", Data->Groups[j] * fToMs[j]);
}
for(; j < nGroupCount; ++j)
printf(",0");
printf("\n");
}
}
void MicroProfileDumpCsv(uint32_t nDumpFrameCount)
{
uint32_t nNumFrames, nFirstFrame, nLastFrame;
MicroProfileGetFramesToDump((uint64_t)-1, nDumpFrameCount, nFirstFrame, nLastFrame, nNumFrames);
char Path[MICROPROFILE_MAX_PATH];
int Length;
if(S.FrameExtraCounterData)
{
Length = snprintf(Path, sizeof(S.CsvDumpPath), "%s_timer_frames.csv", S.CsvDumpPath);
if(Length > 0 && Length < MICROPROFILE_MAX_PATH)
{
FILE* F = fopen(Path, "w");
if(F)
{
MicroProfileDumpCsvTimerFrames(MicroProfileWriteFile, F, nFirstFrame, nLastFrame, nNumFrames);
fclose(F);
}
}
Length = snprintf(Path, sizeof(S.CsvDumpPath), "%s_group_frames.csv", S.CsvDumpPath);
if(Length > 0 && Length < MICROPROFILE_MAX_PATH)
{
FILE* F = fopen(Path, "w");
if(F)
{
MicroProfileDumpCsvGroupFrames(MicroProfileWriteFile, F, nFirstFrame, nLastFrame, nNumFrames);
fclose(F);
}
}
}
if(S.CsvConfig.State == MicroProfileCsvConfig::ACTIVE)
{
Length = snprintf(Path, sizeof(S.CsvDumpPath), "%s_custom.csv", S.CsvDumpPath);
if(Length > 0 && Length < MICROPROFILE_MAX_PATH)
{
FILE* F = fopen(Path, "w");
if(F)
{
MicroProfileDumpCsvWithConfig(MicroProfileWriteFile, F, nFirstFrame, nLastFrame, nNumFrames);
fclose(F);
}
}
}
}
void MicroProfileDumpCsvLegacy(MicroProfileWriteCallback CB, void* Handle)
{
uint32_t nAggregateFrames = S.nAggregateFrames ? S.nAggregateFrames : 1;
float fToMsCPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
float fToMsGPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondGpu());
printf("frames,%d\n", nAggregateFrames);
printf("group,name,average,max,callaverage\n");
uint32_t nNumTimers = S.nTotalTimers;
uint32_t nBlockSize = 2 * nNumTimers;
float* pTimers = (float*)alloca(nBlockSize * 9 * sizeof(float));
float* pAverage = pTimers + nBlockSize;
float* pMax = pTimers + 2 * nBlockSize;
float* pMin = pTimers + 3 * nBlockSize;
float* pCallAverage = pTimers + 4 * nBlockSize;
float* pTimersExclusive = pTimers + 5 * nBlockSize;
float* pAverageExclusive = pTimers + 6 * nBlockSize;
float* pMaxExclusive = pTimers + 7 * nBlockSize;
float* pTotal = pTimers + 8 * nBlockSize;
MicroProfileCalcAllTimers(pTimers, pAverage, pMax, pMin, pCallAverage, pTimersExclusive, pAverageExclusive, pMaxExclusive, pTotal, nNumTimers);
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
uint32_t nIdx = i * 2;
printf("\"%s\",\"%s\",%f,%f,%f\n", S.TimerInfo[i].pName, S.GroupInfo[S.TimerInfo[i].nGroupIndex].pName, pAverage[nIdx], pMax[nIdx], pCallAverage[nIdx]);
}
printf("\n\n");
printf("group,average,max,total\n");
for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
{
const char* pGroupName = S.GroupInfo[j].pName;
float fToMs = S.GroupInfo[j].Type == MicroProfileTokenTypeGpu ? fToMsGPU : fToMsCPU;
if(pGroupName[0] != '\0')
{
printf("\"%s\",%.3f,%.3f,%.3f\n", pGroupName, fToMs * S.AggregateGroup[j] / nAggregateFrames, fToMs * S.AggregateGroup[j] / nAggregateFrames, fToMs * S.AggregateGroup[j]);
}
}
printf("\n\n");
printf("group,thread,average,total\n");
for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
{
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
if(S.Pool[i])
{
const char* pThreadName = &S.Pool[i]->ThreadName[0];
// MicroProfilePrintf(CB, Handle, "var ThreadGroupTime%d = [", i);
float fToMs = S.Pool[i]->nGpu ? fToMsGPU : fToMsCPU;
{
uint64_t nTicks = S.Pool[i]->nAggregateGroupTicks[j];
float fTime = nTicks / nAggregateFrames * fToMs;
float fTimeTotal = nTicks * fToMs;
if(fTimeTotal > 0.01f)
{
const char* pGroupName = S.GroupInfo[j].pName;
printf("\"%s\",\"%s\",%.3f,%.3f\n", pGroupName, pThreadName, fTime, fTimeTotal);
}
}
}
}
}
printf("\n\n");
printf("frametimecpu\n");
const uint32_t nCount = MICROPROFILE_MAX_FRAME_HISTORY - MICROPROFILE_GPU_FRAME_DELAY - 3;
const uint32_t nStart = S.nFrameCurrent;
for(uint32_t i = nCount; i > 0; i--)
{
uint32_t nFrame = (nStart + MICROPROFILE_MAX_FRAME_HISTORY - i) % MICROPROFILE_MAX_FRAME_HISTORY;
uint32_t nFrameNext = (nStart + MICROPROFILE_MAX_FRAME_HISTORY - i + 1) % MICROPROFILE_MAX_FRAME_HISTORY;
uint64_t nTicks = S.Frames[nFrameNext].nFrameStartCpu - S.Frames[nFrame].nFrameStartCpu;
printf("%f,", nTicks * fToMsCPU);
}
printf("\n");
printf("\n\n");
printf("frametimegpu\n");
for(uint32_t i = nCount; i > 0; i--)
{
uint32_t nFrame = (nStart + MICROPROFILE_MAX_FRAME_HISTORY - i) % MICROPROFILE_MAX_FRAME_HISTORY;
uint32_t nFrameNext = (nStart + MICROPROFILE_MAX_FRAME_HISTORY - i + 1) % MICROPROFILE_MAX_FRAME_HISTORY;
uint64_t nTicks = S.Frames[nFrameNext].nFrameStartGpu - S.Frames[nFrame].nFrameStartGpu;
printf("%f,", nTicks * fToMsGPU);
}
printf("\n\n");
}
#undef printf
void MicroProfileDumpCsvLegacy()
{
char Path[MICROPROFILE_MAX_PATH];
int Length = snprintf(Path, sizeof(S.CsvDumpPath), "%s.csv", S.CsvDumpPath);
if(Length > 0 && Length < MICROPROFILE_MAX_PATH)
{
FILE* F = fopen(Path, "w");
if(F)
{
MicroProfileDumpCsvLegacy(MicroProfileWriteFile, F);
fclose(F);
}
}
}
void MicroProfileDumpHtmlLive(MicroProfileWriteCallback CB, void* Handle)
{
for(size_t i = 0; i < g_MicroProfileHtmlLive_begin_count; ++i)
{
CB(Handle, g_MicroProfileHtmlLive_begin_sizes[i] - 1, g_MicroProfileHtmlLive_begin[i]);
}
for(size_t i = 0; i < g_MicroProfileHtmlLive_end_count; ++i)
{
CB(Handle, g_MicroProfileHtmlLive_end_sizes[i] - 1, g_MicroProfileHtmlLive_end[i]);
}
}
void MicroProfileGetCoreInformation()
{
#ifdef _WIN32
unsigned long BufferSize;
HANDLE Process = GetCurrentProcess();
GetSystemCpuSetInformation(nullptr, 0, &BufferSize, Process, 0);
char* Buffer = (char*)alloca(BufferSize);
if(!GetSystemCpuSetInformation((PSYSTEM_CPU_SET_INFORMATION)Buffer, BufferSize, &BufferSize, Process, 0))
{
return;
}
for(ULONG Size = 0; Size < BufferSize;)
{
PSYSTEM_CPU_SET_INFORMATION CpuSet = reinterpret_cast<PSYSTEM_CPU_SET_INFORMATION>(Buffer);
if(CpuSet->Type == CPU_SET_INFORMATION_TYPE::CpuSetInformation)
{
if(CpuSet->CpuSet.CoreIndex < MICROPROFILE_MAX_CPU_CORES)
{
S.CoreEfficiencyClass[CpuSet->CpuSet.LogicalProcessorIndex] = CpuSet->CpuSet.EfficiencyClass;
}
}
Buffer += CpuSet->Size;
Size += CpuSet->Size;
}
#endif
}
void MicroProfileDumpHtml(MicroProfileWriteCallback CB, void* Handle, uint64_t nMaxFrames, const char* pHost, uint64_t nStartFrameId = (uint64_t)-1)
{
// Stall pushing of timers
uint64_t nActiveGroup[MICROPROFILE_MAX_GROUP_INTS];
memcpy(nActiveGroup, S.nActiveGroups, sizeof(S.nActiveGroups));
memset(S.nActiveGroups, 0, sizeof(S.nActiveGroups));
bool AnyActive = S.AnyActive;
S.AnyActive = false;
S.nPauseTicks = MP_TICK();
MicroProfileGetCoreInformation();
if(S.bContextSwitchRunning)
{
auto StallForContextSwitchThread = []()
{
int64_t nPauseTicks = S.nPauseTicks;
int64_t nContextSwitchStalledTick = S.nContextSwitchStalledTick;
return (nPauseTicks - nContextSwitchStalledTick) > 0;
};
int SleepMs = 1;
while(S.bContextSwitchRunning && !S.bContextSwitchStop && StallForContextSwitchThread())
{
MicroProfileSleep(SleepMs);
SleepMs = SleepMs * 2 / 3;
SleepMs = MicroProfileMin(128, SleepMs);
}
int64_t TicksAfterStall = MP_TICK();
uprintf("Stalled %7.2fms for context switch data\n", MicroProfileTickToMsMultiplierCpu() * (TicksAfterStall - S.nPauseTicks));
}
MicroProfileHashTable StringsHashTable;
MicroProfileHashTableInit(&StringsHashTable, 50, 25, MicroProfileHashTableCompareString, MicroProfileHashTableHashString);
defer
{
MicroProfileHashTableDestroy(&StringsHashTable);
};
MicroProfileCounterFetchCounters();
for(size_t i = 0; i < g_MicroProfileHtml_begin_count; ++i)
{
CB(Handle, g_MicroProfileHtml_begin_sizes[i] - 1, g_MicroProfileHtml_begin[i]);
}
// dump info
uint64_t nTicks = MP_TICK();
float fToMsCPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
float fToMsGPU = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondGpu());
float fAggregateMs = fToMsCPU * (nTicks - S.nAggregateFlipTick);
uint32_t nNumFrames = 0;
uint32_t nFirstFrame = (uint32_t)-1;
if(nStartFrameId != (uint64_t)-1)
{
// search for the frane
for(uint32_t i = 0; i < MICROPROFILE_MAX_FRAME_HISTORY; ++i)
{
if(S.Frames[i].nFrameId == nStartFrameId)
{
nFirstFrame = i;
break;
}
}
if(nFirstFrame != (uint32_t)-1)
{
uint32_t nLastFrame = S.nFrameCurrent;
uint32_t nDistance = (MICROPROFILE_MAX_FRAME_HISTORY + nFirstFrame - nLastFrame) % MICROPROFILE_MAX_FRAME_HISTORY;
nNumFrames = MicroProfileMin(nDistance, (uint32_t)nMaxFrames);
}
}
if(nNumFrames == 0)
{
nNumFrames = (MICROPROFILE_MAX_FRAME_HISTORY - MICROPROFILE_GPU_FRAME_DELAY - 3); // leave a few to not overwrite
nNumFrames = MicroProfileMin(nNumFrames, (uint32_t)nMaxFrames);
nFirstFrame = (S.nFrameCurrent + MICROPROFILE_MAX_FRAME_HISTORY - nNumFrames) % MICROPROFILE_MAX_FRAME_HISTORY;
}
uint32_t nLastFrame = (nFirstFrame + nNumFrames) % MICROPROFILE_MAX_FRAME_HISTORY;
MP_ASSERT(nFirstFrame < MICROPROFILE_MAX_FRAME_HISTORY);
MP_ASSERT(nLastFrame < MICROPROFILE_MAX_FRAME_HISTORY);
MicroProfilePrintf(CB, Handle, "S.DumpHost = '%s';\n", pHost ? pHost : "");
time_t CaptureTime;
time(&CaptureTime);
MicroProfilePrintf(CB, Handle, "S.DumpUtcCaptureTime = %ld;\n", CaptureTime);
MicroProfilePrintf(CB, Handle, "S.AggregateInfo = {'Frames':%d, 'Time':%f};\n", S.nAggregateFrames, fAggregateMs);
// categories
MicroProfilePrintf(CB, Handle, "S.CategoryInfo = Array(%d);\n", S.nCategoryCount);
for(uint32_t i = 0; i < S.nCategoryCount; ++i)
{
MicroProfilePrintf(CB, Handle, "S.CategoryInfo[%d] = \"%s\";\n", i, S.CategoryInfo[i].pName);
}
// groups
MicroProfilePrintf(CB, Handle, "S.GroupInfo = Array(%d);\n\n", S.nGroupCount + 1);
uint32_t nAggregateFrames = S.nAggregateFrames ? S.nAggregateFrames : 1;
float fRcpAggregateFrames = 1.f / nAggregateFrames;
(void)fRcpAggregateFrames;
char ColorString[32];
for(uint32_t i = 0; i < S.nGroupCount; ++i)
{
MP_ASSERT(i == S.GroupInfo[i].nGroupIndex);
float fToMs = S.GroupInfo[i].Type == MicroProfileTokenTypeCpu ? fToMsCPU : fToMsGPU;
const char* pColorStr = "";
if(S.GroupInfo[i].nColor != 0x42)
{
stbsp_snprintf(ColorString,
sizeof(ColorString) - 1,
"#%02x%02x%02x",
MICROPROFILE_UNPACK_RED(S.GroupInfo[i].nColor) & 0xff,
MICROPROFILE_UNPACK_GREEN(S.GroupInfo[i].nColor) & 0xff,
MICROPROFILE_UNPACK_BLUE(S.GroupInfo[i].nColor) & 0xff);
pColorStr = &ColorString[0];
}
MicroProfilePrintf(CB,
Handle,
"S.GroupInfo[%d] = MakeGroup(%d, \"%s\", %d, %d, %d, %f, %f, %f, '%s');\n",
S.GroupInfo[i].nGroupIndex,
S.GroupInfo[i].nGroupIndex,
S.GroupInfo[i].pName,
S.GroupInfo[i].nCategory,
S.GroupInfo[i].nNumTimers,
S.GroupInfo[i].Type == MicroProfileTokenTypeGpu ? 1 : 0,
fToMs * S.AggregateGroup[i],
fToMs * S.AggregateGroup[i] / nAggregateFrames,
fToMs * S.AggregateGroupMax[i],
pColorStr);
}
uint32_t nUncategorized = S.nGroupCount;
MicroProfilePrintf(CB,
Handle,
"S.GroupInfo[%d] = MakeGroup(%d, \"%s\", %d, %d, %d, %f, %f, %f, 'grey');\n",
nUncategorized,
nUncategorized,
"Uncategorized",
-1,
1,
// S.GroupInfo[i].Type == MicroProfileTokenTypeGpu ? 1 :
0,
0,
0,
0);
// timers
uint32_t nNumTimers = S.nTotalTimers;
uint32_t nBlockSize = 2 * nNumTimers;
float* pTimers = (float*)alloca(nBlockSize * 9 * sizeof(float));
float* pAverage = pTimers + nBlockSize;
float* pMax = pTimers + 2 * nBlockSize;
float* pMin = pTimers + 3 * nBlockSize;
float* pCallAverage = pTimers + 4 * nBlockSize;
float* pTimersExclusive = pTimers + 5 * nBlockSize;
float* pAverageExclusive = pTimers + 6 * nBlockSize;
float* pMaxExclusive = pTimers + 7 * nBlockSize;
float* pTotal = pTimers + 8 * nBlockSize;
MicroProfileCalcAllTimers(pTimers, pAverage, pMax, pMin, pCallAverage, pTimersExclusive, pAverageExclusive, pMaxExclusive, pTotal, nNumTimers);
MicroProfilePrintf(CB, Handle, "\nS.TimerInfo = Array(%d);\n\n", S.nTotalTimers);
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
uint32_t nIdx = i * 2;
MP_ASSERT(i == S.TimerInfo[i].nTimerIndex);
MicroProfilePrintf(CB, Handle, "S.Meta%d = [];\n", i);
MicroProfilePrintf(CB, Handle, "S.MetaAvg%d = [];\n", i);
MicroProfilePrintf(CB, Handle, "S.MetaMax%d = [];\n", i);
uint32_t nColor = S.TimerInfo[i].nColor;
uint32_t nColorDark = (nColor >> 1) & ~0x80808080;
MicroProfilePrintf(CB,
Handle,
"S.TimerInfo[%d] = MakeTimer(%d, \"%s\", %d, '#%02x%02x%02x','#%02x%02x%02x', %f, %f, %f, %f, %f, %f, %d, %f, S.Meta%d, S.MetaAvg%d, S.MetaMax%d, %d);\n",
S.TimerInfo[i].nTimerIndex,
S.TimerInfo[i].nTimerIndex,
S.TimerInfo[i].pName,
S.TimerInfo[i].nGroupIndex,
MICROPROFILE_UNPACK_RED(nColor) & 0xff,
MICROPROFILE_UNPACK_GREEN(nColor) & 0xff,
MICROPROFILE_UNPACK_BLUE(nColor) & 0xff,
MICROPROFILE_UNPACK_RED(nColorDark) & 0xff,
MICROPROFILE_UNPACK_GREEN(nColorDark) & 0xff,
MICROPROFILE_UNPACK_BLUE(nColorDark) & 0xff,
pAverage[nIdx],
pMax[nIdx],
pMin[nIdx],
pAverageExclusive[nIdx],
pMaxExclusive[nIdx],
pCallAverage[nIdx],
S.Aggregate[i].nCount,
pTotal[nIdx],
i,
i,
i,
S.TimerInfo[i].Flags);
}
uint32_t nTotalTimersExt = S.nTotalTimers;
{
for(uint32_t j = 0; j < S.nNumLogs; ++j)
{
MicroProfileThreadLog* pLog = S.Pool[j];
uint32_t nLogStart = S.Frames[nFirstFrame].nLogStart[j];
uint32_t nLogEnd = S.Frames[nLastFrame].nLogStart[j];
uint64_t nLogType;
if(nLogStart != nLogEnd)
{
for(uint32_t k = nLogStart; k != nLogEnd; k = (k + 1) % MICROPROFILE_BUFFER_SIZE)
{
uint64_t v = pLog->Log[k];
nLogType = MicroProfileLogGetType(v);
uint32_t tidx = MicroProfileLogGetTimerIndex(v);
if((nLogType == MP_LOG_ENTER || nLogType == MP_LOG_LEAVE) && tidx == ETOKEN_CSTR_PTR)
{
MP_ASSERT(k + 1 != nLogEnd);
uint64_t v1 = pLog->Log[(k + 1) % MICROPROFILE_BUFFER_SIZE];
const char* pString = (const char*)MicroProfileLogGetExtendedPayloadNoDataPtr(v1);
uintptr_t value;
if(!MicroProfileHashTableGet(&StringsHashTable, (uint64_t)pString, &value))
{
uintptr_t nTimerIndex = nTotalTimersExt++;
MicroProfileHashTableSet(&StringsHashTable, (uint64_t)pString, nTimerIndex);
MicroProfilePrintf(
CB, Handle, "S.TimerInfo.push(MakeTimer(%d, \"%s\", %d, '#000000','#000000', 0, 0, 0, 0, 0, 0, 0, 0, null, null, null, 0));\n", nTimerIndex, pString, nUncategorized);
}
}
}
}
}
}
MicroProfilePrintf(CB, Handle, "\nS.ThreadNames = [");
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
if(S.Pool[i])
{
MicroProfilePrintf(CB, Handle, "'%s',", S.Pool[i]->ThreadName);
}
else
{
MicroProfilePrintf(CB, Handle, "'Thread %d',", i);
}
}
MicroProfilePrintf(CB, Handle, "];\n\n");
MicroProfilePrintf(CB, Handle, "\nS.ISGPU = [");
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
MicroProfilePrintf(CB, Handle, "%d,", (S.Pool[i] && S.Pool[i]->nGpu) ? 1 : 0);
}
MicroProfilePrintf(CB, Handle, "];\n\n");
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
if(S.Pool[i])
{
MicroProfilePrintf(CB, Handle, "S.ThreadGroupTime%d = [", i);
float fToMs = S.Pool[i]->nGpu ? fToMsGPU : fToMsCPU;
for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
{
MicroProfilePrintf(CB, Handle, "%f,", S.Pool[i]->nAggregateGroupTicks[j] / nAggregateFrames * fToMs);
}
MicroProfilePrintf(CB, Handle, "];\n");
}
}
MicroProfilePrintf(CB, Handle, "\nS.ThreadGroupTimeArray = [");
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
if(S.Pool[i])
{
MicroProfilePrintf(CB, Handle, "S.ThreadGroupTime%d,", i);
}
}
MicroProfilePrintf(CB, Handle, "];\n");
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
if(S.Pool[i])
{
MicroProfilePrintf(CB, Handle, "S.ThreadGroupTimeTotal%d = [", i);
float fToMs = S.Pool[i]->nGpu ? fToMsGPU : fToMsCPU;
for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
{
MicroProfilePrintf(CB, Handle, "%f,", S.Pool[i]->nAggregateGroupTicks[j] * fToMs);
}
MicroProfilePrintf(CB, Handle, "];\n");
}
}
MicroProfilePrintf(CB, Handle, "\nS.ThreadGroupTimeTotalArray = [");
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
if(S.Pool[i])
{
MicroProfilePrintf(CB, Handle, "S.ThreadGroupTimeTotal%d,", i);
}
}
MicroProfilePrintf(CB, Handle, "];");
MicroProfilePrintf(CB, Handle, "\nS.ThreadIds = [");
for(uint32_t i = 0; i < S.nNumLogs; ++i)
{
if(S.Pool[i])
{
MicroProfileThreadIdType ThreadId = S.Pool[i]->nThreadId;
if(!ThreadId)
{
ThreadId = (MicroProfileThreadIdType)-1;
}
MicroProfilePrintf(CB, Handle, "%" PRIu64 ",", (uint64_t)ThreadId);
}
else
{
MicroProfilePrintf(CB, Handle, "-1,");
}
}
MicroProfilePrintf(CB, Handle, "];\n\n");
for(int i = 0; i < (int)S.nNumCounters; ++i)
{
bool IsDouble = (S.CounterInfo[i].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) != 0;
if(0 != (S.CounterInfo[i].nFlags & MICROPROFILE_COUNTER_FLAG_DETAILED) && !IsDouble)
{
int64_t nCounterMax = S.nCounterMax[i];
int64_t nCounterMin = S.nCounterMin[i];
uint32_t nBaseIndex = S.nCounterHistoryPut;
MicroProfilePrintf(CB, Handle, "\nS.CounterHistoryArray%d =[", i);
for(uint32_t j = 0; j < MICROPROFILE_GRAPH_HISTORY; ++j)
{
uint32_t nHistoryIndex = (nBaseIndex + j) % MICROPROFILE_GRAPH_HISTORY;
int64_t nValue = MicroProfileClamp(S.nCounterHistory[nHistoryIndex][i], nCounterMin, nCounterMax);
MicroProfilePrintf(CB, Handle, "%lld,", nValue);
}
MicroProfilePrintf(CB, Handle, "];\n");
int64_t nCounterHeightBase = nCounterMax;
int64_t nCounterOffset = 0;
if(nCounterMin < 0)
{
nCounterHeightBase = nCounterMax - nCounterMin;
nCounterOffset = -nCounterMin;
}
double fRcp = nCounterHeightBase ? (1.0 / nCounterHeightBase) : 0;
MicroProfilePrintf(CB, Handle, "\nS.CounterHistoryArrayPrc%d =[", i);
for(uint32_t j = 0; j < MICROPROFILE_GRAPH_HISTORY; ++j)
{
uint32_t nHistoryIndex = (nBaseIndex + j) % MICROPROFILE_GRAPH_HISTORY;
int64_t nValue = MicroProfileClamp(S.nCounterHistory[nHistoryIndex][i], nCounterMin, nCounterMax);
float fPrc = (nValue + nCounterOffset) * fRcp;
MicroProfilePrintf(CB, Handle, "%f,", fPrc);
}
MicroProfilePrintf(CB, Handle, "];\n");
MicroProfilePrintf(CB, Handle, "S.CounterHistory%d = MakeCounterHistory(%d, S.CounterHistoryArray%d, S.CounterHistoryArrayPrc%d)\n", i, i, i, i);
}
else
{
MicroProfilePrintf(CB, Handle, "S.CounterHistory%d;\n", i);
}
}
MicroProfilePrintf(CB, Handle, "\nS.CounterInfo = [");
for(int i = 0; i < (int)S.nNumCounters; ++i)
{
bool IsDouble = (S.CounterInfo[i].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) != 0;
float fCounterPrc = 0.f;
float fBoxPrc = 1.f;
double dCounter, dLimit, dMax, dMin;
char Formatted[64];
char FormattedLimit[64];
if(!IsDouble)
{
uint64_t nCounter = S.Counters[i].load();
uint64_t nLimit = S.CounterInfo[i].nLimit;
fCounterPrc = 0.f;
if(nLimit)
{
fCounterPrc = (float)nCounter / nLimit;
if(fCounterPrc > 1.f)
{
fBoxPrc = 1.f / fCounterPrc;
fCounterPrc = 1.f;
}
}
MicroProfileFormatCounter(S.CounterInfo[i].eFormat, nCounter, Formatted, sizeof(Formatted) - 1);
MicroProfileFormatCounter(S.CounterInfo[i].eFormat, S.CounterInfo[i].nLimit, FormattedLimit, sizeof(FormattedLimit) - 1);
dCounter = (double)nCounter;
dMin = (double)S.nCounterMin[i];
dMax = (double)S.nCounterMax[i];
dLimit = (double)nLimit;
}
else
{
dCounter = S.CountersDouble[i].load();
dLimit = S.CounterInfo[i].dLimit;
fCounterPrc = 0.f;
if(dLimit > 0.f)
{
fCounterPrc = (float)(dCounter / dLimit);
if(fCounterPrc > 1.f)
{
fBoxPrc = 1.f / fCounterPrc;
fCounterPrc = 1.f;
}
}
MicroProfileFormatCounterDouble(S.CounterInfo[i].eFormat, dCounter, Formatted, sizeof(Formatted) - 1);
MicroProfileFormatCounterDouble(S.CounterInfo[i].eFormat, S.CounterInfo[i].dLimit, FormattedLimit, sizeof(FormattedLimit) - 1);
dMin = (double)S.dCounterMin[i];
dMax = (double)S.dCounterMax[i];
}
MicroProfilePrintf(CB,
Handle,
"MakeCounter(%d, %d, %d, %d, %d, '%s', %f, %f, %f, '%s', %f, '%s', %f, %f, %d, S.CounterHistory%d),",
i,
S.CounterInfo[i].nParent,
S.CounterInfo[i].nSibling,
S.CounterInfo[i].nFirstChild,
S.CounterInfo[i].nLevel,
S.CounterInfo[i].pName,
dCounter,
dMin,
dMax,
Formatted,
dLimit,
FormattedLimit,
fCounterPrc,
fBoxPrc,
S.CounterInfo[i].eFormat == MICROPROFILE_COUNTER_FORMAT_BYTES ? 1 : 0,
i);
}
MicroProfilePrintf(CB, Handle, "];\n\n");
const int64_t nTickStart = S.Frames[nFirstFrame].nFrameStartCpu;
const int64_t nTickEnd = S.Frames[nLastFrame].nFrameStartCpu;
int64_t nTickStartGpu = S.Frames[nFirstFrame].nFrameStartGpu;
int64_t nTickReferenceCpu, nTickReferenceGpu;
int64_t nTicksPerSecondCpu = MicroProfileTicksPerSecondCpu();
int64_t nTicksPerSecondGpu = MicroProfileTicksPerSecondGpu();
int nTickReference = 0;
if(MicroProfileGetGpuTickReference(&nTickReferenceCpu, &nTickReferenceGpu))
{
nTickStartGpu = (nTickStart - nTickReferenceCpu) * nTicksPerSecondGpu / nTicksPerSecondCpu + nTickReferenceGpu;
nTickReference = 1;
}
uprintf("dumping %d frames\n", nNumFrames);
uprintf("dumping frame %d to %d\n", nFirstFrame, nLastFrame);
uint32_t* nTimerCounter = (uint32_t*)alloca(sizeof(uint32_t) * S.nTotalTimers);
memset(nTimerCounter, 0, sizeof(uint32_t) * S.nTotalTimers);
{
MicroProfilePrintf(CB, Handle, " //Timeline begin\n");
MicroProfileThreadLog* pLog = &S.TimelineLog;
uint32_t nFrameIndexFirst = (nFirstFrame) % MICROPROFILE_MAX_FRAME_HISTORY;
uint32_t nFrameIndexLast = (nFirstFrame + nNumFrames) % MICROPROFILE_MAX_FRAME_HISTORY;
{
// find the frame that has an active marker the furtest distance from the selected range
int nDelta = 0;
int nOffset = 0;
for(uint32_t i = nFrameIndexFirst; i != nFrameIndexLast; i = (i + 1) % MICROPROFILE_MAX_FRAME_HISTORY)
{
int D = (int)S.Frames[i].nTimelineFrameMax - nOffset;
nDelta = MicroProfileMax(D, nDelta);
nOffset++;
}
nFrameIndexFirst = (nFirstFrame - nDelta) % MICROPROFILE_MAX_FRAME_HISTORY;
}
uint32_t nLogStart = S.Frames[nFrameIndexFirst].nLogStartTimeline;
uint32_t nLogEnd = S.Frames[nFrameIndexLast].nLogStartTimeline;
float fToMs = MicroProfileTickToMsMultiplier(nTicksPerSecondCpu);
#define pp(...) MicroProfilePrintf(CB, Handle, __VA_ARGS__)
if(nLogStart != nLogEnd)
{
uint32_t nLogType;
float fTime;
int f = 0;
pp("S.TimelineColorArray=[");
for(uint32_t k = nLogStart; k != nLogEnd; k = (k + 1) % MICROPROFILE_BUFFER_SIZE)
{
uint64_t v = pLog->Log[k];
uint64_t nIndex = MicroProfileLogGetTimerIndex(v);
uint64_t nTick = MicroProfileLogGetTick(v);
(void)nTick;
nLogType = MicroProfileLogGetType(v);
switch(nLogType)
{
case MP_LOG_ENTER:
break;
case MP_LOG_LEAVE:
pp("%c'%s'", f++ ? ',' : ' ', "#ff8080");
break;
case MP_LOG_EXTENDED:
case MP_LOG_EXTENDED_NO_DATA:
uint32_t payload = MicroProfileLogGetExtendedPayload(v);
if(nIndex == ETOKEN_CUSTOM_COLOR)
{
uint32_t nColor = payload;
pp("%c'#%02x%02x%02x'", f++ ? ',' : ' ', MICROPROFILE_UNPACK_RED(nColor) & 0xff, MICROPROFILE_UNPACK_GREEN(nColor) & 0xff, MICROPROFILE_UNPACK_BLUE(nColor) & 0xff);
}
k += MicroProfileLogGetDataSize(v);
break;
}
}
pp("];\n");
f = 0;
pp("S.TimelineIdArray=[");
for(uint32_t k = nLogStart; k != nLogEnd; k = (k + 1) % MICROPROFILE_BUFFER_SIZE)
{
uint64_t v = pLog->Log[k];
uint64_t nIndex = MicroProfileLogGetTimerIndex(v);
uint64_t nTick = MicroProfileLogGetTick(v);
(void)nTick;
nLogType = MicroProfileLogGetType(v);
switch(nLogType)
{
case MP_LOG_ENTER:
case MP_LOG_LEAVE:
case MP_LOG_EXTENDED_NO_DATA:
break;
case MP_LOG_EXTENDED:
if(nIndex == ETOKEN_CUSTOM_ID)
{
pp("%c%d", f++ ? ',' : ' ', (uint32_t)nTick);
}
k += MicroProfileLogGetDataSize(v);
break;
}
}
pp("];\n");
f = 0;
pp("S.TimelineArray=[");
for(uint32_t k = nLogStart; k != nLogEnd; k = (k + 1) % MICROPROFILE_BUFFER_SIZE)
{
uint64_t v = pLog->Log[k];
nLogType = MicroProfileLogGetType(v);
switch(nLogType)
{
case MP_LOG_ENTER:
case MP_LOG_LEAVE:
fTime = MicroProfileLogTickDifference(nTickStart, v) * fToMs;
pp("%c%f", f++ ? ',' : ' ', fTime);
break;
case MP_LOG_EXTENDED:
k += MicroProfileLogGetDataSize(v);
break;
case MP_LOG_EXTENDED_NO_DATA:
break;
}
}
pp("];\n");
pp("S.TimelineNames=[");
f = 0;
char String[MICROPROFILE_MAX_STRING + 1];
for(uint32_t k = nLogStart; k != nLogEnd;)
{
uint64_t v = pLog->Log[k];
nLogType = MicroProfileLogGetType(v);
uint64_t nIndex = MicroProfileLogGetTimerIndex(v);
uint64_t nTick = MicroProfileLogGetTick(v);
(void)nTick;
switch(nLogType)
{
case MP_LOG_ENTER:
case MP_LOG_LEAVE:
if(nIndex == ETOKEN_CUSTOM_NAME && nLogType == MP_LOG_LEAVE)
{
// pp(f++ ? ",''" : "''");
}
k = (k + 1) % MICROPROFILE_BUFFER_SIZE;
break;
case MP_LOG_EXTENDED_NO_DATA:
k = (k + 1) % MICROPROFILE_BUFFER_SIZE;
break;
case MP_LOG_EXTENDED:
uint32_t nSize = MicroProfileLogGetDataSize(v);
if(nIndex == ETOKEN_CUSTOM_ID)
{
char* pSource = (char*)&pLog->Log[(k + 1) % MICROPROFILE_BUFFER_SIZE];
const char* pOut = nullptr;
if(nSize == 0)
{
pOut = "";
}
else if(k + nSize <= MICROPROFILE_BUFFER_SIZE)
{
pOut = pSource;
}
else
{
pOut = &String[0];
char* pDest = &String[0];
MP_ASSERT(nSize * 8 < sizeof(MICROPROFILE_MAX_STRING) + 1);
uint32_t Index = (k + 1) % MICROPROFILE_BUFFER_SIZE;
for(uint32_t l = 0; l < nSize; ++l)
{
memcpy(pDest, (char*)pLog->Log[Index], sizeof(uint64_t));
Index = (Index + 1) % MICROPROFILE_BUFFER_SIZE;
}
}
if(f++)
{
pp(",'%s'", pOut);
}
else
{
pp("'%s'", pOut);
}
}
k = (k + 1 + nSize) % MICROPROFILE_BUFFER_SIZE;
break;
}
}
pp("];\n");
}
MicroProfilePrintf(CB, Handle, " //Timeline end\n");
}
MicroProfilePrintf(CB, Handle, "S.Frames = Array(%d);\n", nNumFrames);
for(uint32_t i = 0; i < nNumFrames; ++i)
{
uint32_t nFrameIndex = (nFirstFrame + i) % MICROPROFILE_MAX_FRAME_HISTORY;
uint32_t nFrameIndexNext = (nFrameIndex + 1) % MICROPROFILE_MAX_FRAME_HISTORY;
for(uint32_t j = 0; j < S.nNumLogs; ++j)
{
MicroProfileThreadLog* pLog = S.Pool[j];
int64_t nStartTickBase = pLog->nGpu ? nTickStartGpu : nTickStart;
uint32_t nLogStart = S.Frames[nFrameIndex].nLogStart[j];
uint32_t nLogEnd = S.Frames[nFrameIndexNext].nLogStart[j];
uint32_t nLogType;
float fToMs;
uint64_t nStartTick;
float fToMsCpu = MicroProfileTickToMsMultiplier(nTicksPerSecondCpu);
float fToMsBase = MicroProfileTickToMsMultiplier(pLog->nGpu ? nTicksPerSecondGpu : nTicksPerSecondCpu);
MicroProfilePrintf(CB, Handle, "S.ts_%d_%d = [", i, j);
if(nLogStart != nLogEnd)
{
int f = 0;
for(uint32_t k = nLogStart; k != nLogEnd; k = (k + 1) % MICROPROFILE_BUFFER_SIZE)
{
float fTime;
MicroProfileLogEntry v = pLog->Log[k];
nLogType = MicroProfileLogGetType(v);
fToMs = fToMsBase;
nStartTick = nStartTickBase;
switch(nLogType)
{
case MP_LOG_EXTENDED:
{
fTime = 0.f;
k += MicroProfileLogGetDataSize(v);
break;
}
case MP_LOG_EXTENDED_NO_DATA:
{
uint32_t nTimerIndex = (uint32_t)MicroProfileLogGetTimerIndex(v);
if(nTimerIndex == ETOKEN_GPU_CPU_TIMESTAMP)
{
fToMs = fToMsCpu;
nStartTick = nTickStart;
fTime = MicroProfileLogTickDifference(nStartTick, v) * fToMs;
}
else
{
fTime = 0.f;
}
break;
}
default:
fTime = MicroProfileLogTickDifference(nStartTick, pLog->Log[k]) * fToMs;
}
MicroProfilePrintf(CB, Handle, f++ ? ",%f" : "%f", fTime);
}
}
MicroProfilePrintf(CB, Handle, "];\n");
MicroProfilePrintf(CB, Handle, "S.tt_%d_%d = [", i, j);
if(nLogStart != nLogEnd)
{
uint32_t k = nLogStart;
MicroProfilePrintf(CB, Handle, "%d", MicroProfileLogGetType(pLog->Log[k]));
for(k = (k + 1) % MICROPROFILE_BUFFER_SIZE; k != nLogEnd; k = (k + 1) % MICROPROFILE_BUFFER_SIZE)
{
uint64_t v = pLog->Log[k];
uint32_t nLogType2 = MicroProfileLogGetType(v);
if(nLogType2 > MP_LOG_ENTER)
nLogType2 |= (MicroProfileLogGetExtendedToken(v))
<< 2; // pack extended token here.. this way all code can check agains ENTER/LEAVE, and only the ext code needs to care about the top bits.
MicroProfilePrintf(CB, Handle, ",%d", nLogType2);
if(nLogType2 == MP_LOG_EXTENDED)
k += MicroProfileLogGetDataSize(v);
}
}
MicroProfilePrintf(CB, Handle, "];\n");
MicroProfilePrintf(CB, Handle, "S.ti_%d_%d = [", i, j);
if(nLogStart != nLogEnd)
{
for(uint32_t k = nLogStart; k != nLogEnd; k = (k + 1) % MICROPROFILE_BUFFER_SIZE)
{
uint64_t v = pLog->Log[k];
nLogType = MicroProfileLogGetType(v);
const char* pFormat = k == nLogStart ? "%d" : ",%d";
if(nLogType == MP_LOG_ENTER || nLogType == MP_LOG_LEAVE)
{
uint32_t nTimerIndex = (uint32_t)MicroProfileLogGetTimerIndex(pLog->Log[k]);
if(ETOKEN_CSTR_PTR == nTimerIndex)
{
MP_ASSERT(k + 1 != nLogEnd);
uint64_t v1 = pLog->Log[(k + 1) % MICROPROFILE_BUFFER_SIZE];
const char* pString = (const char*)MicroProfileLogGetExtendedPayloadNoDataPtr(v1);
uintptr_t value;
if(!MicroProfileHashTableGet(&StringsHashTable, (uint64_t)pString, &value))
{
MP_BREAK(); // should be covered earlier.
}
MicroProfilePrintf(CB, Handle, pFormat, value);
}
else
{
if(nTimerIndex < S.nTotalTimers)
{
nTimerCounter[nTimerIndex]++;
}
MicroProfilePrintf(CB, Handle, pFormat, nTimerIndex);
}
}
else
{
uint64_t ExtendedToken = MicroProfileLogGetExtendedToken(v);
uint64_t PayloadNoData = MicroProfileLogGetExtendedPayloadNoData(v);
switch(ExtendedToken)
{
case ETOKEN_GPU_CPU_SOURCE_THREAD:
MicroProfilePrintf(CB, Handle, pFormat, PayloadNoData);
break;
default:
MicroProfilePrintf(CB, Handle, pFormat, -1);
}
if(nLogType == MP_LOG_EXTENDED)
k += MicroProfileLogGetDataSize(v);
}
}
}
MicroProfilePrintf(CB, Handle, "];\n");
}
MicroProfilePrintf(CB, Handle, "S.ts%d = [", i);
for(uint32_t j = 0; j < S.nNumLogs; ++j)
{
MicroProfilePrintf(CB, Handle, "S.ts_%d_%d,", i, j);
}
MicroProfilePrintf(CB, Handle, "];\n");
MicroProfilePrintf(CB, Handle, "S.tt%d = [", i);
for(uint32_t j = 0; j < S.nNumLogs; ++j)
{
MicroProfilePrintf(CB, Handle, "S.tt_%d_%d,", i, j);
}
MicroProfilePrintf(CB, Handle, "];\n");
MicroProfilePrintf(CB, Handle, "S.ti%d = [", i);
for(uint32_t j = 0; j < S.nNumLogs; ++j)
{
MicroProfilePrintf(CB, Handle, "S.ti_%d_%d,", i, j);
}
MicroProfilePrintf(CB, Handle, "];\n");
int64_t nFrameStart = S.Frames[nFrameIndex].nFrameStartCpu;
int64_t nFrameEnd = S.Frames[nFrameIndexNext].nFrameStartCpu;
float fToMs = MicroProfileTickToMsMultiplier(nTicksPerSecondCpu);
float fFrameMs = MicroProfileLogTickDifference(nTickStart, nFrameStart) * fToMs;
float fFrameEndMs = MicroProfileLogTickDifference(nTickStart, nFrameEnd) * fToMs;
float fFrameGpuMs = 0;
float fFrameGpuEndMs = 0;
if(nTickReference)
{
fFrameGpuMs = MicroProfileLogTickDifference(nTickStartGpu, S.Frames[nFrameIndex].nFrameStartGpu) * fToMsGPU;
fFrameGpuEndMs = MicroProfileLogTickDifference(nTickStartGpu, S.Frames[nFrameIndexNext].nFrameStartGpu) * fToMsGPU;
}
MicroProfilePrintf(CB, Handle, "S.Frames[%d] = MakeFrame(%d, %f, %f, %f, %f, S.ts%d, S.tt%d, S.ti%d);\n", i, 0, fFrameMs, fFrameEndMs, fFrameGpuMs, fFrameGpuEndMs, i, i, i);
}
uint32_t nContextSwitchStart = 0;
uint32_t nContextSwitchEnd = 0;
MicroProfileContextSwitchSearch(&nContextSwitchStart, &nContextSwitchEnd, nTickStart, nTickEnd);
uprintf("CONTEXT SWITCH SEARCH .... %d %d %d .... %lld, %lld\n", nContextSwitchStart, nContextSwitchEnd, nContextSwitchEnd - nContextSwitchStart, nTickStart, nTickEnd);
uint32_t nWrittenBefore = S.nWebServerDataSent;
MicroProfilePrintf(CB, Handle, "S.CSwitchThreadInOutCpu = [");
for(uint32_t j = nContextSwitchStart; j != nContextSwitchEnd; j = (j + 1) % MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE)
{
MicroProfileContextSwitch CS = S.ContextSwitch[j];
int nCpu = CS.nCpu;
MicroProfilePrintf(CB, Handle, "%d,%d,%d,", CS.nThreadIn, CS.nThreadOut, nCpu);
}
MicroProfilePrintf(CB, Handle, "];\n");
MicroProfilePrintf(CB, Handle, "S.CSwitchTime = [");
float fToMsCpu = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
for(uint32_t j = nContextSwitchStart; j != nContextSwitchEnd; j = (j + 1) % MICROPROFILE_CONTEXT_SWITCH_BUFFER_SIZE)
{
MicroProfileContextSwitch CS = S.ContextSwitch[j];
float fTime = MicroProfileLogTickDifference(nTickStart, CS.nTicks) * fToMsCpu;
MicroProfilePrintf(CB, Handle, "%f,", fTime);
}
MicroProfilePrintf(CB, Handle, "];\n");
MicroProfilePrintf(CB, Handle, "S.CSwitchThreads = {");
MicroProfileThreadInfo* pThreadInfo = nullptr;
uint32_t nNumThreads = MicroProfileGetThreadInfoArray(&pThreadInfo);
for(uint32_t i = 0; i < nNumThreads; ++i)
{
const char* p1 = pThreadInfo[i].pThreadModule ? pThreadInfo[i].pThreadModule : "?";
const char* p2 = pThreadInfo[i].pProcessModule ? pThreadInfo[i].pProcessModule : "?";
MicroProfilePrintf(CB,
Handle,
"%" PRId64 ":{\'tid\':%" PRId64 ",\'pid\':%" PRId64 ",\'t\':\'%s\',\'p\':\'%s\'},",
(uint64_t)pThreadInfo[i].tid,
(uint64_t)pThreadInfo[i].tid,
(uint64_t)pThreadInfo[i].pid,
p1,
p2);
}
MicroProfilePrintf(CB, Handle, "};\n");
MicroProfilePrintf(CB, Handle, "S.CoreEfficiencyClass = [");
for(uint32_t i = 0; i < MICROPROFILE_MAX_CPU_CORES; ++i)
{
MicroProfilePrintf(CB, Handle, "%d,", S.CoreEfficiencyClass[i]);
}
MicroProfilePrintf(CB, Handle, "];\n");
{
MicroProfilePrintf(CB, Handle, "//String Table\n");
MicroProfilePrintf(CB, Handle, "S.StringTable = {}\n");
// dump string table
MicroProfileHashTableIterator beg = MicroProfileGetHashTableIteratorBegin(&StringsHashTable);
MicroProfileHashTableIterator end = MicroProfileGetHashTableIteratorEnd(&StringsHashTable);
while(beg != end)
{
uint64_t Key = beg->Key;
uint64_t Value = beg->Value;
MicroProfilePrintf(CB, Handle, "S.StringTable[%d] = '%s';\n", Value, (const char*)Key);
beg++;
}
}
uint32_t nWrittenAfter = S.nWebServerDataSent;
MicroProfilePrintf(CB, Handle, "//CSwitch Size %d\n", nWrittenAfter - nWrittenBefore);
for(size_t i = 0; i < g_MicroProfileHtml_end_count; ++i)
{
CB(Handle, g_MicroProfileHtml_end_sizes[i] - 1, g_MicroProfileHtml_end[i]);
}
uint32_t* nGroupCounter = (uint32_t*)alloca(sizeof(uint32_t) * S.nGroupCount);
memset(nGroupCounter, 0, sizeof(uint32_t) * S.nGroupCount);
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
uint32_t nGroupIndex = S.TimerInfo[i].nGroupIndex;
nGroupCounter[nGroupIndex] += nTimerCounter[i];
}
uint32_t* nGroupCounterSort = (uint32_t*)alloca(sizeof(uint32_t) * S.nGroupCount);
uint32_t* nTimerCounterSort = (uint32_t*)alloca(sizeof(uint32_t) * S.nTotalTimers);
for(uint32_t i = 0; i < S.nGroupCount; ++i)
{
nGroupCounterSort[i] = i;
}
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
nTimerCounterSort[i] = i;
}
std::sort(nGroupCounterSort, nGroupCounterSort + S.nGroupCount, [nGroupCounter](const uint32_t l, const uint32_t r) { return nGroupCounter[l] > nGroupCounter[r]; });
std::sort(nTimerCounterSort, nTimerCounterSort + S.nTotalTimers, [nTimerCounter](const uint32_t l, const uint32_t r) { return nTimerCounter[l] > nTimerCounter[r]; });
MicroProfilePrintf(CB, Handle, "\n<!--\nMarker Per Group\n");
for(uint32_t i = 0; i < S.nGroupCount; ++i)
{
uint32_t idx = nGroupCounterSort[i];
MicroProfilePrintf(CB, Handle, "%8d:%s\n", nGroupCounter[idx], S.GroupInfo[idx].pName);
}
MicroProfilePrintf(CB, Handle, "Marker Per Timer\n");
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
uint32_t idx = nTimerCounterSort[i];
MicroProfilePrintf(CB, Handle, "%8d:%s(%s)\n", nTimerCounter[idx], S.TimerInfo[idx].pName, S.GroupInfo[S.TimerInfo[idx].nGroupIndex].pName);
}
MicroProfilePrintf(CB, Handle, "\n-->\n");
memcpy(S.nActiveGroups, nActiveGroup, sizeof(S.nActiveGroups));
S.AnyActive = AnyActive;
#if MICROPROFILE_DEBUG
int64_t nTicksEnd = MP_TICK();
float fMs = fToMsCpu * (nTicksEnd - S.nPauseTicks);
uprintf("html dump took %6.2fms\n", fMs);
#endif
#undef pp
S.nPauseTicks = 0;
}
void MicroProfileWriteFile(void* Handle, size_t nSize, const char* pData)
{
fwrite(pData, nSize, 1, (FILE*)Handle);
}
void MicroProfileDumpToFile()
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
if(S.nDumpFileNextFrame & 1)
{
char Path[MICROPROFILE_MAX_PATH];
int Length = snprintf(Path, sizeof(S.HtmlDumpPath), "%s.html", S.HtmlDumpPath);
if(Length > 0 && Length < MICROPROFILE_MAX_PATH)
{
FILE* F = fopen(Path, "w");
if(F)
{
MicroProfileDumpHtml(MicroProfileWriteFile, F, S.DumpFrameCount, S.HtmlDumpPath);
fclose(F);
}
}
}
if(S.nDumpFileNextFrame & 2)
{
#if MICROPROFILE_LEGACY_CSV
MicroProfileDumpCsvLegacy();
#else
MicroProfileDumpCsv(S.DumpFrameCount);
#endif
}
}
void MicroProfileFlushSocket(MpSocket Socket)
{
send(Socket, &S.WebServerBuffer[0], S.WebServerPut, 0);
S.WebServerPut = 0;
}
void MicroProfileWriteSocket(void* Handle, size_t nSize, const char* pData)
{
S.nWebServerDataSent += nSize;
MpSocket Socket = *(MpSocket*)Handle;
if(nSize > MICROPROFILE_WEBSERVER_SOCKET_BUFFER_SIZE / 2)
{
MicroProfileFlushSocket(Socket);
send(Socket, pData, (int)nSize, 0);
}
else
{
memcpy(&S.WebServerBuffer[S.WebServerPut], pData, nSize);
S.WebServerPut += (uint32_t)nSize;
if(S.WebServerPut > MICROPROFILE_WEBSERVER_SOCKET_BUFFER_SIZE / 2)
{
MicroProfileFlushSocket(Socket);
}
}
}
#if MICROPROFILE_MINIZ
#ifndef MICROPROFILE_COMPRESS_BUFFER_SIZE
#define MICROPROFILE_COMPRESS_BUFFER_SIZE (256 << 10)
#endif
#define MICROPROFILE_COMPRESS_CHUNK (MICROPROFILE_COMPRESS_BUFFER_SIZE / 2)
struct MicroProfileCompressedSocketState
{
unsigned char DeflateOut[MICROPROFILE_COMPRESS_CHUNK];
unsigned char DeflateIn[MICROPROFILE_COMPRESS_CHUNK];
mz_stream Stream;
MpSocket Socket;
uint32_t nSize;
uint32_t nCompressedSize;
uint32_t nFlushes;
uint32_t nMemmoveBytes;
};
void MicroProfileCompressedSocketFlush(MicroProfileCompressedSocketState* pState)
{
mz_stream& Stream = pState->Stream;
unsigned char* pSendStart = &pState->DeflateOut[0];
unsigned char* pSendEnd = &pState->DeflateOut[MICROPROFILE_COMPRESS_CHUNK - Stream.avail_out];
if(pSendStart != pSendEnd)
{
send(pState->Socket, (const char*)pSendStart, pSendEnd - pSendStart, 0);
pState->nCompressedSize += pSendEnd - pSendStart;
}
Stream.next_out = &pState->DeflateOut[0];
Stream.avail_out = MICROPROFILE_COMPRESS_CHUNK;
}
void MicroProfileCompressedSocketStart(MicroProfileCompressedSocketState* pState, MpSocket Socket)
{
mz_stream& Stream = pState->Stream;
memset(&Stream, 0, sizeof(Stream));
Stream.next_out = &pState->DeflateOut[0];
Stream.avail_out = MICROPROFILE_COMPRESS_CHUNK;
Stream.next_in = &pState->DeflateIn[0];
Stream.avail_in = 0;
mz_deflateInit(&Stream, Z_DEFAULT_COMPRESSION);
pState->Socket = Socket;
pState->nSize = 0;
pState->nCompressedSize = 0;
pState->nFlushes = 0;
pState->nMemmoveBytes = 0;
}
void MicroProfileCompressedSocketFinish(MicroProfileCompressedSocketState* pState)
{
mz_stream& Stream = pState->Stream;
MicroProfileCompressedSocketFlush(pState);
int r = mz_deflate(&Stream, MZ_FINISH);
MP_ASSERT(r == MZ_STREAM_END);
MicroProfileCompressedSocketFlush(pState);
r = mz_deflateEnd(&Stream);
MP_ASSERT(r == MZ_OK);
}
void MicroProfileCompressedWriteSocket(void* Handle, size_t nSize, const char* pData)
{
MicroProfileCompressedSocketState* pState = (MicroProfileCompressedSocketState*)Handle;
mz_stream& Stream = pState->Stream;
const unsigned char* pDeflateInEnd = Stream.next_in + Stream.avail_in;
const unsigned char* pDeflateInStart = &pState->DeflateIn[0];
const unsigned char* pDeflateInRealEnd = &pState->DeflateIn[MICROPROFILE_COMPRESS_CHUNK];
pState->nSize += (uint32_t)nSize;
if((ptrdiff_t)nSize <= pDeflateInRealEnd - pDeflateInEnd)
{
memcpy((void*)pDeflateInEnd, pData, nSize);
Stream.avail_in += (uint32_t)nSize;
MP_ASSERT(Stream.next_in + Stream.avail_in <= pDeflateInRealEnd);
return;
}
int Flush = 0;
while(nSize)
{
pDeflateInEnd = Stream.next_in + Stream.avail_in;
if(Flush)
{
pState->nFlushes++;
MicroProfileCompressedSocketFlush(pState);
pDeflateInRealEnd = &pState->DeflateIn[MICROPROFILE_COMPRESS_CHUNK];
if(pDeflateInEnd == pDeflateInRealEnd)
{
if(Stream.avail_in)
{
MP_ASSERT(pDeflateInStart != Stream.next_in);
memmove((void*)pDeflateInStart, Stream.next_in, Stream.avail_in);
pState->nMemmoveBytes += Stream.avail_in;
}
Stream.next_in = pDeflateInStart;
pDeflateInEnd = Stream.next_in + Stream.avail_in;
}
}
size_t nSpace = pDeflateInRealEnd - pDeflateInEnd;
size_t nBytes = MicroProfileMin(nSpace, nSize);
MP_ASSERT(nBytes + pDeflateInEnd <= pDeflateInRealEnd);
memcpy((void*)pDeflateInEnd, pData, nBytes);
Stream.avail_in += (uint32_t)nBytes;
nSize -= nBytes;
pData += nBytes;
int r = mz_deflate(&Stream, MZ_NO_FLUSH);
Flush = r == MZ_BUF_ERROR || nBytes == 0 || Stream.avail_out == 0 ? 1 : 0;
MP_ASSERT(r == MZ_BUF_ERROR || r == MZ_OK);
if(r == MZ_BUF_ERROR)
{
r = mz_deflate(&Stream, MZ_SYNC_FLUSH);
}
}
}
#endif
#ifndef MicroProfileSetNonBlocking // fcntl doesnt work on a some unix like platforms..
void MicroProfileSetNonBlocking(MpSocket Socket, int NonBlocking)
{
#ifdef _WIN32
u_long nonBlocking = NonBlocking ? 1 : 0;
ioctlsocket(Socket, FIONBIO, &nonBlocking);
#else
int Options = fcntl(Socket, F_GETFL);
if(NonBlocking)
{
fcntl(Socket, F_SETFL, Options | O_NONBLOCK);
}
else
{
fcntl(Socket, F_SETFL, Options & (~O_NONBLOCK));
}
#endif
}
#endif
void MicroProfileWebServerStart()
{
#ifdef _WIN32
WSADATA wsa;
if(WSAStartup(MAKEWORD(2, 2), &wsa))
{
S.ListenerSocket = (MpSocket)-1;
return;
}
#endif
S.ListenerSocket = socket(PF_INET, SOCK_STREAM, 6);
MP_ASSERT(!MP_INVALID_SOCKET(S.ListenerSocket));
MicroProfileSetNonBlocking(S.ListenerSocket, 1);
{
int r = 0;
int on = 1;
#if defined(_WIN32)
r = setsockopt(S.ListenerSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
#else
r = setsockopt(S.ListenerSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&on, sizeof(on));
#endif
(void)r;
}
int nStartPort = S.nWebServerPort;
struct sockaddr_in Addr;
Addr.sin_family = AF_INET;
Addr.sin_addr.s_addr = INADDR_ANY;
for(int i = 0; i < 20; ++i)
{
Addr.sin_port = htons(nStartPort + i);
if(0 == bind(S.ListenerSocket, (sockaddr*)&Addr, sizeof(Addr)))
{
S.nWebServerPort = (uint32_t)(nStartPort + i);
break;
}
}
listen(S.ListenerSocket, 8);
}
void MicroProfileWebServerJoin()
{
if(S.WebSocketThreadRunning)
{
MicroProfileThreadJoin(&S.WebSocketSendThread);
}
S.WebSocketThreadJoined = 1;
}
void MicroProfileWebServerStop()
{
MP_ASSERT(S.WebSocketThreadJoined);
#ifdef _WIN32
closesocket(S.ListenerSocket);
WSACleanup();
#else
close(S.ListenerSocket);
#endif
}
enum MicroProfileGetCommand
{
EMICROPROFILE_GET_COMMAND_DUMP,
EMICROPROFILE_GET_COMMAND_DUMP_RANGE,
EMICROPROFILE_GET_COMMAND_LIVE,
EMICROPROFILE_GET_COMMAND_FAVICON,
EMICROPROFILE_GET_COMMAND_SERVICE_WORKER,
EMICROPROFILE_GET_COMMAND_UNKNOWN,
};
struct MicroProfileParseGetResult
{
uint64_t nFrames;
uint64_t nFrameStart;
};
MicroProfileGetCommand MicroProfileParseGet(const char* pGet, MicroProfileParseGetResult* pResult)
{
if(0 == strlen(pGet))
{
return EMICROPROFILE_GET_COMMAND_LIVE;
}
if(0 == strcmp(pGet, "favicon.ico"))
{
return EMICROPROFILE_GET_COMMAND_FAVICON;
}
if(0 == strcmp(pGet, "favicon.png"))
{
return EMICROPROFILE_GET_COMMAND_FAVICON;
}
if(0 == strcmp(pGet, "service-worker.js"))
{
return EMICROPROFILE_GET_COMMAND_SERVICE_WORKER;
}
const char* pStart = pGet;
if(*pStart == 'b' || *pStart == 'p')
{
S.nWSWasConnected = 1; // do not load default when url has one specified.
return EMICROPROFILE_GET_COMMAND_LIVE;
}
if(*pStart == 'r') // range
{
// very very manual parsing
if('/' != *++pStart)
return EMICROPROFILE_GET_COMMAND_UNKNOWN;
++pStart;
char* pEnd = nullptr;
uint64_t nFrameStart = strtoll(pStart, &pEnd, 10);
if(pEnd == pStart || *pEnd != '/' || *pEnd == '\0')
{
return EMICROPROFILE_GET_COMMAND_UNKNOWN;
}
pStart = pEnd + 1;
uint64_t nFrameEnd = strtoll(pStart, &pEnd, 10);
if(pEnd == pStart || nFrameEnd <= nFrameStart)
{
return EMICROPROFILE_GET_COMMAND_UNKNOWN;
}
pResult->nFrames = nFrameEnd - nFrameStart;
pResult->nFrameStart = nFrameStart;
return EMICROPROFILE_GET_COMMAND_DUMP_RANGE;
}
while(*pGet != '\0')
{
if(*pGet < '0' || *pGet > '9')
return EMICROPROFILE_GET_COMMAND_UNKNOWN;
pGet++;
}
int nFrames = atoi(pStart);
pResult->nFrameStart = (uint64_t)-1;
if(nFrames)
{
pResult->nFrames = nFrames;
}
else
{
pResult->nFrames = MICROPROFILE_WEBSERVER_DEFAULT_FRAMES;
}
return EMICROPROFILE_GET_COMMAND_DUMP;
}
void MicroProfileBase64Encode(char* pOut, const uint8_t* pIn, uint32_t nLen)
{
static const char* CODES = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
//..straight from wikipedia.
int b;
char* o = pOut;
for(uint32_t i = 0; i < nLen; i += 3)
{
b = (pIn[i] & 0xfc) >> 2;
*o++ = CODES[b];
b = (pIn[i] & 0x3) << 4;
if(i + 1 < nLen)
{
b |= (pIn[i + 1] & 0xF0) >> 4;
*o++ = CODES[b];
b = (pIn[i + 1] & 0x0F) << 2;
if(i + 2 < nLen)
{
b |= (pIn[i + 2] & 0xC0) >> 6;
*o++ = CODES[b];
b = pIn[i + 2] & 0x3F;
*o++ = CODES[b];
}
else
{
*o++ = CODES[b];
*o++ = '=';
}
}
else
{
*o++ = CODES[b];
*o++ = '=';
*o++ = '=';
}
}
}
// begin: SHA-1 in C
// ftp://ftp.funet.fi/pub/crypt/hash/sha/sha1.c
// SHA-1 in C
// By Steve Reid <steve@edmweb.com>
// 100% Public Domain
typedef struct
{
uint32_t state[5];
uint32_t count[2];
unsigned char buffer[64];
} MicroProfile_SHA1_CTX;
#include <string.h>
#ifndef _WIN32
#include <netinet/in.h>
#endif
static void MicroProfile_SHA1_Transform(uint32_t[5], const unsigned char[64]);
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
#define blk0(i) (block->l[i] = htonl(block->l[i]))
#define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
#define R0(v, w, x, y, z, i) \
z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
w = rol(w, 30);
#define R1(v, w, x, y, z, i) \
z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
w = rol(w, 30);
#define R2(v, w, x, y, z, i) \
z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
w = rol(w, 30);
#define R3(v, w, x, y, z, i) \
z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
w = rol(w, 30);
#define R4(v, w, x, y, z, i) \
z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
w = rol(w, 30);
// Hash a single 512-bit block. This is the core of the algorithm.
static void MicroProfile_SHA1_Transform(uint32_t state[5], const unsigned char buffer[64])
{
uint32_t a, b, c, d, e;
typedef union
{
unsigned char c[64];
uint32_t l[16];
} CHAR64LONG16;
CHAR64LONG16* block;
block = (CHAR64LONG16*)buffer;
// Copy context->state[] to working vars
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
// 4 rounds of 20 operations each. Loop unrolled.
R0(a, b, c, d, e, 0);
R0(e, a, b, c, d, 1);
R0(d, e, a, b, c, 2);
R0(c, d, e, a, b, 3);
R0(b, c, d, e, a, 4);
R0(a, b, c, d, e, 5);
R0(e, a, b, c, d, 6);
R0(d, e, a, b, c, 7);
R0(c, d, e, a, b, 8);
R0(b, c, d, e, a, 9);
R0(a, b, c, d, e, 10);
R0(e, a, b, c, d, 11);
R0(d, e, a, b, c, 12);
R0(c, d, e, a, b, 13);
R0(b, c, d, e, a, 14);
R0(a, b, c, d, e, 15);
R1(e, a, b, c, d, 16);
R1(d, e, a, b, c, 17);
R1(c, d, e, a, b, 18);
R1(b, c, d, e, a, 19);
R2(a, b, c, d, e, 20);
R2(e, a, b, c, d, 21);
R2(d, e, a, b, c, 22);
R2(c, d, e, a, b, 23);
R2(b, c, d, e, a, 24);
R2(a, b, c, d, e, 25);
R2(e, a, b, c, d, 26);
R2(d, e, a, b, c, 27);
R2(c, d, e, a, b, 28);
R2(b, c, d, e, a, 29);
R2(a, b, c, d, e, 30);
R2(e, a, b, c, d, 31);
R2(d, e, a, b, c, 32);
R2(c, d, e, a, b, 33);
R2(b, c, d, e, a, 34);
R2(a, b, c, d, e, 35);
R2(e, a, b, c, d, 36);
R2(d, e, a, b, c, 37);
R2(c, d, e, a, b, 38);
R2(b, c, d, e, a, 39);
R3(a, b, c, d, e, 40);
R3(e, a, b, c, d, 41);
R3(d, e, a, b, c, 42);
R3(c, d, e, a, b, 43);
R3(b, c, d, e, a, 44);
R3(a, b, c, d, e, 45);
R3(e, a, b, c, d, 46);
R3(d, e, a, b, c, 47);
R3(c, d, e, a, b, 48);
R3(b, c, d, e, a, 49);
R3(a, b, c, d, e, 50);
R3(e, a, b, c, d, 51);
R3(d, e, a, b, c, 52);
R3(c, d, e, a, b, 53);
R3(b, c, d, e, a, 54);
R3(a, b, c, d, e, 55);
R3(e, a, b, c, d, 56);
R3(d, e, a, b, c, 57);
R3(c, d, e, a, b, 58);
R3(b, c, d, e, a, 59);
R4(a, b, c, d, e, 60);
R4(e, a, b, c, d, 61);
R4(d, e, a, b, c, 62);
R4(c, d, e, a, b, 63);
R4(b, c, d, e, a, 64);
R4(a, b, c, d, e, 65);
R4(e, a, b, c, d, 66);
R4(d, e, a, b, c, 67);
R4(c, d, e, a, b, 68);
R4(b, c, d, e, a, 69);
R4(a, b, c, d, e, 70);
R4(e, a, b, c, d, 71);
R4(d, e, a, b, c, 72);
R4(c, d, e, a, b, 73);
R4(b, c, d, e, a, 74);
R4(a, b, c, d, e, 75);
R4(e, a, b, c, d, 76);
R4(d, e, a, b, c, 77);
R4(c, d, e, a, b, 78);
R4(b, c, d, e, a, 79);
// Add the working vars back into context.state[]
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
// Wipe variables
a = b = c = d = e = 0;
}
void MicroProfile_SHA1_Init(MicroProfile_SHA1_CTX* context)
{
// SHA1 initialization constants
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
context->state[4] = 0xC3D2E1F0;
context->count[0] = context->count[1] = 0;
}
// Run your data through this.
void MicroProfile_SHA1_Update(MicroProfile_SHA1_CTX* context, const unsigned char* data, unsigned int len)
{
unsigned int i, j;
j = (context->count[0] >> 3) & 63;
if((context->count[0] += len << 3) < (len << 3))
context->count[1]++;
context->count[1] += (len >> 29);
i = 64 - j;
while(len >= i)
{
memcpy(&context->buffer[j], data, i);
MicroProfile_SHA1_Transform(context->state, context->buffer);
data += i;
len -= i;
i = 64;
j = 0;
}
memcpy(&context->buffer[j], data, len);
}
// Add padding and return the message digest.
void MicroProfile_SHA1_Final(unsigned char digest[20], MicroProfile_SHA1_CTX* context)
{
uint32_t i, j;
unsigned char finalcount[8];
for(i = 0; i < 8; i++)
{
finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); // Endian independent
}
MicroProfile_SHA1_Update(context, (unsigned char*)"\200", 1);
while((context->count[0] & 504) != 448)
{
MicroProfile_SHA1_Update(context, (unsigned char*)"\0", 1);
}
MicroProfile_SHA1_Update(context, finalcount, 8); // Should cause a SHA1Transform()
for(i = 0; i < 20; i++)
{
digest[i] = (unsigned char)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
}
// Wipe variables
i = j = 0;
memset(context->buffer, 0, 64);
memset(context->state, 0, 20);
memset(context->count, 0, 8);
memset(&finalcount, 0, 8);
}
#undef rol
#undef blk0
#undef blk
#undef R0
#undef R1
#undef R2
#undef R3
#undef R4
// end: SHA-1 in C
void MicroProfileWebSocketSendState(MpSocket C);
void MicroProfileWebSocketSendEnabled(MpSocket C);
void MicroProfileWSPrintStart(MpSocket C);
void MicroProfileWSPrintf(const char* pFmt, ...);
void MicroProfileWSPrintEnd();
void MicroProfileWSFlush();
bool MicroProfileWebSocketReceive(MpSocket C);
enum
{
TYPE_NONE = 0,
TYPE_TIMER = 1,
TYPE_GROUP = 2,
TYPE_CATEGORY = 3,
TYPE_SETTING = 4,
TYPE_COUNTER = 5,
};
enum
{
SETTING_FORCE_ENABLE = 0,
SETTING_CONTEXT_SWITCH_TRACE = 1,
SETTING_PLATFORM_MARKERS = 2,
};
enum
{
MSG_TIMER_TREE = 1,
MSG_ENABLED = 2,
MSG_FRAME = 3,
MSG_LOADSETTINGS = 4,
MSG_PRESETS = 5,
MSG_CURRENTSETTINGS = 6,
MSG_COUNTERS = 7,
MSG_FUNCTION_RESULTS = 8,
MSG_INACTIVE_FRAME = 9,
MSG_FUNCTION_NAMES = 10,
MSG_INSTRUMENT_ERROR = 11,
MSG_QUERY_INDEX = 12,
// MSG_MODULE_NAME = 12,
};
enum
{
VIEW_GRAPH_SPLIT = 0,
VIEW_GRAPH_PERCENTILE = 1,
VIEW_GRAPH_THREAD_GROUP = 2,
VIEW_BAR = 3,
VIEW_BAR_ALL = 4,
VIEW_BAR_SINGLE = 5,
VIEW_COUNTERS = 6,
VIEW_SIZE = 7,
};
void MicroProfileSocketDumpState()
{
fd_set Read, Write, Error;
FD_ZERO(&Read);
FD_ZERO(&Write);
FD_ZERO(&Error);
MpSocket LastSocket = 1;
for(uint32_t i = 0; i < S.nNumWebSockets; ++i)
{
LastSocket = MicroProfileMax(LastSocket, S.WebSockets[i] + 1);
FD_SET(S.WebSockets[i], &Read);
FD_SET(S.WebSockets[i], &Write);
FD_SET(S.WebSockets[i], &Error);
}
timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
if(-1 == select(LastSocket, &Read, &Write, &Error, &tv))
{
MP_ASSERT(0);
}
for(uint32_t i = 0; i < S.nNumWebSockets; i++)
{
MpSocket s = S.WebSockets[i];
uprintf("%" PRId64 " ", (uint64_t)s);
if(FD_ISSET(s, &Error))
{
uprintf("e");
}
else
{
uprintf("_");
}
if(FD_ISSET(s, &Read))
{
uprintf("r");
}
else
{
uprintf(" ");
}
if(FD_ISSET(s, &Write))
{
uprintf("w");
}
else
{
uprintf(" ");
}
}
uprintf("\n");
for(uint32_t i = 1; i < S.nNumWebSockets; i++)
{
MpSocket s = S.WebSockets[i];
int error_code;
socklen_t error_code_size = sizeof(error_code);
int r = getsockopt(s, SOL_SOCKET, SO_ERROR, (char*)&error_code, &error_code_size);
MP_ASSERT(r >= 0);
if(error_code != 0)
{
#ifdef _WIN32
char buffer[1024];
strerror_s(buffer, sizeof(buffer) - 1, error_code);
fprintf(stderr, "socket error: %d %s\n", (int)s, buffer);
#else
fprintf(stderr, "socket error: %d %s\n", (int)s, strerror(error_code));
#endif
MP_ASSERT(0);
}
}
}
bool MicroProfileSocketSend2(MpSocket Connection, const void* pMessage, int nLen);
void* MicroProfileSocketSenderThread(void*)
{
MicroProfileOnThreadCreate("MicroProfileSocketSenderThread");
while(!S.nMicroProfileShutdown)
{
if(S.nSocketFail)
{
MicroProfileSleep(100);
continue;
}
uint32_t nEnd = MICROPROFILE_WEBSOCKET_BUFFER_SIZE;
uint32_t nGet = S.WSBuf.nSendGet.load();
uint32_t nPut = S.WSBuf.nSendPut.load();
uint32_t nSendStart = 0;
uint32_t nSendAmount = 0;
if(nGet > nPut)
{
nSendStart = nGet;
nSendAmount = nEnd - nGet;
}
else if(nGet < nPut)
{
nSendStart = nGet;
nSendAmount = nPut - nGet;
}
if(nSendAmount)
{
MICROPROFILE_SCOPE(g_MicroProfileSendLoop);
MICROPROFILE_COUNTER_LOCAL_ADD_ATOMIC(g_MicroProfileBytesPerFlip, nSendAmount);
if(!MicroProfileSocketSend2(S.WebSockets[0], &S.WSBuf.SendBuffer[nSendStart], nSendAmount))
{
S.nSocketFail = 1;
}
else
{
S.WSBuf.nSendGet.store((nGet + nSendAmount) % MICROPROFILE_WEBSOCKET_BUFFER_SIZE);
}
}
else
{
MicroProfileSleep(20);
}
}
MicroProfileOnThreadExit();
return 0;
}
void MicroProfileSocketSend(MpSocket Connection, const void* pMessage, int nLen)
{
if(S.nSocketFail || nLen <= 0)
{
return;
}
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileSocketSend", MP_GREEN4);
while(nLen != 0)
{
MP_ASSERT(nLen > 0);
uint32_t nEnd = MICROPROFILE_WEBSOCKET_BUFFER_SIZE;
uint32_t nGet = S.WSBuf.nSendGet.load();
uint32_t nPut = S.WSBuf.nSendPut.load();
uint32_t nAmount = 0;
if(nPut < nGet)
{
nAmount = nGet - nPut - 1;
}
else
{
if(nGet == 0)
{
nAmount = nEnd - nPut - 1;
}
else
{
nAmount = nEnd - nPut;
}
}
MP_ASSERT((int)nAmount >= 0);
nAmount = MicroProfileMin(nLen, (int)nAmount);
if(nAmount)
{
memcpy(&S.WSBuf.SendBuffer[nPut], pMessage, nAmount);
pMessage = (void*)((char*)pMessage + nAmount);
nLen -= nAmount;
S.WSBuf.nSendPut.store((nPut + nAmount) % MICROPROFILE_WEBSOCKET_BUFFER_SIZE);
}
else
{
if(S.nSocketFail)
{
return;
}
MicroProfileSleep(20);
}
}
}
bool MicroProfileSocketSend2(MpSocket Connection, const void* pMessage, int nLen)
{
if(S.nSocketFail || nLen <= 0)
{
return false;
}
// MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileSocketSend2", 0);
#ifndef _WIN32
int error_code;
socklen_t error_code_size = sizeof(error_code);
getsockopt(Connection, SOL_SOCKET, SO_ERROR, &error_code, &error_code_size);
if(error_code != 0)
{
return false;
}
#endif
int s = 0;
while(nLen)
{
s = send(Connection, (const char*)pMessage, nLen, 0);
if(s < 0)
{
const int error = errno;
if(error == EAGAIN || error == EWOULDBLOCK)
{
MicroProfileSleep(20);
continue;
}
break;
}
nLen -= s;
pMessage = (const char*)pMessage + s;
}
#ifdef _WIN32
if(s == SOCKET_ERROR)
{
return false;
}
#endif
if(s < 0)
{
return false;
}
return true;
}
uint32_t MicroProfileWebSocketIdPack(uint32_t type, uint32_t element)
{
MP_ASSERT(type < 255);
MP_ASSERT(element < 0xffffff);
return type << 24 | element;
}
void MicroProfileWebSocketIdUnpack(uint32_t nPacked, uint32_t& type, uint32_t& element)
{
type = (nPacked >> 24) & 0xff;
element = nPacked & 0xffffff;
}
struct MicroProfileWebSocketHeader0
{
union
{
struct
{
uint8_t opcode : 4;
uint8_t RSV3 : 1;
uint8_t RSV2 : 1;
uint8_t RSV1 : 1;
uint8_t FIN : 1;
};
uint8_t v;
};
};
struct MicroProfileWebSocketHeader1
{
union
{
struct
{
uint8_t payload : 7;
uint8_t MASK : 1;
};
uint8_t v;
};
};
bool MicroProfileWebSocketSend(MpSocket Connection, const char* pMessage, uint64_t nLen)
{
MicroProfileWebSocketHeader0 h0;
MicroProfileWebSocketHeader1 h1;
h0.v = 0;
h1.v = 0;
h0.opcode = 1;
h0.FIN = 1;
uint32_t nExtraSizeBytes = 0;
uint8_t nExtraSize[8];
if(nLen > 125)
{
if(nLen > 0xffff)
{
nExtraSizeBytes = 8;
h1.payload = 127;
}
else
{
h1.payload = 126;
nExtraSizeBytes = 2;
}
uint64_t nCount = nLen;
for(uint32_t i = 0; i < nExtraSizeBytes; ++i)
{
nExtraSize[nExtraSizeBytes - i - 1] = nCount & 0xff;
nCount >>= 8;
}
uint32_t nSize = 0;
for(uint32_t i = 0; i < nExtraSizeBytes; i++)
{
nSize <<= 8;
nSize += nExtraSize[i];
}
MP_ASSERT(nSize == nLen); // verify
}
else
{
h1.payload = nLen;
}
MP_ASSERT(pMessage == S.WSBuf.pBuffer); // space for header is preallocated here
MP_ASSERT(pMessage == S.WSBuf.pBufferAllocation + 20); // space for header is preallocated here
MP_ASSERT(nExtraSizeBytes < 18);
char* pTmp = (char*)(pMessage - nExtraSizeBytes - 2);
memcpy(pTmp + 2, &nExtraSize[0], nExtraSizeBytes);
pTmp[1] = *(char*)&h1;
pTmp[0] = *(char*)&h0;
// MicroProfileSocketSend(Connection, pTmp, nExtraSizeBytes + 2 + nLen);
#if 1
MicroProfileSocketSend(Connection, &h0, 1);
MicroProfileSocketSend(Connection, &h1, 1);
if(nExtraSizeBytes)
{
MicroProfileSocketSend(Connection, &nExtraSize[0], nExtraSizeBytes);
}
MicroProfileSocketSend(Connection, pMessage, nLen);
#endif
return true;
}
void MicroProfileWebSocketClearTimers()
{
while(S.WebSocketTimers > -1)
{
int nNext = S.TimerInfo[S.WebSocketTimers].nWSNext;
S.TimerInfo[S.WebSocketTimers].nWSNext = -2;
S.WebSocketTimers = nNext;
}
MP_ASSERT(S.WebSocketTimers == -1);
while(S.WebSocketCounters > -1)
{
int nNext = S.CounterInfo[S.WebSocketCounters].nWSNext;
S.CounterInfo[S.WebSocketCounters].nWSNext = -2;
S.WebSocketCounters = nNext;
}
MP_ASSERT(S.WebSocketCounters == -1);
while(S.WebSocketGroups > -1)
{
int nNext = S.GroupInfo[S.WebSocketGroups].nWSNext;
S.GroupInfo[S.WebSocketGroups].nWSNext = -2;
S.WebSocketGroups = nNext;
}
MP_ASSERT(S.WebSocketGroups == -1);
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
}
void MicroProfileWebSocketToggleTimer(uint32_t nTimer)
{
if(nTimer < S.nTotalTimers)
{
auto& TI = S.TimerInfo[nTimer];
int* pPrev = &S.WebSocketTimers;
while(*pPrev > -1 && *pPrev != (int)nTimer)
{
MP_ASSERT(*pPrev < (int)S.nTotalTimers && *pPrev >= 0);
pPrev = &S.TimerInfo[*pPrev].nWSNext;
}
if(TI.nWSNext >= -1)
{
MP_ASSERT(*pPrev == (int)nTimer);
*pPrev = TI.nWSNext;
TI.nWSNext = -2;
}
else
{
MP_ASSERT(*pPrev == -1);
TI.nWSNext = -1;
*pPrev = (int)nTimer;
}
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
}
}
void MicroProfileWebSocketToggleCounter(uint32_t nCounter)
{
if(nCounter < S.nNumCounters)
{
auto& TI = S.CounterInfo[nCounter];
int* pPrev = &S.WebSocketCounters;
while(*pPrev > -1 && *pPrev != (int)nCounter)
{
MP_ASSERT(*pPrev < (int)S.nNumCounters && *pPrev >= 0);
pPrev = &S.CounterInfo[*pPrev].nWSNext;
}
if(TI.nWSNext >= -1)
{
MP_ASSERT(*pPrev == (int)nCounter);
*pPrev = TI.nWSNext;
TI.nWSNext = -2;
}
else
{
MP_ASSERT(*pPrev == -1);
TI.nWSNext = -1;
*pPrev = (int)nCounter;
}
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
}
}
void MicroProfileWebSocketToggleGroup(uint32_t nGroup)
{
if(nGroup < S.nGroupCount)
{
auto& TI = S.GroupInfo[nGroup];
int* pPrev = &S.WebSocketGroups;
while(*pPrev > -1 && *pPrev != (int)nGroup)
{
MP_ASSERT(*pPrev < (int)S.nGroupCount && *pPrev >= 0);
pPrev = &S.GroupInfo[*pPrev].nWSNext;
}
if(TI.nWSNext >= -1)
{
MP_ASSERT(*pPrev == (int)nGroup);
*pPrev = TI.nWSNext;
TI.nWSNext = -2;
}
else
{
MP_ASSERT(*pPrev == -1);
TI.nWSNext = -1;
*pPrev = (int)nGroup;
}
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
}
}
bool MicroProfileWebSocketTimerEnabled(uint32_t nTimer)
{
if(nTimer < S.nTotalTimers)
{
return S.TimerInfo[nTimer].nWSNext > -2;
}
return false;
}
bool MicroProfileWebSocketCounterEnabled(uint32_t nCounter)
{
if(nCounter < S.nNumCounters)
{
return S.CounterInfo[nCounter].nWSNext > -2;
}
return false;
}
void MicroProfileWebSocketCommand(uint32_t nCommand)
{
uint32_t nType, nElement;
MicroProfileWebSocketIdUnpack(nCommand, nType, nElement);
switch(nType)
{
case TYPE_NONE:
break;
case TYPE_SETTING:
switch(nElement)
{
case SETTING_FORCE_ENABLE:
MicroProfileSetEnableAllGroups(!MicroProfileGetEnableAllGroups());
break;
case SETTING_CONTEXT_SWITCH_TRACE:
if(!S.bContextSwitchRunning)
{
MicroProfileStartContextSwitchTrace();
}
else
{
MicroProfileStopContextSwitchTrace();
}
break;
case SETTING_PLATFORM_MARKERS:
MicroProfilePlatformMarkersSetEnabled(!MicroProfilePlatformMarkersGetEnabled());
break;
}
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
break;
case TYPE_TIMER:
MicroProfileWebSocketToggleTimer(nElement);
break;
case TYPE_GROUP:
MicroProfileToggleGroup(nElement);
break;
case TYPE_CATEGORY:
MicroProfileToggleCategory(nElement);
break;
case TYPE_COUNTER:
MicroProfileWebSocketToggleCounter(nElement);
break;
default:
uprintf("unknown type %d\n", nType);
}
}
#define MICROPROFILE_PRESET_HEADER_MAGIC2 0x28586813
#define MICROPROFILE_PRESET_HEADER_VERSION2 0x00000200
struct MicroProfileSettingsFileHeader
{
uint32_t nMagic;
uint32_t nVersion;
uint32_t nNumHeaders;
uint32_t nHeadersOffset;
uint32_t nMaxJsonSize;
uint32_t nMaxNameSize;
};
struct MicroProfileSettingsHeader
{
uint32_t nJsonOffset;
uint32_t nJsonSize;
uint32_t nNameOffset;
uint32_t nNameSize;
};
template <typename T>
void MicroProfileParseSettings(const char* pFileName, T CB)
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileGetMutex());
FILE* F = fopen(pFileName, "rb");
if(!F)
{
return;
}
long nFileSize = 0;
fseek(F, 0, SEEK_END);
nFileSize = ftell(F);
char* pFile = 0;
char* pAlloc = 0;
if(nFileSize > (32 << 10))
{
pFile = pAlloc = (char*)MP_ALLOC(nFileSize + 1, 1);
}
else
{
pFile = (char*)alloca(nFileSize + 1);
}
fseek(F, 0, SEEK_SET);
if(1 != fread(pFile, nFileSize, 1, F))
{
uprintf("failed to read settings file\n");
fclose(F);
return;
}
fclose(F);
pFile[nFileSize] = '\0';
char* pPos = pFile;
char* pEnd = pFile + nFileSize;
while(pPos != pEnd)
{
const char* pName = 0;
int nNameLen = 0;
const char* pJson = 0;
int nJsonLen = 0;
int Failed = 0;
auto SkipWhite = [&](char* pPos, const char* pEnd)
{
while(pPos != pEnd)
{
if(isspace(*pPos))
{
pPos++;
}
else if('#' == *pPos)
{
while(pPos != pEnd && *pPos != '\n')
{
++pPos;
}
}
else
{
break;
}
}
return pPos;
};
auto ParseName = [&](char* pPos, char* pEnd, const char** ppName, int* pLen)
{
pPos = SkipWhite(pPos, pEnd);
int nLen = 0;
*ppName = pPos;
while(pPos != pEnd && (isalpha(*pPos) || isdigit(*pPos) || *pPos == '_'))
{
nLen++;
pPos++;
}
*pLen = nLen;
if(pPos == pEnd || !isspace(*pPos))
{
Failed = 1;
return pEnd;
}
*pPos++ = '\0';
return pPos;
};
auto ParseJson = [&](char* pPos, char* pEnd, const char** pJson, int* pLen) -> char*
{
pPos = SkipWhite(pPos, pEnd);
if(*pPos != '{' || pPos == pEnd)
{
Failed = 1;
return pPos;
}
*pJson = pPos++;
int nLen = 1;
int nDepth = 1;
while(pPos != pEnd && nDepth != 0)
{
nLen++;
char nChar = *pPos++;
if(nChar == '{')
{
nDepth++;
}
else if(nChar == '}')
{
nDepth--;
}
}
if(pPos == pEnd || !isspace(*pPos))
{
Failed = 1;
return pEnd;
}
*pLen = nLen;
*pPos++ = '\0';
return pPos;
};
pPos = ParseName(pPos, pEnd, &pName, &nNameLen);
pPos = ParseJson(pPos, pEnd, &pJson, &nJsonLen);
if(Failed)
{
break;
}
if(!CB(pName, nNameLen, pJson, nJsonLen))
{
break;
}
}
if(pAlloc)
MP_FREE(pAlloc);
}
bool MicroProfileSavePresets(const char* pSettingsName, const char* pJsonSettings)
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileGetMutex());
FILE* F = fopen(S.pSettingsTemp, "w");
if(!F)
{
return false;
}
bool bWritten = false;
MicroProfileParseSettings(S.pSettings,
[&](const char* pName, uint32_t nNameSize, const char* pJson, uint32_t nJsonSize) -> bool
{
fwrite(pName, nNameSize, 1, F);
fputc(' ', F);
if(0 != MP_STRCASECMP(pSettingsName, pName))
{
fwrite(pJson, nJsonSize, 1, F);
}
else
{
bWritten = true;
fwrite(pJsonSettings, strlen(pJsonSettings), 1, F);
}
fputc('\n', F);
return true;
});
if(!bWritten)
{
fwrite(pSettingsName, strlen(pSettingsName), 1, F);
fputc(' ', F);
fwrite(pJsonSettings, strlen(pJsonSettings), 1, F);
fputc('\n', F);
}
fflush(F);
fclose(F);
#ifdef MICROPROFILE_MOVE_FILE
MICROPROFILE_MOVE_FILE(S.pSettingsTemp, S.pSettings);
#elif defined(_WIN32)
MoveFileExA(S.pSettingsTemp, S.pSettings, MOVEFILE_REPLACE_EXISTING);
#else
rename(S.pSettingsTemp, S.pSettings);
#endif
return false;
}
void MicroProfileWriteJsonString(const char* pJson, uint32_t nJsonLen)
{
char* pCur = (char*)pJson;
char* pEnd = pCur + nJsonLen;
MicroProfileWSPrintf("\"", pCur);
while(pCur != pEnd)
{
char* pTag = strchr(pCur, '\"');
if(pTag)
{
*pTag = '\0';
MicroProfileWSPrintf("%s\\\"", pCur);
*pTag = '\"';
pCur = pTag + 1;
}
else
{
MicroProfileWSPrintf("%s\"", pCur);
pCur = pEnd;
}
}
};
void MicroProfileWebSocketSendPresets(MpSocket Connection)
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileGetMutex());
uprintf("sending presets ... \n");
MicroProfileWSPrintStart(Connection);
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":{", MSG_PRESETS);
MicroProfileWSPrintf("\"p\":{\"Default\":\"{}\"");
MicroProfileParseSettings(S.pSettings,
[](const char* pName, uint32_t nNameLen, const char* pJson, uint32_t nJsonLen)
{
MicroProfileWSPrintf(",\"%s\":", pName);
MicroProfileWriteJsonString(pJson, nJsonLen);
return true;
});
MicroProfileWSPrintf("},\"r\":{");
bool bFirst = true;
MicroProfileParseSettings(S.pSettingsReadOnly,
[&bFirst](const char* pName, uint32_t nNameLen, const char* pJson, uint32_t nJsonLen)
{
MicroProfileWSPrintf("%c\"%s\":", bFirst ? ' ' : ',', pName);
MicroProfileWriteJsonString(pJson, nJsonLen);
bFirst = false;
return true;
});
MicroProfileWSPrintf("}}}");
MicroProfileWSFlush();
MicroProfileWSPrintEnd();
}
#define LOAD_PRESET_DEFAULT 0x1
#define LOAD_PRESET_READONLY 0x2
void MicroProfileLoadPresets(const char* pSettingsName, uint32_t nLoadPresetType)
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileGetMutex());
const char* pPresetFiles[] = { S.pSettings, S.pSettingsReadOnly };
for(uint32_t i = 0; i < 2; ++i)
{
if(nLoadPresetType & (1u << i))
{
const char* pPresetFile = pPresetFiles[i];
bool bReadOnly = (1u << i) == LOAD_PRESET_READONLY;
bool bSuccess = false;
MicroProfileParseSettings(pPresetFile,
[&bSuccess, bReadOnly, pSettingsName](const char* pName, uint32_t l0, const char* pJson, uint32_t l1)
{
if(0 == MP_STRCASECMP(pName, pSettingsName))
{
uint32_t nLen = (uint32_t)strlen(pJson) + 1;
if(nLen > S.nJsonSettingsBufferSize)
{
if(S.pJsonSettings)
S.pJsonSettings = nullptr;
S.pJsonSettings = (char*)MP_ALLOC(nLen, 1);
S.nJsonSettingsBufferSize = nLen;
}
S.pJsonSettingsName = pSettingsName;
memcpy(S.pJsonSettings, pJson, nLen);
S.nJsonSettingsPending = 1;
S.bJsonSettingsReadOnly = bReadOnly ? 1 : 0;
bSuccess = true;
return false;
}
return true;
});
if(bSuccess)
return;
}
}
}
bool MicroProfileWebSocketReceive(MpSocket Connection)
{
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-------+-+-------------+-------------------------------+
// |F|R|R|R| opcode|M| Payload len | Extended payload length |
// |I|S|S|S| (4) |A| (7) | (16/64) |
// |N|V|V|V| |S| | (if payload len==126/127) |
// | |1|2|3| |K| | |
// +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
int r;
uint64_t nSize;
uint64_t nSizeBytes = 0;
uint8_t Mask[4];
static unsigned char* Bytes = 0;
static uint64_t BytesAllocated = 0;
MicroProfileWebSocketHeader0 h0;
MicroProfileWebSocketHeader1 h1;
static_assert(sizeof(h0) == 1, "");
static_assert(sizeof(h1) == 1, "");
r = recv(Connection, (char*)&h0, 1, 0);
if(1 != r)
goto fail;
r = recv(Connection, (char*)&h1, 1, 0);
if(1 != r)
goto fail;
if(h0.v == 0x88)
{
goto fail;
}
if(h0.RSV1 != 0 || h0.RSV2 != 0 || h0.RSV3 != 0)
goto fail;
nSize = h1.payload;
nSizeBytes = 0;
switch(nSize)
{
case 126:
nSizeBytes = 2;
break;
case 127:
nSizeBytes = 8;
break;
default:
break;
}
if(nSizeBytes)
{
nSize = 0;
uint64_t MessageLength = 0;
uint8_t BytesMessage[8];
r = recv(Connection, (char*)&BytesMessage[0], nSizeBytes, 0);
if((int)nSizeBytes != r)
goto fail;
for(uint32_t i = 0; i < nSizeBytes; i++)
{
nSize <<= 8;
nSize += BytesMessage[i];
}
for(uint32_t i = 0; i < nSizeBytes; i++)
MessageLength |= BytesMessage[i] << ((nSizeBytes - 1 - i) * 8);
MP_ASSERT(MessageLength == nSize);
}
if(h1.MASK)
{
recv(Connection, (char*)&Mask[0], 4, 0);
}
MICROPROFILE_COUNTER_LOCAL_ADD_ATOMIC(g_MicroProfileBytesPerFlip, nSize);
if(nSize + 1 > BytesAllocated)
{
Bytes = (unsigned char*)MP_REALLOC(Bytes, nSize + 1);
BytesAllocated = nSize + 1;
}
recv(Connection, (char*)Bytes, nSize, 0);
for(uint32_t i = 0; i < nSize; ++i)
Bytes[i] ^= Mask[i & 3];
Bytes[nSize] = '\0';
switch(Bytes[0])
{
case 'a':
{
S.nAggregateFlip = strtoll((const char*)&Bytes[1], nullptr, 10);
}
break;
case 's':
{
char* pJson = strchr((char*)Bytes, ',');
if(pJson && *pJson != '\0')
{
*pJson = '\0';
MicroProfileSavePresets((const char*)Bytes + 1, (const char*)pJson + 1);
}
break;
}
case 'l':
{
MicroProfileLoadPresets((const char*)Bytes + 1, LOAD_PRESET_DEFAULT);
break;
}
case 'm':
{
MicroProfileLoadPresets((const char*)Bytes + 1, LOAD_PRESET_READONLY);
break;
}
case 'd':
{
MicroProfileWebSocketClearTimers();
memset(&S.nActiveGroupsWanted, 0, sizeof(S.nActiveGroupsWanted));
S.nWebSocketDirty |= MICROPROFILE_WEBSOCKET_DIRTY_ENABLED;
break;
}
case 'c':
{
char* pStr = (char*)Bytes + 1;
char* pEnd = pStr + nSize - 1;
uint32_t Message = strtol(pStr, &pEnd, 10);
MicroProfileWebSocketCommand(Message);
}
break;
case 'f':
MicroProfileToggleFrozen();
break;
case 'v':
S.nWSViewMode = (int)Bytes[1] - '0';
break;
case 'r':
uprintf("got clear message\n");
S.nAggregateClear = 1;
break;
case 'x':
MicroProfileWebSocketClearTimers();
break;
#if MICROPROFILE_DYNAMIC_INSTRUMENT
case 'D': // instrumentation without loading queryable symbols.
{
uprintf("got INSTRUMENT Message: %s\n", (const char*)&Bytes[0]);
char* pGet = (char*)&Bytes[1];
uint32_t nNumArguments = 0;
#ifdef _WIN32
r = sscanf_s(pGet, "%d", &nNumArguments);
#else
r = sscanf(pGet, "%d", &nNumArguments);
#endif
if(r != 1)
{
uprintf("failed to parse..\n");
break;
}
while(' ' == *pGet || (*pGet >= '0' && *pGet <= '9'))
{
pGet++;
}
if(nNumArguments > 200)
nNumArguments = 200;
uint32_t nParsedArguments = 0;
const char* pModule = 0;
const char* pSymbol = 0;
const char** pModules = (const char**)(alloca(sizeof(const char*) * nNumArguments));
const char** pSymbols = (const char**)(alloca(sizeof(const char*) * nNumArguments));
auto Next = [&pGet]() -> const char*
{
if(!pGet)
return 0;
const char* pRet = pGet;
pGet = (char*)strchr(pRet, '!');
if(!pGet)
{
return 0;
}
*pGet++ = '\0';
return (const char*)pRet;
};
do
{
pModule = Next();
pSymbol = Next();
if(pModule && pSymbol)
{
pModules[nParsedArguments] = pModule;
pSymbols[nParsedArguments] = pSymbol;
uprintf("found symbol %s ::: %s \n", pModule, pSymbol);
nParsedArguments++;
if(nParsedArguments == nNumArguments)
{
break;
}
}
} while(pGet);
MicroProfileInstrumentWithoutSymbols(pModules, pSymbols, nParsedArguments);
break;
}
case 'I':
case 'i':
{
uprintf("got Message: %s\n", (const char*)&Bytes[0]);
void* p = 0;
uint32_t nColor = 0x0;
int nMinBytes = 0;
int nMaxCalls = 0;
int nCharsRead = 0;
#ifdef _WIN32
r = sscanf_s((const char*)&Bytes[1], "%p %x %d %d%n", &p, &nColor, &nMinBytes, &nMaxCalls, &nCharsRead);
#else
r = sscanf((const char*)&Bytes[1], "%p %x %d %d%n", &p, &nColor, &nMinBytes, &nMaxCalls, &nCharsRead);
#endif
if(r == 4)
{
const char* pModule = (const char*)&Bytes[1];
// int nNumChars = stbsp_snprintf(0, 0, "%p %x", p, nColor);
pModule += nCharsRead;
while(*pModule != ' ' && *pModule != '\0')
++pModule;
if(*pModule == '\0')
break;
pModule++;
const char* pName = pModule;
while(*pName != '!' && *pName != '\0')
{
pName++;
}
if(*pName == '!')
{
// name and module seperately
*(char*)pName = '\0';
pName++;
}
else
{
// name only
pName = pModule;
pModule = "";
}
uprintf("scanning for ptr %p %x mod:'%s' name'%s'\n", p, nColor, pModule, pName);
if(Bytes[0] == 'I')
{
MicroProfileInstrumentFunctionsCalled(p, pModule, pName, nMinBytes, nMaxCalls);
}
else
{
MicroProfileInstrumentFunction(p, pModule, pName, nColor);
}
}
}
break;
case 'S':
uprintf("loading symbols...\n");
MicroProfileSymbolInitialize(true);
break;
case 'q':
MicroProfileSymbolQueryFunctions(Connection, 1 + (const char*)Bytes);
break;
case 'L':
uprintf("LOAD MODULE: '%s'\n", 1 + (const char*)Bytes);
MicroProfileSymbolInitialize(true, 1 + (const char*)Bytes);
break;
#else
case 'D':
case 'I':
case 'i':
case 'S':
case 'q':
case 'L':
break;
#endif
default:
uprintf("got unknown message size %lld: '%s'\n", (long long)nSize, Bytes);
}
return true;
fail:
return false;
}
void MicroProfileWebSocketSendPresets(MpSocket Connection);
void MicroProfileWebSocketHandshake(MpSocket Connection, char* pWebSocketKey)
{
// reset web socket buffer
S.WSBuf.nSendPut.store(0);
S.WSBuf.nSendGet.store(0);
S.nSocketFail = 0;
const char* pGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
const char* pHandShake = "HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: ";
char EncodeBuffer[512];
int nLen = stbsp_snprintf(EncodeBuffer, sizeof(EncodeBuffer) - 1, "%s%s", pWebSocketKey, pGUID);
// uprintf("encode buffer is '%s' %d, %d\n", EncodeBuffer, nLen, (int)strlen(EncodeBuffer));
uint8_t sha[20];
MicroProfile_SHA1_CTX ctx;
MicroProfile_SHA1_Init(&ctx);
MicroProfile_SHA1_Update(&ctx, (unsigned char*)EncodeBuffer, nLen);
MicroProfile_SHA1_Final((unsigned char*)&sha[0], &ctx);
char HashOut[(2 + sizeof(sha) / 3) * 4];
memset(&HashOut[0], 0, sizeof(HashOut));
MicroProfileBase64Encode(&HashOut[0], &sha[0], sizeof(sha));
char Reply[11024];
nLen = stbsp_snprintf(Reply, sizeof(Reply) - 1, "%s%s\r\n\r\n", pHandShake, HashOut);
;
MP_ASSERT(nLen >= 0);
MicroProfileSocketSend(Connection, Reply, nLen);
S.WebSockets[S.nNumWebSockets++] = Connection;
S.WSCategoriesSent = 0;
S.WSGroupsSent = 0;
S.WSTimersSent = 0;
S.WSCountersSent = 0;
S.nJsonSettingsPending = 0;
#if MICROPROFILE_DYNAMIC_INSTRUMENT
S.WSFunctionsInstrumentedSent = 0;
S.WSSymbolModulesSent = 0;
{
uint64_t t0 = MP_TICK();
MicroProfileSymbolUpdateModuleList();
uint64_t t1 = MP_TICK();
float fTime = float(MicroProfileTickToMsMultiplierCpu()) * (t1 - t0);
(void)fTime;
uprintf("update module list time %6.2fms\n", fTime);
}
#endif
MicroProfileWebSocketSendState(Connection);
MicroProfileWebSocketSendPresets(Connection);
if(!S.nWSWasConnected)
{
S.nWSWasConnected = 1;
MicroProfileLoadPresets("Default", LOAD_PRESET_DEFAULT | LOAD_PRESET_READONLY);
}
else
{
#if MICROPROFILE_DYNAMIC_INSTRUMENT
MicroProfileWSPrintStart(Connection);
MicroProfileWSPrintf("{\"k\":\"%d\",\"qp\":%d}", MSG_QUERY_INDEX, S.nQueryProcessed);
MicroProfileWSFlush();
MicroProfileWSPrintEnd();
#endif
if(S.pJsonSettings)
{
MicroProfileWSPrintStart(Connection);
MicroProfileWSPrintf(
"{\"k\":\"%d\",\"ro\":%d,\"name\":\"%s\",\"v\":%s}", MSG_CURRENTSETTINGS, S.bJsonSettingsReadOnly ? 1 : 0, S.pJsonSettingsName ? S.pJsonSettingsName : "", S.pJsonSettings);
MicroProfileWSFlush();
MicroProfileWSPrintEnd();
}
}
}
void MicroProfileWebSocketSendCounters()
{
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileWebSocketSendCounters", MP_GREEN4);
if(S.nWSViewMode == VIEW_COUNTERS)
{
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":[", MSG_COUNTERS);
for(uint32_t i = 0; i < S.nNumCounters; ++i)
{
bool IsDouble = (S.CounterInfo[i].nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) != 0;
if(IsDouble)
{
double dCounter = S.CountersDouble[i].load();
MicroProfileWSPrintf("%c%f", i == 0 ? ' ' : ',', dCounter);
}
else
{
uint64_t nCounter = S.Counters[i].load();
MicroProfileWSPrintf("%c%lld", i == 0 ? ' ' : ',', nCounter);
}
}
MicroProfileWSPrintf("]}");
MicroProfileWSFlush();
}
}
#if MICROPROFILE_DYNAMIC_INSTRUMENT
void MicroProfileSymbolSendModuleState()
{
if(S.WSSymbolModulesSent != S.SymbolNumModules || S.nSymbolsDirty.load()) // todo: tag when modulestate is updated.
{
S.nSymbolsDirty.exchange(0);
MicroProfileWSPrintf(",\"M\":[");
bool bFirst = true;
for(int i = 0; i < S.SymbolNumModules; ++i)
{
MicroProfileSymbolModule& M = S.SymbolModules[i];
const char* pModuleName = (const char*)M.pBaseString;
uint64_t nAddrBegin = M.Regions[0].nBegin;
// intptr_t nProgress = M.nProgress;
intptr_t nProgressTarget = M.nProgressTarget;
nProgressTarget = MicroProfileMax(intptr_t(1), M.nProgressTarget);
// nProgress = MicroProfileMin(nProgressTarget, M.nProgress);
float fLoadPrc = M.nProgress / float(nProgressTarget);
uint64_t nNumSymbols = M.nSymbolsLoaded;
#define FMT "{\"n\":\"%s\",\"a\":\"%llx\",\"s\":\"%lld\", \"p\":%f, \"d\":%d}"
MicroProfileWSPrintf(bFirst ? FMT : ("," FMT), pModuleName, nAddrBegin, nNumSymbols, fLoadPrc, M.bDownloading ? 1 : 0);
#undef FMT
bFirst = false;
}
MicroProfileWSPrintf("]");
S.WSSymbolModulesSent = S.SymbolNumModules;
}
}
#endif
void MicroProfileWebSocketSendFrame(MpSocket Connection)
{
if(S.nFrameCurrent != S.WebSocketFrameLast[0] || S.nFrozen)
{
MicroProfileWebSocketSendState(Connection);
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileWebSocketSendFrame", MP_GREEN4);
MicroProfileWSPrintStart(Connection);
float fTickToMsCpu = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
float fTickToMsGpu = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondGpu());
MicroProfileFrameState* pFrameCurrent = &S.Frames[S.nFrameCurrent];
MicroProfileFrameState* pFrameNext = &S.Frames[S.nFrameNext];
uint64_t nFrameTicks = pFrameNext->nFrameStartCpu - pFrameCurrent->nFrameStartCpu;
uint64_t nFrame = pFrameCurrent->nFrameId;
double fTime = nFrameTicks * fTickToMsCpu;
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":{\"t\":%f,\"f\":%lld,\"a\":%d,\"fr\":%d,\"m\":%d", MSG_FRAME, fTime, nFrame, MicroProfileGetCurrentAggregateFrames(), S.nFrozen, S.nWSViewMode);
#if MICROPROFILE_DYNAMIC_INSTRUMENT
MicroProfileWSPrintf(",\"s\":{\"n\":%d,\"f\":%d,\"r\":%d,\"l\":%d,\"q\":%d}",
S.SymbolNumModules,
S.SymbolState.nModuleLoadsFinished.load(),
S.SymbolState.nModuleLoadsRequested.load(),
S.SymbolState.nSymbolsLoaded.load(),
S.pPendingQuery ? 1 : 0);
MicroProfileSymbolSendModuleState();
#endif
auto WriteTickArray = [fTickToMsCpu, fTickToMsGpu](MicroProfile::GroupTime* pFrameGroup)
{
MicroProfileWSPrintf("[");
int f = 0;
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUPS; ++i)
{
uint64_t nTicksExcl = pFrameGroup[i].nTicksExclusive;
if(nTicksExcl)
{
uint64_t nTicks = pFrameGroup[i].nTicks;
float fCount = (float)pFrameGroup[i].nCount;
float fToMs = S.GroupInfo[i].Type == MicroProfileTokenTypeCpu ? fTickToMsCpu : fTickToMsGpu;
MicroProfileWSPrintf("%c[%f,%f,%f]", f ? ',' : ' ', nTicks * fToMs, nTicksExcl * fToMs, fCount);
f = 1;
}
}
MicroProfileWSPrintf("]");
};
auto WriteIndexArray = [](MicroProfile::GroupTime* pFrameGroup)
{
MicroProfileWSPrintf("[");
int f = 0;
for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUPS; ++i)
{
uint64_t nTicksExcl = pFrameGroup[i].nTicksExclusive;
if(nTicksExcl)
{
uint32_t id = MicroProfileWebSocketIdPack(TYPE_GROUP, i);
MicroProfileWSPrintf("%c%d", f ? ',' : ' ', id);
f = 1;
}
}
MicroProfileWSPrintf("]");
};
MicroProfileWSPrintf(",\"g\":");
WriteTickArray(S.FrameGroup);
MicroProfileWSPrintf(",\"gi\":");
WriteIndexArray(S.FrameGroup);
if(S.nWSViewMode == VIEW_GRAPH_THREAD_GROUP)
{
MicroProfileWSPrintf(",\"gt\":[");
int f = 0;
for(uint32_t i = 0; i < MICROPROFILE_MAX_THREADS; ++i)
{
if(0 != (S.FrameGroupThreadValid[i / 32] & (1 << (i % 32))))
{
if(!f)
MicroProfileWSPrintf("{");
else
MicroProfileWSPrintf(",{");
MicroProfileThreadLog* pLog = S.Pool[i];
MicroProfileWSPrintf("\"i\":%d,\"n\":\"%s\",\"g\":", i, pLog->ThreadName);
WriteTickArray(&S.FrameGroupThread[i][0]);
MicroProfileWSPrintf(",\"gi\":");
WriteIndexArray(&S.FrameGroupThread[i][0]);
MicroProfileWSPrintf("}");
f = 1;
}
}
MicroProfileWSPrintf("]");
}
if(S.nFrameCurrent != S.WebSocketFrameLast[0])
{
MicroProfileWSPrintf(",\"x\":{\"t\":{");
int nTimer = S.WebSocketTimers;
// uprintf("T : ");
while(nTimer >= 0)
{
MicroProfileTimerInfo& TI = S.TimerInfo[nTimer];
float fTickToMs = TI.Type == MicroProfileTokenTypeGpu ? fTickToMsGpu : fTickToMsCpu;
uint32_t id = MicroProfileWebSocketIdPack(TYPE_TIMER, nTimer);
fTime = fTickToMs * S.Frame[nTimer].nTicks;
float fCount = (float)S.Frame[nTimer].nCount;
float fTimeExcl = fTickToMs * S.FrameExclusive[nTimer];
// uprintf("%4.2f, ", fTimeExcl);
if(!MicroProfileGroupActive(TI.nGroupIndex))
{
fTime = fCount = fTimeExcl = 0.f;
}
nTimer = TI.nWSNext;
MicroProfileWSPrintf("\"%d\":[%f,%f,%f]%c", id, fTime, fTimeExcl, fCount, nTimer == -1 ? ' ' : ',');
}
MicroProfileWSPrintf("}, \"c\":{");
int nCounter = S.WebSocketCounters;
while(nCounter >= 0)
{
MicroProfileCounterInfo& CI = S.CounterInfo[nCounter];
bool IsDouble = (CI.nFlags & MICROPROFILE_COUNTER_FLAG_DOUBLE) != 0;
uint32_t id = MicroProfileWebSocketIdPack(TYPE_COUNTER, nCounter);
int nCounterNext = CI.nWSNext;
if(IsDouble)
{
double value = S.CountersDouble[nCounter].load();
MicroProfileWSPrintf("\"%d\":%f%c", id, value, nCounterNext < 0 ? ' ' : ',');
}
else
{
uint64_t value = S.Counters[nCounter].load();
MicroProfileWSPrintf("\"%d\":%lld%c", id, value, nCounterNext < 0 ? ' ' : ',');
}
nCounter = nCounterNext;
}
MicroProfileWSPrintf("}, \"g\":{");
// uprintf("\n");
MicroProfileWSPrintf("}}");
}
MicroProfileWSPrintf("}}");
MicroProfileWSFlush();
MicroProfileWebSocketSendCounters();
MicroProfileWSPrintEnd();
S.WebSocketFrameLast[0] = S.nFrameCurrent;
}
else
{
MicroProfileWSPrintStart(Connection);
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":{\"fr\":%d,\"m\":%d", MSG_INACTIVE_FRAME, S.nFrozen, S.nWSViewMode);
#if MICROPROFILE_DYNAMIC_INSTRUMENT
MicroProfileWSPrintf(",\"s\":{\"n\":%d,\"f\":%d,\"r\":%d,\"l\":%d,\"q\":%d}",
S.SymbolNumModules,
S.SymbolState.nModuleLoadsFinished.load(),
S.SymbolState.nModuleLoadsRequested.load(),
S.SymbolState.nSymbolsLoaded.load(),
S.pPendingQuery ? 1 : 0);
#endif
MicroProfileWSPrintf("}}");
MicroProfileWSFlush();
MicroProfileWebSocketSendCounters();
MicroProfileWSPrintEnd();
}
#if MICROPROFILE_DYNAMIC_INSTRUMENT
MicroProfileSymbolQuerySendResult(Connection);
MicroProfileSymbolSendFunctionNames(Connection);
MicroProfileSymbolSendErrors(Connection);
#endif
}
void MicroProfileWebSocketFrame()
{
if(!S.nNumWebSockets)
{
return;
}
MICROPROFILE_SCOPEI("MicroProfile", "Websocket-update", MP_GREEN4);
fd_set Read, Write, Error;
FD_ZERO(&Read);
FD_ZERO(&Write);
FD_ZERO(&Error);
MpSocket LastSocket = 1;
for(uint32_t i = 0; i < S.nNumWebSockets; ++i)
{
LastSocket = MicroProfileMax(LastSocket, S.WebSockets[i] + 1);
FD_SET(S.WebSockets[i], &Read);
FD_SET(S.WebSockets[i], &Write);
FD_SET(S.WebSockets[i], &Error);
}
timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
if(-1 == select(LastSocket, &Read, &Write, &Error, &tv))
{
MP_ASSERT(0);
}
for(uint32_t i = 0; i < S.nNumWebSockets;)
{
MpSocket s = S.WebSockets[i];
bool bConnected = true;
if(FD_ISSET(s, &Error))
{
MP_ASSERT(0); // todo, remove & fix.
}
if(FD_ISSET(s, &Read))
{
bConnected = MicroProfileWebSocketReceive(s);
}
if(FD_ISSET(s, &Write))
{
if(S.nJsonSettingsPending)
{
MicroProfileWSPrintStart(s);
MicroProfileWSPrintf(
"{\"k\":\"%d\",\"ro\":%d,\"name\":\"%s\",\"v\":%s}", MSG_LOADSETTINGS, S.bJsonSettingsReadOnly ? 1 : 0, S.pJsonSettingsName ? S.pJsonSettingsName : "", S.pJsonSettings);
MicroProfileWSFlush();
MicroProfileWSPrintEnd();
S.nJsonSettingsPending = 0;
}
if(S.nWebSocketDirty)
{
MicroProfileFlipEnabled();
MicroProfileWebSocketSendEnabled(s);
S.nWebSocketDirty = 0;
}
MicroProfileWebSocketSendFrame(s);
}
if(S.nSocketFail)
{
bConnected = false;
}
S.nSocketFail = 0;
if(!bConnected)
{
uprintf("removing socket %" PRId64 "\n", (uint64_t)s);
#ifndef _WIN32
shutdown(S.WebSockets[i], SHUT_WR);
#else
shutdown(S.WebSockets[i], 1);
#endif
char tmp[128];
int r = 1;
while(r > 0)
{
r = recv(S.WebSockets[i], tmp, sizeof(tmp), 0);
}
#ifdef _WIN32
closesocket(S.WebSockets[i]);
#else
close(S.WebSockets[i]);
#endif
--S.nNumWebSockets;
S.WebSockets[i] = S.WebSockets[S.nNumWebSockets];
uprintf("done removing\n");
}
else
{
++i;
}
}
if(S.nWasFrozen)
{
S.nWasFrozen--;
}
}
void MicroProfileWSPrintStart(MpSocket C)
{
MP_ASSERT(S.WSBuf.Socket == 0);
MP_ASSERT(S.WSBuf.nPut == 0);
S.WSBuf.Socket = C;
}
void MicroProfileResizeWSBuf(uint32_t nMinSize = 0)
{
uint32_t nNewSize = MicroProfileMax(S.WSBuf.nPut + 2 * (nMinSize + 2 + 20), MicroProfileMax(S.WSBuf.nBufferSize * 3 / 2, (uint32_t)MICROPROFILE_WEBSOCKET_BUFFER_SIZE));
S.WSBuf.pBufferAllocation = (char*)MICROPROFILE_REALLOC(S.WSBuf.pBufferAllocation, nNewSize);
S.WSBuf.pBuffer = S.WSBuf.pBufferAllocation + 20;
S.WSBuf.nBufferSize = nNewSize - 20;
}
char* MicroProfileWSPrintfCallback(const char* buf, void* user, int len)
{
MP_ASSERT(S.WSBuf.nPut == buf - S.WSBuf.pBuffer);
S.WSBuf.nPut += len;
if(S.WSBuf.nPut + STB_SPRINTF_MIN + 2 >= S.WSBuf.nBufferSize) //
{
MicroProfileResizeWSBuf(S.WSBuf.nPut + STB_SPRINTF_MIN);
}
return S.WSBuf.pBuffer + S.WSBuf.nPut;
}
void MicroProfileWSPrintf(const char* pFmt, ...)
{
if(!S.WSBuf.nBufferSize)
{
MicroProfileResizeWSBuf(STB_SPRINTF_MIN * 2);
}
va_list args;
va_start(args, pFmt);
MP_ASSERT(S.WSBuf.nPut + STB_SPRINTF_MIN < S.WSBuf.nBufferSize);
stbsp_vsprintfcb(MicroProfileWSPrintfCallback, 0, S.WSBuf.pBuffer + S.WSBuf.nPut, pFmt, args);
va_end(args);
}
void MicroProfileWSPrintEnd()
{
MP_ASSERT(S.WSBuf.nPut == 0);
S.WSBuf.Socket = 0;
}
void MicroProfileWSFlush()
{
MP_ASSERT(S.WSBuf.Socket != 0);
MP_ASSERT(S.WSBuf.nPut != 0);
MicroProfileWebSocketSend(S.WSBuf.Socket, &S.WSBuf.pBuffer[0], S.WSBuf.nPut);
S.WSBuf.nPut = 0;
}
void MicroProfileWebSocketSendEnabledMessage(uint32_t id, int bEnabled)
{
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":{\"id\":%d,\"e\":%d}}", MSG_ENABLED, id, bEnabled ? 1 : 0);
MicroProfileWSFlush();
}
void MicroProfileWebSocketSendEnabled(MpSocket C)
{
MICROPROFILE_SCOPEI("MicroProfile", "Websocket-SendEnabled", MP_GREEN4);
MicroProfileWSPrintStart(C);
for(uint32_t i = 0; i < S.nCategoryCount; ++i)
{
MicroProfileWebSocketSendEnabledMessage(MicroProfileWebSocketIdPack(TYPE_CATEGORY, i), MicroProfileCategoryEnabled(i));
}
for(uint32_t i = 0; i < S.nGroupCount; ++i)
{
MicroProfileWebSocketSendEnabledMessage(MicroProfileWebSocketIdPack(TYPE_GROUP, i), MicroProfileGroupEnabled(i));
}
for(uint32_t i = 0; i < S.nTotalTimers; ++i)
{
MicroProfileWebSocketSendEnabledMessage(MicroProfileWebSocketIdPack(TYPE_TIMER, i), MicroProfileWebSocketTimerEnabled(i));
}
for(uint32_t i = 0; i < S.nNumCounters; ++i)
{
MicroProfileWebSocketSendEnabledMessage(MicroProfileWebSocketIdPack(TYPE_COUNTER, i), MicroProfileWebSocketCounterEnabled(i));
}
MicroProfileWebSocketSendEnabledMessage(MicroProfileWebSocketIdPack(TYPE_SETTING, SETTING_FORCE_ENABLE), MicroProfileGetEnableAllGroups());
MicroProfileWebSocketSendEnabledMessage(MicroProfileWebSocketIdPack(TYPE_SETTING, SETTING_CONTEXT_SWITCH_TRACE), S.bContextSwitchRunning);
MicroProfileWebSocketSendEnabledMessage(MicroProfileWebSocketIdPack(TYPE_SETTING, SETTING_PLATFORM_MARKERS), MicroProfilePlatformMarkersGetEnabled());
MicroProfileWSPrintEnd();
}
void MicroProfileWebSocketSendEntry(uint32_t id, uint32_t parent, const char* pName, int nEnabled, uint32_t nColor, uint32_t nType)
{
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":{\"id\":%d,\"pid\":%d,", MSG_TIMER_TREE, id, parent);
MicroProfileWSPrintf("\"name\":\"%s\",", pName);
MicroProfileWSPrintf("\"e\":%d,", nEnabled);
MicroProfileWSPrintf("\"type\":%d,", nType);
if(nColor == 0x42)
{
MicroProfileWSPrintf("\"color\":\"\"");
}
else
{
MicroProfileWSPrintf("\"color\":\"#%02x%02x%02x\"", MICROPROFILE_UNPACK_RED(nColor) & 0xff, MICROPROFILE_UNPACK_GREEN(nColor) & 0xff, MICROPROFILE_UNPACK_BLUE(nColor) & 0xff);
}
MicroProfileWSPrintf("}}");
MicroProfileWSFlush();
}
void MicroProfileWebSocketSendCounterEntry(uint32_t id, uint32_t parent, const char* pName, int nEnabled, int64_t nLimit, int nFormat)
{
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":{\"id\":%d,\"pid\":%d,", MSG_TIMER_TREE, id, parent);
MicroProfileWSPrintf("\"name\":\"%s\",", pName);
MicroProfileWSPrintf("\"e\":%d,", nEnabled);
MicroProfileWSPrintf("\"limit\":%lld,", nLimit);
MicroProfileWSPrintf("\"format\":%d", nFormat);
MicroProfileWSPrintf("}}");
MicroProfileWSFlush();
}
void MicroProfileWebSocketSendState(MpSocket C)
{
if(S.WSCategoriesSent != S.nCategoryCount || S.WSGroupsSent != S.nGroupCount || S.WSTimersSent != S.nTotalTimers || S.WSCountersSent != S.nNumCounters)
{
MicroProfileWSPrintStart(C);
uint32_t root = MicroProfileWebSocketIdPack(TYPE_SETTING, SETTING_FORCE_ENABLE);
MicroProfileWebSocketSendEntry(root, 0, "All", MicroProfileGetEnableAllGroups(), (uint32_t)-1, 0);
for(uint32_t i = S.WSCategoriesSent; i < S.nCategoryCount; ++i)
{
MicroProfileCategory& CI = S.CategoryInfo[i];
uint32_t id = MicroProfileWebSocketIdPack(TYPE_CATEGORY, i);
uint32_t parent = root;
MicroProfileWebSocketSendEntry(id, parent, CI.pName, MicroProfileCategoryEnabled(i), 0xffffffff, 0);
}
for(uint32_t i = S.WSGroupsSent; i < S.nGroupCount; ++i)
{
MicroProfileGroupInfo& GI = S.GroupInfo[i];
uint32_t id = MicroProfileWebSocketIdPack(TYPE_GROUP, i);
uint32_t parent = MicroProfileWebSocketIdPack(TYPE_CATEGORY, GI.nCategory);
MicroProfileWebSocketSendEntry(id, parent, GI.pName, MicroProfileGroupEnabled(i), GI.nColor, GI.Type);
}
for(uint32_t i = S.WSTimersSent; i < S.nTotalTimers; ++i)
{
MicroProfileTimerInfo& TI = S.TimerInfo[i];
uint32_t id = MicroProfileWebSocketIdPack(TYPE_TIMER, i);
uint32_t parent = MicroProfileWebSocketIdPack(TYPE_GROUP, TI.nGroupIndex);
MicroProfileWebSocketSendEntry(id, parent, TI.pName, MicroProfileWebSocketTimerEnabled(i), TI.nColor, TI.Type);
}
for(uint32_t i = S.WSCountersSent; i < S.nNumCounters; ++i)
{
MicroProfileCounterInfo& CI = S.CounterInfo[i];
uint32_t id = MicroProfileWebSocketIdPack(TYPE_COUNTER, i);
uint32_t parent = CI.nParent == -1 ? 0u : MicroProfileWebSocketIdPack(TYPE_COUNTER, CI.nParent);
MicroProfileWebSocketSendCounterEntry(id, parent, CI.pName, MicroProfileWebSocketCounterEnabled(i), CI.nLimit, CI.eFormat);
}
#if MICROPROFILE_CONTEXT_SWITCH_TRACE
MicroProfileWebSocketSendEntry(MicroProfileWebSocketIdPack(TYPE_SETTING, SETTING_CONTEXT_SWITCH_TRACE), 0, "Context Switch Trace", S.bContextSwitchRunning, (uint32_t)-1, 0);
#endif
#if MICROPROFILE_PLATFORM_MARKERS
MicroProfileWebSocketSendEntry(MicroProfileWebSocketIdPack(TYPE_SETTING, SETTING_PLATFORM_MARKERS), 0, "Platform Markers", S.bContextSwitchRunning, (uint32_t)-1);
#endif
MicroProfileWSPrintEnd();
S.WSCategoriesSent = S.nCategoryCount;
S.WSGroupsSent = S.nGroupCount;
S.WSTimersSent = S.nTotalTimers;
S.WSCountersSent = S.nNumCounters;
}
}
bool MicroProfileWebServerUpdate()
{
MICROPROFILE_SCOPEI("MicroProfile", "Webserver-update", MP_GREEN4);
MpSocket Connection = accept(S.ListenerSocket, 0, 0);
bool bServed = false;
MicroProfileWebSocketFrame();
if(!MP_INVALID_SOCKET(Connection))
{
std::lock_guard<std::recursive_mutex> Lock(MicroProfileMutex());
char Req[8192];
int nReceived = recv(Connection, Req, sizeof(Req) - 1, 0);
if(nReceived > 0)
{
Req[nReceived] = '\0';
uprintf("req received\n%s", Req);
#define MICROPROFILE_HTML_PNG_HEADER "HTTP/1.0 200 OK\r\nContent-Type: image/png\r\n\r\n"
#define MICROPROFILE_HTML_JS_HEADER "HTTP/1.0 200 OK\r\nContent-Type: text/javascript\r\n\r\n"
#if MICROPROFILE_MINIZ
// Expires: Tue, 01 Jan 2199 16:00:00 GMT\r\n
#define MICROPROFILE_HTML_HEADER "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\nContent-Encoding: deflate\r\n\r\n"
#else
#define MICROPROFILE_HTML_HEADER "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"
#endif
char* pHttp = strstr(Req, "HTTP/");
char* pGet = strstr(Req, "GET /");
char* pHost = strstr(Req, "Host: ");
char* pWebSocketKey = strstr(Req, "Sec-WebSocket-Key: ");
auto Terminate = [](char* pString)
{
char* pEnd = pString;
while(*pEnd != '\0')
{
if(*pEnd == '\r' || *pEnd == '\n' || *pEnd == ' ')
{
*pEnd = '\0';
return;
}
pEnd++;
}
};
if(pWebSocketKey)
{
if(S.nNumWebSockets) // only allow 1
{
return false;
}
pWebSocketKey += sizeof("Sec-WebSocket-Key: ") - 1;
Terminate(pWebSocketKey);
MicroProfileWebSocketHandshake(Connection, pWebSocketKey);
return false;
}
if(pHost)
{
pHost += sizeof("Host: ") - 1;
Terminate(pHost);
}
if(pHttp && pGet)
{
*pHttp = '\0';
pGet += sizeof("GET /") - 1;
Terminate(pGet);
MicroProfileParseGetResult R;
auto P = MicroProfileParseGet(pGet, &R);
switch(P)
{
case EMICROPROFILE_GET_COMMAND_SERVICE_WORKER:
{
MicroProfileSetNonBlocking(Connection, 1);
uint64_t nTickStart = MP_TICK();
send(Connection, MICROPROFILE_HTML_JS_HEADER, sizeof(MICROPROFILE_HTML_JS_HEADER) - 1, 0);
const char* JsCode = "self.addEventListener(\"fetch\", () => {}); \r\n\r\n";
send(Connection, JsCode, (int)strlen(JsCode), 0);
break;
}
case EMICROPROFILE_GET_COMMAND_FAVICON:
{
MicroProfileSetNonBlocking(Connection, 1);
uint64_t nTickStart = MP_TICK();
send(Connection, MICROPROFILE_HTML_PNG_HEADER, sizeof(MICROPROFILE_HTML_PNG_HEADER) - 1, 0);
extern const uint32_t uprof_512[];
extern const uint32_t uprof_512_len;
const char* pFile = (const char*)&uprof_512[0];
uint32_t nFileSize = uprof_512_len;
send(Connection, pFile, nFileSize, 0);
}
break;
case EMICROPROFILE_GET_COMMAND_LIVE:
{
MicroProfileSetNonBlocking(Connection, 0);
uint64_t nTickStart = MP_TICK();
send(Connection, MICROPROFILE_HTML_HEADER, sizeof(MICROPROFILE_HTML_HEADER) - 1, 0);
uint64_t nDataStart = S.nWebServerDataSent;
S.WebServerPut = 0;
#if 0 == MICROPROFILE_MINIZ
MicroProfileDumpHtmlLive(MicroProfileWriteSocket, &Connection);
uint64_t nDataEnd = S.nWebServerDataSent;
uint64_t nTickEnd = MP_TICK();
uint64_t nDiff = (nTickEnd - nTickStart);
float fMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu()) * nDiff;
int nKb = ((nDataEnd-nDataStart)>>10) + 1;
int nCompressedKb = nKb;
MicroProfilePrintf(MicroProfileWriteSocket, &Connection, "\n<!-- Sent %dkb in %.2fms-->\n\n",nKb, fMs);
MicroProfileFlushSocket(Connection);
#else
MicroProfileCompressedSocketState CompressState;
MicroProfileCompressedSocketStart(&CompressState, Connection);
MicroProfileDumpHtmlLive(MicroProfileCompressedWriteSocket, &CompressState);
S.nWebServerDataSent += CompressState.nSize;
uint64_t nDataEnd = S.nWebServerDataSent;
uint64_t nTickEnd = MP_TICK();
uint64_t nDiff = (nTickEnd - nTickStart);
float fMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu()) * nDiff;
int nKb = ((nDataEnd - nDataStart) >> 10) + 1;
int nCompressedKb = ((CompressState.nCompressedSize) >> 10) + 1;
MicroProfilePrintf(MicroProfileCompressedWriteSocket, &CompressState, "\n<!-- Sent %dkb(compressed %dkb) in %.2fms-->\n\n", nKb, nCompressedKb, fMs);
MicroProfileCompressedSocketFinish(&CompressState);
MicroProfileFlushSocket(Connection);
#endif
uprintf("\n<!-- Sent %dkb(compressed %dkb) in %.2fms-->\n\n", nKb, nCompressedKb, fMs);
(void)nCompressedKb;
}
break;
case EMICROPROFILE_GET_COMMAND_DUMP_RANGE:
case EMICROPROFILE_GET_COMMAND_DUMP:
{
{
MicroProfileSetNonBlocking(Connection, 0);
uint64_t nTickStart = MP_TICK();
send(Connection, MICROPROFILE_HTML_HEADER, sizeof(MICROPROFILE_HTML_HEADER) - 1, 0);
uint64_t nDataStart = S.nWebServerDataSent;
S.WebServerPut = 0;
#if 0 == MICROPROFILE_MINIZ
MicroProfileDumpHtml(MicroProfileWriteSocket, &Connection, R.nFrames, pHost, R.nFrameStart);
uint64_t nDataEnd = S.nWebServerDataSent;
uint64_t nTickEnd = MP_TICK();
uint64_t nDiff = (nTickEnd - nTickStart);
float fMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu()) * nDiff;
int nKb = ((nDataEnd-nDataStart)>>10) + 1;
int nCompressedKb = nKb;
MicroProfilePrintf(MicroProfileWriteSocket, &Connection, "\n<!-- Sent %dkb in %.2fms-->\n\n",nKb, fMs);
MicroProfileFlushSocket(Connection);
#else
MicroProfileCompressedSocketState CompressState;
MicroProfileCompressedSocketStart(&CompressState, Connection);
MicroProfileDumpHtml(MicroProfileCompressedWriteSocket, &CompressState, R.nFrames, pHost, R.nFrameStart);
S.nWebServerDataSent += CompressState.nSize;
uint64_t nDataEnd = S.nWebServerDataSent;
uint64_t nTickEnd = MP_TICK();
uint64_t nDiff = (nTickEnd - nTickStart);
float fMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu()) * nDiff;
int nKb = ((nDataEnd - nDataStart) >> 10) + 1;
int nCompressedKb = ((CompressState.nCompressedSize) >> 10) + 1;
MicroProfilePrintf(MicroProfileCompressedWriteSocket, &CompressState, "\n<!-- Sent %dkb(compressed %dkb) in %.2fms-->\n\n", nKb, nCompressedKb, fMs);
MicroProfileCompressedSocketFinish(&CompressState);
MicroProfileFlushSocket(Connection);
#endif
uprintf("\n<!-- Sent %dkb(compressed %dkb) in %.2fms-->\n\n", nKb, nCompressedKb, fMs);
(void)nCompressedKb;
}
}
break;
case EMICROPROFILE_GET_COMMAND_UNKNOWN:
{
uprintf("unknown get command %s\n", pGet);
}
break;
}
}
}
#ifdef _WIN32
closesocket(Connection);
#else
close(Connection);
#endif
}
return bServed;
}
#endif
#if MICROPROFILE_CONTEXT_SWITCH_TRACE
// functions that need to be implemented per platform.
void* MicroProfileTraceThread(void* unused);
int MicroProfileIsLocalThread(uint32_t nThreadId);
void MicroProfileStartContextSwitchTrace()
{
if(!S.bContextSwitchRunning && !S.nMicroProfileShutdown)
{
S.bContextSwitchRunning = true;
S.bContextSwitchStop = false;
MicroProfileThreadStart(&S.ContextSwitchThread, MicroProfileTraceThread);
}
}
void MicroProfileJoinContextSwitchTrace()
{
if(S.bContextSwitchStop)
{
MicroProfileThreadJoin(&S.ContextSwitchThread);
}
}
void MicroProfileStopContextSwitchTrace()
{
if(S.bContextSwitchRunning)
{
S.bContextSwitchStop = true;
}
}
#ifdef _WIN32
#define INITGUID
#include <evntcons.h>
#include <evntrace.h>
#include <strsafe.h>
static GUID g_MicroProfileThreadClassGuid = { 0x3d6fa8d1, 0xfe05, 0x11d0, 0x9d, 0xda, 0x00, 0xc0, 0x4f, 0xd7, 0xba, 0x7c };
struct MicroProfileSCSwitch
{
uint32_t NewThreadId;
uint32_t OldThreadId;
int8_t NewThreadPriority;
int8_t OldThreadPriority;
uint8_t PreviousCState;
int8_t SpareByte;
int8_t OldThreadWaitReason;
int8_t OldThreadWaitMode;
int8_t OldThreadState;
int8_t OldThreadWaitIdealProcessor;
uint32_t NewThreadWaitTime;
uint32_t Reserved;
};
VOID WINAPI MicroProfileContextSwitchCallback(PEVENT_TRACE pEvent)
{
if(pEvent->Header.Guid == g_MicroProfileThreadClassGuid)
{
if(pEvent->Header.Class.Type == 36)
{
MicroProfileSCSwitch* pCSwitch = (MicroProfileSCSwitch*)pEvent->MofData;
if((pCSwitch->NewThreadId != 0) || (pCSwitch->OldThreadId != 0))
{
MicroProfileContextSwitch Switch;
Switch.nThreadOut = pCSwitch->OldThreadId;
Switch.nThreadIn = pCSwitch->NewThreadId;
Switch.nCpu = pEvent->BufferContext.ProcessorNumber;
Switch.nTicks = pEvent->Header.TimeStamp.QuadPart;
MicroProfileContextSwitchPut(&Switch);
}
}
}
}
ULONG WINAPI MicroProfileBufferCallback(PEVENT_TRACE_LOGFILEA Buffer)
{
return (S.bContextSwitchStop || !S.bContextSwitchRunning) ? FALSE : TRUE;
}
struct MicroProfileKernelTraceProperties : public EVENT_TRACE_PROPERTIES
{
char dummy[sizeof(KERNEL_LOGGER_NAME)];
};
void MicroProfileContextSwitchShutdownTrace()
{
TRACEHANDLE SessionHandle = 0;
MicroProfileKernelTraceProperties sessionProperties;
ZeroMemory(&sessionProperties, sizeof(sessionProperties));
sessionProperties.Wnode.BufferSize = sizeof(sessionProperties);
sessionProperties.Wnode.Flags = WNODE_FLAG_TRACED_GUID;
sessionProperties.Wnode.ClientContext = 1; // QPC clock resolution
sessionProperties.Wnode.Guid = SystemTraceControlGuid;
sessionProperties.BufferSize = 1;
sessionProperties.NumberOfBuffers = 128;
sessionProperties.EnableFlags = EVENT_TRACE_FLAG_CSWITCH;
sessionProperties.LogFileMode = EVENT_TRACE_REAL_TIME_MODE;
sessionProperties.MaximumFileSize = 0;
sessionProperties.LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES);
sessionProperties.LogFileNameOffset = 0;
EVENT_TRACE_LOGFILEA log;
ZeroMemory(&log, sizeof(log));
log.LoggerName = (LPSTR)KERNEL_LOGGER_NAMEA;
log.ProcessTraceMode = 0;
TRACEHANDLE hLog = OpenTraceA(&log);
if(hLog)
{
ControlTrace(SessionHandle, KERNEL_LOGGER_NAME, &sessionProperties, EVENT_TRACE_CONTROL_STOP);
}
CloseTrace(hLog);
}
typedef VOID(WINAPI* EventCallback)(PEVENT_TRACE);
typedef ULONG(WINAPI* BufferCallback)(PEVENT_TRACE_LOGFILEA);
bool MicroProfileStartWin32Trace(EventCallback EvtCb, BufferCallback BufferCB)
{
MicroProfileContextSwitchShutdownTrace();
ULONG status = ERROR_SUCCESS;
TRACEHANDLE SessionHandle = 0;
MicroProfileKernelTraceProperties sessionProperties;
ZeroMemory(&sessionProperties, sizeof(sessionProperties));
sessionProperties.Wnode.BufferSize = sizeof(sessionProperties);
sessionProperties.Wnode.Flags = WNODE_FLAG_TRACED_GUID;
sessionProperties.Wnode.ClientContext = 1; // QPC clock resolution
sessionProperties.Wnode.Guid = SystemTraceControlGuid;
sessionProperties.BufferSize = 1;
sessionProperties.NumberOfBuffers = 128;
sessionProperties.EnableFlags = EVENT_TRACE_FLAG_CSWITCH | EVENT_TRACE_FLAG_PROCESS;
sessionProperties.LogFileMode = EVENT_TRACE_REAL_TIME_MODE;
sessionProperties.MaximumFileSize = 0;
sessionProperties.LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES);
sessionProperties.LogFileNameOffset = 0;
StopTrace(NULL, KERNEL_LOGGER_NAME, &sessionProperties);
status = StartTrace((PTRACEHANDLE)&SessionHandle, KERNEL_LOGGER_NAME, &sessionProperties);
if(ERROR_SUCCESS != status)
{
return false;
}
EVENT_TRACE_LOGFILEA log;
ZeroMemory(&log, sizeof(log));
log.LoggerName = (LPSTR)KERNEL_LOGGER_NAME;
log.ProcessTraceMode = PROCESS_TRACE_MODE_REAL_TIME | PROCESS_TRACE_MODE_RAW_TIMESTAMP;
log.EventCallback = EvtCb;
log.BufferCallback = BufferCB;
TRACEHANDLE hLog = OpenTraceA(&log);
ProcessTrace(&hLog, 1, 0, 0);
CloseTrace(hLog);
MicroProfileContextSwitchShutdownTrace();
return true;
}
#include <psapi.h>
#include <tlhelp32.h>
#include <winternl.h>
#define ThreadQuerySetWin32StartAddress 9
typedef LONG NTSTATUS;
typedef NTSTATUS(WINAPI* pNtQIT)(HANDLE, LONG, PVOID, ULONG, PULONG);
#define STATUS_SUCCESS ((NTSTATUS)0x000 00000L)
#define ThreadQuerySetWin32StartAddress 9
#undef Process32First
#undef Process32Next
#undef PROCESSENTRY32
#undef Module32First
#undef Module32Next
#undef MODULEENTRY32
struct MicroProfileWin32ContextSwitchShared
{
std::atomic<int64_t> nPut;
std::atomic<int64_t> nGet;
std::atomic<int64_t> nQuit;
std::atomic<int64_t> nTickTrace;
std::atomic<int64_t> nTickProgram;
enum
{
BUFFER_SIZE = (2 << 20) / sizeof(MicroProfileContextSwitch),
};
MicroProfileContextSwitch Buffer[BUFFER_SIZE];
};
struct MicroProfileWin32ThreadInfo
{
struct Process
{
uint32_t pid;
uint32_t nNumModules;
uint32_t nModuleStart;
const char* pProcessModule;
};
struct Module
{
int64_t nBase;
int64_t nEnd;
const char* pName;
};
enum
{
MAX_PROCESSES = 5 * 1024,
MAX_THREADS = 20 * 1024,
MAX_MODULES = 20 * 1024,
MAX_STRINGS = 16 * 1024,
MAX_CHARS = 128 * 1024,
};
uint32_t nNumProcesses;
uint32_t nNumThreads;
uint32_t nStringOffset;
uint32_t nNumStrings;
uint32_t nNumModules;
Process P[MAX_PROCESSES];
Module M[MAX_MODULES];
MicroProfileThreadInfo T[MAX_THREADS];
const char* pStrings[MAX_STRINGS];
char StringData[MAX_CHARS];
};
static MicroProfileWin32ThreadInfo g_ThreadInfo;
const char* MicroProfileWin32ThreadInfoAddString(const char* pString)
{
size_t nLen = strlen(pString);
uint32_t nHash = *(uint32_t*)pString;
nHash ^= (nHash >> 16);
enum
{
MAX_SEARCH = 256,
};
for(uint32_t i = 0; i < MAX_SEARCH; ++i)
{
uint32_t idx = (i + nHash) % MicroProfileWin32ThreadInfo::MAX_STRINGS;
if(0 == g_ThreadInfo.pStrings[idx])
{
g_ThreadInfo.pStrings[idx] = &g_ThreadInfo.StringData[g_ThreadInfo.nStringOffset];
memcpy(&g_ThreadInfo.StringData[g_ThreadInfo.nStringOffset], pString, nLen + 1);
g_ThreadInfo.nStringOffset += (uint32_t)(nLen + 1);
return g_ThreadInfo.pStrings[idx];
}
if(0 == strcmp(g_ThreadInfo.pStrings[idx], pString))
{
return g_ThreadInfo.pStrings[idx];
}
}
return "internal hash table fail: should never happen";
}
void MicroProfileWin32ExtractModules(MicroProfileWin32ThreadInfo::Process& P)
{
HANDLE hModuleSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, P.pid);
MODULEENTRY32 me;
if(Module32First(hModuleSnapshot, &me))
{
do
{
if(g_ThreadInfo.nNumModules < MicroProfileWin32ThreadInfo::MAX_MODULES)
{
auto& M = g_ThreadInfo.M[g_ThreadInfo.nNumModules++];
P.nNumModules++;
intptr_t nBase = (intptr_t)me.modBaseAddr;
intptr_t nEnd = nBase + me.modBaseSize;
M.nBase = nBase;
M.nEnd = nEnd;
M.pName = MicroProfileWin32ThreadInfoAddString(&me.szModule[0]);
}
} while(Module32Next(hModuleSnapshot, &me));
}
if(hModuleSnapshot)
CloseHandle(hModuleSnapshot);
}
void MicroProfileWin32InitThreadInfo2()
{
memset(&g_ThreadInfo, 0, sizeof(g_ThreadInfo));
#if MICROPROFILE_DEBUG
float fToMsCpu = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
#endif
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
PROCESSENTRY32 pe32;
THREADENTRY32 te32;
te32.dwSize = sizeof(THREADENTRY32);
pe32.dwSize = sizeof(PROCESSENTRY32);
{
#if MICROPROFILE_DEBUG
int64_t nTickStart = MP_TICK();
#endif
if(Process32First(hSnap, &pe32))
{
do
{
MicroProfileWin32ThreadInfo::Process P;
P.pid = pe32.th32ProcessID;
P.pProcessModule = MicroProfileWin32ThreadInfoAddString(pe32.szExeFile);
g_ThreadInfo.P[g_ThreadInfo.nNumProcesses++] = P;
} while(Process32Next(hSnap, &pe32) && g_ThreadInfo.nNumProcesses < MicroProfileWin32ThreadInfo::MAX_PROCESSES);
}
#if MICROPROFILE_DEBUG
int64_t nTicksEnd = MP_TICK();
float fMs = fToMsCpu * (nTicksEnd - nTickStart);
uprintf("Process iteration %6.2fms processes %d\n", fMs, g_ThreadInfo.nNumProcesses);
#endif
}
{
#if MICROPROFILE_DEBUG
int64_t nTickStart = MP_TICK();
#endif
for(uint32_t i = 0; i < g_ThreadInfo.nNumProcesses; ++i)
{
g_ThreadInfo.P[i].nModuleStart = g_ThreadInfo.nNumModules;
g_ThreadInfo.P[i].nNumModules = 0;
MicroProfileWin32ExtractModules(g_ThreadInfo.P[i]);
}
#if MICROPROFILE_DEBUG
int64_t nTicksEnd = MP_TICK();
float fMs = fToMsCpu * (nTicksEnd - nTickStart);
uprintf("Module iteration %6.2fms NumModules %d\n", fMs, g_ThreadInfo.nNumModules);
#endif
}
pNtQIT NtQueryInformationThread = (pNtQIT)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtQueryInformationThread");
intptr_t dwStartAddress;
ULONG olen;
uint32_t nThreadsTested = 0;
uint32_t nThreadsSucceeded = 0;
if(Thread32First(hSnap, &te32))
{
#if MICROPROFILE_DEBUG
int64_t nTickStart = MP_TICK();
#endif
do
{
nThreadsTested++;
const char* pModule = "?";
HANDLE hThread = OpenThread(THREAD_QUERY_INFORMATION, FALSE, te32.th32ThreadID);
if(hThread)
{
NTSTATUS ntStatus = NtQueryInformationThread(hThread, (THREADINFOCLASS)ThreadQuerySetWin32StartAddress, &dwStartAddress, sizeof(dwStartAddress), &olen);
if(0 == ntStatus)
{
uint32_t nProcessIndex = (uint32_t)-1;
for(uint32_t i = 0; i < g_ThreadInfo.nNumProcesses; ++i)
{
if(g_ThreadInfo.P[i].pid == te32.th32OwnerProcessID)
{
nProcessIndex = i;
break;
}
}
if(nProcessIndex != (uint32_t)-1)
{
uint32_t nModuleStart = g_ThreadInfo.P[nProcessIndex].nModuleStart;
uint32_t nNumModules = g_ThreadInfo.P[nProcessIndex].nNumModules;
for(uint32_t i = 0; i < nNumModules; ++i)
{
auto& M = g_ThreadInfo.M[nModuleStart + i];
if(M.nBase <= dwStartAddress && M.nEnd >= dwStartAddress)
{
pModule = M.pName;
}
}
}
}
}
if(hThread)
CloseHandle(hThread);
{
MicroProfileThreadInfo T;
T.pid = te32.th32OwnerProcessID;
T.tid = te32.th32ThreadID;
const char* pProcess = "unknown";
for(uint32_t i = 0; i < g_ThreadInfo.nNumProcesses; ++i)
{
if(g_ThreadInfo.P[i].pid == T.pid)
{
pProcess = g_ThreadInfo.P[i].pProcessModule;
break;
}
}
T.pProcessModule = pProcess;
T.pThreadModule = MicroProfileWin32ThreadInfoAddString(pModule);
T.nIsLocal = GetCurrentProcessId() == T.pid ? 1 : 0;
nThreadsSucceeded++;
g_ThreadInfo.T[g_ThreadInfo.nNumThreads++] = T;
}
} while(Thread32Next(hSnap, &te32) && g_ThreadInfo.nNumThreads < MicroProfileWin32ThreadInfo::MAX_THREADS);
#if MICROPROFILE_DEBUG
int64_t nTickEnd = MP_TICK();
float fMs = fToMsCpu * (nTickEnd - nTickStart);
uprintf("Thread iteration %6.2fms Threads %d\n", fMs, g_ThreadInfo.nNumThreads);
#endif
}
}
void MicroProfileWin32UpdateThreadInfo()
{
static int nWasRunning = 1;
static int nOnce = 0;
int nRunning = MicroProfileAnyGroupActive() ? 1 : 0;
if((0 == nRunning && 1 == nWasRunning) || nOnce == 0)
{
nOnce = 1;
MicroProfileWin32InitThreadInfo2();
}
nWasRunning = nRunning;
}
const char* MicroProfileThreadNameFromId(MicroProfileThreadIdType nThreadId)
{
MicroProfileWin32UpdateThreadInfo();
static char result[1024];
for(uint32_t i = 0; i < g_ThreadInfo.nNumThreads; ++i)
{
if(g_ThreadInfo.T[i].tid == nThreadId)
{
sprintf_s(result, "p:%s t:%s", g_ThreadInfo.T[i].pProcessModule, g_ThreadInfo.T[i].pThreadModule);
return result;
}
}
sprintf_s(result, "?");
return result;
}
#define MICROPROFILE_FILEMAPPING "microprofile-shared"
#ifdef MICROPROFILE_WIN32_COLLECTOR
#define MICROPROFILE_WIN32_CSWITCH_TIMEOUT 15 // seconds to wait before collector exits
static MicroProfileWin32ContextSwitchShared* g_pShared = 0;
VOID WINAPI MicroProfileContextSwitchCallbackCollector(PEVENT_TRACE pEvent)
{
static int64_t nPackets = 0;
static int64_t nSkips = 0;
if(pEvent->Header.Guid == g_MicroProfileThreadClassGuid)
{
if(pEvent->Header.Class.Type == 36)
{
MicroProfileSCSwitch* pCSwitch = (MicroProfileSCSwitch*)pEvent->MofData;
if((pCSwitch->NewThreadId != 0) || (pCSwitch->OldThreadId != 0))
{
MicroProfileContextSwitch Switch;
Switch.nThreadOut = pCSwitch->OldThreadId;
Switch.nThreadIn = pCSwitch->NewThreadId;
Switch.nCpu = pEvent->BufferContext.ProcessorNumber;
Switch.nTicks = pEvent->Header.TimeStamp.QuadPart;
int64_t nPut = g_pShared->nPut.load(std::memory_order_relaxed);
int64_t nGet = g_pShared->nGet.load(std::memory_order_relaxed);
nPackets++;
if(nPut - nGet < MicroProfileWin32ContextSwitchShared::BUFFER_SIZE)
{
g_pShared->Buffer[nPut % MicroProfileWin32ContextSwitchShared::BUFFER_SIZE] = Switch;
g_pShared->nPut.store(nPut + 1, std::memory_order_release);
nSkips = 0;
}
else
{
nSkips++;
}
}
}
}
if(0 == (nPackets % (4 << 10)))
{
int64_t nTickTrace = MP_TICK();
g_pShared->nTickTrace.store(nTickTrace);
int64_t nTickProgram = g_pShared->nTickProgram.load();
float fTickToMs = MicroProfileTickToMsMultiplier(MicroProfileTicksPerSecondCpu());
float fTime = fabs(fTickToMs * (nTickTrace - nTickProgram));
printf("\rRead %" PRId64 " CSwitch Packets, Skips %" PRId64 " Time difference %6.3fms ", nPackets, nSkips, fTime);
fflush(stdout);
if(fTime > MICROPROFILE_WIN32_CSWITCH_TIMEOUT * 1000)
{
g_pShared->nQuit.store(1);
}
}
}
ULONG WINAPI MicroProfileBufferCallbackCollector(PEVENT_TRACE_LOGFILEA Buffer)
{
return (g_pShared->nQuit.load()) ? FALSE : TRUE;
}
int main(int argc, char* argv[])
{
if(argc != 2)
{
return 1;
}
printf("using file '%s'\n", argv[1]);
HANDLE hMemory = OpenFileMappingA(FILE_MAP_ALL_ACCESS, FALSE, argv[1]);
if(hMemory == NULL)
{
return 1;
}
g_pShared = (MicroProfileWin32ContextSwitchShared*)MapViewOfFile(hMemory, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(MicroProfileWin32ContextSwitchShared));
if(g_pShared != NULL)
{
MicroProfileStartWin32Trace(MicroProfileContextSwitchCallbackCollector, MicroProfileBufferCallbackCollector);
UnmapViewOfFile(g_pShared);
}
CloseHandle(hMemory);
return 0;
}
#endif
#include <shellapi.h>
void* MicroProfileTraceThread(void* unused)
{
MicroProfileOnThreadCreate("ContextSwitchThread");
MicroProfileContextSwitchShutdownTrace();
if(!MicroProfileStartWin32Trace(MicroProfileContextSwitchCallback, MicroProfileBufferCallback))
{
MicroProfileContextSwitchShutdownTrace();
// not running as admin. try and start other process.
MicroProfileWin32ContextSwitchShared* pShared = 0;
char Filename[512];
time_t t = time(NULL);
snprintf(Filename, sizeof(Filename), "%s_%d", MICROPROFILE_FILEMAPPING, (int)t);
HANDLE hMemory = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, sizeof(MicroProfileWin32ContextSwitchShared), Filename);
if(hMemory != NULL)
{
pShared = (MicroProfileWin32ContextSwitchShared*)MapViewOfFile(hMemory, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(MicroProfileWin32ContextSwitchShared));
if(pShared != NULL)
{
#ifdef _M_IX86
#define CSWITCH_EXE "microprofile-win32-cswitch_x86.exe"
#else
#define CSWITCH_EXE "microprofile-win32-cswitch_x64.exe"
#endif
pShared->nTickProgram.store(MP_TICK());
pShared->nTickTrace.store(MP_TICK());
HINSTANCE Instance = ShellExecuteA(NULL, "runas", CSWITCH_EXE, Filename, "", SW_SHOWMINNOACTIVE);
int64_t nInstance = (int64_t)Instance;
if(nInstance >= 32)
{
int64_t nPut, nGet;
while(!S.bContextSwitchStop)
{
nPut = pShared->nPut.load(std::memory_order_acquire);
nGet = pShared->nGet.load(std::memory_order_relaxed);
if(nPut == nGet)
{
Sleep(20);
}
else
{
for(int64_t i = nGet; i != nPut; i++)
{
MicroProfileContextSwitchPut(&pShared->Buffer[i % MicroProfileWin32ContextSwitchShared::BUFFER_SIZE]);
}
pShared->nGet.store(nPut, std::memory_order_release);
pShared->nTickProgram.store(MP_TICK());
}
}
pShared->nQuit.store(1);
}
}
UnmapViewOfFile(pShared);
}
CloseHandle(hMemory);
}
S.bContextSwitchRunning = false;
MicroProfileOnThreadExit();
return 0;
}
MicroProfileThreadInfo MicroProfileGetThreadInfo(MicroProfileThreadIdType nThreadId)
{
MicroProfileWin32UpdateThreadInfo();
for(uint32_t i = 0; i < g_ThreadInfo.nNumThreads; ++i)
{
if(g_ThreadInfo.T[i].tid == nThreadId)
{
return g_ThreadInfo.T[i];
}
}
MicroProfileThreadInfo TI((uint32_t)nThreadId, 0, 0);
return TI;
}
uint32_t MicroProfileGetThreadInfoArray(MicroProfileThreadInfo** pThreadArray)
{
MicroProfileWin32InitThreadInfo2();
*pThreadArray = &g_ThreadInfo.T[0];
return g_ThreadInfo.nNumThreads;
}
#elif defined(__APPLE__)
#include <sys/time.h>
void* MicroProfileTraceThread(void* unused)
{
FILE* pFile = fopen("mypipe", "r");
if(!pFile)
{
uprintf("CONTEXT SWITCH FAILED TO OPEN FILE: make sure to run dtrace script\n");
S.bContextSwitchRunning = false;
return 0;
}
uprintf("STARTING TRACE THREAD\n");
char* pLine = 0;
size_t cap = 0;
size_t len = 0;
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t nsSinceEpoch = ((uint64_t)(tv.tv_sec) * 1000000 + (uint64_t)(tv.tv_usec)) * 1000;
uint64_t nTickEpoch = MP_TICK();
uint32_t nLastThread[MICROPROFILE_MAX_CONTEXT_SWITCH_THREADS] = { 0 };
mach_timebase_info_data_t sTimebaseInfo;
mach_timebase_info(&sTimebaseInfo);
S.bContextSwitchRunning = true;
uint64_t nProcessed = 0;
uint64_t nProcessedLast = 0;
while((len = getline(&pLine, &cap, pFile)) > 0 && !S.bContextSwitchStop)
{
nProcessed += len;
if(nProcessed - nProcessedLast > 10 << 10)
{
nProcessedLast = nProcessed;
uprintf("processed %llukb %llukb\n", (nProcessed - nProcessedLast) >> 10, nProcessed >> 10);
}
char* pX = strchr(pLine, 'X');
if(pX)
{
int cpu = atoi(pX + 1);
char* pX2 = strchr(pX + 1, 'X');
char* pX3 = strchr(pX2 + 1, 'X');
int thread = atoi(pX2 + 1);
char* lala;
int64_t timestamp = strtoll(pX3 + 1, &lala, 10);
MicroProfileContextSwitch Switch;
// convert to ticks.
uint64_t nDeltaNsSinceEpoch = timestamp - nsSinceEpoch;
uint64_t nDeltaTickSinceEpoch = sTimebaseInfo.numer * nDeltaNsSinceEpoch / sTimebaseInfo.denom;
uint64_t nTicks = nDeltaTickSinceEpoch + nTickEpoch;
if(cpu < MICROPROFILE_MAX_CONTEXT_SWITCH_THREADS)
{
Switch.nThreadOut = nLastThread[cpu];
Switch.nThreadIn = thread;
nLastThread[cpu] = thread;
Switch.nCpu = cpu;
Switch.nTicks = nTicks;
MicroProfileContextSwitchPut(&Switch);
}
}
}
uprintf("EXITING TRACE THREAD\n");
S.bContextSwitchRunning = false;
return 0;
}
MicroProfileThreadInfo MicroProfileGetThreadInfo(MicroProfileThreadIdType nThreadId)
{
MicroProfileThreadInfo TI((uint32_t)nThreadId, 0, 0);
return TI;
}
uint32_t MicroProfileGetThreadInfoArray(MicroProfileThreadInfo** pThreadArray)
{
*pThreadArray = 0;
return 0;
}
#endif
#else
MicroProfileThreadInfo MicroProfileGetThreadInfo(MicroProfileThreadIdType nThreadId)
{
MicroProfileThreadInfo TI((uint32_t)nThreadId, 0, 0);
return TI;
}
uint32_t MicroProfileGetThreadInfoArray(MicroProfileThreadInfo** pThreadArray)
{
*pThreadArray = 0;
return 0;
}
void MicroProfileStopContextSwitchTrace()
{
}
void MicroProfileJoinContextSwitchTrace()
{
}
void MicroProfileStartContextSwitchTrace()
{
}
#endif
#if MICROPROFILE_GPU_TIMERS
void MicroProfileGpuShutdownPlatform()
{
if(S.pGPU)
{
MicroProfileGpuShutdown();
MP_FREE(S.pGPU);
S.pGPU = nullptr;
MicroProfileGpuInsertTimeStamp_Callback = nullptr;
MicroProfileGpuGetTimeStamp_Callback = nullptr;
MicroProfileTicksPerSecondGpu_Callback = nullptr;
MicroProfileGetGpuTickReference_Callback = nullptr;
MicroProfileGpuFlip_Callback = nullptr;
MicroProfileGpuShutdown_Callback = nullptr;
}
}
void MicroProfileGpuInitPlatform(MicroProfileGpuTimerStateType eType,
MicroProfileGpuTimerState* pGPU,
MicroProfileGpuInsertTimeStamp_CB InsertTimeStamp,
MicroProfileGpuGetTimeStamp_CB GetTimeStamp,
MicroProfileTicksPerSecondGpu_CB TicksPerSecond,
MicroProfileGetGpuTickReference_CB GetTickReference,
MicroProfileGpuFlip_CB Flip,
MicroProfileGpuShutdown_CB Shutdown)
{
MP_ASSERT(S.pGPU == nullptr);
pGPU->Type = eType;
S.pGPU = pGPU;
MicroProfileGpuInsertTimeStamp_Callback = InsertTimeStamp;
MicroProfileGpuGetTimeStamp_Callback = GetTimeStamp;
MicroProfileTicksPerSecondGpu_Callback = TicksPerSecond;
MicroProfileGetGpuTickReference_Callback = GetTickReference;
MicroProfileGpuFlip_Callback = Flip;
MicroProfileGpuShutdown_Callback = Shutdown;
}
#endif
#if MICROPROFILE_GPU_TIMERS_D3D11
//:'######:::'########::'##::::'##::::'########:::'#######::'########:::::'##::::::'##:::
//'##... ##:: ##.... ##: ##:::: ##:::: ##.... ##:'##.... ##: ##.... ##::'####::::'####:::
// ##:::..::: ##:::: ##: ##:::: ##:::: ##:::: ##:..::::: ##: ##:::: ##::.. ##::::.. ##:::
// ##::'####: ########:: ##:::: ##:::: ##:::: ##::'#######:: ##:::: ##:::: ##:::::: ##:::
// ##::: ##:: ##.....::: ##:::: ##:::: ##:::: ##::...... ##: ##:::: ##:::: ##:::::: ##:::
// ##::: ##:: ##:::::::: ##:::: ##:::: ##:::: ##:'##:::: ##: ##:::: ##:::: ##:::::: ##:::
//. ######::: ##::::::::. #######::::: ########::. #######:: ########:::'######::'######:
//:......::::..::::::::::.......::::::........::::.......:::........::::......:::......::
uint32_t MicroProfileGpuInsertTimeStampD3D11(void* pContext_)
{
MicroProfileGpuTimerStateD3D11* pGPU = MicroProfileGetGpuTimerStateD3D11();
if(!pGPU)
return 0;
MicroProfileD3D11Frame& Frame = pGPU->m_QueryFrames[pGPU->m_nQueryFrame];
uint32_t nStart = Frame.m_nQueryStart;
if(Frame.m_nRateQueryStarted)
{
uint32_t nIndex = (uint32_t)-1;
do
{
nIndex = Frame.m_nQueryCount.load();
if(nIndex + 1 >= Frame.m_nQueryCountMax)
{
return (uint32_t)-1;
}
} while(!Frame.m_nQueryCount.compare_exchange_weak(nIndex, nIndex + 1));
nIndex += nStart;
uint32_t nQueryIndex = nIndex % MICROPROFILE_D3D11_MAX_QUERIES;
ID3D11Query* pQuery = (ID3D11Query*)pGPU->m_pQueries[nQueryIndex];
ID3D11DeviceContext* pContext = (ID3D11DeviceContext*)pContext_;
pContext->End(pQuery);
return nQueryIndex;
}
return (uint32_t)-1;
}
uint64_t MicroProfileGpuGetTimeStampD3D11(uint32_t nIndex)
{
if(nIndex == (uint32_t)-1)
{
return (uint64_t)-1;
}
MicroProfileGpuTimerStateD3D11* pGPU = MicroProfileGetGpuTimerStateD3D11();
if(!pGPU)
return 0;
int64_t nResult = pGPU->m_nQueryResults[nIndex];
MP_ASSERT(nResult != -1);
return nResult;
}
bool MicroProfileGpuGetDataD3D11(void* pQuery, void* pData, uint32_t nDataSize)
{
MicroProfileGpuTimerStateD3D11* pGPU = MicroProfileGetGpuTimerStateD3D11();
if(!pGPU)
return false;
HRESULT hr;
do
{
hr = ((ID3D11DeviceContext*)pGPU->m_pImmediateContext)->GetData((ID3D11Query*)pQuery, pData, nDataSize, 0);
} while(hr == S_FALSE);
switch(hr)
{
case DXGI_ERROR_DEVICE_REMOVED:
case DXGI_ERROR_INVALID_CALL:
case E_INVALIDARG:
MP_BREAK();
return false;
}
return true;
}
uint64_t MicroProfileTicksPerSecondGpuD3D11()
{
MicroProfileGpuTimerStateD3D11* pGPU = MicroProfileGetGpuTimerStateD3D11();
if(!pGPU)
return 1;
return pGPU->m_nQueryFrequency;
}
uint32_t MicroProfileGpuFlipD3D11(void* pDeviceContext_)
{
if(!pDeviceContext_)
{
return (uint32_t)-1;
}
MicroProfileGpuTimerStateD3D11* pGPU = MicroProfileGetGpuTimerStateD3D11();
if(!pGPU)
return 0;
ID3D11DeviceContext* pDeviceContext = (ID3D11DeviceContext*)pDeviceContext_;
uint32_t nFrameTimeStamp = MicroProfileGpuInsertTimeStamp(pDeviceContext);
MicroProfileD3D11Frame& CurrentFrame = pGPU->m_QueryFrames[pGPU->m_nQueryFrame];
ID3D11DeviceContext* pImmediateContext = (ID3D11DeviceContext*)pGPU->m_pImmediateContext;
if(CurrentFrame.m_nRateQueryStarted)
{
pImmediateContext->End((ID3D11Query*)CurrentFrame.m_pRateQuery);
}
uint32_t nNextFrame = (pGPU->m_nQueryFrame + 1) % MICROPROFILE_GPU_FRAME_DELAY;
pGPU->m_nQueryPut = (CurrentFrame.m_nQueryStart + CurrentFrame.m_nQueryCount) % MICROPROFILE_D3D11_MAX_QUERIES;
MicroProfileD3D11Frame& OldFrame = pGPU->m_QueryFrames[nNextFrame];
if(OldFrame.m_nRateQueryStarted)
{
struct RateQueryResult
{
uint64_t nFrequency;
BOOL bDisjoint;
};
RateQueryResult Result;
if(MicroProfileGpuGetDataD3D11(OldFrame.m_pRateQuery, &Result, sizeof(Result)))
{
if(pGPU->m_nQueryFrequency != (int64_t)Result.nFrequency)
{
if(pGPU->m_nQueryFrequency)
{
OutputDebugStringA("Query freq changing");
}
pGPU->m_nQueryFrequency = Result.nFrequency;
}
uint32_t nStart = OldFrame.m_nQueryStart;
uint32_t nCount = OldFrame.m_nQueryCount;
for(uint32_t i = 0; i < nCount; ++i)
{
uint32_t nIndex = (i + nStart) % MICROPROFILE_D3D11_MAX_QUERIES;
if(!MicroProfileGpuGetDataD3D11(pGPU->m_pQueries[nIndex], &pGPU->m_nQueryResults[nIndex], sizeof(uint64_t)))
{
pGPU->m_nQueryResults[nIndex] = -1;
}
}
}
else
{
uint32_t nStart = OldFrame.m_nQueryStart;
uint32_t nCount = OldFrame.m_nQueryCount;
for(uint32_t i = 0; i < nCount; ++i)
{
uint32_t nIndex = (i + nStart) % MICROPROFILE_D3D11_MAX_QUERIES;
pGPU->m_nQueryResults[nIndex] = -1;
}
}
pGPU->m_nQueryGet = (OldFrame.m_nQueryStart + OldFrame.m_nQueryCount) % MICROPROFILE_D3D11_MAX_QUERIES;
}
pGPU->m_nQueryFrame = nNextFrame;
MicroProfileD3D11Frame& NextFrame = pGPU->m_QueryFrames[nNextFrame];
pImmediateContext->Begin((ID3D11Query*)NextFrame.m_pRateQuery);
NextFrame.m_nQueryStart = pGPU->m_nQueryPut;
NextFrame.m_nQueryCount = 0;
if(pGPU->m_nQueryPut >= pGPU->m_nQueryGet)
{
NextFrame.m_nQueryCountMax = (MICROPROFILE_D3D11_MAX_QUERIES - pGPU->m_nQueryPut) + pGPU->m_nQueryGet;
}
else
{
NextFrame.m_nQueryCountMax = pGPU->m_nQueryGet - pGPU->m_nQueryPut - 1;
}
if(NextFrame.m_nQueryCountMax)
NextFrame.m_nQueryCountMax -= 1;
NextFrame.m_nRateQueryStarted = 1;
return nFrameTimeStamp;
}
void MicroProfileGpuInitD3D11(void* pDevice_, void* pImmediateContext)
{
ID3D11Device* pDevice = (ID3D11Device*)pDevice_;
MicroProfileGpuTimerStateD3D11* pGPU = MP_ALLOC_OBJECT(MicroProfileGpuTimerStateD3D11);
MicroProfileGpuInitPlatform(MicroProfileGpuTimerStateType_D3D11,
pGPU,
MicroProfileGpuInsertTimeStampD3D11,
MicroProfileGpuGetTimeStampD3D11,
MicroProfileTicksPerSecondGpuD3D11,
MicroProfileGetGpuTickReferenceD3D11,
MicroProfileGpuFlipD3D11,
MicroProfileGpuShutdownD3D11);
pGPU->m_pImmediateContext = pImmediateContext;
D3D11_QUERY_DESC Desc;
Desc.MiscFlags = 0;
Desc.Query = D3D11_QUERY_TIMESTAMP;
for(uint32_t i = 0; i < MICROPROFILE_D3D11_MAX_QUERIES; ++i)
{
HRESULT hr = pDevice->CreateQuery(&Desc, (ID3D11Query**)&pGPU->m_pQueries[i]);
MP_ASSERT(hr == S_OK);
pGPU->m_nQueryResults[i] = -1;
}
HRESULT hr = pDevice->CreateQuery(&Desc, (ID3D11Query**)&pGPU->pSyncQuery);
MP_ASSERT(hr == S_OK);
pGPU->m_nQueryPut = 0;
pGPU->m_nQueryGet = 0;
pGPU->m_nQueryFrame = 0;
pGPU->m_nQueryFrequency = 0;
Desc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT;
for(uint32_t i = 0; i < MICROPROFILE_GPU_FRAME_DELAY; ++i)
{
pGPU->m_QueryFrames[i].m_nQueryStart = 0;
pGPU->m_QueryFrames[i].m_nQueryCount = 0;
pGPU->m_QueryFrames[i].m_nRateQueryStarted = 0;
hr = pDevice->CreateQuery(&Desc, (ID3D11Query**)&pGPU->m_QueryFrames[i].m_pRateQuery);
MP_ASSERT(hr == S_OK);
}
}
void MicroProfileGpuShutdownD3D11()
{
MicroProfileGpuTimerStateD3D11* pGPU = MicroProfileGetGpuTimerStateD3D11();
if(!pGPU)
return;
for(uint32_t i = 0; i < MICROPROFILE_D3D11_MAX_QUERIES; ++i)
{
if(pGPU->m_pQueries[i])
{
ID3D11Query* pQuery = (ID3D11Query*)pGPU->m_pQueries[i];
pQuery->Release();
pGPU->m_pQueries[i] = 0;
}
}
for(uint32_t i = 0; i < MICROPROFILE_GPU_FRAME_DELAY; ++i)
{
if(pGPU->m_QueryFrames[i].m_pRateQuery)
{
ID3D11Query* pQuery = (ID3D11Query*)pGPU->m_QueryFrames[i].m_pRateQuery;
pQuery->Release();
pGPU->m_QueryFrames[i].m_pRateQuery = 0;
}
}
if(pGPU->pSyncQuery)
{
ID3D11Query* pSyncQuery = (ID3D11Query*)pGPU->pSyncQuery;
pSyncQuery->Release();
pGPU->pSyncQuery = 0;
}
}
int MicroProfileGetGpuTickReferenceD3D11(int64_t* pOutCPU, int64_t* pOutGpu)
{
MicroProfileGpuTimerStateD3D11* pGPU = MicroProfileGetGpuTimerStateD3D11();
if(!pGPU)
return 0;
{
MicroProfileD3D11Frame& Frame = pGPU->m_QueryFrames[pGPU->m_nQueryFrame];
if(Frame.m_nRateQueryStarted)
{
ID3D11Query* pSyncQuery = (ID3D11Query*)pGPU->pSyncQuery;
ID3D11DeviceContext* pImmediateContext = (ID3D11DeviceContext*)pGPU->m_pImmediateContext;
pImmediateContext->End(pSyncQuery);
HRESULT hr;
do
{
hr = pImmediateContext->GetData(pSyncQuery, pOutGpu, sizeof(*pOutGpu), 0);
} while(hr == S_FALSE);
*pOutCPU = MP_TICK();
switch(hr)
{
case DXGI_ERROR_DEVICE_REMOVED:
case DXGI_ERROR_INVALID_CALL:
case E_INVALIDARG:
MP_BREAK();
return false;
}
MP_ASSERT(hr == S_OK);
return 1;
}
}
return 0;
}
MicroProfileGpuTimerStateD3D11* MicroProfileGetGpuTimerStateD3D11()
{
if(S.pGPU && S.pGPU->Type == MicroProfileGpuTimerStateType_D3D11)
return (MicroProfileGpuTimerStateD3D11*)S.pGPU;
return nullptr;
}
#endif
#if MICROPROFILE_GPU_TIMERS_D3D12
//:'######:::'########::'##::::'##::::'########:::'#######::'########:::::'##::::'#######::
//'##... ##:: ##.... ##: ##:::: ##:::: ##.... ##:'##.... ##: ##.... ##::'####:::'##.... ##:
// ##:::..::: ##:::: ##: ##:::: ##:::: ##:::: ##:..::::: ##: ##:::: ##::.. ##:::..::::: ##:
// ##::'####: ########:: ##:::: ##:::: ##:::: ##::'#######:: ##:::: ##:::: ##::::'#######::
// ##::: ##:: ##.....::: ##:::: ##:::: ##:::: ##::...... ##: ##:::: ##:::: ##:::'##::::::::
// ##::: ##:: ##:::::::: ##:::: ##:::: ##:::: ##:'##:::: ##: ##:::: ##:::: ##::: ##::::::::
//. ######::: ##::::::::. #######::::: ########::. #######:: ########:::'######: #########:
//:......::::..::::::::::.......::::::........::::.......:::........::::......::.........::
#include <d3d12.h>
uint32_t MicroProfileGpuInsertTimeStampD3D12(void* pContext)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU || !pContext)
return 0;
ID3D12GraphicsCommandList* pCommandList = (ID3D12GraphicsCommandList*)pContext;
bool IsCopy = D3D12_COMMAND_LIST_TYPE_COPY == pCommandList->GetType();
uint32_t nNode = pGPU->nCurrentNode;
uint32_t nFrame = pGPU->nFrame;
ID3D12QueryHeap* pHeap = IsCopy ? pGPU->NodeState[nNode].pCopyQueueHeap : pGPU->NodeState[nNode].pHeap;
uint32_t nQueryIndex = IsCopy ? ((pGPU->nFrameCountCopyQueueTimeStamps.fetch_add(1) + pGPU->nFrameStartCopyQueueTimeStamps) % MICROPROFILE_D3D12_MAX_QUERIES)
: ((pGPU->nFrameCountTimeStamps.fetch_add(1) + pGPU->nFrameStartTimeStamps) % MICROPROFILE_D3D12_MAX_QUERIES);
pCommandList->EndQuery(pHeap, D3D12_QUERY_TYPE_TIMESTAMP, nQueryIndex);
MP_ASSERT(nQueryIndex <= 0xffff);
uint32_t res = (IsCopy ? 0x80000000 : 0) | ((nFrame << 16) & 0x7fff0000) | (nQueryIndex);
return res;
}
void MicroProfileGpuFetchRange(uint32_t nBegin, int32_t nCount, uint64_t nFrame, int64_t nTimestampOffset)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU || nCount <= 0)
return;
void* pData = 0;
// uprintf("fetch [%d-%d]\n", nBegin, nBegin + nCount);
D3D12_RANGE Range = { sizeof(uint64_t) * nBegin, sizeof(uint64_t) * (nBegin + nCount) };
pGPU->pBuffer->Map(0, &Range, &pData);
memcpy(&pGPU->nResults[nBegin], nBegin + (uint64_t*)pData, nCount * sizeof(uint64_t));
for(int i = 0; i < nCount; ++i)
{
pGPU->nQueryFrames[i + nBegin] = nFrame;
pGPU->nResults[i + nBegin] -= nTimestampOffset;
}
pGPU->pBuffer->Unmap(0, 0);
}
void MicroProfileGpuFetchRangeCopy(uint32_t nBegin, int32_t nCount, uint64_t nFrame, int64_t nTimestampOffset)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU || nCount <= 0)
return;
void* pData = 0;
D3D12_RANGE Range = { sizeof(uint64_t) * nBegin, sizeof(uint64_t) * (nBegin + nCount) };
pGPU->pBufferCopy->Map(0, &Range, &pData);
memcpy(&pGPU->nResultsCopy[nBegin], nBegin + (uint64_t*)pData, nCount * sizeof(uint64_t));
for(int i = 0; i < nCount; ++i)
{
pGPU->nQueryFramesCopy[i + nBegin] = nFrame;
pGPU->nResultsCopy[i + nBegin] -= nTimestampOffset;
}
pGPU->pBufferCopy->Unmap(0, 0);
}
void MicroProfileGpuWaitFenceD3D12(uint32_t nNode, uint64_t nFence)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU)
return;
auto GetFence = [&]() -> uint64_t
{
uint64_t f0 = pGPU->NodeState[nNode].pFence->GetCompletedValue();
uint64_t f1 = pGPU->NodeState[nNode].pFenceCopy->GetCompletedValue();
return MicroProfileMin(f0, f1);
};
uint64_t nCompletedFrame = GetFence();
// while(nCompletedFrame < nPending)
// while(0 < nPending - nCompletedFrame)
while(0 < (int64_t)(nFence - nCompletedFrame))
{
MICROPROFILE_SCOPEI("Microprofile", "gpu-wait", MP_GREEN4);
Sleep(20); // todo: use event.
nCompletedFrame = GetFence();
if((uint64_t)-1 == nCompletedFrame) // likely device removed.
return;
}
}
void MicroProfileGpuFetchResultsD3D12(uint64_t nFrame)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU)
return;
uint64_t nPending = pGPU->nPendingFrame;
// while(nPending <= nFrame)
// while(0 <= nFrame - nPending)
while(0 <= (int64_t)(nFrame - nPending))
{
uint32_t nInternal = nPending % MICROPROFILE_D3D_INTERNAL_DELAY;
uint32_t nNode = pGPU->Frames[nInternal].nNode;
MicroProfileGpuWaitFenceD3D12(nNode, nPending);
int64_t nTimestampOffset = 0;
if(nNode != 0)
{
// Adjust timestamp queries from GPU x to be in GPU 0's frame of reference
HRESULT hr;
int64_t nCPU0, nGPU0;
hr = pGPU->NodeState[0].pCommandQueue->GetClockCalibration((uint64_t*)&nGPU0, (uint64_t*)&nCPU0);
MP_ASSERT(hr == S_OK);
int64_t nCPUx, nGPUx;
hr = pGPU->NodeState[nNode].pCommandQueue->GetClockCalibration((uint64_t*)&nGPUx, (uint64_t*)&nCPUx);
MP_ASSERT(hr == S_OK);
int64_t nFreqCPU = MicroProfileTicksPerSecondCpu();
int64_t nElapsedCPU = nCPUx - nCPU0;
int64_t nElapsedGPU = pGPU->nFrequency * nElapsedCPU / nFreqCPU;
nTimestampOffset = nGPUx - nGPU0 - nElapsedGPU;
}
{
uint32_t nTimeStampBegin = pGPU->Frames[nInternal].nTimeStampBegin;
uint32_t nTimeStampCount = pGPU->Frames[nInternal].nTimeStampCount;
MicroProfileGpuFetchRange(
nTimeStampBegin, (nTimeStampBegin + nTimeStampCount) > MICROPROFILE_D3D12_MAX_QUERIES ? MICROPROFILE_D3D12_MAX_QUERIES - nTimeStampBegin : nTimeStampCount, nPending, nTimestampOffset);
MicroProfileGpuFetchRange(0, (nTimeStampBegin + nTimeStampCount) - MICROPROFILE_D3D12_MAX_QUERIES, nPending, nTimestampOffset);
}
{
uint32_t nTimeStampBegin = pGPU->Frames[nInternal].nTimeStampBeginCopyQueue;
uint32_t nTimeStampCount = pGPU->Frames[nInternal].nTimeStampCountCopyQueue;
MicroProfileGpuFetchRangeCopy(
nTimeStampBegin, (nTimeStampBegin + nTimeStampCount) > MICROPROFILE_D3D12_MAX_QUERIES ? MICROPROFILE_D3D12_MAX_QUERIES - nTimeStampBegin : nTimeStampCount, nPending, nTimestampOffset);
MicroProfileGpuFetchRangeCopy(0, (nTimeStampBegin + nTimeStampCount) - MICROPROFILE_D3D12_MAX_QUERIES, nPending, nTimestampOffset);
}
nPending = ++pGPU->nPendingFrame;
MP_ASSERT(pGPU->nFrame > nPending);
}
}
uint64_t MicroProfileGpuGetTimeStampD3D12(uint32_t nIndex)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU)
return 0;
uint32_t nFrame = nIndex >> 16;
bool IsCopy = (nFrame & 0x8000) != 0;
nFrame &= 0x7fff;
uint32_t nQueryIndex = nIndex & 0xffff;
uint32_t lala = IsCopy ? pGPU->nQueryFramesCopy[nQueryIndex] : pGPU->nQueryFrames[nQueryIndex];
// uprintf("read TS [%d <- %lld]\n", nQueryIndex, pGPU->nResults[nQueryIndex]);
MP_ASSERT(nIndex == 0 || (0x7fff & lala) == nFrame);
uint64_t r = IsCopy ? pGPU->nResultsCopy[nQueryIndex] : pGPU->nResults[nQueryIndex];
if(r == 0x7fffffffffffffff)
{
MP_BREAK();
}
return r;
}
uint64_t MicroProfileTicksPerSecondGpuD3D12()
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU)
return 1;
return pGPU->nFrequency;
}
uint32_t MicroProfileGpuFlipD3D12(void* pContext)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU)
return 0;
uint32_t nNode = pGPU->nCurrentNode;
uint32_t nFrameIndex = pGPU->nFrame % MICROPROFILE_D3D_INTERNAL_DELAY;
uint32_t nCount = 0, nStart = 0;
uint32_t nCountCopyQueue = 0, nStartCopyQueue = 0;
ID3D12CommandAllocator* pCommandAllocator = pGPU->Frames[nFrameIndex].pCommandAllocator;
ID3D12CommandAllocator* pCommandAllocatorCopy = pGPU->Frames[nFrameIndex].pCommandAllocatorCopy;
pCommandAllocator->Reset();
pCommandAllocatorCopy->Reset();
ID3D12GraphicsCommandList* pCommandList = pGPU->Frames[nFrameIndex].pCommandList[nNode];
pCommandList->Reset(pCommandAllocator, nullptr);
ID3D12GraphicsCommandList* pCommandListCopy = nullptr;
uint32_t nFrameTimeStamp = MicroProfileGpuInsertTimeStamp(pCommandList);
{
nCount = pGPU->nFrameCountTimeStamps.exchange(0);
nStart = pGPU->nFrameStartTimeStamps;
pGPU->nFrameStartTimeStamps = (pGPU->nFrameStartTimeStamps + nCount) % MICROPROFILE_D3D12_MAX_QUERIES;
uint32_t nEnd = MicroProfileMin(nStart + nCount, (uint32_t)MICROPROFILE_D3D12_MAX_QUERIES);
MP_ASSERT(nStart != nEnd);
uint32_t nSize = nEnd - nStart;
pCommandList->ResolveQueryData(pGPU->NodeState[nNode].pHeap, D3D12_QUERY_TYPE_TIMESTAMP, nStart, nEnd - nStart, pGPU->pBuffer, nStart * sizeof(int64_t));
if(nStart + nCount > MICROPROFILE_D3D12_MAX_QUERIES)
{
pCommandList->ResolveQueryData(pGPU->NodeState[nNode].pHeap, D3D12_QUERY_TYPE_TIMESTAMP, 0, nEnd + nStart - MICROPROFILE_D3D12_MAX_QUERIES, pGPU->pBuffer, 0);
}
pCommandList->Close();
}
{
pCommandListCopy = pGPU->Frames[nFrameIndex].pCommandListCopy[nNode];
pCommandListCopy->Reset(pCommandAllocatorCopy, nullptr);
nCountCopyQueue = pGPU->nFrameCountCopyQueueTimeStamps.exchange(0);
nStartCopyQueue = pGPU->nFrameStartCopyQueueTimeStamps;
pGPU->nFrameStartCopyQueueTimeStamps = (nStartCopyQueue + nCountCopyQueue) % MICROPROFILE_D3D12_MAX_QUERIES;
uint32_t nEnd = MicroProfileMin(nStartCopyQueue + nCountCopyQueue, (uint32_t)MICROPROFILE_D3D12_MAX_QUERIES);
if(nStartCopyQueue != nEnd)
{
uint32_t nSize = nEnd - nStartCopyQueue;
pCommandListCopy->ResolveQueryData(
pGPU->NodeState[nNode].pCopyQueueHeap, D3D12_QUERY_TYPE_TIMESTAMP, nStartCopyQueue, nEnd - nStartCopyQueue, pGPU->pBufferCopy, nStartCopyQueue * sizeof(int64_t));
if(nStartCopyQueue + nCountCopyQueue > MICROPROFILE_D3D12_MAX_QUERIES)
{
pCommandListCopy->ResolveQueryData(pGPU->NodeState[nNode].pCopyQueueHeap, D3D12_QUERY_TYPE_TIMESTAMP, 0, nEnd + nStartCopyQueue - MICROPROFILE_D3D12_MAX_QUERIES, pGPU->pBufferCopy, 0);
}
}
pCommandListCopy->Close();
}
if(pCommandList)
{
ID3D12CommandList* pList = pCommandList;
pGPU->NodeState[nNode].pCommandQueue->ExecuteCommandLists(1, &pList);
}
if(pCommandListCopy)
{
ID3D12CommandList* pList = pCommandListCopy;
pGPU->NodeState[nNode].pCommandQueueCopy->ExecuteCommandLists(1, &pList);
}
pGPU->NodeState[nNode].pCommandQueue->Signal(pGPU->NodeState[nNode].pFence, pGPU->nFrame);
pGPU->NodeState[nNode].pCommandQueueCopy->Signal(pGPU->NodeState[nNode].pFenceCopy, pGPU->nFrame);
pGPU->Frames[nFrameIndex].nTimeStampBegin = nStart;
pGPU->Frames[nFrameIndex].nTimeStampCount = nCount;
pGPU->Frames[nFrameIndex].nTimeStampBeginCopyQueue = nStartCopyQueue;
pGPU->Frames[nFrameIndex].nTimeStampCountCopyQueue = nCountCopyQueue;
pGPU->Frames[nFrameIndex].nNode = nNode;
pGPU->nFrame++;
// fetch from earlier frames
MicroProfileGpuFetchResultsD3D12(pGPU->nFrame - MICROPROFILE_GPU_FRAME_DELAY);
return nFrameTimeStamp;
}
void MicroProfileGpuInitD3D12(void* pDevice_, uint32_t nNodeCount, void** pCommandQueues_, void** pCommandQueuesCopy_)
{
MicroProfileGpuTimerStateD3D12* pGPU = MP_ALLOC_OBJECT(MicroProfileGpuTimerStateD3D12);
memset(pGPU, 0, sizeof(MicroProfileGpuTimerStateD3D12));
MicroProfileGpuInitPlatform(MicroProfileGpuTimerStateType_D3D12,
pGPU,
MicroProfileGpuInsertTimeStampD3D12,
MicroProfileGpuGetTimeStampD3D12,
MicroProfileTicksPerSecondGpuD3D12,
MicroProfileGetGpuTickReferenceD3D12,
MicroProfileGpuFlipD3D12,
MicroProfileGpuShutdownD3D12);
ID3D12Device* pDevice = (ID3D12Device*)pDevice_;
pGPU->pDevice = pDevice;
pGPU->nNodeCount = nNodeCount;
MP_ASSERT(pGPU->nNodeCount <= MICROPROFILE_D3D_MAX_NODE_COUNT);
for(uint32_t nNode = 0; nNode < pGPU->nNodeCount; ++nNode)
{
pGPU->NodeState[nNode].pCommandQueue = (ID3D12CommandQueue*)pCommandQueues_[nNode];
pGPU->NodeState[nNode].pCommandQueueCopy = (ID3D12CommandQueue*)pCommandQueuesCopy_[nNode];
if(nNode == 0)
{
pGPU->NodeState[nNode].pCommandQueue->GetTimestampFrequency((uint64_t*)&(pGPU->nFrequency));
MP_ASSERT(pGPU->nFrequency);
}
else
{
// Don't support GPUs with different timer frequencies for now
int64_t nFrequency;
pGPU->NodeState[nNode].pCommandQueue->GetTimestampFrequency((uint64_t*)&nFrequency);
MP_ASSERT(nFrequency == pGPU->nFrequency);
}
D3D12_QUERY_HEAP_DESC QHDesc;
QHDesc.Count = MICROPROFILE_D3D12_MAX_QUERIES;
QHDesc.Type = D3D12_QUERY_HEAP_TYPE_TIMESTAMP;
QHDesc.NodeMask = MP_NODE_MASK_ONE(nNode);
HRESULT hr = pDevice->CreateQueryHeap(&QHDesc, IID_PPV_ARGS(&pGPU->NodeState[nNode].pHeap));
MP_ASSERT(hr == S_OK);
QHDesc.Type = D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP;
hr = pDevice->CreateQueryHeap(&QHDesc, IID_PPV_ARGS(&pGPU->NodeState[nNode].pCopyQueueHeap));
MP_ASSERT(hr == S_OK);
pDevice->CreateFence(pGPU->nPendingFrame, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&pGPU->NodeState[nNode].pFence));
pDevice->CreateFence(pGPU->nPendingFrame, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&pGPU->NodeState[nNode].pFenceCopy));
}
HRESULT hr;
D3D12_HEAP_PROPERTIES HeapProperties;
HeapProperties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
HeapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
HeapProperties.CreationNodeMask = 0;
HeapProperties.VisibleNodeMask = MP_NODE_MASK_ALL(pGPU->nNodeCount);
HeapProperties.Type = D3D12_HEAP_TYPE_READBACK;
const size_t nResourceSize = MICROPROFILE_D3D12_MAX_QUERIES * 8;
D3D12_RESOURCE_DESC ResourceDesc;
ResourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
ResourceDesc.Alignment = 0;
ResourceDesc.Width = nResourceSize;
ResourceDesc.Height = 1;
ResourceDesc.DepthOrArraySize = 1;
ResourceDesc.MipLevels = 1;
ResourceDesc.Format = DXGI_FORMAT_UNKNOWN;
ResourceDesc.SampleDesc.Count = 1;
ResourceDesc.SampleDesc.Quality = 0;
ResourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
ResourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
hr = pDevice->CreateCommittedResource(&HeapProperties, D3D12_HEAP_FLAG_NONE, &ResourceDesc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&pGPU->pBuffer));
MP_ASSERT(hr == S_OK);
hr = pDevice->CreateCommittedResource(&HeapProperties, D3D12_HEAP_FLAG_NONE, &ResourceDesc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&pGPU->pBufferCopy));
MP_ASSERT(hr == S_OK);
pGPU->nFrame = 0;
pGPU->nPendingFrame = 0;
for(MicroProfileFrameD3D12& Frame : pGPU->Frames)
{
hr = pDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&Frame.pCommandAllocator));
MP_ASSERT(hr == S_OK);
hr = pDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COPY, IID_PPV_ARGS(&Frame.pCommandAllocatorCopy));
MP_ASSERT(hr == S_OK);
for(uint32_t nNode = 0; nNode < pGPU->nNodeCount; ++nNode)
{
hr = pDevice->CreateCommandList(MP_NODE_MASK_ONE(nNode), D3D12_COMMAND_LIST_TYPE_DIRECT, Frame.pCommandAllocator, nullptr, IID_PPV_ARGS(&Frame.pCommandList[nNode]));
MP_ASSERT(hr == S_OK);
hr = Frame.pCommandList[nNode]->Close();
MP_ASSERT(hr == S_OK);
hr = pDevice->CreateCommandList(MP_NODE_MASK_ONE(nNode), D3D12_COMMAND_LIST_TYPE_COPY, Frame.pCommandAllocatorCopy, nullptr, IID_PPV_ARGS(&Frame.pCommandListCopy[nNode]));
MP_ASSERT(hr == S_OK);
hr = Frame.pCommandListCopy[nNode]->Close();
MP_ASSERT(hr == S_OK);
}
}
}
void MicroProfileGpuShutdownD3D12()
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU)
return;
for(uint32_t nNode = 0; nNode < pGPU->nNodeCount; ++nNode)
{
MicroProfileGpuWaitFenceD3D12(nNode, pGPU->nFrame - 1);
}
for(uint32_t nNode = 0; nNode < pGPU->nNodeCount; ++nNode)
{
pGPU->NodeState[nNode].pHeap->Release();
pGPU->NodeState[nNode].pCopyQueueHeap->Release();
pGPU->NodeState[nNode].pFence->Release();
pGPU->NodeState[nNode].pFenceCopy->Release();
}
pGPU->pBuffer->Release();
pGPU->pBufferCopy->Release();
for(MicroProfileFrameD3D12& Frame : pGPU->Frames)
{
Frame.pCommandAllocator->Release();
Frame.pCommandAllocatorCopy->Release();
for(uint32_t nNode = 0; nNode < pGPU->nNodeCount; ++nNode)
{
Frame.pCommandList[nNode]->Release();
Frame.pCommandListCopy[nNode]->Release();
}
}
}
void MicroProfileSetCurrentNodeD3D12(uint32_t nNode)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
pGPU->nCurrentNode = nNode;
}
int MicroProfileGetGpuTickReferenceD3D12(int64_t* pOutCPU, int64_t* pOutGpu)
{
MicroProfileGpuTimerStateD3D12* pGPU = MicroProfileGetGpuTimerStateD3D12();
if(!pGPU)
{
*pOutCPU = 1;
*pOutGpu = 1;
return 1;
}
HRESULT hr = pGPU->NodeState[0].pCommandQueue->GetClockCalibration((uint64_t*)pOutGpu, (uint64_t*)pOutCPU);
MP_ASSERT(hr == S_OK);
return 1;
}
MicroProfileGpuTimerStateD3D12* MicroProfileGetGpuTimerStateD3D12()
{
if(S.pGPU && S.pGPU->Type == MicroProfileGpuTimerStateType_D3D12)
return (MicroProfileGpuTimerStateD3D12*)S.pGPU;
return nullptr;
}
#endif
#if MICROPROFILE_GPU_TIMERS_VULKAN
//:'######:::'########::'##::::'##::::'##::::'##:'##::::'##:'##:::::::'##:::'##::::'###::::'##::: ##:
//'##... ##:: ##.... ##: ##:::: ##:::: ##:::: ##: ##:::: ##: ##::::::: ##::'##::::'## ##::: ###:: ##:
// ##:::..::: ##:::: ##: ##:::: ##:::: ##:::: ##: ##:::: ##: ##::::::: ##:'##::::'##:. ##:: ####: ##:
// ##::'####: ########:: ##:::: ##:::: ##:::: ##: ##:::: ##: ##::::::: #####::::'##:::. ##: ## ## ##:
// ##::: ##:: ##.....::: ##:::: ##::::. ##:: ##:: ##:::: ##: ##::::::: ##. ##::: #########: ##. ####:
// ##::: ##:: ##:::::::: ##:::: ##:::::. ## ##::: ##:::: ##: ##::::::: ##:. ##:: ##.... ##: ##:. ###:
//. ######::: ##::::::::. #######:::::::. ###::::. #######:: ########: ##::. ##: ##:::: ##: ##::. ##:
//:......::::..::::::::::.......:::::::::...::::::.......:::........::..::::..::..:::::..::..::::..::
#ifndef MICROPROFILE_VULKAN_MAX_QUERIES
#define MICROPROFILE_VULKAN_MAX_QUERIES (32 << 10)
#endif
#define MICROPROFILE_VULKAN_MAX_NODE_COUNT 4
#define MICROPROFILE_VULKAN_INTERNAL_DELAY 8
#include <vulkan/vulkan.h>
struct MicroProfileGpuFrameVulkan
{
uint32_t nBegin;
uint32_t nCount;
uint32_t nNode;
VkCommandBuffer CommandBuffer[MICROPROFILE_VULKAN_MAX_NODE_COUNT];
VkFence Fences[MICROPROFILE_VULKAN_MAX_NODE_COUNT];
};
struct MicroProfileGpuTimerStateVulkan : public MicroProfileGpuTimerState
{
VkDevice Devices[MICROPROFILE_VULKAN_MAX_NODE_COUNT];
VkPhysicalDevice PhysicalDevices[MICROPROFILE_VULKAN_MAX_NODE_COUNT];
VkQueue Queues[MICROPROFILE_VULKAN_MAX_NODE_COUNT];
VkQueryPool QueryPool[MICROPROFILE_VULKAN_MAX_NODE_COUNT];
VkCommandPool CommandPool[MICROPROFILE_VULKAN_MAX_NODE_COUNT];
uint32_t nNodeCount;
uint32_t nCurrentNode;
uint64_t nFrame;
uint64_t nPendingFrame;
uint32_t nFrameStart;
std::atomic<uint32_t> nFrameCount;
int64_t nFrequency;
uint16_t nQueryFrames[MICROPROFILE_VULKAN_MAX_QUERIES];
int64_t nResults[MICROPROFILE_VULKAN_MAX_QUERIES];
MicroProfileGpuFrameVulkan Frames[MICROPROFILE_VULKAN_INTERNAL_DELAY];
};
MicroProfileGpuTimerStateVulkan* MicroProfileGetGpuTimerStateVulkan()
{
if(S.pGPU && S.pGPU->Type == MicroProfileGpuTimerStateType_Vulkan)
return (MicroProfileGpuTimerStateVulkan*)S.pGPU;
return nullptr;
}
uint32_t MicroProfileGpuInsertTimeStampVulkan(void* pContext)
{
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return 0;
VkCommandBuffer CB = (VkCommandBuffer)pContext;
uint32_t nNode = pGPU->nCurrentNode;
uint32_t nFrame = pGPU->nFrame;
uint32_t nQueryIndex = (pGPU->nFrameCount.fetch_add(1) + pGPU->nFrameStart) % MICROPROFILE_VULKAN_MAX_QUERIES;
vkCmdWriteTimestamp(CB, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, pGPU->QueryPool[nNode], nQueryIndex);
MP_ASSERT(nQueryIndex <= 0xffff);
// uprintf("insert timestamp %d :: %d ... ctx %p\n", nQueryIndex, nFrame, pContext);
return ((nFrame << 16) & 0xffff0000) | (nQueryIndex);
}
void MicroProfileGpuFetchRangeVulkan(VkCommandBuffer CommandBuffer, uint32_t nNode, uint32_t nBegin, int32_t nCount, uint64_t nFrame, int64_t nTimestampOffset)
{
if(nCount <= 0)
return;
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return;
vkGetQueryPoolResults(pGPU->Devices[nNode], pGPU->QueryPool[nNode], nBegin, nCount, 8 * nCount, &pGPU->nResults[nBegin], 8, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_PARTIAL_BIT);
vkCmdResetQueryPool(CommandBuffer, pGPU->QueryPool[nNode], nBegin, nCount);
for(int i = 0; i < nCount; ++i)
{
pGPU->nQueryFrames[i + nBegin] = nFrame;
}
}
void MicroProfileGpuWaitFenceVulkan(uint32_t nNode, uint64_t nFrame)
{
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return;
int r;
int c = 0;
do
{
MICROPROFILE_SCOPEI("Microprofile", "gpu-wait", MP_GREEN4);
r = vkWaitForFences(pGPU->Devices[nNode], 1, &pGPU->Frames[nFrame].Fences[nNode], 1, 1000 * 30);
#if 0
if(c++ > 1000 && (c%100) == 0)
{
uprintf("waiting really long time for fence\n");
OutputDebugString("waiting really long time for fence\n");
}
#endif
} while(r != VK_SUCCESS);
}
void MicroProfileGpuFetchResultsVulkan(VkCommandBuffer Buffer, uint64_t nFrame)
{
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return;
uint64_t nPending = pGPU->nPendingFrame;
// while(nPending <= nFrame)
// while(0 <= nFrame - nPending)
while(0 <= (int64_t)(nFrame - nPending))
{
uint32_t nInternal = nPending % MICROPROFILE_VULKAN_INTERNAL_DELAY;
uint32_t nNode = pGPU->Frames[nInternal].nNode;
MicroProfileGpuWaitFenceVulkan(nNode, nInternal);
int64_t nTimestampOffset = 0;
if(nNode != 0)
{
MP_ASSERT(0 && "NOT IMPLEMENTED");
// note: timestamp adjustment not implemented.
}
uint32_t nBegin = pGPU->Frames[nInternal].nBegin;
uint32_t nCount = pGPU->Frames[nInternal].nCount;
MicroProfileGpuFetchRangeVulkan(Buffer, nNode, nBegin, (nBegin + nCount) > MICROPROFILE_VULKAN_MAX_QUERIES ? MICROPROFILE_VULKAN_MAX_QUERIES - nBegin : nCount, nPending, nTimestampOffset);
MicroProfileGpuFetchRangeVulkan(Buffer, nNode, 0, (nBegin + nCount) - MICROPROFILE_VULKAN_MAX_QUERIES, nPending, nTimestampOffset);
nPending = ++pGPU->nPendingFrame;
MP_ASSERT(pGPU->nFrame > nPending);
}
}
uint64_t MicroProfileGpuGetTimeStampVulkan(uint32_t nIndex)
{
if(nIndex == (uint32_t)-1)
{
return 0;
}
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return 0;
uint32_t nFrame = nIndex >> 16;
uint32_t nQueryIndex = nIndex & 0xffff;
uint32_t lala = pGPU->nQueryFrames[nQueryIndex];
MP_ASSERT((0xffff & lala) == nFrame);
// uprintf("read TS [%d <- %lld]\n", nQueryIndex, pGPU->nResults[nQueryIndex]);
return pGPU->nResults[nQueryIndex];
}
uint64_t MicroProfileTicksPerSecondGpuVulkan()
{
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return 1;
return pGPU->nFrequency;
}
uint32_t MicroProfileGpuFlipVulkan(void* pContext)
{
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return 0;
uint32_t nNode = pGPU->nCurrentNode;
uint32_t nFrameIndex = pGPU->nFrame % MICROPROFILE_VULKAN_INTERNAL_DELAY;
uint32_t nCount = 0, nStart = 0;
VkCommandBuffer CommandBuffer = pGPU->Frames[nFrameIndex].CommandBuffer[nNode];
auto& F = pGPU->Frames[nFrameIndex];
VkFence Fence = F.Fences[nNode];
VkDevice Device = pGPU->Devices[nNode];
VkQueue Queue = pGPU->Queues[nNode];
vkWaitForFences(Device, 1, &Fence, 1, (uint64_t)-1);
uint32_t nFrameTimeStamp = MicroProfileGpuInsertTimeStamp(pContext);
vkResetCommandBuffer(F.CommandBuffer[nNode], VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
VkCommandBufferBeginInfo CBI;
CBI.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
CBI.pNext = 0;
CBI.pInheritanceInfo = 0;
CBI.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(F.CommandBuffer[nNode], &CBI);
vkResetFences(Device, 1, &Fence);
nCount = pGPU->nFrameCount.exchange(0);
nStart = pGPU->nFrameStart;
pGPU->nFrameStart = (pGPU->nFrameStart + nCount) % MICROPROFILE_VULKAN_MAX_QUERIES;
uint32_t nEnd = MicroProfileMin(nStart + nCount, (uint32_t)MICROPROFILE_VULKAN_MAX_QUERIES);
MP_ASSERT(nStart != nEnd);
uint32_t nSize = nEnd - nStart;
pGPU->Frames[nFrameIndex].nBegin = nStart;
pGPU->Frames[nFrameIndex].nCount = nCount;
pGPU->Frames[nFrameIndex].nNode = nNode;
pGPU->nFrame++;
////fetch from earlier frames
MicroProfileGpuFetchResultsVulkan(CommandBuffer, pGPU->nFrame - MICROPROFILE_GPU_FRAME_DELAY);
vkEndCommandBuffer(F.CommandBuffer[nNode]);
VkSubmitInfo SubmitInfo = {};
SubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
SubmitInfo.pNext = nullptr;
SubmitInfo.waitSemaphoreCount = 0;
SubmitInfo.pWaitSemaphores = nullptr;
SubmitInfo.commandBufferCount = 1;
SubmitInfo.pCommandBuffers = &CommandBuffer;
SubmitInfo.signalSemaphoreCount = 0;
SubmitInfo.pSignalSemaphores = nullptr;
vkQueueSubmit(Queue, 1, &SubmitInfo, Fence);
return nFrameTimeStamp;
}
void MicroProfileGpuInitVulkan(VkDevice* pDevices, VkPhysicalDevice* pPhysicalDevices, VkQueue* pQueues, uint32_t* QueueFamily, uint32_t nNodeCount)
{
MicroProfileGpuTimerStateVulkan* pGPU = MP_ALLOC_OBJECT(MicroProfileGpuTimerStateVulkan);
memset(pGPU, 0, sizeof(MicroProfileGpuTimerStateVulkan));
MicroProfileGpuInitPlatform(MicroProfileGpuTimerStateType_Vulkan,
pGPU,
MicroProfileGpuInsertTimeStampVulkan,
MicroProfileGpuGetTimeStampVulkan,
MicroProfileTicksPerSecondGpuVulkan,
MicroProfileGetGpuTickReferenceVulkan,
MicroProfileGpuFlipVulkan,
MicroProfileGpuShutdownVulkan);
pGPU->nNodeCount = nNodeCount;
VkQueryPoolCreateInfo Q;
Q.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
Q.pNext = 0;
Q.flags = 0;
Q.queryType = VK_QUERY_TYPE_TIMESTAMP;
Q.queryCount = MICROPROFILE_VULKAN_MAX_QUERIES + 1;
VkCommandPoolCreateInfo CreateInfo;
CreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
CreateInfo.pNext = 0;
CreateInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
VkResult r;
for(uint32_t i = 0; i < nNodeCount; ++i)
{
pGPU->Devices[i] = pDevices[i];
pGPU->PhysicalDevices[i] = pPhysicalDevices[i];
pGPU->Queues[i] = pQueues[i];
r = vkCreateQueryPool(pGPU->Devices[i], &Q, 0, &pGPU->QueryPool[i]);
MP_ASSERT(r == VK_SUCCESS);
CreateInfo.queueFamilyIndex = QueueFamily[i];
r = vkCreateCommandPool(pGPU->Devices[i], &CreateInfo, 0, &pGPU->CommandPool[i]);
MP_ASSERT(r == VK_SUCCESS);
for(uint32_t j = 0; j < MICROPROFILE_VULKAN_INTERNAL_DELAY; ++j)
{
auto& F = pGPU->Frames[j];
VkCommandBufferAllocateInfo AllocInfo;
AllocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
AllocInfo.pNext = 0;
AllocInfo.commandBufferCount = 1;
AllocInfo.commandPool = pGPU->CommandPool[i];
AllocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
r = vkAllocateCommandBuffers(pGPU->Devices[i], &AllocInfo, &F.CommandBuffer[i]);
MP_ASSERT(r == VK_SUCCESS);
VkFenceCreateInfo FCI;
FCI.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
FCI.pNext = 0;
FCI.flags = j == 0 ? 0 : VK_FENCE_CREATE_SIGNALED_BIT;
r = vkCreateFence(pGPU->Devices[i], &FCI, 0, &F.Fences[i]);
MP_ASSERT(r == VK_SUCCESS);
if(j == 0)
{
VkCommandBufferBeginInfo CBI;
CBI.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
CBI.pNext = 0;
CBI.pInheritanceInfo = 0;
CBI.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(F.CommandBuffer[i], &CBI);
vkCmdResetQueryPool(F.CommandBuffer[i], pGPU->QueryPool[i], 0, MICROPROFILE_VULKAN_MAX_QUERIES + 1);
vkEndCommandBuffer(F.CommandBuffer[i]);
VkSubmitInfo SubmitInfo = {};
SubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
SubmitInfo.pNext = nullptr;
SubmitInfo.waitSemaphoreCount = 0;
SubmitInfo.pWaitSemaphores = nullptr;
SubmitInfo.commandBufferCount = 1;
SubmitInfo.pCommandBuffers = &F.CommandBuffer[i];
SubmitInfo.signalSemaphoreCount = 0;
SubmitInfo.pSignalSemaphores = nullptr;
vkQueueSubmit(pQueues[i], 1, &SubmitInfo, F.Fences[i]);
vkWaitForFences(pGPU->Devices[i], 1, &F.Fences[i], 1, (uint64_t)-1);
vkResetCommandBuffer(F.CommandBuffer[i], VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
}
}
}
VkPhysicalDeviceProperties Properties;
vkGetPhysicalDeviceProperties(pPhysicalDevices[0], &Properties);
pGPU->nFrequency = 1000000000ll / Properties.limits.timestampPeriod;
}
void MicroProfileGpuShutdownVulkan()
{
// this is clearly leaking ..
}
void MicroProfileSetCurrentNodeVulkan(uint32_t nNode)
{
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return;
pGPU->nCurrentNode = nNode;
}
int MicroProfileGetGpuTickReferenceVulkan(int64_t* pOutCPU, int64_t* pOutGpu)
{
MicroProfileGpuTimerStateVulkan* pGPU = MicroProfileGetGpuTimerStateVulkan();
if(!pGPU)
return 0;
auto& F = pGPU->Frames[pGPU->nFrame % MICROPROFILE_VULKAN_INTERNAL_DELAY];
uint32_t nGpu = pGPU->nCurrentNode;
VkCommandBufferBeginInfo CBI;
CBI.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
CBI.pNext = 0;
CBI.pInheritanceInfo = 0;
CBI.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
VkCommandBuffer CB = F.CommandBuffer[nGpu];
VkDevice Device = pGPU->Devices[nGpu];
VkFence Fence = F.Fences[nGpu];
vkWaitForFences(Device, 1, &Fence, 1, (uint64_t)-1);
vkResetFences(Device, 1, &Fence);
vkResetCommandBuffer(CB, VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
vkBeginCommandBuffer(CB, &CBI);
vkCmdResetQueryPool(CB, pGPU->QueryPool[nGpu], MICROPROFILE_VULKAN_MAX_QUERIES, 1);
vkCmdWriteTimestamp(CB, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, pGPU->QueryPool[nGpu], MICROPROFILE_VULKAN_MAX_QUERIES);
vkEndCommandBuffer(CB);
VkSubmitInfo SubmitInfo = {};
SubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
SubmitInfo.pNext = nullptr;
SubmitInfo.waitSemaphoreCount = 0;
SubmitInfo.pWaitSemaphores = nullptr;
SubmitInfo.commandBufferCount = 1;
SubmitInfo.pCommandBuffers = &CB;
SubmitInfo.signalSemaphoreCount = 0;
SubmitInfo.pSignalSemaphores = nullptr;
vkQueueSubmit(pGPU->Queues[nGpu], 1, &SubmitInfo, Fence);
vkWaitForFences(Device, 1, &Fence, 1, (uint64_t)-1);
*pOutGpu = 0;
vkGetQueryPoolResults(Device, pGPU->QueryPool[nGpu], MICROPROFILE_VULKAN_MAX_QUERIES, 1, 8, pOutGpu, 8, VK_QUERY_RESULT_64_BIT);
*pOutCPU = MP_TICK();
return 1;
}
#endif
#if MICROPROFILE_GPU_TIMERS_GL
//:'######:::'########::'##::::'##:::::'######:::'##:::::::
//'##... ##:: ##.... ##: ##:::: ##::::'##... ##:: ##:::::::
// ##:::..::: ##:::: ##: ##:::: ##:::: ##:::..::: ##:::::::
// ##::'####: ########:: ##:::: ##:::: ##::'####: ##:::::::
// ##::: ##:: ##.....::: ##:::: ##:::: ##::: ##:: ##:::::::
// ##::: ##:: ##:::::::: ##:::: ##:::: ##::: ##:: ##:::::::
//. ######::: ##::::::::. #######:::::. ######::: ########:
//:......::::..::::::::::.......:::::::......::::........::
void MicroProfileGpuInitGL()
{
MicroProfileGpuTimerStateGL* pGPU = MP_ALLOC_OBJECT(MicroProfileGpuTimerStateGL);
memset(pGPU, 0, sizeof(MicroProfileGpuTimerStateGL));
MicroProfileGpuInitPlatform(MicroProfileGpuTimerStateType_GL,
pGPU,
MicroProfileGpuInsertTimeStampGL,
MicroProfileGpuGetTimeStampGL,
MicroProfileTicksPerSecondGpuGL,
MicroProfileGetGpuTickReferenceGL,
MicroProfileGpuFlipGL,
MicroProfileGpuShutdownGL);
pGPU->GLTimerPos = 0;
glGenQueries(MICROPROFILE_GL_MAX_QUERIES, &pGPU->GLTimers[0]);
}
uint32_t MicroProfileGpuInsertTimeStampGL(void* pContext)
{
MicroProfileGpuTimerStateGL* pGPU = MicroProfileGetGpuTimerStateGL();
if(!pGPU)
return 0;
uint32_t nIndex = (pGPU->GLTimerPos + 1) % MICROPROFILE_GL_MAX_QUERIES;
glQueryCounter(pGPU->GLTimers[nIndex], GL_TIMESTAMP);
pGPU->GLTimerPos = nIndex;
return nIndex;
}
uint64_t MicroProfileGpuGetTimeStampGL(uint32_t nKey)
{
MicroProfileGpuTimerStateGL* pGPU = MicroProfileGetGpuTimerStateGL();
if(!pGPU)
return 0;
uint64_t result;
glGetQueryObjectui64v(pGPU->GLTimers[nKey], GL_QUERY_RESULT, &result);
return result;
}
uint64_t MicroProfileTicksPerSecondGpuGL()
{
return 1000000000ll;
}
int MicroProfileGetGpuTickReferenceGL(int64_t* pOutCpu, int64_t* pOutGpu)
{
MicroProfileGpuTimerStateGL* pGPU = MicroProfileGetGpuTimerStateGL();
if(!pGPU)
return 0;
int64_t nGpuTimeStamp;
glGetInteger64v(GL_TIMESTAMP, &nGpuTimeStamp);
if(nGpuTimeStamp)
{
*pOutCpu = MP_TICK();
*pOutGpu = nGpuTimeStamp;
#if 0 // debug test if timestamp diverges
static int64_t nTicksPerSecondCpu = MicroProfileTicksPerSecondCpu();
static int64_t nTicksPerSecondGpu = MicroProfileTicksPerSecondGpu();
static int64_t nGpuStart = 0;
static int64_t nCpuStart = 0;
if(!nCpuStart)
{
nCpuStart = *pOutCpu;
nGpuStart = *pOutGpu;
}
static int nCountDown = 100;
if(0 == nCountDown--)
{
int64_t nCurCpu = *pOutCpu;
int64_t nCurGpu = *pOutGpu;
double fDistanceCpu = (nCurCpu - nCpuStart) / (double)nTicksPerSecondCpu;
double fDistanceGpu = (nCurGpu - nGpuStart) / (double)nTicksPerSecondGpu;
char buf[254];
snprintf(buf, sizeof(buf)-1,"Distance %f %f diff %f\n", fDistanceCpu, fDistanceGpu, fDistanceCpu-fDistanceGpu);
OutputDebugString(buf);
nCountDown = 100;
}
#endif
return 1;
}
return 0;
}
uint32_t MicroProfileGpuFlipGL(void* pContext)
{
return MicroProfileGpuInsertTimeStampGL(pContext);
}
void MicroProfileGpuShutdownGL()
{
MicroProfileGpuTimerStateGL* pGPU = MicroProfileGetGpuTimerStateGL();
if(!pGPU)
return;
glDeleteQueries(MICROPROFILE_GL_MAX_QUERIES, &pGPU->GLTimers[0]);
}
MicroProfileGpuTimerStateGL* MicroProfileGetGpuTimerStateGL()
{
if(S.pGPU && S.pGPU->Type == MicroProfileGpuTimerStateType_GL)
return (MicroProfileGpuTimerStateGL*)S.pGPU;
return nullptr;
}
#endif
uint32_t MicroProfileStringHash(const char* pString) // note matching: code in javascript: microprofilelive.html: function StringHash(s)
{
uint32_t h = 0xfeedba3e;
char c;
while(0 != (c = *pString++))
{
h = c + ((h << 5) - h);
}
return h;
}
const char* MicroProfileStrDup(const char* pStr)
{
size_t len = strlen(pStr) + 1;
char* pOut = (char*)MP_ALLOC(len, 8);
memcpy(pOut, pStr, len);
return pOut;
}
uint32_t MicroProfileColorFromString(const char* pString) // note matching code/constants in javascript: microprofilelive.html: function StringToColor(s)
{
// var h = StringHash(s);
// var cidx = h % 360;
// return "hsl(" + cidx + ",50%, 70%)"; //note: matching code constants in microprofile.cpp: MicroProfileColorFromString
float h = MicroProfileStringHash(pString) % 360;
float s = 0.5f;
float l = 0.7f;
// from https://www.rapidtables.com/convert/color/hsl-to-rgb.html
float c = (1 - fabsf(2 * l - 1)) * s;
float x = c * (1 - fabsf(fmodf(h / 60, 2.f) - 1));
float m = l - c / 2.f;
float r = 0.f, g = 0.f, b = 0.f;
if(h < 60)
{
r = c;
g = x;
}
else if(h < 120.f)
{
r = x;
g = c;
}
else if(h < 180.f)
{
g = c;
b = x;
}
else if(h < 240.f)
{
g = x;
b = c;
}
else if(h < 300.f)
{
r = x;
b = c;
}
else
{
r = c;
b = x;
}
r += m;
g += m;
b += m;
r *= 255.f;
g *= 255.f;
b *= 255.f;
uint32_t R = MicroProfileMin(0xffu, (uint32_t)r);
uint32_t G = MicroProfileMin(0xffu, (uint32_t)g);
uint32_t B = MicroProfileMin(0xffu, (uint32_t)b);
return (R << 16) | (G << 8) | B;
}
#if MICROPROFILE_DYNAMIC_INSTRUMENT
// '##::::'##::'#######:::'#######::'##:::'##:::::'######::'##::::'##::::'###::::'########::'########:'########::
// ##:::: ##:'##.... ##:'##.... ##: ##::'##:::::'##... ##: ##:::: ##:::'## ##::: ##.... ##: ##.....:: ##.... ##:
// ##:::: ##: ##:::: ##: ##:::: ##: ##:'##:::::: ##:::..:: ##:::: ##::'##:. ##:: ##:::: ##: ##::::::: ##:::: ##:
// #########: ##:::: ##: ##:::: ##: #####:::::::. ######:: #########:'##:::. ##: ########:: ######::: ##:::: ##:
// ##.... ##: ##:::: ##: ##:::: ##: ##. ##:::::::..... ##: ##.... ##: #########: ##.. ##::: ##...:::: ##:::: ##:
// ##:::: ##: ##:::: ##: ##:::: ##: ##:. ##:::::'##::: ##: ##:::: ##: ##.... ##: ##::. ##:: ##::::::: ##:::: ##:
// ##:::: ##:. #######::. #######:: ##::. ##::::. ######:: ##:::: ##: ##:::: ##: ##:::. ##: ########: ########::
// ..:::::..:::.......::::.......:::..::::..::::::......:::..:::::..::..:::::..::..:::::..::........::........:::
#include <distorm.h>
#include <mnemonics.h>
#if MICROPROFILE_BREAK_ON_PATCH_FAIL
#define BREAK_ON_PATCH_FAIL() MP_BREAK()
#else
#define BREAK_ON_PATCH_FAIL() \
do \
{ \
} while(0)
#endif
void* MicroProfileX64FollowJump(void* pSrc);
bool MicroProfileCopyInstructionBytes(char* pDest,
void* pSrc,
const int nLimit,
const int nMaxSize,
char* pTrunk,
intptr_t nTrunkSize,
uint32_t nUsableJumpRegs,
int* nBytesDest,
int* nBytesSrc,
uint32_t* pRegsWritten,
uint32_t* nRetSafe);
bool MicroProfilePatchFunction(void* f, int Argument, MicroProfileHookFunc enter, MicroProfileHookFunc leave, MicroProfilePatchError* pError);
template <typename Callback>
void MicroProfileIterateSymbols(Callback CB, uint32_t* nModules, uint32_t nNumModules);
bool MicroProfileDemangleName(const char* pName, char* OutName, uint32_t Size);
bool MicroProfilePatchBeginSuspend();
void MicroProfilePatchEndSuspend();
bool MicroProfilePatchHasSuspendedThread(intptr_t Begin, intptr_t End);
#if 1
#define STRING_MATCH_SIZE 64
typedef uint64_t uint_string_match;
#else
#define STRING_MATCH_SIZE 32
typedef uint32_t uint_string_match;
#endif
struct MicroProfileStringMatchMask
{
uint_string_match nMask;
uint_string_match M[64];
};
struct MicroProfileSymbolDesc
{
const char* pName;
const char* pShortName;
intptr_t nAddress;
intptr_t nAddressEnd;
uint_string_match nMask;
int nIgnoreSymbol;
uint32_t nModule;
};
struct MicroProfileSymbolBlock
{
MicroProfileSymbolBlock* pNext;
uint32_t nNumSymbols;
uint32_t nNumChars;
uint_string_match nMask;
MicroProfileStringMatchMask MatchMask;
enum
{
ESIZE = 4 << 10,
};
union
{
MicroProfileSymbolDesc Symbols[ESIZE / sizeof(MicroProfileSymbolDesc)];
char Chars[ESIZE];
};
};
typedef void (*MicroProfileOnSymbolCallback)(const char* pSymbolName, intptr_t nAddress);
MP_THREAD_LOCAL uintptr_t g_MicroProfile_TLS[17] = { 16 };
extern "C" MP_NOINLINE uintptr_t MicroProfile_Patch_TLS_PUSH(uintptr_t t)
{
uintptr_t* pTLS = &g_MicroProfile_TLS[0];
uintptr_t Limit = (uint32_t)pTLS[0];
uintptr_t Pos = (uint32_t)(pTLS[0] >> 32);
if(Pos == Limit)
{
return 0;
}
else
{
pTLS[0] = (Limit) | ((Pos + 1) << 32);
}
pTLS[Pos + 1] = t;
return 1;
}
extern "C" MP_NOINLINE uintptr_t MicroProfile_Patch_TLS_POP()
{
uintptr_t* pTLS = &g_MicroProfile_TLS[0];
uintptr_t Limit = (uint32_t)pTLS[0];
uintptr_t Pos = (uint32_t)(pTLS[0] >> 32);
if(Pos == 0)
{
MP_BREAK(); // this should never happen
return 0;
}
else
{
pTLS[0] = (Limit) | ((Pos - 1) << 32);
}
uintptr_t t = pTLS[Pos];
return t;
}
char* MicroProfileInsertRegisterJump(char* pCode, intptr_t pDest, int reg)
{
MP_ASSERT(reg >= R_RAX && reg <= R_R15);
int large = reg >= R_R8 ? 1 : 0;
int offset = large ? (reg - R_R8) : (reg - R_RAX);
unsigned char* uc = (unsigned char*)pCode;
*uc++ = large ? 0x49 : 0x48;
*uc++ = 0xb8 + offset;
memcpy(uc, &pDest, 8);
uc += 8;
if(large)
*uc++ = 0x41;
*uc++ = 0xff;
*uc++ = 0xe0 + offset;
return (char*)uc;
// 164: 48 b8 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %rax
// 16e: 48 b9 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %rcx
// 178: 48 ba 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %rdx
// 182: 48 bb 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %rbx
// 18c: 48 bc 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %rsp
// 196: 48 bd 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %rbp
// 1a0: 48 be 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %rsi
// 1aa: 48 bf 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %rdi
// 1b4: 49 b8 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %r8
// 1be: 49 b9 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %r9
// 1c8: 49 ba 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %r10
// 1d2: 49 bb 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %r11
// 1dc: 49 bc 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %r12
// 1e6: 49 bd 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %r13
// 1f0: 49 be 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %r14
// 1fa: 49 bf 08 07 06 05 04 03 02 01 movabsq $72623859790382856, %r15
// 204: ff e0 jmpq *%rax
// 206: ff e1 jmpq *%rcx
// 208: ff e2 jmpq *%rdx
// 20a: ff e3 jmpq *%rbx
// 20c: ff e4 jmpq *%rsp
// 20e: ff e5 jmpq *%rbp
// 210: ff e6 jmpq *%rsi
// 212: ff e7 jmpq *%rdi
// 214: 41 ff e0 jmpq *%r8
// 217: 41 ff e1 jmpq *%r9
// 21a: 41 ff e2 jmpq *%r10
// 21d: 41 ff e3 jmpq *%r11
// 220: 41 ff e4 jmpq *%r12
// 223: 41 ff e5 jmpq *%r13
// 226: 41 ff e6 jmpq *%r14
// 229: 41 ff e7 jmpq *%r15
}
char* MicroProfileInsertRelativeJump(char* pCode, intptr_t pDest)
{
intptr_t src = intptr_t(pCode) + 5;
intptr_t off = pDest - src;
MP_ASSERT(off > intptr_t(0xffffffff80000000) && off <= 0x7fffffff);
int32_t i32off = (int32_t)off;
unsigned char* uc = (unsigned char*)pCode;
unsigned char* c = (unsigned char*)&i32off;
*uc++ = 0xe9;
memcpy(uc, c, 4);
uc += 4;
return (char*)uc;
}
char* MicroProfileInsertRetJump(char* pCode, intptr_t pDest)
{
uint32_t lower = (uint32_t)pDest;
uint32_t upper = (uint32_t)(pDest >> 32);
unsigned char* uc = (unsigned char*)pCode;
*uc++ = 0x68;
memcpy(uc, &lower, 4);
uc += 4;
*uc++ = 0xc7;
*uc++ = 0x44;
*uc++ = 0x24;
*uc++ = 0x04;
memcpy(uc, &upper, 4);
uc += 4;
*uc++ = 0xc3;
return (char*)uc;
}
uint8_t* MicroProfileInsertMov(uint8_t* p, uint8_t* pend, int r, intptr_t value)
{
int Large = r >= R_R8 ? 1 : 0;
int RegIndex = Large ? (r - R_R8) : (r - R_RAX);
*p++ = Large ? 0x49 : 0x48;
*p++ = 0xb8 + RegIndex; // + (reg - (large?(R_R8-R_RAX):0));
intptr_t* pAddress = (intptr_t*)p;
pAddress[0] = value;
p = (uint8_t*)(pAddress + 1);
MP_ASSERT(p < pend);
return p;
}
uint8_t* MicroProfileInsertCall(uint8_t* p, uint8_t* pend, int r)
{
int Large = r >= R_R8 ? 1 : 0;
int RegIndex = Large ? (r - R_R8) : (r - R_RAX);
if(Large)
{
*p++ = 0x41;
}
*p++ = 0xff;
*p++ = 0xd0 + RegIndex;
MP_ASSERT(p < pend);
return p;
}
bool MicroProfileStringMatch(const char* pSymbol, uint32_t nStartOffset, const char** pPatterns, uint32_t* nPatternLength, uint32_t nNumPatterns)
{
MP_ASSERT(nStartOffset <= nNumPatterns);
const char* p = pSymbol;
for(uint32_t i = nStartOffset; i < nNumPatterns; ++i)
{
p = MP_STRCASESTR(p, pPatterns[i]);
if(p)
{
p += nPatternLength[i];
}
else
{
return false;
}
}
return true;
}
int MicroProfileStringMatchOffset(const char* pSymbol, const char** pPatterns, uint32_t* nPatternLength, uint32_t nNumPatterns)
{
int nOffset = 0;
const char* p = pSymbol;
for(uint32_t i = 0; i < nNumPatterns; ++i)
{
p = MP_STRCASESTR(p, pPatterns[i]);
if(p)
{
p += nPatternLength[i];
nOffset++;
}
else
{
break;
}
}
return nOffset;
}
void* MicroProfileX64FollowJump(void* pSrc)
{
for(uint32_t i = 0; i < S.DynamicTokenIndex; ++i)
if(S.FunctionsInstrumented[i] == pSrc)
return pSrc; // if already instrumented, do not follow the jump inserted by itself.
// uprintf("deref possible trampoline for %p\n", pSrc);
_DecodeType dt = Decode64Bits;
_DInst Instructions[1];
unsigned int nCount = 0;
_CodeInfo ci;
ci.code = (uint8_t*)pSrc;
ci.codeLen = 15;
ci.codeOffset = 0;
ci.dt = dt;
ci.features = DF_NONE;
int r = distorm_decompose(&ci, Instructions, 1, &nCount);
if(!r || nCount != 1)
{
return pSrc; // fail, just return
}
auto& I = Instructions[0];
if(I.opcode == I_JMP)
{
if(I.ops[0].type == O_PC)
{
if(I.ops[0].size == 0x20)
{
intptr_t p = (intptr_t)pSrc;
p += I.size;
p += I.imm.sdword;
return (void*)p;
}
}
else if(I.ops[0].type == O_SMEM)
{
if(I.ops[0].index == R_RIP)
{
intptr_t p = (intptr_t)pSrc;
p += I.size;
p += I.disp;
void* pHest = *(void**)p;
return pHest;
}
}
uprintf("failed to interpret I_JMP %p %d %d\n", pSrc, I.ops[0].size, I.ops[0].type);
return pSrc;
MP_BREAK();
}
return pSrc;
}
bool MicroProfileCopyInstructionBytes(char* pDest,
void* pSrc,
const int nLimit,
const int nMaxSize,
char* pTrunk,
intptr_t nTrunkSize,
const uint32_t nUsableJumpRegs,
int* pBytesDest,
int* pBytesSrc,
uint32_t* pRegsWritten,
uint32_t* pRetSafe)
{
_DecodeType dt = Decode64Bits;
_DInst Instructions[128];
int rip[128] = { 0 };
uint32_t nRegsWrittenInstr[128] = { 0 };
int offsets[129] = { 0 };
unsigned int nCount = 0;
_CodeInfo ci;
ci.code = (uint8_t*)pSrc;
ci.codeLen = nLimit + 15;
ci.codeOffset = 0;
ci.dt = dt;
ci.features = DF_NONE;
int r = distorm_decompose(&ci, Instructions, 128, &nCount);
if(r != DECRES_SUCCESS)
{
BREAK_ON_PATCH_FAIL();
return false;
}
int offset = 0;
unsigned int i = 0;
unsigned nInstructions = 0;
int64_t nTrunkUsage = 0;
offsets[0] = 0;
uint32_t nRegsWritten = 0;
auto Align16 = [](intptr_t p) { return (p + 15) & (~15); };
{
intptr_t iTrunk = (intptr_t)pTrunk;
intptr_t iTrunkEnd = iTrunk + nTrunkSize;
intptr_t iTrunkAligned = (iTrunk + 15) & ~15;
nTrunkSize = iTrunkEnd - iTrunkAligned;
pTrunk = (char*)iTrunkAligned;
}
const uint8_t* pTrunkEnd = (uint8_t*)(pTrunk + nTrunkSize);
auto RegToBit = [](int r) -> uint32_t
{
if(r >= R_RAX && r <= R_R15)
{
return (1u << (r - R_RAX));
}
else if(r >= R_EAX && r <= R_R15D)
{
return (1u << (r - R_EAX));
}
else if(r >= R_AX && r <= R_R15W)
{
return (1u << (r - R_AX));
}
else if(r >= R_AL && r <= R_R15B)
{
return (1u << (r - R_AL));
}
return 0; // might hit on registers like RIP
MP_BREAK();
};
#ifdef _WIN32
const uint32_t nUsableRegisters = RegToBit(R_RAX) | RegToBit(R_R10) | RegToBit(R_R11);
#else
const uint32_t nUsableRegisters = RegToBit(R_RAX) | RegToBit(R_R10) | RegToBit(R_R11);
#endif
int nBytesToMove = 0;
for(i = 0; i < nCount; ++i)
{
nBytesToMove += Instructions[i].size;
if(nBytesToMove >= nLimit)
break;
}
*pBytesSrc = nBytesToMove;
uint32_t nRspMask = RegToBit(R_RSP);
*pRetSafe = 1;
for(i = 0; i < nCount; ++i)
{
rip[i] = 0;
auto& I = Instructions[i];
// bool bHasRipReference = false;
if(I.opcode == I_LEA)
{
}
if(I.opcode == I_CALL)
{
auto& O = I.ops[0];
if(O.type != O_PC || O.size != 0x20)
{
uprintf("unknown call encountered. cannot move\n");
BREAK_ON_PATCH_FAIL();
return false;
}
if((nRegsWritten & nUsableRegisters) == nUsableRegisters)
{
uprintf("call encountered, but register all regs was written to. TODO: push regs?\n");
BREAK_ON_PATCH_FAIL();
return false;
}
// return value might be used past return so preserve registers.
#ifdef _WIN32
nRegsWritten |= RegToBit(R_RAX);
#else
nRegsWritten |= RegToBit(R_RAX) | RegToBit(R_RDX);
#endif
}
switch(I.ops[0].type)
{
case O_REG:
{
uint32_t reg = I.ops[0].index;
nRegsWritten |= RegToBit(reg);
auto& O2 = I.ops[1];
switch(O2.type)
{
case O_REG:
case O_MEM:
case O_SMEM:
{
// if register is RSP 'contaminated', it prevents us from using that to do retjmps
uint32_t nMask = RegToBit(O2.index);
if(nRspMask & nMask)
{
nRspMask |= RegToBit(reg);
}
}
default:
break;
}
break;
}
case O_MEM:
case O_SMEM:
{
uint32_t reg = I.ops[0].index;
if(nRspMask & RegToBit(reg))
{
uprintf("found contaminated reg at +%lld\n", (long long)I.addr);
*pRetSafe = 0;
}
break;
}
}
nRegsWrittenInstr[i] = nRegsWritten;
for(int j = 0; j < 4; ++j)
{
auto& O = I.ops[j];
switch(O.type)
{
case O_REG:
case O_SMEM:
case O_MEM:
{
if(O.index == R_RIP)
{
if(j != 1)
{
uprintf("found non base reference of rip. fail\n");
BREAK_ON_PATCH_FAIL();
return false;
}
if(I.dispSize != 0x20 && I.dispSize != 0x10)
{
uprintf("found offset size != 32 && != 16 bit. not implemented\n");
BREAK_ON_PATCH_FAIL();
return false;
}
rip[i] = 1;
nTrunkUsage += Align16(O.size / 8);
if(nTrunkUsage > nTrunkSize)
{
uprintf("overuse of trunk %lld\n", (long long)nTrunkUsage);
BREAK_ON_PATCH_FAIL();
return false;
}
}
break;
}
}
}
if(rip[i])
{
if(I.ops[0].type != O_REG)
{
uprintf("arg 0 should be O_REG, fail\n");
BREAK_ON_PATCH_FAIL();
return false;
}
if(I.ops[1].type != O_SMEM)
{
uprintf("arg 1 should be O_SMEM, fail was %d\n", O_SMEM);
BREAK_ON_PATCH_FAIL();
return false;
}
}
int fc = META_GET_FC(Instructions[i].meta);
switch(fc)
{
case FC_CALL:
{
break;
}
case FC_RET:
case FC_SYS:
case FC_UNC_BRANCH:
case FC_CND_BRANCH:
uprintf("found branch inst %d :: %d\n", fc, offset);
BREAK_ON_PATCH_FAIL();
return false;
}
offset += Instructions[i].size;
offsets[i + 1] = offset;
if(offset >= nLimit)
{
nInstructions = i + 1;
break;
}
}
if(nTrunkUsage > nTrunkSize)
{
uprintf("function using too much trunk space\n");
BREAK_ON_PATCH_FAIL();
return false;
}
if(offset < nLimit)
{
uprintf("function only had %d bytes of %d\n", offset, nLimit);
BREAK_ON_PATCH_FAIL();
return false;
}
if(0 == *pRetSafe && 0 == (nUsableJumpRegs & ~nRegsWritten))
{
// if ret jump is unsafe all of the usable jump regs are taken, fail.
uprintf("cannot patch function without breaking code]\n");
BREAK_ON_PATCH_FAIL();
MP_BREAK();
return false;
}
// MP_BREAK();
*pRegsWritten = nRegsWritten;
uint8_t* d = (uint8_t*)pDest;
uint8_t* dend = d + nMaxSize;
const uint8_t* s = (const uint8_t*)pSrc;
nTrunkUsage = 0;
for(i = 0; i < nInstructions; ++i)
{
auto& I = Instructions[i];
unsigned size = Instructions[i].size;
if(I.opcode == I_CALL)
{
// find reg
uint32_t nRegsWritten = nRegsWrittenInstr[i];
uint32_t nUsable = nUsableRegisters & ~nRegsWritten;
MP_ASSERT(nUsable);
int r = R_RAX;
while(0 == (1 & nUsable))
{
nUsable >>= 1;
r++;
}
intptr_t p = offsets[i + 1];
p += (intptr_t)pSrc;
p += I.imm.sdword;
d = MicroProfileInsertMov(d, dend, r, p);
d = MicroProfileInsertCall(d, dend, r);
s += size;
}
else if(rip[i])
{
if(I.opcode == I_LEA)
{
if(I.ops[0].type != O_REG)
{
MP_BREAK();
}
if(I.ops[1].index != R_RIP)
{
MP_BREAK();
}
int reg = I.ops[0].index - R_RAX;
int large = I.ops[0].index >= R_R8 ? 1 : 0;
*d++ = large ? 0x49 : 0x48;
*d++ = 0xb8 + (reg - (large ? (R_R8 - R_RAX) : 0));
// calculate the offset
int64_t offset = offsets[i + 1] + I.disp;
intptr_t base = (intptr_t)pSrc;
intptr_t sum = base + offset;
intptr_t* pAddress = (intptr_t*)d;
pAddress[0] = sum;
s += size;
d += 10;
d = (uint8_t*)(pAddress + 1);
}
else
{
if(15 & (intptr_t)pTrunk)
{
MP_BREAK();
}
intptr_t t = (intptr_t)pTrunk;
t = (t + 15) & ~15;
pTrunk = (char*)t;
auto& O = I.ops[1];
uint32_t Op1Size = O.size / 8;
memcpy(d, s, size);
int32_t DispOriginal = (int32_t)I.disp;
const uint8_t* pOriginal = (s + size) + DispOriginal;
intptr_t DispNew = ((uint8_t*)pTrunk - (d + size));
if(!((intptr_t)pTrunk + Op1Size <= (intptr_t)pTrunkEnd))
{
MP_BREAK();
}
memcpy(pTrunk, pOriginal, Op1Size);
pTrunk += Align16(Op1Size);
if(I.dispSize == 32)
{
int32_t off = (int32_t)DispNew;
if(DispNew > 0x7fffffff || DispNew < 0)
{
MP_BREAK();
}
memcpy(d + size - 4, &off, 4);
}
else if(I.dispSize == 16)
{
int16_t off = (int16_t)DispNew;
if(DispNew > 0x7fff || DispNew < 0)
{
MP_BREAK();
}
memcpy(d + size - 2, &off, 2);
}
d += size;
s += size;
}
}
else
{
memcpy(d, s, size);
d += size;
s += size;
}
}
*pBytesDest = (int)(d - (uint8_t*)pDest);
return true;
}
extern "C" void MicroProfileInterceptEnter(int a)
{
MicroProfileToken T = S.DynamicTokens[a];
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog2();
MP_ASSERT(pLog->nStackScope < MICROPROFILE_STACK_MAX); // if youre hitting this assert your instrumenting a deeply nested function
MicroProfileScopeStateC* pScopeState = &pLog->ScopeState[pLog->nStackScope++];
pScopeState->Token = T;
if(T)
{
pScopeState->nTick = MicroProfileEnterInternal(T);
}
else
{
pScopeState->nTick = MICROPROFILE_INVALID_TICK;
}
}
extern "C" void MicroProfileInterceptLeave(int a)
{
MicroProfileThreadLog* pLog = MicroProfileGetThreadLog2();
MP_ASSERT(pLog->nStackScope > 0); // if youre hitting this assert you probably have mismatched _ENTER/_LEAVE markers
MicroProfileScopeStateC* pScopeState = &pLog->ScopeState[--pLog->nStackScope];
MicroProfileLeaveInternal(pScopeState->Token, pScopeState->nTick);
}
bool MicroProfileInstrumentFromAddressOnly(void* pFunction)
{
MicroProfileSymbolDesc* pDesc = MicroProfileSymbolFindFuction(pFunction);
if(pDesc)
{
uprintf("Found function %p :: %s %s\n", (void*)pDesc->nAddress, pDesc->pName, pDesc->pShortName);
uint32_t nColor = MicroProfileColorFromString(pDesc->pName);
return MicroProfileInstrumentFunction(pFunction, MicroProfileSymbolModuleGetString(pDesc->nModule), pDesc->pName, nColor);
}
else
{
uprintf("No Function Found %p\n", pFunction);
return false;
}
}
template <typename CB>
void MicroProfileInstrumentScanForFunctionCalls(CB Callback, void* pFunction, size_t nFunctionSize)
{
pFunction = MicroProfileX64FollowJump(pFunction);
const intptr_t nCodeLen = nFunctionSize;
const uint32_t nMaxInstructions = 15;
intptr_t nOffset = 0;
_DecodeType dt = Decode64Bits;
_DInst Instructions[15];
_CodeInfo ci;
do
{
ci.code = nOffset + (uint8_t*)pFunction;
ci.codeLen = nCodeLen - nOffset;
ci.codeOffset = 0;
ci.dt = dt;
ci.features = DF_RETURN_FC_ONLY;
uint32_t nCount = 0;
uint32_t nOffsetNext = 0;
int r = distorm_decompose(&ci, Instructions, nMaxInstructions, &nCount);
// uprintf("decomposed %d\n", nCount);
if(r != DECRES_SUCCESS && r != DECRES_MEMORYERR)
{
BREAK_ON_PATCH_FAIL();
return;
}
if(nCount == 0)
{
// no instructions left
break;
}
// uprintf("instructions decoded %d %p ::\n", nCount, pFunction);
for(int i = 0; i < (int)nCount; ++i)
{
// rip[i] = 0;
auto& I = Instructions[i];
// bool bHasRipReference = false;
if(I.addr < nOffsetNext)
{
MP_BREAK();
}
nOffsetNext = I.addr + I.size;
if(I.opcode == I_CALL)
{
auto& O = I.ops[0];
if(O.type != O_PC || O.size != 0x20)
{
uprintf("non immediate call encountered. cannot follow\n");
BREAK_ON_PATCH_FAIL();
continue;
}
intptr_t pDst = nOffset + (intptr_t)pFunction;
pDst += I.addr;
pDst += I.size;
pDst += I.imm.sdword;
void* fFun1 = MicroProfileX64FollowJump((void*)pDst);
Callback(fFun1);
}
}
nOffset += nOffsetNext;
} while(nOffset < nCodeLen);
}
void MicroProfileInstrumentFunctionsCalled(void* pFunction, const char* pModuleName, const char* pFunctionName, int nMinBytes, int nMaxCalls)
{
pFunction = MicroProfileX64FollowJump(pFunction);
MicroProfileSymbolDesc* pDesc = MicroProfileSymbolFindFuction(pFunction);
if(pDesc)
{
uprintf("instrumenting child functions %p %p :: %s :: %s\n", (void*)pDesc->nAddress, (void*)pDesc->nAddressEnd, pDesc->pName, pDesc->pShortName);
int a = 0;
(void)a;
}
else
{
uprintf("could not find symbol info\n");
return;
}
const intptr_t nCodeLen = (intptr_t)pDesc->nAddressEnd - (intptr_t)pDesc->nAddress;
MicroProfilePatchBeginSuspend();
int NumFunctionsInstrumented = 0;
auto Callback = [&NumFunctionsInstrumented, nMinBytes, nMaxCalls](void* pFunc)
{
MicroProfileSymbolDesc* pDesc = MicroProfileSymbolFindFuction(pFunc);
if(!pDesc)
return;
const char* pName = pDesc ? pDesc->pName : "??";
intptr_t Size = pDesc->nAddressEnd - pDesc->nAddress;
if(nMinBytes == 0 || Size >= nMinBytes)
{
if(0 == nMaxCalls || NumFunctionsInstrumented < nMaxCalls)
{
uprintf("** func Instrumented, count %d, size %d %s\n", NumFunctionsInstrumented, Size, pName);
if(MicroProfileInstrumentFromAddressOnly(pFunc))
{
++NumFunctionsInstrumented;
}
}
else
{
uprintf("** func Skipped, count %d>=%d :: %s\n", NumFunctionsInstrumented, nMaxCalls, pName);
}
}
else
{
uprintf("** func Skipped, Size %d<%d :: %s\n", Size, nMinBytes, pName);
}
};
MicroProfileInstrumentScanForFunctionCalls(Callback, pFunction, nCodeLen);
MicroProfilePatchEndSuspend();
}
bool MicroProfileInstrumentFunction(void* pFunction, const char* pModuleName, const char* pFunctionName, uint32_t nColor)
{
MicroProfilePatchBeginSuspend();
struct ScopeExit
{
~ScopeExit()
{
MicroProfilePatchEndSuspend();
}
} dummy;
MicroProfilePatchError Err;
if(S.DynamicTokenIndex == MICROPROFILE_MAX_DYNAMIC_TOKENS)
{
uprintf("instrument failing, out of dynamic tokens %d\n", S.DynamicTokenIndex);
return false;
}
for(uint32_t i = 0; i < S.DynamicTokenIndex; ++i)
{
if(S.FunctionsInstrumented[i] == pFunction)
{
uprintf("function %p already instrumented\n", pFunction);
return false;
}
}
if(MicroProfilePatchFunction(pFunction, S.DynamicTokenIndex, MicroProfileInterceptEnter, MicroProfileInterceptLeave, &Err))
{
MicroProfileToken Tok = S.DynamicTokens[S.DynamicTokenIndex] = MicroProfileGetToken("PATCHED", pFunctionName, nColor, MicroProfileTokenTypeCpu, 0);
S.FunctionsInstrumented[S.DynamicTokenIndex] = pFunction;
S.FunctionsInstrumentedName[S.DynamicTokenIndex] = MicroProfileStringIntern(pFunctionName);
S.FunctionsInstrumentedModuleNames[S.DynamicTokenIndex] = MicroProfileStringIntern(pModuleName);
S.DynamicTokenIndex++;
uint16_t nGroup = MicroProfileGetGroupIndex(Tok);
if(!MicroProfileGroupActive(nGroup))
{
MicroProfileGroupSetEnabled(nGroup);
}
#if MICROPROFILE_WEBSERVER
MicroProfileWebSocketToggleTimer(MicroProfileGetTimerIndex(Tok));
#endif
return false;
}
else
{
bool bFound = false;
for(int i = 0; i < S.nNumPatchErrors; ++i)
{
if(Err.nCodeSize == S.PatchErrors[i].nCodeSize && 0 == memcmp(Err.Code, S.PatchErrors[i].Code, Err.nCodeSize))
{
bFound = true;
break;
}
}
if(!bFound && S.nNumPatchErrors < MICROPROFILE_MAX_PATCH_ERRORS)
{
memcpy(&S.PatchErrors[S.nNumPatchErrors++], &Err, sizeof(Err));
}
bFound = false;
for(int i = 0; i < S.nNumPatchErrorFunctions; ++i)
{
if(0 == strcmp(pFunctionName, S.PatchErrorFunctionNames[i]))
{
bFound = true;
}
}
if(!bFound && S.nNumPatchErrorFunctions < MICROPROFILE_MAX_PATCH_ERRORS)
{
S.PatchErrorFunctionNames[S.nNumPatchErrorFunctions++] = pFunctionName;
}
uprintf("interception fail!!\n");
return false;
}
}
void MicroProfileInstrumentPreInit();
void MicroProfileSymbolInitializeInternal();
void MicroProfileSymbolFreeDataInternal();
void MicroProfileSymbolKickThread();
void MicroProfileQueryJoinThread();
bool MicroProfileSymbolInitialize(bool bStartLoad, const char* pModuleName)
{
if(!bStartLoad)
return S.SymbolState.nModuleLoadsFinished.load() != 0;
// int nRequests = 0;
{
MicroProfileScopeLock L(MicroProfileMutex());
for(int i = 0; i < S.SymbolNumModules; ++i)
{
if(0 == pModuleName || 0 == strcmp(pModuleName, (const char*)S.SymbolModules[i].pBaseString))
{
if(0 == S.SymbolModules[i].nModuleLoadRequested.exchange(1))
{
S.SymbolState.nModuleLoadsRequested.fetch_add(1);
}
}
}
}
// todo: unload modules
MicroProfileSymbolKickThread();
return S.SymbolState.nModuleLoadsRequested.load() == S.SymbolState.nModuleLoadsFinished.load();
// if(S.SymbolState.nState == MICROPROFILE_SYMBOLSTATE_DEFAULT)
// {
// if(!bStartLoad)
// return false;
// {
// MicroProfileScopeLock L(MicroProfileMutex());
// S.SymbolState.nState.store(MICROPROFILE_SYMBOLSTATE_LOADING);
// S.SymbolState.nSymbolsLoaded.store(0);
// }
// MicroProfileSymbolKickThread();
// return false;
// }
// if(nRequests)
// {
// }
// if(S.SymbolState.nState.load() == MICROPROFILE_SYMBOLSTATE_DONE)
// {
// MicroProfileQueryJoinThread();
// }
// if(S.SymbolState.nState == MICROPROFILE_SYMBOLSTATE_DONE && bStartLoad)
// {
// MicroProfileSymbolFreeDataInternal();
// {
// MicroProfileScopeLock L(MicroProfileMutex());
// S.SymbolState.nState.store(MICROPROFILE_SYMBOLSTATE_LOADING);
// S.SymbolState.nSymbolsLoaded.store(0);
// }
// MicroProfileSymbolKickThread();
// return false;
// }
// else
// {
// return S.SymbolState.nState == MICROPROFILE_SYMBOLSTATE_DONE;
// }
}
void MicroProfileSymbolFreeDataInternal()
{
{
uprintf("todod;....\n");
MP_BREAK();
// MP_ASSERT(S.SymbolState.nState == MICROPROFILE_SYMBOLSTATE_DONE);
S.nNumPatchErrorFunctions = 0;
memset(S.PatchErrorFunctionNames, 0, sizeof(S.PatchErrorFunctionNames));
for(int i = 0; i < S.SymbolNumModules; ++i)
{
while(S.SymbolModules[i].pSymbolBlock)
{
MicroProfileSymbolBlock* pBlock = S.SymbolModules[i].pSymbolBlock;
S.SymbolModules[i].pSymbolBlock = pBlock->pNext;
MP_FREE(pBlock);
MICROPROFILE_COUNTER_SUB("/MicroProfile/Symbols/Allocs", 1);
MICROPROFILE_COUNTER_SUB("/MicroProfile/Symbols/Memory", sizeof(MicroProfileSymbolBlock));
}
}
memset(&S.SymbolModules[0], 0, sizeof(S.SymbolModules));
memset(&S.SymbolModuleNameBuffer[0], 0, sizeof(S.SymbolModuleNameBuffer));
S.SymbolModuleNameOffset = 0;
S.SymbolNumModules = 0;
}
}
#if STRING_MATCH_SIZE == 64
int MicroProfileCharacterMaskCharIndex(char c)
{
if(c >= 'A' && c <= 'Z')
c = 'a' + (c - 'A');
// abcdefghijklmnopqrstuvwxyz
if(c >= 'a' && c <= 'z')
{
int b = c - 'a';
return b;
}
if(c >= '0' && c <= '9')
{
int b = c - '0';
return b + 26;
}
switch(c)
{
case ':':
return 37;
case ';':
return 38;
case '\\':
return 39;
case '\'':
return 40;
case '\"':
return 41;
case '/':
return 42;
case '{':
return 43;
case '}':
return 44;
case '(':
return 45;
case ')':
return 46;
case '[':
return 47;
case ']':
return 48;
case '<':
return 49;
case '>':
return 50;
case '.':
return 51;
case ',':
return 52; // special characters
case ' ':
return -1; // special characters
}
return 63;
}
uint64_t MicroProfileCharacterMaskChar(char c)
{
uint64_t nMask = 1;
int nIndex = MicroProfileCharacterMaskCharIndex(c);
if(nIndex == -1)
return 0;
return nMask << nIndex;
}
#else
uint32_t MicroProfileCharacterMaskChar(char c)
{
if(c >= 'A' && c <= 'Z')
c = 'a' + (c - 'A');
// abcdefghijklmnopqrstuvwxyz
if(c >= 'a' && c <= 'z')
{
int b = c - 'a';
b = MicroProfileMin(20, b); // squish the last together
// static int once = 0;
// if(0 == once)
//{
// for(int i = 20; i < 28; ++i)
// {
// uprintf("char %d is %c\n", i, (char)('a' + i));
// }
// once = 1;
//}
uint32_t v = 1;
return v << b;
}
if(c >= '0' && c <= '9')
{
int b = c - '0';
b += 21;
if(b < 21 || b > 30)
MP_BREAK();
return 1 << b;
}
switch(c)
{
case ':':
case ';':
case '\\':
case '\'':
case '\"':
case '/':
case '{':
case '}':
case '(':
case ')':
case '[':
case ']':
return 1u << 31; // special characters
case ' ':
return 0;
}
return 0;
}
int MicroProfileCharacterMaskCharIndex(char c)
{
if(c >= 'A' && c <= 'Z')
c = 'a' + (c - 'A');
// abcdefghijklmnopqrstuvwxyz
if(c >= 'a' && c <= 'z')
{
int b = c - 'a';
b = MicroProfileMin(20, b); // squish the last together
static int once = 0;
if(0 == once)
{
for(int i = 20; i < 28; ++i)
{
uprintf("char %d is %c\n", i, (char)('a' + i));
}
once = 1;
}
return b;
}
if(c >= '0' && c <= '9')
{
int b = c - '0';
b += 21;
if(b < 21 || b > 30)
MP_BREAK();
return b;
}
switch(c)
{
case ':':
case ';':
case '\\':
case '\'':
case '\"':
case '/':
case '{':
case '}':
case '(':
case ')':
case '[':
case ']':
return 31; // special characters
case ' ':
return -1;
}
return 1;
}
#endif
uint_string_match MicroProfileCharacterMaskString(const char* pStr)
{
uint_string_match nMask = 0;
char c = 0;
while(0 != (c = *pStr++))
{
nMask |= MicroProfileCharacterMaskChar(c);
}
return nMask;
}
void MicroProfileCharacterMaskString2(const char* pStr, MicroProfileStringMatchMask& M)
{
uint_string_match nMask = 0;
char c = 0;
int nLast = -1;
while(0 != (c = *pStr++))
{
nMask |= MicroProfileCharacterMaskChar(c);
int nIndex = MicroProfileCharacterMaskCharIndex(c);
if(nIndex >= 0 && nLast >= 0)
{
MP_ASSERT(nIndex < STRING_MATCH_SIZE);
M.M[nLast] |= 1llu << nIndex;
}
nLast = nIndex;
}
M.nMask |= nMask;
}
bool MicroProfileCharacterMatch(const MicroProfileStringMatchMask& Block, const MicroProfileStringMatchMask& String)
{
if(String.nMask != (Block.nMask & String.nMask))
return false;
for(uint32_t i = 0; i < STRING_MATCH_SIZE; ++i)
{
if(String.M[i] != (Block.M[i] & String.M[i]))
return false;
}
return true;
}
uint32_t MicroProfileSymbolGetModule(const char* pString, intptr_t nBaseAddr)
{
for(int i = 0; i < S.SymbolNumModules; ++i)
{
auto& M = S.SymbolModules[i];
for(int j = 0; j < M.nNumExecutableRegions; ++j)
{
if(M.Regions[j].nBegin <= nBaseAddr && nBaseAddr < M.Regions[j].nEnd)
return i;
}
}
MP_BREAK(); // should never happen.
return 0;
}
void MicroProfileSymbolMergeExecutableRegions()
{
for(int i = 0; i < S.SymbolNumModules; ++i)
{
auto& M = S.SymbolModules[i];
if(M.nNumExecutableRegions > 1)
{
std::sort(&M.Regions[0], &M.Regions[M.nNumExecutableRegions], [](const MicroProfileSymbolModuleRegion& l, const MicroProfileSymbolModuleRegion& r) { return l.nBegin < r.nBegin; });
int p = 0;
int g = 1;
while(g < M.nNumExecutableRegions)
{
if(M.Regions[p].nEnd == M.Regions[g].nBegin)
{
M.Regions[p].nEnd = M.Regions[g].nEnd;
g++;
}
else
{
++p;
if(p != g)
M.Regions[p] = M.Regions[g];
g++;
}
}
M.nNumExecutableRegions = p + 1;
}
}
for(int i = 0; i < S.SymbolNumModules; ++i)
{
auto& M = S.SymbolModules[i];
uprintf("region %s %s\n", M.pTrimmedString, M.pBaseString);
for(int j = 0; j < M.nNumExecutableRegions; ++j)
uprintf("\t[%p-%p]\n", (void*)M.Regions[j].nBegin, (void*)M.Regions[j].nEnd);
}
}
uint32_t MicroProfileSymbolInitModule(const char* pString_, intptr_t nAddrBegin, intptr_t nAddrEnd)
{
const char* pString = MicroProfileStringInternSlash(pString_);
for(int i = 0; i < S.SymbolNumModules; ++i)
{
auto& M = S.SymbolModules[i];
for(int j = 0; j < M.nNumExecutableRegions; ++j)
{
if(M.Regions[j].nBegin <= nAddrBegin && nAddrEnd < M.Regions[j].nEnd)
{
MP_ASSERT(pString == M.pBaseString);
return i;
}
}
}
for(int i = 0; i < S.SymbolNumModules; ++i)
{
auto& M = S.SymbolModules[i];
if(M.pBaseString == pString)
{
MP_ASSERT((intptr_t)pString != -2);
for(int j = 0; j < M.nNumExecutableRegions; ++j)
if(nAddrBegin == M.Regions[j].nBegin)
return i;
if(M.nNumExecutableRegions == MICROPROFILE_MAX_MODULE_EXEC_REGIONS)
{
return (uint32_t)-1;
}
M.Regions[M.nNumExecutableRegions].nBegin = nAddrBegin;
M.Regions[M.nNumExecutableRegions].nEnd = nAddrEnd;
// uprintf("added module region %d %p %p %s \n", M.nNumExecutableRegions, (void*)nAddrBegin, (void*)nAddrEnd, pString);
M.nNumExecutableRegions++;
return i;
}
}
MP_ASSERT((intptr_t)pString != -2);
// trim untill last path char
const char* pTrimmedString = pString;
const char* pWork = pTrimmedString;
bool bLastSeperator = false;
while(*pWork != '\0')
{
if(bLastSeperator)
pTrimmedString = pWork;
bLastSeperator = *pWork == '\\' || *pWork == '/';
pWork++;
}
int nLen = (int)strlen(pTrimmedString) + 1;
// uprintf("STRING '%s' :: trimmedstring %s . len %d\n", pString, pTrimmedString, nLen);
const char* pTrimmedIntern = MicroProfileStringIntern(pTrimmedString);
if(S.SymbolModuleNameOffset + nLen > MICROPROFILE_INSTRUMENT_MAX_MODULE_CHARS)
return 0;
memcpy(S.SymbolModuleNameOffset + &S.SymbolModuleNameBuffer[0], pTrimmedString, nLen);
MP_ASSERT(S.SymbolNumModules < MICROPROFILE_INSTRUMENT_MAX_MODULES);
S.SymbolModules[S.SymbolNumModules].nModuleBase = nAddrBegin;
S.SymbolModules[S.SymbolNumModules].nMatchOffset = 0;
S.SymbolModules[S.SymbolNumModules].nStringOffset = S.SymbolModuleNameOffset;
S.SymbolModules[S.SymbolNumModules].pBaseString = (const char*)pString;
S.SymbolModules[S.SymbolNumModules].pTrimmedString = pTrimmedIntern;
S.SymbolModules[S.SymbolNumModules].Regions[0].nBegin = nAddrBegin;
S.SymbolModules[S.SymbolNumModules].Regions[0].nEnd = nAddrEnd;
S.SymbolModules[S.SymbolNumModules].nNumExecutableRegions = 1;
S.SymbolModules[S.SymbolNumModules].bDownloading = false;
S.SymbolModules[S.SymbolNumModules].nProgress = 0;
S.SymbolModules[S.SymbolNumModules].nProgressTarget = 0;
S.SymbolModuleNameOffset += nLen;
return S.SymbolNumModules++;
}
const char* MicroProfileSymbolModuleGetString(uint32_t nIndex)
{
MP_ASSERT(S.SymbolNumModules > (int)nIndex);
return S.SymbolModules[nIndex].nStringOffset + &S.SymbolModuleNameBuffer[0];
}
bool MicroProfileSymbolIgnoreSymbol(const char* pName)
{
if(strstr(pName, "MicroProfile"))
{
#if MICROPROFILE_INSTRUMENT_MICROPROFILE == 0
return true;
#else
if(strstr(pName, "Log") || strstr(pName, "Scope") || strstr(pName, "Tick") || strstr(pName, "Enter") || strstr(pName, "Leave") || strstr(pName, "Thread") || strstr(pName, "Thread") ||
strstr(pName, "Mutex")) // just for debugging: skip these so we can play around with the sample projects
{
return true;
}
#endif
}
#ifdef _WIN32
if(pName[0] == '_' && pName[1] == '_')
return true;
if(strstr(pName, "__security_check_cookie") || strstr(pName, "_RTC_CheckStackVars") || strstr(pName, "__chkstk") || strstr(pName, "std::_Atomic") || strstr(pName, "_Init_thread_header") ||
strstr(pName, "_Init_thread_footer"))
{
return true;
}
#endif
return false;
}
void MicroProfileSymbolInitializeInternal()
{
uprintf("Starting load...\n");
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileSymbolInitialize", MP_CYAN);
auto AllocBlock = []() -> MicroProfileSymbolBlock*
{
MicroProfileSymbolBlock* pBlock = MP_ALLOC_OBJECT(MicroProfileSymbolBlock);
MICROPROFILE_COUNTER_ADD("/MicroProfile/Symbols/Allocs", 1);
MICROPROFILE_COUNTER_ADD("/MicroProfile/Symbols/Memory", sizeof(MicroProfileSymbolBlock));
MICROPROFILE_COUNTER_CONFIG_ONCE("/MicroProfile/Symbols/Memory", MICROPROFILE_COUNTER_FORMAT_BYTES, 0, 0);
memset(pBlock, 0, sizeof(MicroProfileSymbolBlock));
return pBlock;
};
auto SymbolCallback = [&](const char* pName, const char* pShortName, intptr_t nAddress, intptr_t nAddressEnd, uint32_t nModuleId)
{
MICROPROFILE_SCOPEI("microprofile", "SymbolCallback", MP_AUTO);
uint32_t nModule = nModuleId;
if(MicroProfileHashTableGetPtr(&S.SymbolModules[nModule].AddressToSymbol, (void*)nAddress))
{
return;
}
char Demangled[1024];
if(MicroProfileDemangleName(pName, Demangled, sizeof(Demangled)))
{
pName = &Demangled[0];
pShortName = &Demangled[0];
}
intptr_t delta = nAddressEnd - nAddress;
S.SymbolModules[nModule].nProgress = MicroProfileMax(delta, S.SymbolModules[nModule].nProgress);
S.nSymbolsDirty++;
int nIgnoreSymbol = MicroProfileSymbolIgnoreSymbol(pName) ? 1 : 0;
MicroProfileSymbolBlock* pActiveBlock = S.SymbolModules[nModule].pSymbolBlock;
if(!pActiveBlock)
{
pActiveBlock = AllocBlock();
pActiveBlock->pNext = S.SymbolModules[nModule].pSymbolBlock;
S.SymbolModules[nModule].pSymbolBlock = pActiveBlock;
}
if(pName == pShortName)
{
pShortName = 0;
}
uint32_t nLen = (uint32_t)strlen(pName) + 1;
if(nLen > MICROPROFILE_INSTRUMENT_SYMBOLNAME_MAXLEN)
nLen = MICROPROFILE_INSTRUMENT_SYMBOLNAME_MAXLEN;
uint32_t nLenShort = (uint32_t)(pShortName ? 1 + strlen(pShortName) : 0);
if(nLenShort && nLenShort > MICROPROFILE_INSTRUMENT_SYMBOLNAME_MAXLEN)
nLenShort = MICROPROFILE_INSTRUMENT_SYMBOLNAME_MAXLEN;
uint32_t S0 = sizeof(MicroProfileSymbolDesc) * pActiveBlock->nNumSymbols;
uint32_t S1 = pActiveBlock->nNumChars;
uint32_t S3 = nLenShort + nLen + sizeof(MicroProfileSymbolDesc) + 64;
if(S0 + S1 + S3 >= MicroProfileSymbolBlock::ESIZE)
{
MicroProfileSymbolBlock* pNewBlock = AllocBlock();
MP_ASSERT(pActiveBlock == S.SymbolModules[nModule].pSymbolBlock);
pNewBlock->pNext = pActiveBlock;
S.SymbolModules[nModule].pSymbolBlock = pNewBlock;
pActiveBlock = pNewBlock;
}
S0 = sizeof(MicroProfileSymbolDesc) * pActiveBlock->nNumSymbols;
S1 = pActiveBlock->nNumChars;
S3 = nLenShort + nLen + sizeof(MicroProfileSymbolDesc);
MP_ASSERT(S0 + S1 + S3 < MicroProfileSymbolBlock::ESIZE);
pActiveBlock->nNumChars += nLen;
char* pStr = &pActiveBlock->Chars[MicroProfileSymbolBlock::ESIZE - pActiveBlock->nNumChars - 1];
memcpy(pStr, pName, nLen);
pStr[nLen - 1] = '\0';
MicroProfileSymbolDesc& E = pActiveBlock->Symbols[pActiveBlock->nNumSymbols++];
MicroProfileHashTableSetPtr(&S.SymbolModules[nModule].AddressToSymbol, (void*)nAddress, &E);
E.pName = pStr;
E.nAddress = nAddress;
E.nAddressEnd = nAddressEnd;
E.nIgnoreSymbol = nIgnoreSymbol;
E.nModule = nModule;
if(pShortName && strlen(pShortName))
{
pActiveBlock->nNumChars += nLenShort;
char* pStrShort = &pActiveBlock->Chars[MicroProfileSymbolBlock::ESIZE - pActiveBlock->nNumChars - 1];
memcpy(pStrShort, pShortName, nLenShort);
pStrShort[nLenShort - 1] = '\0';
E.pShortName = pStrShort;
}
else
{
E.pShortName = E.pName;
}
#define SYMDBG 0
#if SYMDBG
uprintf("Got symbol %lld %lld %f .. %llx %llx %llx %s\n",
S.SymbolModules[nModule].nProgress,
S.SymbolModules[nModule].nProgressTarget,
S.SymbolModules[nModule].nProgressTarget ? float(S.SymbolModules[nModule].nProgress) / float(S.SymbolModules[nModule].nProgressTarget) : 0.f,
(int64_t)E.nAddress,
(int64_t)S.SymbolModules[nModule].nAddrBegin,
(int64_t)S.SymbolModules[nModule].nAddrEnd,
E.pName);
if(E.nAddress < (int64_t)S.SymbolModules[nModule].nAddrBegin || E.nAddress > (int64_t)S.SymbolModules[nModule].nAddrEnd)
{
MP_BREAK();
}
#endif
E.nMask = MicroProfileCharacterMaskString(E.pShortName);
MicroProfileCharacterMaskString2(E.pShortName, pActiveBlock->MatchMask);
pActiveBlock->nMask |= E.nMask;
MICROPROFILE_COUNTER_ADD("/MicroProfile/Symbols/Count", 1);
if(nIgnoreSymbol)
{
MICROPROFILE_COUNTER_ADD("/MicroProfile/Symbols/Ignored", 1);
}
#if SYMDBG
MicroProfileSleep(10);
#endif
#undef SYMDBG
S.SymbolModules[nModule].nSymbolsLoaded.fetch_add(1);
S.nSymbolsDirty.exchange(1);
S.SymbolState.nSymbolsLoaded.fetch_add(1);
MP_ASSERT((intptr_t)E.pShortName >= (intptr_t)&E); // assert pointer arithmetic is correct.
};
do
{
uint32_t nModuleLoad[MICROPROFILE_INSTRUMENT_MAX_MODULES];
uint32_t nNumModulesRequested = 0;
for(int i = 0; i < S.SymbolNumModules; ++i)
{
if(S.SymbolModules[i].nModuleLoadRequested.load() != 0 && S.SymbolModules[i].nModuleLoadFinished.load() == 0)
{
nModuleLoad[nNumModulesRequested] = i;
S.SymbolModules[i].nProgress = 0;
MicroProfileHashTableInit(&S.SymbolModules[i].AddressToSymbol, 256, 64, MicroProfileHashTableComparePtr, MicroProfileHashTableHashPtr);
nNumModulesRequested++;
}
}
if(0 == nNumModulesRequested)
{
break;
}
MicroProfileIterateSymbols(SymbolCallback, nModuleLoad, nNumModulesRequested);
S.SymbolState.nModuleLoadsFinished.fetch_add(nNumModulesRequested);
for(uint32_t i = 0; i < nNumModulesRequested; ++i)
{
if(S.SymbolModules[nModuleLoad[i]].nModuleLoadRequested.load() == S.SymbolModules[nModuleLoad[i]].nModuleLoadFinished.load())
{
S.SymbolModules[nModuleLoad[i]].nProgress = S.SymbolModules[nModuleLoad[i]].nProgressTarget;
S.nSymbolsDirty.exchange(1);
}
}
} while(1);
}
MicroProfileSymbolDesc* MicroProfileSymbolFindFuction(void* pAddress)
{
for(int i = 0; i < S.SymbolNumModules; ++i)
{
MicroProfileSymbolDesc* pDesc = nullptr;
if(MicroProfileHashTableGetPtr(&S.SymbolModules[i].AddressToSymbol, pAddress, &pDesc))
{
if(0 == pDesc->nIgnoreSymbol)
return pDesc;
else
return nullptr;
}
}
return nullptr;
}
#define MICROPROFILE_MAX_FILTER 32
#define MICROPROFILE_MAX_QUERY_RESULTS 32
#define MICROPROFILE_MAX_FILTER_STRING 1024
struct MicroProfileFunctionQuery
{
MicroProfileFunctionQuery* pNext;
uint32_t nState;
const char* pFilterStrings[MICROPROFILE_MAX_FILTER];
uint32_t nPatternLength[MICROPROFILE_MAX_FILTER];
int nMaxFilter;
uint32_t nModuleFilterMatch[MICROPROFILE_INSTRUMENT_MAX_MODULES]; // prematch the modules, so it can be skipped during search
uint32_t nMask[MICROPROFILE_MAX_FILTER]; // masks for subpatterns skipped
MicroProfileStringMatchMask MatchMask[MICROPROFILE_MAX_FILTER]; // masks for subpatterns skipped
// results
MicroProfileSymbolDesc* Results[MICROPROFILE_MAX_QUERY_RESULTS];
uint32_t nNumResults;
char FilterString[MICROPROFILE_MAX_FILTER_STRING];
uint32_t QueryId;
};
MicroProfileFunctionQuery* MicroProfileAllocFunctionQuery()
{
MicroProfileScopeLock L(MicroProfileMutex());
MicroProfileFunctionQuery* pQ = nullptr;
S.nNumQueryAllocated++;
if(S.pQueryFreeList != 0)
{
pQ = S.pQueryFreeList;
S.pQueryFreeList = pQ->pNext;
S.nNumQueryFree--;
}
else
{
pQ = MP_ALLOC_OBJECT(MicroProfileFunctionQuery);
MICROPROFILE_COUNTER_ADD("MicroProfile/Symbols/FunctionQuery", 1);
MICROPROFILE_COUNTER_ADD("MicroProfile/Symbols/FunctionQueryMem", sizeof(MicroProfileFunctionQuery));
S.nNumQueryAllocated++;
}
memset(pQ, 0, sizeof(MicroProfileFunctionQuery));
return pQ;
}
void MicroProfileFreeFunctionQuery(MicroProfileFunctionQuery* pQ)
{
pQ->pNext = S.pQueryFreeList;
S.pQueryFreeList = pQ;
}
void MicroProfileProcessQuery(MicroProfileFunctionQuery* pQuery)
{
MicroProfileFunctionQuery& Q = *pQuery;
int nBlocksTested = 0, nSymbolsTested = 0, nStringsTested = 0, nStringsTested0 = 0;
int nBlocks = 0;
// (void)nBlocksTested;
// (void)nSymbolsTested;
// (void)nStringsTested;
// (void)nStringsTested0;
// (void)nBlocks;
int64_t t = MP_TICK();
int64_t tt = 0;
for(int i = 0; i < S.SymbolNumModules; ++i)
{
int nModule = i;
uint32_t nModuleMatchOffset = Q.nModuleFilterMatch[nModule];
MicroProfileSymbolBlock* pSymbols = S.SymbolModules[nModule].pSymbolBlock;
uint32_t nMaskQ = Q.nMask[nModuleMatchOffset];
MicroProfileStringMatchMask& MatchMaskQ = Q.MatchMask[nModuleMatchOffset];
{
while(pSymbols && 0 == S.pPendingQuery && Q.nNumResults < MICROPROFILE_MAX_QUERY_RESULTS)
{
MICROPROFILE_SCOPEI("MicroProfile", "SymbolQueryLoop", MP_YELLOW);
nBlocks++;
if(MicroProfileCharacterMatch(pSymbols->MatchMask, MatchMaskQ))
{
nBlocksTested++;
for(uint32_t i = 0; i < pSymbols->nNumSymbols && 0 == S.pPendingQuery && Q.nNumResults < MICROPROFILE_MAX_QUERY_RESULTS; ++i)
{
MicroProfileSymbolDesc& E = pSymbols->Symbols[i];
if(0 == E.nIgnoreSymbol)
{
nSymbolsTested++;
if(nMaskQ == (nMaskQ & E.nMask))
{
nStringsTested++;
MP_ASSERT((int)E.nModule < S.SymbolNumModules);
if(MicroProfileStringMatch(E.pShortName, nModuleMatchOffset, &Q.pFilterStrings[0], Q.nPatternLength, Q.nMaxFilter))
{
if(Q.nNumResults < MICROPROFILE_MAX_QUERY_RESULTS)
{
Q.Results[Q.nNumResults++] = &E;
if(Q.nNumResults == MICROPROFILE_MAX_QUERY_RESULTS)
tt = MP_TICK();
}
}
if(Q.nNumResults < MICROPROFILE_MAX_QUERY_RESULTS)
nStringsTested0++;
}
}
}
}
pSymbols = pSymbols->pNext;
}
}
}
int64_t tend = MP_TICK();
float ToMS = MicroProfileTickToMsMultiplierCpu();
float TIME = (tend - t) * ToMS;
float TIME0 = (tt - t) * ToMS;
uprintf(" %6.3fms [%6.3f]: %5d/%5d blocks tested. %5d symbols %5d/%5d string compares\n", TIME, TIME0, nBlocksTested, nBlocks, nSymbolsTested, nStringsTested, nStringsTested0);
}
void* MicroProfileQueryThread(void* p)
{
MicroProfileOnThreadCreate("MicroProfileSymbolThread");
{
while(1)
{
MicroProfileSleep(100); // todo:: use an event instead
MicroProfileScopeLock L(MicroProfileMutex());
if(S.pPendingQuery != nullptr)
{
MICROPROFILE_SCOPEI("MicroProfile", "SymbolQuery", MP_WHEAT);
MicroProfileFunctionQuery* pQuery = S.pPendingQuery;
MP_ASSERT(pQuery->QueryId > S.nQueryProcessed);
S.pPendingQuery = 0;
L.Unlock();
// uprintf("processing query %d\n", pQuery->QueryId);
MicroProfileProcessQuery(pQuery);
L.Lock();
S.nQueryProcessed = MicroProfileMax(pQuery->QueryId, S.nQueryProcessed);
pQuery->pNext = S.pFinishedQuery;
S.pFinishedQuery = pQuery;
}
if(S.SymbolState.nModuleLoadsRequested.load() != S.SymbolState.nModuleLoadsFinished.load())
{
L.Unlock();
MicroProfileSymbolInitializeInternal();
L.Lock();
}
}
S.SymbolThreadFinished = 1;
}
MicroProfileOnThreadExit();
return 0;
}
void MicroProfileQueryJoinThread()
{
if(S.SymbolThreadFinished)
{
MicroProfileThreadJoin(&S.SymbolThread);
S.SymbolThreadFinished = 0;
S.SymbolThreadRunning = 0;
}
}
void MicroProfileSymbolKickThread()
{
// MicroProfileQueryJoinThread();
if(S.SymbolThreadRunning == 0)
{
S.SymbolThreadRunning = 1;
MicroProfileThreadStart(&S.SymbolThread, MicroProfileQueryThread);
}
}
#if MICROPROFILE_WEBSERVER
void MicroProfileSymbolSendFunctionNames(MpSocket Connection)
{
if(S.WSFunctionsInstrumentedSent < S.DynamicTokenIndex)
{
MicroProfileWSPrintStart(Connection);
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":[", MSG_FUNCTION_NAMES);
bool bFirst = true;
for(uint32_t i = S.WSFunctionsInstrumentedSent; i < S.DynamicTokenIndex; ++i)
{
const char* pString = S.FunctionsInstrumentedName[i];
const char* pModuleString = S.FunctionsInstrumentedModuleNames[i];
MicroProfileWSPrintf(bFirst ? "[\"%s\",\"%s\",\"%s\"]" : ",[\"%s\",\"%s\",\"%s\"]", pString, pModuleString, "unused");
bFirst = false;
}
MicroProfileWSPrintf("]}");
MicroProfileWSFlush();
MicroProfileWSPrintEnd();
S.WSFunctionsInstrumentedSent = S.DynamicTokenIndex;
}
}
void MicroProfileSymbolSendErrors(MpSocket Connection)
{
if(S.nNumPatchErrors)
{
MicroProfileWSPrintStart(Connection);
MicroProfileWSPrintf("{\"k\":\"%d\",\"v\":{\"version\":\"%d.%d\",\"data\":[", MSG_INSTRUMENT_ERROR, MICROPROFILE_MAJOR_VERSION, MICROPROFILE_MINOR_VERSION);
bool bFirst = true;
for(int i = 0; i < S.nNumPatchErrors; ++i)
{
MicroProfilePatchError& E = S.PatchErrors[i];
(void)E;
if(!bFirst)
MicroProfileWSPrintf(",");
MicroProfileWSPrintf("{\"code\":\"");
for(int i = 0; i < E.nCodeSize; ++i)
MicroProfileWSPrintf("%02x", E.Code[i] & 0xff);
MicroProfileWSPrintf("\",\"message\":\"%s\",\"already\":%d}", &E.Message[0], E.AlreadyInstrumented);
bFirst = false;
}
MicroProfileWSPrintf("],\"functions\":[");
bFirst = true;
for(int i = 0; i < S.nNumPatchErrorFunctions; ++i)
{
if(!bFirst)
MicroProfileWSPrintf(",");
MicroProfileWSPrintf("\"%s\"", S.PatchErrorFunctionNames[i]);
bFirst = false;
}
MicroProfileWSPrintf("]}}");
MicroProfileWSFlush();
MicroProfileWSPrintEnd();
S.nNumPatchErrors = 0;
S.nNumPatchErrorFunctions = 0;
}
}
void MicroProfileSymbolQuerySendResult(MpSocket Connection)
{
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileSymbolQuerySendResult", MP_PINK2);
MicroProfileFunctionQuery* pQuery = 0;
{
MicroProfileScopeLock L(MicroProfileMutex());
uint32_t nBest = 0;
while(S.pFinishedQuery != nullptr)
{
if(!pQuery)
{
pQuery = S.pFinishedQuery;
nBest = pQuery->QueryId;
S.pFinishedQuery = pQuery->pNext;
}
else
{
MicroProfileFunctionQuery* pQ = S.pFinishedQuery;
S.pFinishedQuery = pQ->pNext;
if(pQ->QueryId > nBest)
{
MicroProfileFreeFunctionQuery(pQuery);
nBest = pQ->QueryId;
pQuery = pQ;
}
else
{
MicroProfileFreeFunctionQuery(pQ);
}
}
}
}
if(pQuery)
{
uprintf("Sending result for query %d\n", pQuery->QueryId);
MicroProfileWSPrintStart(Connection);
MicroProfileWSPrintf("{\"k\":\"%d\",\"q\":%d,\"v\":[", MSG_FUNCTION_RESULTS, pQuery->QueryId);
bool bFirst = true;
for(uint32_t i = 0; i < pQuery->nNumResults; ++i)
{
MicroProfileSymbolDesc& E = *pQuery->Results[i];
if(bFirst)
{
MicroProfileWSPrintf("{\"a\":\"%p\",\"n\":\"%s\",\"sn\":\"%s\",\"m\":\"%s\"}", E.nAddress, E.pName, E.pShortName, MicroProfileSymbolModuleGetString(E.nModule));
bFirst = false;
}
else
{
MicroProfileWSPrintf(",{\"a\":\"%p\",\"n\":\"%s\",\"sn\":\"%s\",\"m\":\"%s\"}", E.nAddress, E.pName, E.pShortName, MicroProfileSymbolModuleGetString(E.nModule));
}
}
MicroProfileWSPrintf("]}");
MicroProfileWSFlush();
MicroProfileWSPrintEnd();
MicroProfileScopeLock L(MicroProfileMutex());
MicroProfileFreeFunctionQuery(pQuery);
}
}
#endif
void MicroProfileSymbolQueryFunctions(MpSocket Connection, const char* pFilter)
{
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileSymbolQueryFunctions", MP_WHEAT);
if(!MicroProfileSymbolInitialize(false))
{
return;
}
{
int QueryId = atoi(pFilter);
pFilter = strchr(pFilter, 'x');
pFilter++;
MicroProfileScopeLock L(MicroProfileMutex());
if(0 == S.pPendingQuery || S.pPendingQuery->QueryId < (uint32_t)QueryId)
{
MicroProfileFunctionQuery* pQuery = S.pPendingQuery;
if(!pQuery)
{
S.pPendingQuery = pQuery = MicroProfileAllocFunctionQuery();
}
MP_ASSERT(pQuery->pNext == 0);
memset(pQuery, 0, sizeof(*pQuery));
MicroProfileFunctionQuery& Q = *pQuery;
Q.QueryId = QueryId;
uint32_t nLen = (uint32_t)strlen(pFilter) + 1;
if(nLen >= MICROPROFILE_MAX_FILTER_STRING)
nLen = MICROPROFILE_MAX_FILTER_STRING - 1;
memcpy(Q.FilterString, pFilter, nLen);
Q.FilterString[nLen] = '\0';
char* pBuffer = Q.FilterString;
bool bStartString = true;
for(uint32_t i = 0; i < nLen; ++i)
{
char c = pBuffer[i];
if(c == '\0')
{
break;
}
if(isspace(c) || c == '*')
{
pBuffer[i] = '\0';
bStartString = true;
}
else
{
if(bStartString)
{
if(Q.nMaxFilter < MICROPROFILE_MAX_FILTER)
{
const char* pstr = &pBuffer[i];
Q.nMask[Q.nMaxFilter] = MicroProfileCharacterMaskString(pstr);
MicroProfileCharacterMaskString2(pstr, Q.MatchMask[Q.nMaxFilter]);
Q.pFilterStrings[Q.nMaxFilter++] = &pBuffer[i];
}
}
bStartString = false;
}
}
memset(Q.nModuleFilterMatch, 0xff, sizeof(Q.nModuleFilterMatch));
for(int i = 0; i < S.SymbolNumModules; ++i)
{
Q.nModuleFilterMatch[i] = MicroProfileStringMatchOffset(MicroProfileSymbolModuleGetString(i), Q.pFilterStrings, Q.nPatternLength, Q.nMaxFilter);
}
#if 0
uprintf("query %d::",QueryId);
for(int i = 0; i < Q.nMaxFilter; ++i)
{
Q.nPatternLength[i] = (uint32_t)strlen(Q.pFilterStrings[i]);
uprintf("'%s' ", Q.pFilterStrings[i]);
}
uprintf("\n");
#endif
}
}
MicroProfileSymbolKickThread();
}
#if defined(_WIN32)
// '##::::'##::'#######:::'#######::'##:::'##::::'##:::::'##:'####:'##::: ##::'#######:::'#######::
// ##:::: ##:'##.... ##:'##.... ##: ##::'##::::: ##:'##: ##:. ##:: ###:: ##:'##.... ##:'##.... ##:
// ##:::: ##: ##:::: ##: ##:::: ##: ##:'##:::::: ##: ##: ##:: ##:: ####: ##:..::::: ##:..::::: ##:
// #########: ##:::: ##: ##:::: ##: #####::::::: ##: ##: ##:: ##:: ## ## ##::'#######:::'#######::
// ##.... ##: ##:::: ##: ##:::: ##: ##. ##:::::: ##: ##: ##:: ##:: ##. ####::...... ##:'##::::::::
// ##:::: ##: ##:::: ##: ##:::: ##: ##:. ##::::: ##: ##: ##:: ##:: ##:. ###:'##:::: ##: ##::::::::
// ##:::: ##:. #######::. #######:: ##::. ##::::. ###. ###::'####: ##::. ##:. #######:: #########:
// ..:::::..:::.......::::.......:::..::::..::::::...::...:::....::..::::..:::.......:::.........::
#ifdef _WIN32
static void* MicroProfileAllocExecutableMemory(void* pBase, size_t s);
static void* MicroProfileAllocExecutableMemoryFar(size_t s);
static void MicroProfileMakeMemoryExecutable(void* p, size_t s);
static void MicroProfileMakeWriteable(void* p_, size_t size, DWORD* oldFlags);
static void MicroProfileRestore(void* p_, size_t size, DWORD* oldFlags);
extern "C" void microprofile_tramp_enter_patch();
extern "C" void microprofile_tramp_enter();
extern "C" void microprofile_tramp_code_begin();
extern "C" void microprofile_tramp_code_end();
extern "C" void microprofile_tramp_intercept0();
extern "C" void microprofile_tramp_end();
extern "C" void microprofile_tramp_exit();
extern "C" void microprofile_tramp_leave();
extern "C" void microprofile_tramp_trunk();
extern "C" void microprofile_tramp_call_patch_pop();
extern "C" void microprofile_tramp_call_patch_push();
bool MicroProfilePatchFunction(void* f, int Argument, MicroProfileHookFunc enter, MicroProfileHookFunc leave, MicroProfilePatchError* pError)
{
char* pOriginal = (char*)f;
f = MicroProfileX64FollowJump(f);
if(MicroProfilePatchHasSuspendedThread((intptr_t)f, (intptr_t)f + 32))
{
uprintf("failed to patch, thread running in patch position");
return false;
}
intptr_t t_enter = (intptr_t)microprofile_tramp_enter;
intptr_t t_enter_patch_offset = (intptr_t)microprofile_tramp_enter_patch - t_enter;
intptr_t t_code_begin_offset = (intptr_t)microprofile_tramp_code_begin - t_enter;
intptr_t t_code_end_offset = (intptr_t)microprofile_tramp_code_end - t_enter;
intptr_t t_code_intercept0_offset = (intptr_t)microprofile_tramp_intercept0 - t_enter;
intptr_t t_code_exit_offset = (intptr_t)microprofile_tramp_exit - t_enter;
intptr_t t_code_leave_offset = (intptr_t)microprofile_tramp_leave - t_enter;
intptr_t t_code_call_patch_push_offset = (intptr_t)microprofile_tramp_call_patch_push - t_enter;
intptr_t t_code_call_patch_pop_offset = (intptr_t)microprofile_tramp_call_patch_pop - t_enter;
intptr_t codemaxsize = t_code_end_offset - t_code_begin_offset;
intptr_t t_end_offset = (intptr_t)microprofile_tramp_end - t_enter;
intptr_t t_trunk_offset = (intptr_t)microprofile_tramp_trunk - t_enter;
int t_trunk_size = (int)((intptr_t)microprofile_tramp_end - (intptr_t)microprofile_tramp_trunk);
char* ptramp = (char*)MicroProfileAllocExecutableMemory(f, t_end_offset);
if(!ptramp)
ptramp = (char*)MicroProfileAllocExecutableMemoryFar(t_end_offset);
intptr_t offset = ((intptr_t)f + 6 - (intptr_t)ptramp);
uint32_t nBytesToCopy = 14;
if(offset < 0x80000000 && offset > -0x7fffffff)
{
/// offset is small enough to insert a relative jump
nBytesToCopy = 5;
}
memcpy(ptramp, (void*)t_enter, t_end_offset);
int nInstructionBytesDest = 0;
char* pInstructionMoveDest = ptramp + t_code_begin_offset;
char* pTrunk = ptramp + t_trunk_offset;
int nInstructionBytesSrc = 0;
uint32_t nRegsWritten = 0;
uint32_t nRetSafe = 1;
uint32_t nUsableJumpRegs = (1 << R_RAX) | (1 << R_R10) | (1 << R_R11);
static_assert(R_RAX == 0, "R_RAX must be 0");
if(!MicroProfileCopyInstructionBytes(
pInstructionMoveDest, f, nBytesToCopy, (int)codemaxsize, pTrunk, t_trunk_size, nUsableJumpRegs, &nInstructionBytesDest, &nInstructionBytesSrc, &nRegsWritten, &nRetSafe))
{
if(pError)
{
const char* pCode = (const char*)f;
memset(pError->Code, 0, sizeof(pError->Code));
memcpy(pError->Code, pCode, nInstructionBytesSrc);
int off = stbsp_snprintf(pError->Message, sizeof(pError->Message), "Failed to move %d code bytes ", nInstructionBytesSrc);
pError->nCodeSize = nInstructionBytesSrc;
for(int i = 0; i < nInstructionBytesSrc; ++i)
{
off += stbsp_snprintf(off + pError->Message, sizeof(pError->Message) - off, "%02x ", 0xff & pCode[i]);
}
uprintf("%s\n", pError->Message);
}
return false;
}
intptr_t phome = nInstructionBytesSrc + (intptr_t)f;
uint32_t reg = nUsableJumpRegs & ~nRegsWritten;
if(0 == reg)
{
if(0 == nRetSafe)
MP_BREAK(); // should be caught earlier
MicroProfileInsertRetJump(pInstructionMoveDest + nInstructionBytesDest, phome);
}
else
{
int r = R_RAX;
while((reg & 1) == 0)
{
reg >>= 1;
r++;
}
MicroProfileInsertRegisterJump(pInstructionMoveDest + nInstructionBytesDest, phome, r);
}
// PATCH 1 TRAMP EXIT
intptr_t microprofile_tramp_exit = (intptr_t)ptramp + t_code_exit_offset;
memcpy(ptramp + t_enter_patch_offset + 2, (void*)&microprofile_tramp_exit, 8);
char* pintercept = t_code_intercept0_offset + ptramp;
// PATCH 1.5 Argument
memcpy(pintercept - 4, (void*)&Argument, 4);
// PATCH 2 INTERCEPT0
intptr_t addr = (intptr_t)enter; //&intercept0;
memcpy(pintercept + 2, (void*)&addr, 8);
// PATHC 2.5 argument
memcpy(ptramp + t_code_exit_offset + 3, (void*)&Argument, 4);
intptr_t microprofile_tramp_leave = (intptr_t)ptramp + t_code_leave_offset;
// PATCH 3 INTERCEPT1
intptr_t addr1 = (intptr_t)leave; //&intercept1;
memcpy((char*)microprofile_tramp_leave + 2, (void*)&addr1, 8);
intptr_t patch_push_addr = (intptr_t)(&MicroProfile_Patch_TLS_PUSH);
intptr_t patch_pop_addr = (intptr_t)(&MicroProfile_Patch_TLS_POP);
memcpy((char*)ptramp + t_code_call_patch_push_offset + 2, &patch_push_addr, 8);
memcpy((char*)ptramp + t_code_call_patch_pop_offset + 2, &patch_pop_addr, 8);
MicroProfileMakeMemoryExecutable(ptramp, t_end_offset);
{
// PATCH 4 DEST FUNC
DWORD OldFlags[2] = { 0 };
MicroProfileMakeWriteable(f, nInstructionBytesSrc, OldFlags);
char* pp = (char*)f;
char* ppend = pp + nInstructionBytesSrc;
if(nInstructionBytesSrc < 14)
{
pp = MicroProfileInsertRelativeJump((char*)pp, (intptr_t)ptramp);
}
else
{
pp = MicroProfileInsertRegisterJump((char*)pp, (intptr_t)ptramp, R_RAX);
}
while(pp != ppend)
{
char c = (unsigned char)0x90;
MP_ASSERT((unsigned char)c == (unsigned char)0x90);
*pp++ = (unsigned char)0x90;
}
MicroProfileRestore(f, nInstructionBytesSrc, OldFlags);
}
return true;
}
static void MicroProfileMakeWriteable(void* p_, size_t s, DWORD* oldFlags)
{
static uint64_t nPageSize = 4 << 10;
intptr_t aligned = (intptr_t)p_;
aligned = (aligned & (~(nPageSize - 1)));
intptr_t aligned_end = (intptr_t)p_;
aligned_end += s;
aligned_end = (aligned_end + nPageSize - 1) & (~(nPageSize - 1));
uint32_t nNumPages = (uint32_t)((aligned_end - aligned) / nPageSize);
MP_ASSERT(nNumPages >= 1 && nNumPages <= 2);
for(uint32_t i = 0; i < nNumPages; ++i)
{
if(!VirtualProtect((void*)(aligned + nPageSize * i), nPageSize, PAGE_EXECUTE_READWRITE, oldFlags + i))
{
MP_BREAK();
}
}
//*(unsigned char*)p_ = 0x90;
}
static void MicroProfileRestore(void* p_, size_t s, DWORD* oldFlags)
{
static uint64_t nPageSize = 4 << 10;
intptr_t aligned = (intptr_t)p_;
aligned = (aligned & (~(nPageSize - 1)));
intptr_t aligned_end = (intptr_t)p_;
aligned_end += s;
aligned_end = (aligned_end + nPageSize - 1) & (~(nPageSize - 1));
uint32_t nNumPages = (uint32_t)((aligned_end - aligned) / nPageSize);
DWORD Dummy;
for(uint32_t i = 0; i < nNumPages; ++i)
{
if(!VirtualProtect((void*)(aligned + nPageSize * i), nPageSize, oldFlags[i], &Dummy))
{
MP_BREAK();
}
}
}
void* MicroProfileAllocExecutableMemoryUp(intptr_t nBase, size_t s, uint32_t RegionIndex)
{
SYSTEM_INFO si;
GetSystemInfo(&si);
size_t Granularity = si.dwAllocationGranularity << 1;
nBase = (nBase / Granularity) * Granularity;
intptr_t nEnd = nBase + 0x80000000;
for(uint32_t i = RegionIndex; i < S.MemoryRegions.Size; i++)
{
// try and allocate 2x before
nBase = S.MemoryRegions[i].Start + S.MemoryRegions[i].Size + Granularity;
nBase = (nBase / Granularity) * Granularity;
if(nBase >= nEnd)
break;
void* pMemory = VirtualAlloc((void*)nBase, s, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if(pMemory)
{
return pMemory;
}
}
return nullptr;
}
static void MicroProfileUpdateMemoryRegions()
{
MicroProfileArrayClear(S.MemoryRegions);
SYSTEM_INFO si;
GetSystemInfo(&si);
BYTE* Addr = (BYTE*)si.lpMinimumApplicationAddress;
BYTE* MaxAddr = (BYTE*)si.lpMaximumApplicationAddress;
// uprintf("updating memory regions\n");
uint32_t idx = 0;
(void)idx;
while(Addr < MaxAddr)
{
MEMORY_BASIC_INFORMATION mbi;
SIZE_T Result = VirtualQuery(Addr, &mbi, sizeof(mbi));
if(Result == 0)
break;
MicroProfileInstrumentMemoryRegion region;
region.Start = (intptr_t)mbi.BaseAddress;
region.Size = (intptr_t)mbi.RegionSize;
MicroProfileArrayPushBack(S.MemoryRegions, region);
// uprintf("Memory Region %d: %p(%p) %p .. State=%08x Protect=%08x Type=%08x\n", idx++, mbi.BaseAddress, mbi.AllocationBase, (intptr_t)mbi.BaseAddress + mbi.RegionSize, mbi.State, mbi.Protect,
// mbi.Type);
Addr = (BYTE*)mbi.BaseAddress + mbi.RegionSize;
}
uprintf("Iterated %d regions\n", S.MemoryRegions.Size);
}
static void* MicroProfileAllocExecutableMemoryDown(intptr_t nBase, size_t s, uint32_t RegionIndex)
{
SYSTEM_INFO si;
GetSystemInfo(&si);
size_t Granularity = si.dwAllocationGranularity << 1;
intptr_t nEnd = nBase - 0x80000000;
for(int32_t i = RegionIndex; i >= 0; i--)
{
// try and allocate 2x before
nBase = S.MemoryRegions[i].Start - Granularity;
nBase = (nBase / Granularity) * Granularity;
if(nBase < nEnd)
break;
void* pMemory = VirtualAlloc((void*)nBase, s, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if(pMemory)
{
return pMemory;
}
}
return nullptr;
}
static void* MicroProfileAllocExecutableMemory(void* pBase, size_t s)
{
uint32_t RegionIndex = 0;
for(uint32_t i = 0; i < S.MemoryRegions.Size; ++i)
{
auto& R = S.MemoryRegions[i];
if(R.Start <= (intptr_t)pBase && (intptr_t)pBase < R.Start + R.Size)
{
RegionIndex = i;
break;
}
}
s = (s + 4095) & ~(4095);
intptr_t nBase = (intptr_t)pBase;
void* pResult = 0;
if(0 == pResult && nBase > 0x40000000)
{
pResult = MicroProfileAllocExecutableMemoryDown(nBase - 0x40000000, s, RegionIndex);
if(0 == pResult)
{
pResult = MicroProfileAllocExecutableMemoryUp(nBase - 0x40000000, s, RegionIndex);
}
}
if(0 == pResult && nBase < 0xffffffff40000000)
{
pResult = MicroProfileAllocExecutableMemoryUp(nBase + 0x40000000, s, RegionIndex);
if(0 == pResult)
{
pResult = MicroProfileAllocExecutableMemoryUp(nBase + 0x40000000, s, RegionIndex);
}
}
return pResult;
}
static void* MicroProfileAllocExecutableMemoryFar(size_t s)
{
static uint64_t nPageSize = 4 << 10;
s = (s + (nPageSize - 1)) & (~(nPageSize - 1));
void* pMem = VirtualAlloc(0, s, MEM_COMMIT, PAGE_READWRITE);
MP_ASSERT(pMem);
// uprintf("Allocating %zu %p\n", s, pMem);
return pMem;
}
static void MicroProfileMakeMemoryExecutable(void* p, size_t s)
{
static uint64_t nPageSize = 4 << 10;
s = (s + (nPageSize - 1)) & (~(nPageSize - 1));
DWORD Unused;
if(!VirtualProtect(p, s, PAGE_EXECUTE_READ, &Unused))
{
MP_BREAK();
}
}
#endif
int MicroProfileTrimFunctionName(const char* pStr, char* pOutBegin, char* pOutEnd)
{
const char* pStart = pOutBegin;
int l = (int)strlen(pStr) - 1;
int sz = 0;
pOutEnd--;
if(l < 1024 && pOutBegin != pOutEnd)
{
const char* p = pStr;
const char* pEnd = pStr + l + 1;
int in = 0;
while(p != pEnd && pOutBegin != pOutEnd)
{
char c = *p++;
if(c == '(' || c == '<')
{
in++;
}
else if(c == ')' || c == '>')
{
in--;
continue;
}
if(in == 0)
{
*pOutBegin++ = c;
sz++;
}
}
*pOutBegin++ = '\0';
}
return sz;
}
int MicroProfileFindFunctionName(const char* pStr, const char** ppStart)
{
int l = (int)strlen(pStr) - 1;
if(l < 1024)
{
char b[1024] = { 0 };
char* put = &b[0];
const char* p = pStr;
const char* pEnd = pStr + l + 1;
int in = 0;
while(p != pEnd)
{
char c = *p++;
if(c == '(' || c == '<')
{
in++;
}
else if(c == ')' || c == '>')
{
in--;
continue;
}
if(in == 0)
{
*put++ = c;
}
}
*put++ = '\0';
uprintf("trimmed %s\n", b);
}
// int nFirstParen = l;
int nNumParen = 0;
int c = 0;
while(l >= 0 && pStr[l] != ')' && c++ < sizeof(" const") - 1)
{
l--;
}
if(pStr[l] == ')')
{
do
{
if(pStr[l] == ')')
{
nNumParen++;
}
else if(pStr[l] == '(')
{
nNumParen--;
}
l--;
} while(nNumParen > 0 && l >= 0);
}
else
{
*ppStart = pStr;
return 0;
}
while(l >= 0 && isspace(pStr[l]))
{
--l;
}
int nLast = l;
while(l >= 0 && !isspace(pStr[l]))
{
l--;
}
int nFirst = l;
if(nFirst == nLast)
return 0;
int nCount = nLast - nFirst + 1;
*ppStart = pStr + nFirst;
return nCount;
}
#include <dbghelp.h>
#include <psapi.h>
#include <tlhelp32.h>
#include <winternl.h>
struct MicroProfileQueryContext
{
const char* pFilterStrings[MICROPROFILE_MAX_FILTER];
uint32_t nPatternLength[MICROPROFILE_MAX_FILTER];
int nMaxFilter = 0;
char TempBuffer[128];
uint32_t size = 0;
bool bFirst = false;
};
BOOL CALLBACK MicroProfileEnumModules(_In_ PCTSTR ModuleName, _In_ DWORD64 BaseOfDll, _In_opt_ PVOID UserContext)
{
MODULEINFO MI;
GetModuleInformation(GetCurrentProcess(), (HMODULE)BaseOfDll, &MI, sizeof(MI));
MEMORY_BASIC_INFORMATION B;
int r = VirtualQuery((LPCVOID)BaseOfDll, (MEMORY_BASIC_INFORMATION*)&B, sizeof(B));
char buffer[1024];
int r1 = GetLastError();
if(r == 0)
{
stbsp_snprintf(buffer, sizeof(buffer) - 1, "Error %d\n", r1);
OutputDebugString(buffer);
MP_BREAK();
}
MicroProfileSymbolInitModule(ModuleName, BaseOfDll, BaseOfDll + MI.SizeOfImage);
return true;
}
namespace
{
struct QueryCallbackBase // fucking c++, this is a pain in the ass
{
virtual void CB(const char* pName, const char* pShortName, intptr_t addr, intptr_t addrend, uint32_t nModuleId) = 0;
};
template <typename T>
struct QueryCallbackImpl : public QueryCallbackBase
{
T t;
QueryCallbackImpl(T t)
: t(t)
{
}
virtual void CB(const char* pName, const char* pShortName, intptr_t addr, intptr_t addrend, uint32_t nModuleId)
{
t(pName, pShortName, addr, addrend, nModuleId);
}
};
} // namespace
static uint32_t nLastModuleIdWin32 = (uint32_t)-1;
static intptr_t nLastModuleBaseWin32 = (intptr_t)-1;
BOOL MicroProfileQueryContextEnumSymbols(_In_ PSYMBOL_INFO pSymInfo, _In_ ULONG SymbolSize, _In_opt_ PVOID UserContext)
{
uint32_t nModuleId = nLastModuleIdWin32;
if(nLastModuleBaseWin32 != (intptr_t)pSymInfo->ModBase)
{
nLastModuleIdWin32 = nModuleId = MicroProfileSymbolGetModule((const char*)(intptr_t)-2, pSymInfo->ModBase);
nLastModuleBaseWin32 = (intptr_t)pSymInfo->ModBase;
}
if(pSymInfo->Tag == 5 || pSymInfo->Tag == 10)
{
char FunctionName[1024];
int ret = 0;
int l = MicroProfileTrimFunctionName(pSymInfo->Name, &FunctionName[0], &FunctionName[1024]);
QueryCallbackBase* pCB = (QueryCallbackBase*)UserContext;
pCB->CB(pSymInfo->Name, l ? &FunctionName[0] : 0, (intptr_t)pSymInfo->Address, pSymInfo->Size + (intptr_t)pSymInfo->Address, nModuleId);
}
return TRUE;
};
bool MicroProfileDemangleName(const char* pName, char* OutName, uint32_t Size)
{
MICROPROFILE_SCOPEI("microprofile", "SymbolDemangle", MP_AUTO);
if(UnDecorateSymbolName(pName, OutName, Size, UNDNAME_NAME_ONLY))
{
return true;
}
return false;
}
bool MicroProfileExtractPdbInfo(HMODULE hMod, GUID& guid, DWORD& age, char pdbName[MAX_PATH])
{
struct CV_INFO_PDB70
{
DWORD CvSignature; // "RSDS"
GUID Signature; // GUID
DWORD Age; // Age
char PdbFileName[1]; // Null-terminated string
};
BYTE* base = (BYTE*)hMod;
IMAGE_DOS_HEADER* dos = (IMAGE_DOS_HEADER*)base;
if(dos->e_magic != IMAGE_DOS_SIGNATURE)
return false;
IMAGE_NT_HEADERS* nt = (IMAGE_NT_HEADERS*)(base + dos->e_lfanew);
if(nt->Signature != IMAGE_NT_SIGNATURE)
return false;
auto& dd = nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
if(!dd.VirtualAddress || !dd.Size)
return false;
IMAGE_DEBUG_DIRECTORY* debugDir = (IMAGE_DEBUG_DIRECTORY*)(base + dd.VirtualAddress);
int count = dd.Size / sizeof(IMAGE_DEBUG_DIRECTORY);
for(int i = 0; i < count; i++)
{
if(debugDir[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW)
{
auto cv = (CV_INFO_PDB70*)(base + debugDir[i].AddressOfRawData);
if(cv->CvSignature != 'SDSR')
continue; // "RSDS"
guid = cv->Signature;
age = cv->Age;
strcpy_s(pdbName, MAX_PATH, cv->PdbFileName);
return true;
}
}
return false;
}
bool MicroProfileDownloadPDB(HMODULE Module, HANDLE Process, char outPath[MAX_PATH])
{
GUID guid;
DWORD age;
char pdbName[MAX_PATH];
if(!MicroProfileExtractPdbInfo(Module, guid, age, pdbName))
{
uprintf("Failed to download pdb\n");
MP_BREAK();
return false;
}
uprintf("pdb name %s age %d\n", pdbName, age);
FILE* f = fopen(pdbName, "r");
if(f)
{
fclose(f);
strcpy_s(outPath, MAX_PATH, pdbName);
return true;
}
char localPath[MAX_PATH] = {};
BOOL ok = SymFindFileInPath(Process,
NULL,
pdbName,
(PVOID)&guid, // GUID
age, // Age
0, // FileSize (not used for PDBs)
SSRVOPT_GUIDPTR, // we're passing GUID pointer
outPath,
NULL,
NULL);
return ok != 0;
}
#include "PDB.h"
#include "PDB_DBIStream.h"
#include "PDB_IPIStream.h"
#include "PDB_InfoStream.h"
#include "PDB_NamesStream.h"
#include "PDB_RawFile.h"
#include "PDB_TPIStream.h"
template <typename Callback>
void MicroProfileLoadRawPDB(Callback CB, const char* Filename, uint64_t Base, uint32_t nModuleId)
{
auto OnSymbol = [CB, Base, nModuleId](const char* Sym, uint32_t Offset, uint32_t Size)
{
char FunctionName[1024];
int ret = 0;
int l = MicroProfileTrimFunctionName(Sym, &FunctionName[0], &FunctionName[1024]);
const char* fname = l ? &FunctionName[0] : nullptr;
CB(Sym, fname, (intptr_t)Offset + Base, (intptr_t)Offset + Base + Size, nModuleId);
};
void* File = CreateFileA(Filename, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, nullptr);
if(File == INVALID_HANDLE_VALUE)
{
MP_BREAK();
}
void* FileMapping = CreateFileMappingA(File, nullptr, PAGE_READONLY, 0, 0, nullptr);
if(FileMapping == nullptr)
{
CloseHandle(File);
MP_BREAK();
}
void* BaseAddress = MapViewOfFile(FileMapping, FILE_MAP_READ, 0, 0, 0);
if(BaseAddress == nullptr)
{
CloseHandle(FileMapping);
CloseHandle(File);
}
BY_HANDLE_FILE_INFORMATION FileInformation;
const bool GetInformationResult = GetFileInformationByHandle(File, &FileInformation);
if(!GetInformationResult)
{
UnmapViewOfFile(BaseAddress);
CloseHandle(FileMapping);
CloseHandle(File);
MP_BREAK();
}
const size_t FileSizeHighBytes = static_cast<size_t>(FileInformation.nFileSizeHigh) << 32;
const size_t FileSizeLowBytes = FileInformation.nFileSizeLow;
const size_t FileSize = FileSizeHighBytes | FileSizeLowBytes;
const PDB::RawFile RawPdbFile = PDB::CreateRawFile(BaseAddress);
if(PDB::HasValidDBIStream(RawPdbFile) != PDB::ErrorCode::Success)
{
MP_BREAK();
}
const PDB::InfoStream InfoStream(RawPdbFile);
if(InfoStream.UsesDebugFastLink())
{
MP_BREAK();
}
// const PDB::Header* h = InfoStream.GetHeader();
// uprintf("Version %u, signature %u, age %u, GUID %08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x\n",
// static_cast<uint32_t>(h->version), h->signature, h->age,
// h->guid.Data1, h->guid.Data2, h->guid.Data3,
// h->guid.Data4[0], h->guid.Data4[1], h->guid.Data4[2], h->guid.Data4[3], h->guid.Data4[4], h->guid.Data4[5], h->guid.Data4[6], h->guid.Data4[7]);
const PDB::DBIStream DbiStream = PDB::CreateDBIStream(RawPdbFile);
if(PDB::ErrorCode::Success != DbiStream.HasValidSymbolRecordStream(RawPdbFile))
{
MP_BREAK();
}
if(PDB::ErrorCode::Success != DbiStream.HasValidPublicSymbolStream(RawPdbFile))
{
MP_BREAK();
}
if(PDB::ErrorCode::Success != DbiStream.HasValidGlobalSymbolStream(RawPdbFile))
{
MP_BREAK();
}
if(PDB::ErrorCode::Success != DbiStream.HasValidSectionContributionStream(RawPdbFile))
{
MP_BREAK();
}
if(PDB::ErrorCode::Success != DbiStream.HasValidImageSectionStream(RawPdbFile))
{
MP_BREAK();
}
const PDB::ImageSectionStream ImageSectionStream = DbiStream.CreateImageSectionStream(RawPdbFile);
const PDB::ModuleInfoStream ModuleInfoStream = DbiStream.CreateModuleInfoStream(RawPdbFile);
const PDB::CoalescedMSFStream SymbolRecordStream = DbiStream.CreateSymbolRecordStream(RawPdbFile);
const PDB::ArrayView<PDB::ModuleInfoStream::Module> modules = ModuleInfoStream.GetModules();
for(const PDB::ModuleInfoStream::Module& module : modules)
{
if(!module.HasSymbolStream())
{
continue;
}
const PDB::ModuleSymbolStream moduleSymbolStream = module.CreateSymbolStream(RawPdbFile);
moduleSymbolStream.ForEachSymbol(
[&ImageSectionStream, &OnSymbol](const PDB::CodeView::DBI::Record* record)
{
// only grab function symbols from the module streams
const char* name = nullptr;
uint32_t rva = 0u;
uint32_t size = 0u;
if(record->header.kind == PDB::CodeView::DBI::SymbolRecordKind::S_FRAMEPROC)
{
// functionSymbols[functionSymbols.size() - 1].frameProc = record;
return;
}
else if(record->header.kind == PDB::CodeView::DBI::SymbolRecordKind::S_THUNK32)
{
if(record->data.S_THUNK32.thunk == PDB::CodeView::DBI::ThunkOrdinal::TrampolineIncremental)
{
// we have never seen incremental linking thunks stored inside a S_THUNK32 symbol, but better safe than sorry
name = "ILT";
rva = ImageSectionStream.ConvertSectionOffsetToRVA(record->data.S_THUNK32.section, record->data.S_THUNK32.offset);
size = 5u;
}
}
else if(record->header.kind == PDB::CodeView::DBI::SymbolRecordKind::S_TRAMPOLINE)
{
// incremental linking thunks are stored in the linker module
name = "ILT";
rva = ImageSectionStream.ConvertSectionOffsetToRVA(record->data.S_TRAMPOLINE.thunkSection, record->data.S_TRAMPOLINE.thunkOffset);
size = 5u;
}
else if(record->header.kind == PDB::CodeView::DBI::SymbolRecordKind::S_LPROC32)
{
name = record->data.S_LPROC32.name;
rva = ImageSectionStream.ConvertSectionOffsetToRVA(record->data.S_LPROC32.section, record->data.S_LPROC32.offset);
size = record->data.S_LPROC32.codeSize;
}
else if(record->header.kind == PDB::CodeView::DBI::SymbolRecordKind::S_GPROC32)
{
name = record->data.S_GPROC32.name;
rva = ImageSectionStream.ConvertSectionOffsetToRVA(record->data.S_GPROC32.section, record->data.S_GPROC32.offset);
size = record->data.S_GPROC32.codeSize;
}
else if(record->header.kind == PDB::CodeView::DBI::SymbolRecordKind::S_LPROC32_ID)
{
name = record->data.S_LPROC32_ID.name;
rva = ImageSectionStream.ConvertSectionOffsetToRVA(record->data.S_LPROC32_ID.section, record->data.S_LPROC32_ID.offset);
size = record->data.S_LPROC32_ID.codeSize;
}
else if(record->header.kind == PDB::CodeView::DBI::SymbolRecordKind::S_GPROC32_ID)
{
name = record->data.S_GPROC32_ID.name;
rva = ImageSectionStream.ConvertSectionOffsetToRVA(record->data.S_GPROC32_ID.section, record->data.S_GPROC32_ID.offset);
size = record->data.S_GPROC32_ID.codeSize;
}
if(rva == 0u)
{
return;
}
// uprintf("func %p / %d .. %s \n", rva, size, name);
OnSymbol(name, rva, size);
});
}
const PDB::PublicSymbolStream PublicSymbolStream = DbiStream.CreatePublicSymbolStream(RawPdbFile);
{
const PDB::ArrayView<PDB::HashRecord> HashRecords = PublicSymbolStream.GetRecords();
const size_t Count = HashRecords.GetLength();
for(const PDB::HashRecord& HashRecord : HashRecords)
{
const PDB::CodeView::DBI::Record* Record = PublicSymbolStream.GetRecord(SymbolRecordStream, HashRecord);
if(Record->header.kind != PDB::CodeView::DBI::SymbolRecordKind::S_PUB32)
{
continue;
}
if((PDB_AS_UNDERLYING(Record->data.S_PUB32.flags) & PDB_AS_UNDERLYING(PDB::CodeView::DBI::PublicSymbolFlags::Function)) == 0u)
{
continue;
}
const uint32_t rva = ImageSectionStream.ConvertSectionOffsetToRVA(Record->data.S_PUB32.section, Record->data.S_PUB32.offset);
if(rva == 0u)
{
continue;
}
OnSymbol(Record->data.S_PUB32.name, rva, 0);
}
}
UnmapViewOfFile(BaseAddress);
CloseHandle(FileMapping);
CloseHandle(File);
}
bool MicroProfilePatchHasSuspendedThread(intptr_t Begin, intptr_t End)
{
MicroProfileSuspendState& State = S.SuspendState;
for(uint32_t i = 0; i < State.NumSuspended; ++i)
{
intptr_t ip = State.SuspendedIP[i];
if(Begin <= ip && ip <= End)
return true;
}
return false;
}
bool MicroProfilePatchBeginSuspend()
{
MicroProfileSuspendState& State = S.SuspendState;
if(State.SuspendCounter++ > 0)
return true;
MicroProfileUpdateMemoryRegions();
MicroProfileMutex().lock();
MP_ASSERT(State.NumSuspended == 0);
DWORD ProcessId = GetCurrentProcessId();
DWORD ThreadId = GetCurrentThreadId();
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if(hSnap == INVALID_HANDLE_VALUE)
{
return false;
}
THREADENTRY32 te{};
te.dwSize = sizeof(te);
State.NumSuspended = 0;
if(Thread32First(hSnap, &te))
{
do
{
if(te.th32OwnerProcessID != ProcessId)
continue;
if(te.th32ThreadID == ThreadId)
continue;
HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, te.th32ThreadID);
if(!hThread)
{
continue;
}
DWORD PrevCount = SuspendThread(hThread);
if(PrevCount == (DWORD)-1)
{
CloseHandle(hThread);
continue;
}
CONTEXT ctx{};
ctx.ContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER; // Rip + registers
if(GetThreadContext(hThread, &ctx))
{
State.SuspendedIP[State.NumSuspended] = (intptr_t)ctx.Rip;
}
if(State.NumSuspended < MICROPROFILE_SUSPEND_MAX)
{
State.Suspended[State.NumSuspended++] = hThread;
}
} while(Thread32Next(hSnap, &te));
}
else
{
uprintf("Thread32First failed %08x\n", GetLastError());
CloseHandle(hSnap);
return false;
}
CloseHandle(hSnap);
return State.NumSuspended > 0;
}
void MicroProfilePatchEndSuspend()
{
MicroProfileSuspendState& State = S.SuspendState;
if(0 == --State.SuspendCounter)
{
for(uint32_t i = 0; i < State.NumSuspended; ++i)
{
ResumeThread(State.Suspended[i]);
CloseHandle(State.Suspended[i]);
}
State.NumSuspended = 0;
MicroProfileMutex().unlock();
}
}
template <typename Callback>
void MicroProfileIterateSymbols(Callback CB, uint32_t* nModules, uint32_t nNumModules)
{
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileIterateSymbols", MP_PINK3);
QueryCallbackImpl<Callback> Context(CB);
if(MicroProfileSymInit())
{
// uprintf("symbols loaded!\n");
// API_VERSION* pv = ImagehlpApiVersion();
// uprintf("VERSION %d.%d.%d\n", pv->MajorVersion, pv->MinorVersion, pv->Revision);
nLastModuleBaseWin32 = -1;
if(SymEnumerateModules64(GetCurrentProcess(), (PSYM_ENUMMODULES_CALLBACK64)MicroProfileEnumModules, NULL))
{
}
QueryCallbackBase* pBase = &Context;
if(nNumModules)
{
HANDLE hProcess = GetCurrentProcess();
char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
uint64_t t0 = MP_TICK();
for(uint32_t i = 0; i < nNumModules; ++i)
{
uint32_t nModule = nModules[i];
int64_t nBytes = 0;
MEMORY_BASIC_INFORMATION B;
for(int j = 0; j < S.SymbolModules[nModule].nNumExecutableRegions; ++j)
{
intptr_t b = S.SymbolModules[nModule].Regions[j].nBegin;
intptr_t e = S.SymbolModules[nModule].Regions[j].nEnd;
while(b < e)
{
int r = VirtualQuery((LPCVOID)b, &B, sizeof(B));
if(!r)
break;
switch(B.Protect)
{
case PAGE_EXECUTE:
case PAGE_EXECUTE_READ:
case PAGE_EXECUTE_READWRITE:
case PAGE_EXECUTE_WRITECOPY:
nBytes += B.RegionSize;
// uprintf("RANGE %p, %p .. %5.2fkb %08x, %08x\n", B.BaseAddress, (void*)(intptr_t(B.BaseAddress) + B.RegionSize), B.RegionSize / 1024.f, B.State, B.Protect);
}
b = intptr_t(B.BaseAddress) + B.RegionSize;
}
}
S.SymbolModules[nModule].nProgressTarget = nBytes;
char pdbPath[MAX_PATH];
HMODULE Module = (HMODULE)S.SymbolModules[nModule].nModuleBase;
S.nSymbolsDirty++;
S.SymbolModules[nModule].bDownloading = true;
if(MicroProfileDownloadPDB(Module, hProcess, pdbPath))
{
S.SymbolModules[nModule].bDownloading = false;
S.nSymbolsDirty++;
MicroProfileLoadRawPDB<Callback>(CB, pdbPath, S.SymbolModules[nModule].nModuleBase, nModule);
}
S.SymbolModules[nModule].bDownloading = false;
S.nSymbolsDirty++;
S.SymbolModules[nModule].nProgress = S.SymbolModules[nModule].nProgressTarget;
S.SymbolModules[nModule].nModuleLoadFinished.exchange(1);
}
uint64_t t1 = MP_TICK();
float fTime = float(MicroProfileTickToMsMultiplierCpu()) * (t1 - t0);
uprintf("load symbol time %6.2fms\n", fTime);
}
MicroProfileSymCleanup();
}
}
static int MicroProfileWin32SymInitCount = 0;
static int MicroProfileWin32SymInitSuccess = 0;
bool MicroProfileSymInit()
{
if(0 == MicroProfileWin32SymInitCount++)
{
auto h = GetCurrentProcess();
SymCleanup(h);
SymSetOptions(SYMOPT_DEFERRED_LOADS);
if(SymInitialize(h, 0, FALSE))
{
MicroProfileWin32SymInitSuccess = 1;
char Path[MAX_PATH];
bool PathValid = SymGetSearchPath(h, Path, MAX_PATH) > 0;
if(PathValid)
{
PathValid = strlen(Path) > 3;
}
if(!PathValid)
{
SymSetSearchPath(h, "srv*C:\\symbols*https://msdl.microsoft.com/download/symbols");
}
}
else
{
MicroProfileWin32SymInitSuccess = 0;
}
}
return MicroProfileWin32SymInitSuccess != 0;
}
void MicroProfileSymCleanup()
{
if(0 == --MicroProfileWin32SymInitCount)
{
MicroProfileWin32SymInitSuccess = 0;
SymCleanup(GetCurrentProcess());
}
}
static void* g_pFunctionFoundHack = 0;
static const char* g_pFunctionpNameFound = 0;
static char g_Demangled[512];
BOOL MicroProfileQueryContextEnumSymbols1(_In_ PSYMBOL_INFO pSymInfo, _In_ ULONG SymbolSize, _In_opt_ PVOID UserContext)
{
if(pSymInfo->Tag == 5 || pSymInfo->Tag == 10)
{
char str[200];
stbsp_snprintf(str, sizeof(str) - 1, "%s : %p\n", pSymInfo->Name, (void*)pSymInfo->Address);
OutputDebugStringA(str);
g_pFunctionpNameFound = pSymInfo->Name;
g_pFunctionFoundHack = (void*)pSymInfo->Address;
return FALSE;
}
return TRUE;
};
const char* MicroProfileDemangleSymbol(const char* pSymbol)
{
return pSymbol; // todo: for some reasons all symbols im seaing right now are already undecorated?
}
void MicroProfileInstrumentWithoutSymbols(const char** pModules, const char** pSymbols, uint32_t nNumSymbols)
{
char SymString[512];
const char* pStr = 0;
if(MicroProfileSymInit())
{
HANDLE h = GetCurrentProcess();
for(uint32_t i = 0; i < nNumSymbols; ++i)
{
int nCount = stbsp_snprintf(SymString, sizeof(SymString) - 1, "%s!%s", pModules[i], pSymbols[i]);
if(nCount <= sizeof(SymString) - 1)
{
g_pFunctionFoundHack = 0;
if(SymEnumSymbols(h, 0, SymString, MicroProfileQueryContextEnumSymbols1, 0))
{
if(g_pFunctionFoundHack)
{
uint32_t nColor = MicroProfileColorFromString(pSymbols[i]);
const char* pDemangled = pSymbols[i]; // MicroProfileDemangleSymbol(pSymbols[i]);
MicroProfileInstrumentFunction(g_pFunctionFoundHack, pModules[i], pDemangled, nColor);
}
}
}
}
MicroProfileSymCleanup();
}
}
void MicroProfileSymbolEnumModules()
{
HMODULE modules[1024];
DWORD needed;
HANDLE h = GetCurrentProcess();
if(EnumProcessModules(h, modules, sizeof(modules), &needed))
{
int count = needed / sizeof(HMODULE);
for(int i = 0; i < count; i++)
{
char moduleName[MAX_PATH];
if(GetModuleFileNameEx(h, modules[i], moduleName, MAX_PATH))
{
MODULEINFO mi = {};
if(GetModuleInformation(h, modules[i], &mi, sizeof(mi)))
{
MicroProfileEnumModules(moduleName, (DWORD64)mi.lpBaseOfDll, 0);
}
}
}
}
}
void MicroProfileSymbolUpdateModuleList()
{
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileSymbolUpdateModuleList", MP_PINK3);
// QueryCallbackImpl<Callback> Context(CB);
if(MicroProfileSymInit())
{
uprintf("symbols loaded!\n");
API_VERSION* pv = ImagehlpApiVersion();
uprintf("VERSION %d.%d.%d\n", pv->MajorVersion, pv->MinorVersion, pv->Revision);
nLastModuleBaseWin32 = -1;
MicroProfileSymbolEnumModules();
MicroProfileSymCleanup();
}
}
#endif
#if defined(__APPLE__) && defined(__MACH__)
// '##::::'##::'#######:::'#######::'##:::'##:::::'#######:::'######::'##::::'##:
// ##:::: ##:'##.... ##:'##.... ##: ##::'##:::::'##.... ##:'##... ##:. ##::'##::
// ##:::: ##: ##:::: ##: ##:::: ##: ##:'##:::::: ##:::: ##: ##:::..:::. ##'##:::
// #########: ##:::: ##: ##:::: ##: #####::::::: ##:::: ##:. ######::::. ###::::
// ##.... ##: ##:::: ##: ##:::: ##: ##. ##:::::: ##:::: ##::..... ##::: ## ##:::
// ##:::: ##: ##:::: ##: ##:::: ##: ##:. ##::::: ##:::: ##:'##::: ##:: ##:. ##::
// ##:::: ##:. #######::. #######:: ##::. ##::::. #######::. ######:: ##:::. ##:
// ..:::::..:::.......::::.......:::..::::..::::::.......::::......:::..:::::..::
#include <cxxabi.h>
#include <distorm.h>
#include <dlfcn.h>
#include <mach/mach.h>
#include <mach/mach_vm.h>
#include <mnemonics.h>
#include <sys/mman.h>
#include <unistd.h>
static void* MicroProfileAllocExecutableMemory(void* f, size_t s);
static void MicroProfileMakeWriteable(void* p_);
extern "C" void microprofile_tramp_enter_patch();
extern "C" void microprofile_tramp_enter();
extern "C" void microprofile_tramp_code_begin();
extern "C" void microprofile_tramp_code_end();
extern "C" void microprofile_tramp_intercept0();
extern "C" void microprofile_tramp_end();
extern "C" void microprofile_tramp_exit();
extern "C" void microprofile_tramp_leave();
extern "C" void microprofile_tramp_trunk();
extern "C" void microprofile_tramp_call_patch_pop();
extern "C" void microprofile_tramp_call_patch_push();
bool MicroProfilePatchFunction(void* f, int Argument, MicroProfileHookFunc enter, MicroProfileHookFunc leave, MicroProfilePatchError* pError) __attribute__((optnone))
{
if(pError)
{
memcpy(&pError->Code[0], f, 12);
}
intptr_t t_enter = (intptr_t)microprofile_tramp_enter;
intptr_t t_enter_patch_offset = (intptr_t)microprofile_tramp_enter_patch - t_enter;
intptr_t t_code_begin_offset = (intptr_t)microprofile_tramp_code_begin - t_enter;
intptr_t t_code_end_offset = (intptr_t)microprofile_tramp_code_end - t_enter;
intptr_t t_code_intercept0_offset = (intptr_t)microprofile_tramp_intercept0 - t_enter;
intptr_t t_code_exit_offset = (intptr_t)microprofile_tramp_exit - t_enter;
intptr_t t_code_leave_offset = (intptr_t)microprofile_tramp_leave - t_enter;
intptr_t t_code_call_patch_push_offset = (intptr_t)microprofile_tramp_call_patch_push - t_enter;
intptr_t t_code_call_patch_pop_offset = (intptr_t)microprofile_tramp_call_patch_pop - t_enter;
intptr_t codemaxsize = t_code_end_offset - t_code_begin_offset;
intptr_t t_end_offset = (intptr_t)microprofile_tramp_end - t_enter;
intptr_t t_trunk_offset = (intptr_t)microprofile_tramp_trunk - t_enter;
intptr_t t_trunk_size = (intptr_t)microprofile_tramp_end - (intptr_t)microprofile_tramp_trunk;
char* ptramp = (char*)MicroProfileAllocExecutableMemory(f, t_end_offset);
intptr_t offset = ((intptr_t)f + 6 - (intptr_t)ptramp);
uint32_t nBytesToCopy = 14;
if(offset < 0x80000000 && offset > -0x7fffffff)
{
/// offset is small enough to insert a relative jump
nBytesToCopy = 5;
}
memcpy(ptramp, (void*)t_enter, t_end_offset);
int nInstructionBytesDest = 0;
char* pInstructionMoveDest = ptramp + t_code_begin_offset;
char* pTrunk = ptramp + t_trunk_offset;
int nInstructionBytesSrc = 0;
uint32_t nRegsWritten = 0;
uint32_t nRetSafe = 0;
uint32_t nUsableJumpRegs = (1 << R_RAX) | (1 << R_R10) | (1 << R_R11); // scratch && !parameter register
if(!MicroProfileCopyInstructionBytes(
pInstructionMoveDest, f, nBytesToCopy, codemaxsize, pTrunk, t_trunk_size, nUsableJumpRegs, &nInstructionBytesDest, &nInstructionBytesSrc, &nRegsWritten, &nRetSafe))
{
if(pError)
{
const char* pCode = (const char*)f;
memset(pError->Code, 0, sizeof(pError->Code));
memcpy(pError->Code, pCode, nInstructionBytesSrc);
int off = stbsp_snprintf(pError->Message, sizeof(pError->Message), "Failed to move %d code bytes ", nInstructionBytesSrc);
pError->nCodeSize = nInstructionBytesSrc;
for(int i = 0; i < nInstructionBytesSrc; ++i)
{
off += stbsp_snprintf(off + pError->Message, sizeof(pError->Message) - off, "%02x ", 0xff & pCode[i]);
}
uprintf("%s\n", pError->Message);
}
return false;
}
intptr_t phome = nInstructionBytesSrc + (intptr_t)f;
uint32_t reg = nUsableJumpRegs & ~nRegsWritten;
static_assert(R_RAX == 0, "R_RAX must be 0");
if(0 == reg)
{
if(nRetSafe == 0)
{
MP_BREAK(); // shout fail earlier
}
MicroProfileInsertRetJump(pInstructionMoveDest + nInstructionBytesDest, phome);
}
else
{
int r = R_RAX;
while((reg & 1) == 0)
{
reg >>= 1;
r++;
}
MicroProfileInsertRegisterJump(pInstructionMoveDest + nInstructionBytesDest, phome, r);
}
// PATCH 1 TRAMP EXIT
intptr_t microprofile_tramp_exit = (intptr_t)ptramp + t_code_exit_offset;
memcpy(ptramp + t_enter_patch_offset + 2, (void*)&microprofile_tramp_exit, 8);
char* pintercept = t_code_intercept0_offset + ptramp;
// PATCH 1.5 Argument
memcpy(pintercept - 4, (void*)&Argument, 4);
// PATCH 2 INTERCEPT0
intptr_t addr = (intptr_t)enter; //&intercept0;
memcpy(pintercept + 2, (void*)&addr, 8);
// PATHC 2.5 argument
memcpy(ptramp + t_code_exit_offset + 3, (void*)&Argument, 4);
intptr_t microprofile_tramp_leave = (intptr_t)ptramp + t_code_leave_offset;
// PATCH 3 INTERCEPT1
intptr_t addr1 = (intptr_t)leave; //&intercept1;
memcpy((char*)microprofile_tramp_leave + 2, (void*)&addr1, 8);
intptr_t patch_push_addr = (intptr_t)(&MicroProfile_Patch_TLS_PUSH);
intptr_t patch_pop_addr = (intptr_t)(&MicroProfile_Patch_TLS_POP);
memcpy((char*)ptramp + t_code_call_patch_push_offset + 2, &patch_push_addr, 8);
memcpy((char*)ptramp + t_code_call_patch_pop_offset + 2, &patch_pop_addr, 8);
{
// PATCH 4 DEST FUNC
MicroProfileMakeWriteable(f);
char* pp = (char*)f;
char* ppend = pp + nInstructionBytesSrc;
if(nInstructionBytesSrc < 14)
{
uprintf("inserting 5b jump\n");
pp = MicroProfileInsertRelativeJump((char*)pp, (intptr_t)ptramp);
}
else
{
uprintf("inserting 14b jump\n");
pp = MicroProfileInsertRegisterJump(pp, (intptr_t)ptramp, R_RAX);
}
while(pp != ppend)
{
*pp++ = 0x90;
}
}
return true;
}
static void MicroProfileMakeWriteable(void* p_)
{
#ifdef _PATCH_TEST
// for testing..
static const uint32_t WritableSize = 16;
static uint32_t WritableCount = 0;
static intptr_t WritableStart[WritableSize] = { 0 };
static intptr_t WritableEnd[WritableSize] = { 0 };
for(uint32_t i = 0; i < WritableCount; ++i)
{
intptr_t x = (intptr_t)p_;
if(x >= WritableStart[i] && x < WritableEnd[i])
{
return;
}
}
#endif
intptr_t p = (intptr_t)p_;
// uprintf("MicroProfilemakewriteable %lx\n", p);
mach_port_name_t task = mach_task_self();
vm_map_offset_t vmoffset = 0;
mach_vm_size_t vmsize = 0;
uint32_t nd;
kern_return_t kr;
vm_region_submap_info_64 vbr;
mach_msg_type_number_t vbrcount = sizeof(vbr) / 4;
while(KERN_SUCCESS == (kr = mach_vm_region_recurse(task, &vmoffset, &vmsize, &nd, (vm_region_recurse_info_t)&vbr, &vbrcount)))
{
if(p >= (intptr_t)vmoffset && p <= intptr_t(vmoffset + vmsize))
{
if(0 == (vbr.protection & VM_PROT_WRITE))
{
// uprintf("region match .. enabling write\n");
int x = mprotect((void*)vmoffset, vmsize, PROT_WRITE | PROT_READ | PROT_EXEC);
if(x)
{
// uprintf("mprotect failed ... err %d:: %d %s\n", errno, x, strerror(errno));
}
else
{
uprintf("region is [%llx,%llx] .. %08llx %d", vmoffset, vmoffset + vmsize, vmsize, vbr.is_submap);
uprintf("prot: %c%c%c %c%c%c\n",
vbr.protection & VM_PROT_READ ? 'r' : '-',
vbr.protection & VM_PROT_WRITE ? 'w' : '-',
vbr.protection & VM_PROT_EXECUTE ? 'x' : '-',
vbr.max_protection & VM_PROT_READ ? 'r' : '-',
vbr.max_protection & VM_PROT_WRITE ? 'w' : '-',
vbr.max_protection & VM_PROT_EXECUTE ? 'x' : '-');
continue;
}
}
else
{
#ifdef _PATCH_TEST
if(WritableCount < WritableSize)
{
WritableStart[WritableCount] = vmoffset;
WritableEnd[WritableCount] = vmoffset + vmsize;
WritableCount++;
}
#endif
}
}
vmoffset += vmsize;
vbrcount = sizeof(vbr) / 4;
}
}
int MicroProfileTrimFunctionName(const char* pStr, char* pOutBegin, char* pOutEnd)
{
int l = strlen(pStr) - 1;
int sz = 0;
pOutEnd--;
if(l < pOutEnd - pOutBegin && pOutBegin != pOutEnd)
{
const char* p = pStr;
const char* pEnd = pStr + l + 1;
int in = 0;
while(p != pEnd && pOutBegin != pOutEnd)
{
char c = *p++;
if(c == '(' || c == '<')
{
in++;
}
else if(c == ')' || c == '>')
{
in--;
continue;
}
if(in == 0)
{
*pOutBegin++ = c;
sz++;
}
}
*pOutBegin++ = '\0';
}
return sz;
}
int MicroProfileFindFunctionName(const char* pStr, const char** ppStart)
{
int l = strlen(pStr) - 1;
if(l < 1024)
{
char b[1024] = { 0 };
char* put = &b[0];
const char* p = pStr;
const char* pEnd = pStr + l + 1;
int in = 0;
while(p != pEnd)
{
char c = *p++;
if(c == '(' || c == '<')
{
in++;
}
else if(c == ')' || c == '>')
{
in--;
continue;
}
if(in == 0)
{
*put++ = c;
}
}
*put++ = '\0';
uprintf("trimmed %s\n", b);
}
// int nFirstParen = l;
int nNumParen = 0;
int c = 0;
while(l >= 0 && pStr[l] != ')' && c++ < (int)(sizeof(" const") - 1))
{
l--;
}
if(pStr[l] == ')')
{
do
{
if(pStr[l] == ')')
{
nNumParen++;
}
else if(pStr[l] == '(')
{
nNumParen--;
}
l--;
} while(nNumParen > 0 && l >= 0);
}
else
{
*ppStart = pStr;
return 0;
}
while(l >= 0 && isspace(pStr[l]))
{
--l;
}
int nLast = l;
while(l >= 0 && !isspace(pStr[l]))
{
l--;
}
int nFirst = l;
if(nFirst == nLast)
return 0;
int nCount = nLast - nFirst + 1;
*ppStart = pStr + nFirst;
return nCount;
}
const char* MicroProfileDemangleSymbol(const char* pSymbol)
{
static unsigned long size = 128;
static char* pTempBuffer = (char*)malloc(size); // needs to be malloc because demangle function might realloc it.
unsigned long len = size;
int ret = 0;
char* pBuffer = pTempBuffer;
pBuffer = abi::__cxa_demangle(pSymbol, pTempBuffer, &len, &ret);
if(ret == 0)
{
if(pBuffer != pTempBuffer)
{
pTempBuffer = pBuffer;
if(len < size)
__builtin_trap();
size = len;
}
return pTempBuffer;
}
else
{
return pSymbol;
}
}
template <typename Callback>
void MicroProfileIterateSymbols(Callback CB, uint32_t* nModules, uint32_t nNumModules)
{
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileIterateSymbols", MP_PINK3);
char FunctionName[1024];
(void)FunctionName;
mach_port_name_t task = mach_task_self();
vm_map_offset_t vmoffset = 0;
mach_vm_size_t vmsize = 0;
uint32_t nd;
kern_return_t kr;
vm_region_submap_info_64 vbr;
mach_msg_type_number_t vbrcount = sizeof(vbr) / 4;
intptr_t nCurrentModule = -1;
uint32_t nCurrentModuleId = -1;
auto OnFunction = [&](void* addr, void* addrend, const char* pSymbol, const char* pModuleName, void* pModuleAddr) -> bool
{
const char* pStr = MicroProfileDemangleSymbol(pSymbol);
;
int l = MicroProfileTrimFunctionName(pStr, &FunctionName[0], &FunctionName[1024]);
if(nCurrentModule != (intptr_t)pModuleAddr)
{
nCurrentModule = (intptr_t)pModuleAddr;
nCurrentModuleId = MicroProfileSymbolGetModule(pModuleName, nCurrentModule);
}
CB(l ? &FunctionName[0] : pStr, l ? &FunctionName[0] : 0, (intptr_t)addr, (intptr_t)addrend, nCurrentModuleId);
return true;
};
vm_offset_t addr_prev = 0;
while(KERN_SUCCESS == (kr = mach_vm_region_recurse(task, &vmoffset, &vmsize, &nd, (vm_region_recurse_info_t)&vbr, &vbrcount)))
{
{
addr_prev = vmoffset + vmsize;
if(0 != (vbr.protection & VM_PROT_EXECUTE))
{
bool bProcessModule = true;
int nModule = -1;
if(nNumModules)
{
bProcessModule = false;
for(uint32_t i = 0; i < nNumModules; ++i)
{
intptr_t nBase = S.SymbolModules[nModules[i]].Regions[0].nBegin;
if((intptr_t)vmoffset == nBase)
{
bProcessModule = true;
nModule = nModules[i];
break;
}
}
}
if(bProcessModule)
{
S.SymbolModules[nModule].nProgressTarget = S.SymbolModules[nModule].Regions[0].nEnd - S.SymbolModules[nModule].Regions[0].nBegin;
dl_info di;
int r = 0;
r = dladdr((void*)vmoffset, &di);
if(r)
{
OnFunction(di.dli_saddr, (void*)addr_prev, di.dli_sname, di.dli_fname, di.dli_fbase);
}
intptr_t addr = vmoffset + vmsize - 1;
while(1)
{
r = dladdr((void*)(addr), &di);
if(r)
{
if(!di.dli_sname)
{
break;
}
OnFunction(di.dli_saddr, (void*)addr_prev, di.dli_sname, di.dli_fname, di.dli_fbase);
}
else
{
break;
}
addr_prev = (vm_offset_t)di.dli_saddr;
addr = (intptr_t)di.dli_saddr - 1;
if(di.dli_saddr < (void*)vmoffset)
{
break;
}
}
for(int i = 0; i < S.SymbolNumModules; ++i)
{
if(S.SymbolModules[i].Regions[0].nBegin == (intptr_t)vmoffset)
{
S.SymbolModules[i].nModuleLoadFinished.store(1);
}
}
}
}
}
vmoffset += vmsize;
vbrcount = sizeof(vbr) / 4;
}
}
void MicroProfileSymbolUpdateModuleList()
{
char FunctionName[1024];
(void)FunctionName;
mach_port_name_t task = mach_task_self();
vm_map_offset_t vmoffset = 0;
mach_vm_size_t vmsize = 0;
uint32_t nd;
kern_return_t kr;
vm_region_submap_info_64 vbr;
mach_msg_type_number_t vbrcount = sizeof(vbr) / 4;
while(KERN_SUCCESS == (kr = mach_vm_region_recurse(task, &vmoffset, &vmsize, &nd, (vm_region_recurse_info_t)&vbr, &vbrcount)))
{
{
if(0 != (vbr.protection & VM_PROT_EXECUTE))
{
dl_info di;
int r = 0;
r = dladdr((void*)vmoffset, &di);
if(r)
{
uprintf("[0x%p-0x%p] (0x%p) %s %s\n", (void*)vmoffset, (void*)addr_prev, di.dli_fbase, di.dli_fname, di.dli_sname);
MicroProfileSymbolInitModule(di.dli_fname, (intptr_t)vmoffset, (intptr_t)vmoffset + vmsize);
}
}
}
vmoffset += vmsize;
vbrcount = sizeof(vbr) / 4;
}
}
static void* MicroProfileAllocExecutableMemory(void* f, size_t s)
{
static uint64_t nPageSize = 0;
if(!nPageSize)
{
nPageSize = getpagesize();
}
s = (s + (nPageSize - 1)) & (~(nPageSize - 1));
void* pMem = mmap((void*)f, s, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANON | MAP_PRIVATE, 0, 0);
// uprintf("Allocating %zu %p\n", s, pMem);
return pMem;
}
bool MicroProfileDemangleName(const char* pName, char* OutName, uint32_t Size)
{
// demangle not implemented
strcpy(OutName, pName);
return true;
}
bool MicroProfilePatchBeginSuspend()
{
// Not implemented
return true;
}
void MicroProfilePatchEndSuspend()
{
// Not implemented
}
void MicroProfileInstrumentWithoutSymbols(const char** pModules, const char** pSymbols, uint32_t nNumSymbols)
{
void* M = dlopen(0, 0);
for(uint32_t i = 0; i < nNumSymbols; ++i)
{
// uprintf("trying to find symbol %s\n", pSym);
void* s = dlsym(M, pSymbols[i]);
uprintf("sym returned %p\n", s);
if(s)
{
uint32_t nColor = MicroProfileColorFromString(pSymbols[i]);
const char* pDemangled = MicroProfileDemangleSymbol(pSymbols[i]);
MicroProfileInstrumentFunction(s, pModules[i], pDemangled, nColor);
}
}
dlclose(M);
}
#endif
#if defined(__unix__) && defined(__x86_64__)
// '##::::'##::'#######:::'#######::'##:::'##::::'##:::::::'####:'##::: ##:'##::::'##:'##::::'##:
// ##:::: ##:'##.... ##:'##.... ##: ##::'##::::: ##:::::::. ##:: ###:: ##: ##:::: ##:. ##::'##::
// ##:::: ##: ##:::: ##: ##:::: ##: ##:'##:::::: ##:::::::: ##:: ####: ##: ##:::: ##::. ##'##:::
// #########: ##:::: ##: ##:::: ##: #####::::::: ##:::::::: ##:: ## ## ##: ##:::: ##:::. ###::::
// ##.... ##: ##:::: ##: ##:::: ##: ##. ##:::::: ##:::::::: ##:: ##. ####: ##:::: ##::: ## ##:::
// ##:::: ##: ##:::: ##: ##:::: ##: ##:. ##::::: ##:::::::: ##:: ##:. ###: ##:::: ##:: ##:. ##::
// ##:::: ##:. #######::. #######:: ##::. ##:::: ########:'####: ##::. ##:. #######:: ##:::. ##:
// ..:::::..:::.......::::.......:::..::::..:::::........::....::..::::..:::.......:::..:::::..::
#include <cxxabi.h>
#include <distorm.h>
#include <dlfcn.h>
#include <mnemonics.h>
#include <sys/mman.h>
#include <unistd.h>
static void* MicroProfileAllocExecutableMemory(void* f, size_t s);
static void MicroProfileMakeWriteable(void* p_);
extern "C" void microprofile_tramp_enter_patch() asm("_microprofile_tramp_enter_patch");
extern "C" void microprofile_tramp_enter() asm("_microprofile_tramp_enter");
extern "C" void microprofile_tramp_code_begin() asm("_microprofile_tramp_code_begin");
extern "C" void microprofile_tramp_code_end() asm("_microprofile_tramp_code_end");
extern "C" void microprofile_tramp_intercept0() asm("_microprofile_tramp_intercept0");
extern "C" void microprofile_tramp_end() asm("_microprofile_tramp_end");
extern "C" void microprofile_tramp_exit() asm("_microprofile_tramp_exit");
extern "C" void microprofile_tramp_leave() asm("_microprofile_tramp_leave");
extern "C" void microprofile_tramp_trunk() asm("_microprofile_tramp_trunk");
extern "C" void microprofile_tramp_call_patch_pop() asm("_microprofile_tramp_call_patch_pop");
extern "C" void microprofile_tramp_call_patch_push() asm("_microprofile_tramp_call_patch_push");
bool MicroProfilePatchFunction(void* f, int Argument, MicroProfileHookFunc enter, MicroProfileHookFunc leave, MicroProfilePatchError* pError)
{
if(pError)
{
memcpy(&pError->Code[0], f, 12);
}
intptr_t t_enter = (intptr_t)microprofile_tramp_enter;
intptr_t t_enter_patch_offset = (intptr_t)microprofile_tramp_enter_patch - t_enter;
intptr_t t_code_begin_offset = (intptr_t)microprofile_tramp_code_begin - t_enter;
intptr_t t_code_end_offset = (intptr_t)microprofile_tramp_code_end - t_enter;
intptr_t t_code_intercept0_offset = (intptr_t)microprofile_tramp_intercept0 - t_enter;
intptr_t t_code_exit_offset = (intptr_t)microprofile_tramp_exit - t_enter;
intptr_t t_code_leave_offset = (intptr_t)microprofile_tramp_leave - t_enter;
intptr_t t_code_call_patch_push_offset = (intptr_t)microprofile_tramp_call_patch_push - t_enter;
intptr_t t_code_call_patch_pop_offset = (intptr_t)microprofile_tramp_call_patch_pop - t_enter;
intptr_t codemaxsize = t_code_end_offset - t_code_begin_offset;
intptr_t t_end_offset = (intptr_t)microprofile_tramp_end - t_enter;
intptr_t t_trunk_offset = (intptr_t)microprofile_tramp_trunk - t_enter;
intptr_t t_trunk_size = (intptr_t)microprofile_tramp_end - (intptr_t)microprofile_tramp_trunk;
char* ptramp = (char*)MicroProfileAllocExecutableMemory(f, t_end_offset);
intptr_t offset = ((intptr_t)f + 6 - (intptr_t)ptramp);
uint32_t nBytesToCopy = 14;
if(offset < 0x80000000 && offset > -0x7fffffff)
{
/// offset is small enough to insert a relative jump
nBytesToCopy = 5;
}
memcpy(ptramp, (void*)t_enter, t_end_offset);
int nInstructionBytesDest = 0;
char* pInstructionMoveDest = ptramp + t_code_begin_offset;
char* pTrunk = ptramp + t_trunk_offset;
int nInstructionBytesSrc = 0;
uint32_t nRegsWritten = 0;
uint32_t nRetSafe = 0;
uint32_t nUsableJumpRegs = (1 << R_RAX) | (1 << R_R10) | (1 << R_R11); // scratch && !parameter register
if(!MicroProfileCopyInstructionBytes(
pInstructionMoveDest, f, nBytesToCopy, codemaxsize, pTrunk, t_trunk_size, nUsableJumpRegs, &nInstructionBytesDest, &nInstructionBytesSrc, &nRegsWritten, &nRetSafe))
{
if(pError)
{
const char* pCode = (const char*)f;
memset(pError->Code, 0, sizeof(pError->Code));
memcpy(pError->Code, pCode, nInstructionBytesSrc);
int off = stbsp_snprintf(pError->Message, sizeof(pError->Message), "Failed to move %d code bytes ", nInstructionBytesSrc);
pError->nCodeSize = nInstructionBytesSrc;
for(int i = 0; i < nInstructionBytesSrc; ++i)
{
off += stbsp_snprintf(off + pError->Message, sizeof(pError->Message) - off, "%02x ", 0xff & pCode[i]);
}
uprintf("%s\n", pError->Message);
}
return false;
}
intptr_t phome = nInstructionBytesSrc + (intptr_t)f;
uint32_t reg = nUsableJumpRegs & ~nRegsWritten;
static_assert(R_RAX == 0, "R_RAX must be 0");
if(0 == reg)
{
if(nRetSafe == 0)
{
MP_BREAK(); // shout fail earlier
}
MicroProfileInsertRetJump(pInstructionMoveDest + nInstructionBytesDest, phome);
}
else
{
int r = R_RAX;
while((reg & 1) == 0)
{
reg >>= 1;
r++;
}
MicroProfileInsertRegisterJump(pInstructionMoveDest + nInstructionBytesDest, phome, r);
}
// PATCH 1 TRAMP EXIT
intptr_t microprofile_tramp_exit = (intptr_t)ptramp + t_code_exit_offset;
memcpy(ptramp + t_enter_patch_offset + 2, (void*)&microprofile_tramp_exit, 8);
char* pintercept = t_code_intercept0_offset + ptramp;
// PATCH 1.5 Argument
memcpy(pintercept - 4, (void*)&Argument, 4);
// PATCH 2 INTERCEPT0
intptr_t addr = (intptr_t)enter; //&intercept0;
memcpy(pintercept + 2, (void*)&addr, 8);
// PATHC 2.5 argument
memcpy(ptramp + t_code_exit_offset + 3, (void*)&Argument, 4);
intptr_t microprofile_tramp_leave = (intptr_t)ptramp + t_code_leave_offset;
// PATCH 3 INTERCEPT1
intptr_t addr1 = (intptr_t)leave; //&intercept1;
memcpy((char*)microprofile_tramp_leave + 2, (void*)&addr1, 8);
intptr_t patch_push_addr = (intptr_t)(&MicroProfile_Patch_TLS_PUSH);
intptr_t patch_pop_addr = (intptr_t)(&MicroProfile_Patch_TLS_POP);
memcpy((char*)ptramp + t_code_call_patch_push_offset + 2, &patch_push_addr, 8);
memcpy((char*)ptramp + t_code_call_patch_pop_offset + 2, &patch_pop_addr, 8);
{
// PATCH 4 DEST FUNC
MicroProfileMakeWriteable(f);
char* pp = (char*)f;
char* ppend = pp + nInstructionBytesSrc;
if(nInstructionBytesSrc < 14)
{
uprintf("inserting 5b jump\n");
pp = MicroProfileInsertRelativeJump((char*)pp, (intptr_t)ptramp);
}
else
{
uprintf("inserting 14b jump\n");
pp = MicroProfileInsertRegisterJump(pp, (intptr_t)ptramp, R_RAX);
}
while(pp != ppend)
{
*pp++ = 0x90;
}
}
return true;
}
static void MicroProfileMakeWriteable(void* p_)
{
intptr_t nPageSize = (intptr_t)getpagesize();
intptr_t p = ((intptr_t)p_) & ~(nPageSize - 1);
intptr_t e = nPageSize + ((14 + (intptr_t)p_) & ~(nPageSize - 1));
size_t s = e - p;
mprotect((void*)p, s, PROT_READ | PROT_WRITE | PROT_EXEC);
}
int MicroProfileTrimFunctionName(const char* pStr, char* pOutBegin, char* pOutEnd)
{
int l = strlen(pStr) - 1;
int sz = 0;
pOutEnd--;
if(l < pOutEnd - pOutBegin && pOutBegin != pOutEnd)
{
const char* p = pStr;
const char* pEnd = pStr + l + 1;
int in = 0;
while(p != pEnd && pOutBegin != pOutEnd)
{
char c = *p++;
if(c == '(' || c == '<')
{
in++;
}
else if(c == ')' || c == '>')
{
in--;
continue;
}
if(in == 0)
{
*pOutBegin++ = c;
sz++;
}
}
*pOutBegin++ = '\0';
}
return sz;
}
int MicroProfileFindFunctionName(const char* pStr, const char** ppStart)
{
int l = strlen(pStr) - 1;
if(l < 1024)
{
char b[1024] = { 0 };
char* put = &b[0];
const char* p = pStr;
const char* pEnd = pStr + l + 1;
int in = 0;
while(p != pEnd)
{
char c = *p++;
if(c == '(' || c == '<')
{
in++;
}
else if(c == ')' || c == '>')
{
in--;
continue;
}
if(in == 0)
{
*put++ = c;
}
}
*put++ = '\0';
uprintf("trimmed %s\n", b);
}
// int nFirstParen = l;
int nNumParen = 0;
int c = 0;
while(l >= 0 && pStr[l] != ')' && c++ < (int)(sizeof(" const") - 1))
{
l--;
}
if(pStr[l] == ')')
{
do
{
if(pStr[l] == ')')
{
nNumParen++;
}
else if(pStr[l] == '(')
{
nNumParen--;
}
l--;
} while(nNumParen > 0 && l >= 0);
}
else
{
*ppStart = pStr;
return 0;
}
while(l >= 0 && isspace(pStr[l]))
{
--l;
}
int nLast = l;
while(l >= 0 && !isspace(pStr[l]))
{
l--;
}
int nFirst = l;
if(nFirst == nLast)
return 0;
int nCount = nLast - nFirst + 1;
*ppStart = pStr + nFirst;
return nCount;
}
const char* MicroProfileDemangleSymbol(const char* pSymbol)
{
static unsigned long size = 128;
static char* pTempBuffer = (char*)malloc(size); // needs to be malloc because demangle function might realloc it.
unsigned long len = size;
int ret = 0;
char* pBuffer = pTempBuffer;
pBuffer = abi::__cxa_demangle(pSymbol, pTempBuffer, &len, &ret);
if(ret == 0)
{
if(pBuffer != pTempBuffer)
{
pTempBuffer = pBuffer;
if(len < size)
__builtin_trap();
size = len;
}
return pTempBuffer;
}
else
{
return pSymbol;
}
}
template <typename Callback>
void MicroProfileIterateSymbols(Callback CB, uint32_t* nModules, uint32_t nNumModules)
{
MICROPROFILE_SCOPEI("MicroProfile", "MicroProfileIterateSymbols", MP_PINK3);
char FunctionName[1024];
intptr_t nCurrentModule = -1;
uint32_t nCurrentModuleId = -1;
auto OnFunction = [&](void* addr, void* addrend, const char* pSymbol, const char* pModuleName, void* pModuleAddr) -> bool
{
const char* pStr = MicroProfileDemangleSymbol(pSymbol);
;
int l = MicroProfileTrimFunctionName(pStr, &FunctionName[0], &FunctionName[1024]);
MP_ASSERT(nCurrentModule == (intptr_t)pModuleAddr);
CB(l ? &FunctionName[0] : pStr, l ? &FunctionName[0] : 0, (intptr_t)addr, (intptr_t)addrend, nCurrentModuleId);
return true;
};
for(int i = 0; i < S.SymbolNumModules; ++i)
{
auto& M = S.SymbolModules[i];
if(0 != nNumModules)
{
bool bProcess = false;
for(uint32_t j = 0; j < nNumModules; ++j)
{
if(nModules[j] == (uint32_t)i)
{
bProcess = true;
break;
}
}
if(!bProcess)
continue;
}
nCurrentModuleId = i;
Dl_info di;
int r = 0;
r = dladdr((void*)(M.Regions[0].nBegin), &di);
if(r)
{
nCurrentModule = (intptr_t)di.dli_fbase;
M.nProgressTarget = 0;
for(int j = 0; j < M.nNumExecutableRegions; ++j)
{
M.nProgressTarget += M.Regions[j].nEnd - M.Regions[j].nBegin;
}
for(int j = 0; j < M.nNumExecutableRegions; ++j)
{
const intptr_t nBegin = M.Regions[j].nBegin;
const intptr_t nEnd = M.Regions[j].nEnd;
int r = 0;
intptr_t nAddr = (nEnd - 8) & ~7;
intptr_t nAddrPrev = nEnd;
while(1)
{
r = dladdr((void*)(nAddr), &di);
if(r && di.dli_sname)
{
OnFunction(di.dli_saddr, (void*)nAddrPrev, di.dli_sname, di.dli_fname, di.dli_fbase);
nAddrPrev = (intptr_t)di.dli_saddr;
nAddr = (intptr_t)di.dli_saddr - 1;
}
else
{
nAddr = (nAddr - 7) & ~7; // pretty ineffecient, but it seems linux just returns 0 when there is no symbols, making this the only option I can come up with?
}
if(nAddr < nBegin)
{
break;
}
}
}
M.nProgress = M.nProgressTarget;
M.nModuleLoadFinished.store(1);
}
}
}
void MicroProfileSymbolUpdateModuleList()
{
// So, this was the only way I could find to do this..
// Is this seriously how they want this to be done?
FILE* F = fopen("/proc/self/maps", "r");
char* line = 0;
size_t len;
ssize_t read;
Dl_info di;
while((read = getline(&line, &len, F)) != -1)
{
void* pBase = 0;
void* pEnd = 0;
char c, r, w, x, p;
if(8 == sscanf(line, "%p%c%p%c%c%c%c%c", &pBase, &c, &pEnd, &c, &r, &w, &x, &p))
{
if('x' == x)
{
int r = 0;
r = dladdr(pBase, &di);
if(r)
{
if('[' != di.dli_fname[0])
{
MicroProfileSymbolInitModule(di.dli_fname, (intptr_t)pBase, (intptr_t)pEnd);
}
}
}
}
}
fclose(F);
MicroProfileSymbolMergeExecutableRegions();
}
static void* MicroProfileAllocExecutableMemory(void* f, size_t s)
{
static uint64_t nPageSize = 0;
if(!nPageSize)
{
nPageSize = getpagesize();
}
s = (s + (nPageSize - 1)) & (~(nPageSize - 1));
void* pMem = mmap(f, s, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANON | MAP_PRIVATE, 0, 0);
return pMem;
}
bool MicroProfileDemangleName(const char* pName, char* OutName, uint32_t Size)
{
// demangle not implemented
strcpy(OutName, pName);
return true;
}
bool MicroProfilePatchBeginSuspend()
{
// Not implemented
return true;
}
void MicroProfilePatchEndSuspend()
{
// Not implemented
}
// not yet tested.
void MicroProfileInstrumentWithoutSymbols(const char** pModules, const char** pSymbols, uint32_t nNumSymbols)
{
void* M = dlopen(0, 0);
for(uint32_t i = 0; i < nNumSymbols; ++i)
{
// uprintf("trying to find symbol %s\n", pSym);
void* s = dlsym(M, pSymbols[i]);
uprintf("sym returned %p\n", s);
if(s)
{
uint32_t nColor = MicroProfileColorFromString(pSymbols[i]);
const char* pDemangled = MicroProfileDemangleSymbol(pSymbols[i]);
MicroProfileInstrumentFunction(s, pModules[i], pDemangled, nColor);
}
}
dlclose(M);
}
#endif
#endif
void MicroProfileHashTableInit(MicroProfileHashTable* pTable, uint32_t nInitialSize, uint32_t nSearchLimit, MicroProfileHashCompareFunction CompareFunc, MicroProfileHashFunction HashFunc)
{
pTable->nAllocated = nInitialSize;
pTable->nUsed = 0;
uint32_t nSize = nInitialSize * sizeof(MicroProfileHashTableEntry);
pTable->pEntries = (MicroProfileHashTableEntry*)MICROPROFILE_ALLOC(nSize, 8);
pTable->CompareFunc = CompareFunc;
pTable->HashFunc = HashFunc;
pTable->nSearchLimit = nSearchLimit;
pTable->nLim = pTable->nAllocated / 5;
if(pTable->nLim > pTable->nSearchLimit)
pTable->nLim = pTable->nSearchLimit;
memset(pTable->pEntries, 0, nSize);
}
void MicroProfileHashTableDestroy(MicroProfileHashTable* pTable)
{
MICROPROFILE_FREE(pTable->pEntries);
}
uint64_t MicroProfileHashTableHash(MicroProfileHashTable* pTable, uint64_t K)
{
uint64_t H = pTable->HashFunc ? (*pTable->HashFunc)(K) : K;
return H == 0 ? 1 : H;
}
void MicroProfileHashTableGrow(MicroProfileHashTable* pTable)
{
uint32_t nAllocated = pTable->nAllocated;
uint32_t nNewSize = nAllocated * 2;
uprintf("GROW %d -> %d\n", nAllocated, nNewSize);
MicroProfileHashTable New;
MicroProfileHashTableInit(&New, nNewSize, pTable->nSearchLimit, pTable->CompareFunc, pTable->HashFunc);
for(uint32_t i = 0; i < nAllocated; ++i)
{
MicroProfileHashTableEntry& E = pTable->pEntries[i];
if(E.Hash != 0)
{
MicroProfileHashTableSet(&New, E.Key, E.Value, E.Hash, false);
}
}
MicroProfileHashTableDestroy(pTable);
*pTable = New;
}
bool MicroProfileHashTableSet(MicroProfileHashTable* pTable, uint64_t Key, uintptr_t Value)
{
uint64_t H = MicroProfileHashTableHash(pTable, Key);
return MicroProfileHashTableSet(pTable, Key, Value, H, true);
}
MicroProfileHashTableIterator MicroProfileGetHashTableIteratorBegin(MicroProfileHashTable* HashTable)
{
return MicroProfileHashTableIterator(0, HashTable);
}
MicroProfileHashTableIterator MicroProfileGetHashTableIteratorEnd(MicroProfileHashTable* HashTable)
{
return MicroProfileHashTableIterator(HashTable->nAllocated, HashTable);
}
bool MicroProfileHashTableSet(MicroProfileHashTable* pTable, uint64_t Key, uintptr_t Value, uint64_t H, bool bAllowGrow)
{
if(H == 0)
MP_BREAK(); // not supported.
MicroProfileHashCompareFunction Cmp = pTable->CompareFunc;
while(1)
{
const uint32_t nLim = pTable->nLim;
uint32_t B = H % pTable->nAllocated;
MicroProfileHashTableEntry* pEntries = pTable->pEntries;
for(uint32_t i = 0; i < pTable->nAllocated; ++i)
{
uint32_t Idx = (B + i) % pTable->nAllocated;
if(pEntries[Idx].Hash == 0)
{
pEntries[Idx].Hash = H;
pEntries[Idx].Key = Key;
pEntries[Idx].Value = Value;
return true;
}
else if(pEntries[Idx].Hash == H && (Cmp ? (Cmp)(Key, pEntries[Idx].Key) : Key == pEntries[Idx].Key))
{
pEntries[Idx].Value = Value;
return true;
}
else if(i > nLim)
{
break;
}
}
if(bAllowGrow)
{
MicroProfileHashTableGrow(pTable);
}
else
{
MP_BREAK();
}
}
MP_BREAK();
}
bool MicroProfileHashTableGet(MicroProfileHashTable* pTable, uint64_t Key, uintptr_t* pValue)
{
uint64_t H = MicroProfileHashTableHash(pTable, Key);
uint32_t B = H % pTable->nAllocated;
MicroProfileHashTableEntry* pEntries = pTable->pEntries;
MicroProfileHashCompareFunction Cmp = pTable->CompareFunc;
for(uint32_t i = 0; i < pTable->nAllocated; ++i)
{
uint32_t Idx = (B + i) % pTable->nAllocated;
if(pEntries[Idx].Hash == 0)
{
return false;
}
else if(pEntries[Idx].Hash == H && (Cmp ? (Cmp)(Key, pEntries[Idx].Key) : Key == pEntries[Idx].Key))
{
*pValue = pEntries[Idx].Value;
return true;
}
}
return false;
}
bool MicroProfileHashTableRemove(MicroProfileHashTable* pTable, uint64_t Key)
{
uint64_t H = MicroProfileHashTableHash(pTable, Key);
uint32_t B = H % pTable->nAllocated;
MicroProfileHashTableEntry* pEntries = pTable->pEntries;
MicroProfileHashCompareFunction Cmp = pTable->CompareFunc;
uint32_t nBase = (uint32_t)-1;
uint32_t nAllocated = pTable->nAllocated;
for(uint32_t i = 0; i < nAllocated; ++i)
{
uint32_t Idx = (B + i) % nAllocated;
if(pEntries[Idx].Hash == 0)
{
return false;
}
else if(pEntries[Idx].Hash == H && (Cmp ? (Cmp)(Key, pEntries[Idx].Key) : Key == pEntries[Idx].Key))
{
nBase = Idx;
break;
}
}
pEntries[nBase].Hash = 0;
pEntries[nBase].Key = 0;
pEntries[nBase].Value = 0;
nBase++;
for(uint32_t i = 0; i < nAllocated; ++i)
{
uint32_t Idx = (nBase + i) % nAllocated;
if(pEntries[Idx].Hash == 0)
{
break;
}
else
{
MicroProfileHashTableEntry E = pEntries[Idx];
pEntries[Idx] = {};
MicroProfileHashTableSet(pTable, E.Key, E.Value, E.Hash, false);
}
}
return true;
}
uint64_t MicroProfileHashTableHashString(uint64_t pString)
{
return MicroProfileStringHash((const char*)pString);
}
bool MicroProfileHashTableCompareString(uint64_t L, uint64_t R)
{
return 0 == strcmp((const char*)L, (const char*)R);
}
uint64_t MicroProfileHashTableHashPtr(uint64_t x)
{
x ^= x >> 33;
x *= 0xff51afd7ed558ccdULL;
x ^= x >> 33;
x *= 0xc4ceb9fe1a85ec53ULL;
x ^= x >> 33;
return x;
}
bool MicroProfileHashTableComparePtr(uint64_t L, uint64_t R)
{
return L == R;
}
bool MicroProfileHashTableSetString(MicroProfileHashTable* pTable, const char* pKey, const char* pValue)
{
return MicroProfileHashTableSet(pTable, (uint64_t)pKey, (uintptr_t)pValue);
}
bool MicroProfileHashTableGetString(MicroProfileHashTable* pTable, const char* pKey, const char** pValue)
{
return MicroProfileHashTableGet(pTable, (uint64_t)pKey, (uintptr_t*)pValue);
}
bool MicroProfileHashTableRemoveString(MicroProfileHashTable* pTable, const char* pKey)
{
return MicroProfileHashTableRemove(pTable, (uint64_t)pKey);
}
bool MicroProfileHashTableSetPtr(MicroProfileHashTable* pTable, const void* pKey, void* pValue)
{
return MicroProfileHashTableSet(pTable, (uint64_t)pKey, (uintptr_t)pValue);
}
template <typename T>
bool MicroProfileHashTableGetPtr(MicroProfileHashTable* pTable, const void* pKey, T** pValue)
{
uintptr_t Dummy;
uintptr_t* Arg = pValue ? (uintptr_t*)pValue : &Dummy;
return MicroProfileHashTableGet(pTable, (uint64_t)pKey, Arg);
}
bool MicroProfileHashTableRemovePtr(MicroProfileHashTable* pTable, const char* pKey)
{
return MicroProfileHashTableRemove(pTable, (uint64_t)pKey);
}
template <typename T>
T& MicroProfileArray<T>::operator[](const uint32_t Index)
{
return Data[Index];
}
template <typename T>
const T& MicroProfileArray<T>::operator[](const uint32_t Index) const
{
MP_ASSERT(Index < Size);
return Data[Index];
}
template <typename T>
T* MicroProfileArray<T>::begin()
{
return Data;
}
template <typename T>
T* MicroProfileArray<T>::end()
{
return Data + Size;
}
template <typename T>
void MicroProfileArrayInit(MicroProfileArray<T>& Array, uint32_t InitialCapacity)
{
MP_ASSERT(Array.Data == nullptr);
MP_ASSERT(Array.Size == 0);
MP_ASSERT(Array.Capacity == 0);
Array.Capacity = InitialCapacity;
Array.Data = MP_ALLOC_OBJECT_ARRAY(T, InitialCapacity);
Array.Size = 0;
}
template <typename T>
void MicroProfileArrayDestroy(MicroProfileArray<T>& Array, uint32_t InitialCapacity)
{
if(Array.Data)
MP_FREE(Array.Data);
memset(Array, 0, sizeof(*Array));
}
template <typename T>
void MicroProfileArrayClear(MicroProfileArray<T>& Array)
{
Array.Size = 0;
}
template <typename T>
void MicroProfileArrayPushBack(MicroProfileArray<T>& Array, const T& v)
{
uint32_t& Size = Array.Size;
uint32_t& Capacity = Array.Capacity;
if(Size >= Capacity)
{
uint32_t NewCapacity = (MicroProfileMax<uint32_t>(1u, Capacity) + 1) * 3 / 2;
T* NewData = MP_ALLOC_OBJECT_ARRAY(T, NewCapacity);
memcpy(NewData, Array.Data, Size * sizeof(T));
if(Array.Data)
{
MP_FREE(Array.Data);
}
Array.Data = NewData;
Capacity = NewCapacity;
}
Array.Data[Size++] = v;
}
void MicroProfileStringBlockFree(MicroProfileStringBlock* pBlock)
{
MicroProfileCounterAdd(S.CounterToken_StringBlock_Count, -1);
MicroProfileCounterAdd(S.CounterToken_StringBlock_Memory, -(int64_t)(pBlock->nSize + sizeof(MicroProfileStringBlock)));
MP_FREE(pBlock);
}
MicroProfileStringBlock* MicroProfileStringBlockAlloc(uint32_t nSize)
{
nSize = MicroProfileMax(nSize, (uint32_t)(MicroProfileStringBlock::DEFAULT_SIZE - sizeof(MicroProfileStringBlock)));
nSize += sizeof(MicroProfileStringBlock);
MicroProfileCounterAdd(S.CounterToken_StringBlock_Count, 1);
MicroProfileCounterAdd(S.CounterToken_StringBlock_Memory, nSize);
// uprintf("alloc string block %d sizeof strings is %d\n", nSize, (int)sizeof(MicroProfileStringBlock));
MicroProfileStringBlock* pBlock = (MicroProfileStringBlock*)MP_ALLOC(nSize, 8);
pBlock->pNext = 0;
pBlock->nSize = nSize - sizeof(MicroProfileStringBlock);
pBlock->nUsed = 0;
return pBlock;
}
void MicroProfileStringsInit(MicroProfileStrings* pStrings)
{
MicroProfileHashTableInit(&pStrings->HashTable, 1, 25, MicroProfileHashTableCompareString, MicroProfileHashTableHashString);
pStrings->pFirst = 0;
pStrings->pLast = 0;
}
void MicroProfileStringsDestroy(MicroProfileStrings* pStrings)
{
MicroProfileStringBlock* pBlock = pStrings->pFirst;
while(pBlock)
{
MicroProfileStringBlock* pNext = pBlock->pNext;
MicroProfileStringBlockFree(pBlock);
pBlock = pNext;
}
MicroProfileCounterSet(S.CounterToken_StringBlock_Waste, 0);
MicroProfileCounterSet(S.CounterToken_StringBlock_Strings, 0);
memset(pStrings, 0, sizeof(*pStrings));
}
const char* MicroProfileStringIntern(const char* pStr)
{
return MicroProfileStringIntern(pStr, (uint32_t)strlen(pStr), 0);
}
const char* MicroProfileStringInternLower(const char* pStr)
{
return MicroProfileStringIntern(pStr, (uint32_t)strlen(pStr), ESTRINGINTERN_LOWERCASE);
}
const char* MicroProfileStringInternSlash(const char* pStr)
{
return MicroProfileStringIntern(pStr, (uint32_t)strlen(pStr), ESTRINGINTERN_FORCEFORWARDSLASH);
}
const char* MicroProfileStringIntern(const char* pStr_, uint32_t nLen, uint32_t nFlags)
{
MicroProfileStrings* pStrings = &S.Strings;
const char* pStr = pStr_;
char* pLowerCaseStr = (char*)alloca(nLen + 1);
if(0 != (nFlags & (ESTRINGINTERN_FORCEFORWARDSLASH | ESTRINGINTERN_LOWERCASE)))
{
for(uint32_t i = 0; i < nLen; ++i)
{
char c = pStr[i];
if(nFlags & ESTRINGINTERN_LOWERCASE)
{
c = tolower(c);
}
if(nFlags & ESTRINGINTERN_FORCEFORWARDSLASH)
{
if(c == '\\')
c = '/';
}
pLowerCaseStr[i] = c;
}
pLowerCaseStr[nLen] = '\0';
pStr = pLowerCaseStr;
}
const char* pRet;
if(MicroProfileHashTableGetString(&pStrings->HashTable, pStr, &pRet))
{
if(0 != strcmp(pStr, pRet))
{
MP_BREAK();
}
return pRet;
}
else
{
if(pStr[nLen] != '\0')
MP_BREAK(); // string should be 0 terminated.
nLen += 1;
MicroProfileStringBlock* pBlock = pStrings->pLast;
if(0 == pBlock || pBlock->nUsed + nLen > pBlock->nSize)
{
MicroProfileStringBlock* pNewBlock = MicroProfileStringBlockAlloc(nLen);
if(pBlock)
{
pBlock->pNext = pNewBlock;
pStrings->pLast = pNewBlock;
MicroProfileCounterAdd(S.CounterToken_StringBlock_Waste, pBlock->nSize - pBlock->nUsed);
}
else
{
pStrings->pLast = pStrings->pFirst = pNewBlock;
}
pBlock = pNewBlock;
}
MicroProfileCounterAdd(S.CounterToken_StringBlock_Strings, 1);
char* pDest = &pBlock->Memory[pBlock->nUsed];
pBlock->nUsed += nLen;
MP_ASSERT(pBlock->nUsed <= pBlock->nSize);
memcpy(pDest, pStr, nLen);
MicroProfileHashTableSetString(&pStrings->HashTable, pDest, pDest);
#if 0
void DumpTableStr(MicroProfileHashTable* pTable);
DumpTableStr(&pStrings->HashTable);
#endif
return pDest;
}
}
void DumpTable(MicroProfileHashTable* pTable)
{
for(uint32_t i = 0; i < pTable->nAllocated; ++i)
{
if(pTable->pEntries[i].Hash != 0)
{
uprintf("[%05d,%05" PRIu64 "] ::::%" PRIx64 ", %p .. hash %" PRIx64 "\n",
i,
pTable->pEntries[i].Hash % pTable->nAllocated,
pTable->pEntries[i].Key,
(void*)pTable->pEntries[i].Value,
pTable->pEntries[i].Hash);
}
}
};
void DumpTableStr(MicroProfileHashTable* pTable)
{
int c = 0;
(void)c;
for(uint32_t i = 0; i < pTable->nAllocated; ++i)
{
if(pTable->pEntries[i].Hash != 0)
{
uprintf("%03d [%05d,%05" PRIu64 "] ::::%s, %s .. hash %" PRIx64 "\n",
c++,
i,
pTable->pEntries[i].Hash % pTable->nAllocated,
(const char*)pTable->pEntries[i].Key,
(const char*)pTable->pEntries[i].Value,
pTable->pEntries[i].Hash);
}
}
uprintf("FillPrc %f\n", 100.f * c / (float)pTable->nAllocated);
};
static const char* txt[] = { "gaudy", "chilly", "obtain", "suspend", "jelly", "peel", "nauseating", "complain", "cave", "practise", "sail", "close",
"drawer", "mature", "impossible", "exist", "sister", "poke", "ancient", "paddle", "ask", "shallow", "outrageous", "healthy",
"reading", "obey", "water", "elbow", "abnormal", "trap", "wholesale", "lovely", "stupid", "comparison", "swim", "brash",
"towering", "accept", "invention", "plantation", "spooky", "tiger", "knot", "literate", "awake", "itch", "medical", "ticket",
"tawdry", "correct", "mine", "accidental", "dinner", "produce", "protective", "red", "dreary", "toe", "drain", "zesty",
"inform", "boundless", "ghost", "attend", "rely", "fill", "liquid", "pump", "continue", "spark", "church", "fortunate",
"truthful", "conscious", "possible", "motion", "evanescent", "branch", "skirt", "number", "meek", "hour", "form", "work",
"car", "post", "talk", "fear", "tightfisted", "dress", "perform", "fry", "courageous", "dysfunctional", "page", "one",
"annoy", "abrasive", "dependent", "payment" };
void MicroProfileStringInternTest()
{
MicroProfileStringsInit(&S.Strings);
uint32_t nCount = sizeof(txt) / sizeof(txt[0]);
const char* pStrings[100];
const char* pStrings2[100];
DumpTableStr(&S.Strings.HashTable);
for(uint32_t i = 0; i < nCount; ++i)
{
pStrings[i] = MicroProfileStringIntern(txt[i]);
pStrings2[i] = MicroProfileStrDup(txt[i]);
}
for(uint32_t i = 0; i < nCount; ++i)
{
const char* pStr = MicroProfileStringIntern(pStrings2[i]);
if(pStr != pStrings[i])
{
MP_BREAK();
}
}
DumpTableStr(&S.Strings.HashTable);
MicroProfileStringsDestroy(&S.Strings);
}
void MicroProfileHashTableTest()
{
MicroProfileStringInternTest();
MicroProfileHashTable T;
MicroProfileHashTable* pTable = &T;
MicroProfileHashTableInit(pTable, 1, 100, 0, 0);
#define NUM_ITEMS 100
uint64_t Keys[NUM_ITEMS];
uint64_t Values[NUM_ITEMS];
memset(Keys, 0xff, sizeof(Keys));
memset(Values, 0xff, sizeof(Values));
static int l = 0;
auto RR = [&]() -> uint64_t
{
if(l++ % 4 < 2)
{
return l;
}
uint64_t l2 = rand();
uint64_t u = rand();
return l2 | (u << 32);
};
auto RRUnique = [&]()
{
bool bFound = false;
uint64_t V = 0;
do
{
V = RR();
for(uint32_t i = 0; i != NUM_ITEMS; ++i)
{
if(V == Keys[i])
{
bFound = true;
}
}
if(!bFound)
{
return V;
}
} while(bFound);
MP_BREAK();
return (uint64_t)0;
};
Keys[0] = 0;
Values[0] = 42;
for(uint32_t i = 1; i < NUM_ITEMS; ++i)
{
Keys[i] = RRUnique();
Values[i] = RR();
}
for(uint32_t i = 0; i < NUM_ITEMS; ++i)
{
MicroProfileHashTableSet(pTable, Keys[i], Values[i]);
}
for(uint32_t i = 0; i < NUM_ITEMS; ++i)
{
uintptr_t V;
if(MicroProfileHashTableGet(pTable, Keys[i], &V))
{
if(V != Values[i])
{
MP_BREAK();
}
}
else
{
MP_BREAK();
}
uint64_t nonkey = RRUnique();
if(MicroProfileHashTableGet(pTable, nonkey, &V))
{
MP_BREAK();
}
}
DumpTable(pTable);
if(!MicroProfileHashTableRemove(pTable, 0))
{
MP_BREAK();
}
uprintf("removed\n");
DumpTable(pTable);
uintptr_t v;
if(MicroProfileHashTableGet(pTable, 0, &v))
{
MP_BREAK();
}
if(MicroProfileHashTableGet(pTable, 1, &v))
{
if(v != 2)
MP_BREAK();
}
MicroProfileHashTableDestroy(pTable);
MicroProfileHashTable Strings;
MicroProfileHashTableInit(&Strings, 1, 25, MicroProfileHashTableCompareString, MicroProfileHashTableHashString);
uint32_t nCount = sizeof(txt) / sizeof(txt[0]);
for(uint32_t i = 0; i < nCount; i += 2)
{
MicroProfileHashTableSetString(&Strings, txt[i], txt[i + 1]);
}
DumpTableStr(&Strings);
for(uint32_t i = 0; i < nCount; i += 2)
{
const char* pKey = txt[i];
const char* pValue = txt[i + 1];
const char* pRes = 0;
if(MicroProfileHashTableGetString(&Strings, pKey, &pRes))
{
if(pRes != pValue)
{
MP_BREAK();
}
}
else
{
MP_BREAK();
}
}
uint32_t nRem = nCount / 2;
for(uint32_t i = 0; i < nRem; i += 2)
{
const char* pKey = txt[i];
const char* pValue = txt[i + 1];
if(!MicroProfileHashTableRemoveString(&Strings, pKey))
{
MP_BREAK();
}
if(MicroProfileHashTableRemoveString(&Strings, pValue))
{
MP_BREAK();
}
}
for(uint32_t i = 0; i < nRem; i += 2)
{
const char* pKey = txt[i];
if(MicroProfileHashTableRemoveString(&Strings, pKey))
{
MP_BREAK();
}
}
for(uint32_t i = 0; i < nCount; i += 2)
{
const char* pKey = txt[i];
const char* pValue = txt[i + 1];
const char* V;
if(MicroProfileHashTableGetString(&Strings, pKey, &V))
{
if(i < nRem)
{
MP_BREAK();
}
else
{
if(V != pValue)
MP_BREAK();
}
}
else
{
if(i >= nRem)
MP_BREAK();
}
}
DumpTableStr(&Strings);
MicroProfileHashTableDestroy(&Strings);
}
uint32_t MicroProfileGetColor(uint32_t TimerIndex)
{
MicroProfileTimerInfo& TI = S.TimerInfo[TimerIndex];
if(TI.nColor == MP_AUTO)
{
return MicroProfileColorFromString(TI.pName);
}
else
{
return TI.nColor;
}
}
#if MICROPROFILE_IMGUI
#include "imgui.h"
#ifndef MICROPROFILE_IMGUI_MAX_GRAPHS
#define MICROPROFILE_IMGUI_MAX_GRAPHS 64
#endif
#define MICROPROFILE_IMGUI_GRAPH_SIZE 256
struct MicroProfileImguiTimerState
{
int TimerIndex = -1;
uint64_t FrameFetched = (uint64_t)-1;
uint32_t nColor = 0;
float fValues[MICROPROFILE_IMGUI_GRAPH_SIZE];
};
struct MicroProfileImguiState
{
MicroProfileImguiTimerState Timers[MICROPROFILE_IMGUI_MAX_GRAPHS];
uint32_t NumTimers = 0;
uint32_t GraphPut;
};
static MicroProfileImguiState ImguiState;
void MicroProfileImguiGather()
{
MICROPROFILE_SCOPEI("MicroProfile", "ImguiGather", MP_AUTO);
uint32_t Put = ImguiState.GraphPut;
for(uint32_t i = 0; i < ImguiState.NumTimers; ++i)
{
MicroProfileImguiTimerState* pGraphInfo = &ImguiState.Timers[i];
uint64_t Ticks = S.Frame[pGraphInfo->TimerIndex].nTicks;
float fToMs = S.TimerInfo[pGraphInfo->TimerIndex].Type == MicroProfileTokenTypeGpu ? MicroProfileTickToMsMultiplierGpu() : MicroProfileTickToMsMultiplierCpu();
pGraphInfo->fValues[Put] = fToMs * Ticks;
}
ImguiState.GraphPut = (ImguiState.GraphPut + 1) % MICROPROFILE_IMGUI_GRAPH_SIZE;
}
uint32_t MicroProfileImGuiColor(uint32_t Color)
{
uint32_t A = 0xff;
uint32_t R = 0xff & (Color >> 16);
uint32_t G = 0xff & (Color >> 8);
uint32_t B = 0xff & (Color);
return (A << IM_COL32_A_SHIFT) | (R << IM_COL32_R_SHIFT) | (G << IM_COL32_G_SHIFT) | (B << IM_COL32_B_SHIFT);
}
void MicroProfileImguiControls()
{
using namespace ImGui;
uint32_t IdCounter = 42;
{
PushID(IdCounter++);
int Aggr = MicroProfileGetAggregateFrames();
Text("Aggregate Frames %7d", MicroProfileGetCurrentAggregateFrames());
SameLine();
if(RadioButton("Inf", Aggr == 0))
MicroProfileSetAggregateFrames(0);
int AggrFrameOptions[] = {
30,
60,
100,
1000,
};
for(int i = 0; i < sizeof(AggrFrameOptions) / sizeof(AggrFrameOptions[0]); ++i)
{
int v = AggrFrameOptions[i];
char Buffer[32];
stbsp_snprintf(Buffer, sizeof(Buffer) - 1, "%d", v);
SameLine();
if(RadioButton(Buffer, Aggr == v))
MicroProfileSetAggregateFrames(v);
}
if(Aggr == 0)
{
if(Button("Clear Inf Aggregate"))
S.nAggregateClear = 1;
}
PopID();
}
Separator();
{
PushID(IdCounter++);
Text("Categories");
if(BeginTable("CategoryTable", 3, 0))
{
TableSetupColumn("Name", ImGuiTableColumnFlags_WidthStretch);
TableSetupColumn("On", ImGuiTableColumnFlags_WidthFixed, 70);
TableSetupColumn("Off", ImGuiTableColumnFlags_WidthFixed, 70);
for(uint32_t i = 0; i < S.nCategoryCount; ++i)
{
PushID(i);
TableNextRow();
TableSetColumnIndex(0);
Text(S.CategoryInfo[i].pName);
bool bEnabled = MicroProfileCategoryEnabled(i);
bool bDisabled = MicroProfileCategoryDisabled(i);
TableSetColumnIndex(1);
if(RadioButton("On", bEnabled))
MicroProfileEnableCategory(S.CategoryInfo[i].pName);
TableSetColumnIndex(2);
if(RadioButton("Off", bDisabled))
MicroProfileDisableCategory(S.CategoryInfo[i].pName);
PopID();
}
EndTable();
}
PopID();
}
Separator();
{
PushID(IdCounter++);
Text("Groups");
if(BeginTable("GroupTable", 3, 0))
{
TableSetupColumn("Name", ImGuiTableColumnFlags_WidthStretch);
TableSetupColumn("On", ImGuiTableColumnFlags_WidthFixed, 70);
TableSetupColumn("Off", ImGuiTableColumnFlags_WidthFixed, 70);
for(uint32_t i = 0; i < S.nGroupCount; ++i)
{
TableNextRow();
PushID(i);
const char* pName = S.GroupInfo[i].pName;
bool bEnabled = MicroProfileGroupEnabled(i);
TableSetColumnIndex(0);
Text(pName);
TableSetColumnIndex(1);
if(RadioButton("On", bEnabled))
MicroProfileToggleGroup(i);
TableSetColumnIndex(2);
if(RadioButton("Off", !bEnabled))
MicroProfileToggleGroup(i);
PopID();
}
EndTable();
}
PopID();
}
}
MicroProfileImguiTimerState* MicroProfileImguiGetTimerState(int TimerIndex)
{
MicroProfileImguiTimerState* ptr = nullptr;
for(uint32_t i = 0; i < ImguiState.NumTimers; ++i)
if(ImguiState.Timers[i].TimerIndex == TimerIndex)
return &ImguiState.Timers[i];
if(ImguiState.NumTimers < MICROPROFILE_IMGUI_MAX_GRAPHS)
{
MicroProfileImguiTimerState* pState = &ImguiState.Timers[ImguiState.NumTimers++];
pState->TimerIndex = TimerIndex;
pState->nColor = MicroProfileGetColor(TimerIndex);
memset(&pState->fValues[0], 0, sizeof(pState->fValues));
return pState;
}
return nullptr;
}
void MicroProfileImguiTable(const MicroProfileImguiWindowDesc& Window, const MicroProfileImguiEntryDesc* Entries, uint32_t NumEntries)
{
using namespace ImGui;
const uint32_t NumColumns = 6;
ImGuiIO& io = ImGui::GetIO();
float Padding = GetStyle().CellPadding.x * 2;
float GroupWidth = CalcTextSize("Group").x;
float NameWidth = CalcTextSize("Name").x;
float BaseWidth = CalcTextSize("100000.00").x;
float Height = CalcTextSize("G").y + Padding;
for(uint32_t i = 0; i < NumEntries; ++i)
{
uint32_t TimerIndex = MicroProfileGetTimerIndex(Entries[i].GraphTimer);
const MicroProfileTimerInfo& TI = S.TimerInfo[TimerIndex];
const MicroProfileGroupInfo& GI = S.GroupInfo[TI.nGroupIndex];
GroupWidth = MicroProfileMax(GroupWidth, CalcTextSize(GI.pName).x);
NameWidth = MicroProfileMax(NameWidth, CalcTextSize(TI.pName).x);
}
float TableWidth = GroupWidth + NameWidth + BaseWidth * 4 + NumColumns * Padding + (NumColumns - 1) * GetStyle().ItemSpacing.x;
float TableHeight = Height * (NumEntries + 1);
ImVec2 TablePos = ImVec2(0.f, 0.f);
if(Window.Align == MICROPROFILE_IMGUI_ALIGN_TOP_RIGHT || Window.Align == MICROPROFILE_IMGUI_ALIGN_BOTTOM_RIGHT)
TablePos.x = io.DisplaySize.x - TableWidth;
if(Window.Align == MICROPROFILE_IMGUI_ALIGN_BOTTOM_LEFT || Window.Align == MICROPROFILE_IMGUI_ALIGN_BOTTOM_RIGHT)
TablePos.y = io.DisplaySize.y - TableHeight;
TablePos.x += Window.OffsetX;
TablePos.y += Window.OffsetY;
SetCursorScreenPos(TablePos);
if(BeginTable("MicroProfileImguiTable", NumColumns, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_NoHostExtendX))
{
TableSetupColumn("Group", ImGuiTableColumnFlags_WidthFixed, GroupWidth);
TableSetupColumn("Name", ImGuiTableColumnFlags_WidthFixed, NameWidth);
TableSetupColumn("Max", ImGuiTableColumnFlags_WidthFixed, BaseWidth);
TableSetupColumn("Min", ImGuiTableColumnFlags_WidthFixed, BaseWidth);
TableSetupColumn("Avg", ImGuiTableColumnFlags_WidthFixed, BaseWidth);
TableSetupColumn("Time", ImGuiTableColumnFlags_WidthFixed, BaseWidth);
TableHeadersRow();
for(uint32_t i = 0; i < NumEntries; ++i)
{
uint32_t TimerIndex = MicroProfileGetTimerIndex(Entries[i].GraphTimer);
MicroProfileTimerValues Values;
MicroProfileCalcTimers(TimerIndex, Values);
const MicroProfileTimerInfo& TI = S.TimerInfo[TimerIndex];
const MicroProfileGroupInfo& GI = S.GroupInfo[TI.nGroupIndex];
TableNextRow();
ImU32 RowBGColor = GetColorU32((i % 2) ? ImVec4(0.1f, 0.1f, 0.1f, 0.85f) : ImVec4(0.2f, 0.2f, 0.2f, 0.85f));
TableSetBgColor(ImGuiTableBgTarget_RowBg1, RowBGColor);
PushID(i);
float fMax = 0.f, fMin = 0.f, fAvg = 0.f, fTime = 0.f;
auto RightAlignedFloat = [](float f)
{
float CellWidth = GetContentRegionAvail().x;
char Buffer[32];
stbsp_snprintf(Buffer, sizeof(Buffer) - 1, "%.2f", f);
ImVec2 TextSize = CalcTextSize(Buffer);
SetCursorPosX(GetCursorPosX() + (CellWidth - TextSize.x));
TextUnformatted(Buffer);
};
TableSetColumnIndex(0);
Text(GI.pName);
TableSetColumnIndex(1);
Text(TI.pName);
TableSetColumnIndex(2);
RightAlignedFloat(Values.MaxMs);
TableSetColumnIndex(3);
RightAlignedFloat(Values.MinMs);
TableSetColumnIndex(4);
RightAlignedFloat(Values.AverageMs);
TableSetColumnIndex(5);
RightAlignedFloat(Values.TimeMs);
PopID();
}
EndTable();
}
}
void MicroProfileImguiGraphs(const MicroProfileImguiWindowDesc& Window, const MicroProfileImguiEntryDesc* Entries, uint32_t NumEntries)
{
using namespace ImGui;
ImGuiIO& io = ImGui::GetIO();
uint32_t Width = Window.GraphWidth;
uint32_t Height = (Window.GraphHeight + GetStyle().ItemSpacing.y) * NumEntries;
ImVec2 Pos = ImVec2(0.f, 0.f);
if(Window.Align == MICROPROFILE_IMGUI_ALIGN_TOP_RIGHT || Window.Align == MICROPROFILE_IMGUI_ALIGN_BOTTOM_RIGHT)
Pos.x = io.DisplaySize.x - Width;
if(Window.Align == MICROPROFILE_IMGUI_ALIGN_BOTTOM_LEFT || Window.Align == MICROPROFILE_IMGUI_ALIGN_BOTTOM_RIGHT)
Pos.y = io.DisplaySize.y - Height;
Pos.x += Window.OffsetX;
Pos.y += Window.OffsetY;
for(uint32_t i = 0; i < NumEntries; ++i)
{
SetCursorScreenPos(Pos);
uint32_t TimerIndex = MicroProfileGetTimerIndex(Entries[i].GraphTimer);
float GraphMax = Entries[i].GraphMax;
const MicroProfileTimerInfo& TI = S.TimerInfo[TimerIndex];
MicroProfileImguiTimerState* TimerState = MicroProfileImguiGetTimerState(TimerIndex);
PushID(i << 16 | TimerIndex);
if(TimerState->nColor == 0)
TimerState->nColor = MicroProfileGetColor(TimerIndex);
ImVec4 FrameBg = GetStyleColorVec4(ImGuiCol_FrameBg);
FrameBg.x = 0.15f;
FrameBg.y = 0.15f;
FrameBg.z = 0.15f;
FrameBg.w = 0.8f;
PushStyleColor(ImGuiCol_PlotLines, MicroProfileImGuiColor(TimerState->nColor));
PushStyleColor(ImGuiCol_FrameBg, FrameBg);
uint32_t Start = (ImguiState.GraphPut) % MICROPROFILE_IMGUI_GRAPH_SIZE;
uint32_t Last = (ImguiState.GraphPut + MICROPROFILE_IMGUI_GRAPH_SIZE - 1) % MICROPROFILE_IMGUI_GRAPH_SIZE;
PlotLines("", &TimerState->fValues[0], MICROPROFILE_IMGUI_GRAPH_SIZE, Start, nullptr, 0.f, GraphMax, ImVec2(Window.GraphWidth, Window.GraphHeight));
char TimeStr[32];
stbsp_snprintf(TimeStr, sizeof(TimeStr) - 1, "%.3fms", TimerState->fValues[Last]);
ImVec2 PlotMin = GetItemRectMin();
ImVec2 PlotMax = GetItemRectMax();
ImVec2 NameSize = CalcTextSize(TI.pName);
ImVec2 NamePos = ImVec2(PlotMin.x + 1, PlotMax.y - NameSize.y - 1);
ImVec2 TimeSize = CalcTextSize(TimeStr);
ImVec2 TimePos = ImVec2(PlotMax.x - TimeSize.x - 1, PlotMax.y - TimeSize.y - 1);
GetWindowDrawList()->AddText(NamePos, GetColorU32(ImGuiCol_Text), TI.pName);
GetWindowDrawList()->AddText(TimePos, GetColorU32(ImGuiCol_Text), TimeStr);
PopStyleColor();
PopStyleColor();
PopID();
Pos.y += Window.GraphHeight + GetStyle().ItemSpacing.y;
}
}
#endif
#undef uprintf
#undef S
#ifdef _WIN32
#pragma warning(pop)
#undef microprofile_fopen_helper
#endif
#ifdef MICROPROFILE_PS4
#define MICROPROFILE_PS4_IMPL
#include "microprofile_ps4.h"
#endif
#ifdef MICROPROFILE_XBOXONE
#define MICROPROFILE_XBOXONE_IMPL
#include "microprofile_xboxone.h"
#endif
#endif // #if MICROPROFILE_ENABLED
#include "microprofile_html.h"
#include "microprofile_icons.h"
#endif
Reference in a new issue View git blame Copy permalink