void CanMemberInsert(CanMemberStruct *Data, CanMemberInfo *CanMember)
{ unsigned long Uid;
CanMemberInfo *OldCanMember;
Uid = CanMemberInfoGetUid(CanMember);
OldCanMember = (CanMemberInfo *)MapGet(CanMemberGetCanMemberDb(Data),
(MapKeyType)Uid);
if (OldCanMember != (CanMemberInfo *)NULL)
{
CanMemberInfoSetIsInvalid(OldCanMember, FALSE);
CanMemberInfoSetUid(OldCanMember, CanMemberInfoGetUid(CanMember));
CanMemberInfoSetVersion(OldCanMember, CanMemberInfoGetVersion(CanMember));
CanMemberInfoSetType(OldCanMember, CanMemberInfoGetType(CanMember));
}
else
{
OldCanMember = (CanMemberInfo *)malloc(sizeof(CanMemberInfo));
if (OldCanMember != (CanMemberInfo *)NULL)
{
CanMemberInfoSetIsInvalid(OldCanMember, FALSE);
CanMemberInfoSetUid(OldCanMember, CanMemberInfoGetUid(CanMember));
CanMemberInfoSetVersion(OldCanMember, CanMemberInfoGetVersion(CanMember));
CanMemberInfoSetType(OldCanMember, CanMemberInfoGetType(CanMember));
MapSet(CanMemberGetCanMemberDb(Data),
(MapKeyType)Uid, (MapDataType)OldCanMember);
CanMemberSetNumMembers(Data, CanMemberGetNumMembers(Data) + 1);
}
}
}
void GleisbildInsert(GleisbildStruct *Data, GleisbildInfo *Gleisbild)
{ int Id;
GleisbildInfo *OldGleisbild;
Id = GleisbildInfoGetId(Gleisbild);
OldGleisbild = (GleisbildInfo *)MapGet(GleisbildGetGleisbildDb(Data),
(MapKeyType)Id);
if (OldGleisbild != (GleisbildInfo *)NULL)
{
GleisbildInfoSetId(OldGleisbild, GleisbildInfoGetId(Gleisbild));
GleisbildInfoSetName(OldGleisbild, GleisbildInfoGetName(Gleisbild));
GleisbildInfoSetZustand(OldGleisbild, GleisbildInfoGetZustand(Gleisbild));
}
else
{
OldGleisbild = (GleisbildInfo *)malloc(sizeof(GleisbildInfo));
if (OldGleisbild != (GleisbildInfo *)NULL)
{
GleisbildInfoSetId(OldGleisbild, GleisbildInfoGetId(Gleisbild));
GleisbildInfoSetName(OldGleisbild, GleisbildInfoGetName(Gleisbild));
GleisbildInfoSetZustand(OldGleisbild,
GleisbildInfoGetZustand(Gleisbild));
MapSet(GleisbildGetGleisbildDb(Data),
(MapKeyType)Id, (MapDataType)OldGleisbild);
}
}
}
///////////////////////////////////////////////////////////////
//
// CPerfStatFunctionTimingImpl::UpdateTiming
//
//
//
///////////////////////////////////////////////////////////////
void CPerfStatFunctionTimingImpl::UpdateTiming ( const SString& strResourceName, const char* szFunctionName, TIMEUS timeUs, uint uiDeltaBytes )
{
if ( !m_bIsActive )
return;
// Ignore any single calls under lowest threshold from any viewer
if ( timeUs < ms_PeakUsThresh )
return;
float fTimeMs = timeUs * ( 1 / 1000.f );
// Record the timing
SFunctionTimingInfo& item = MapGet ( m_TimingMap, szFunctionName );
item.now5s.uiNumCalls++;
item.now5s.fTotalMs += fTimeMs;
item.now5s.fPeakMs = Max ( item.now5s.fPeakMs, fTimeMs );
if ( item.now5s.fResBiggestMs < fTimeMs )
{
item.now5s.fResBiggestMs = fTimeMs;
item.now5s.strResBiggestMsName = strResourceName;
}
item.now5s.uiTotalBytes += uiDeltaBytes;
item.now5s.uiPeakBytes = Max ( item.now5s.uiPeakBytes, uiDeltaBytes );
if ( item.now5s.uiResBiggestBytes < uiDeltaBytes )
{
item.now5s.uiResBiggestBytes = uiDeltaBytes;
item.now5s.strResBiggestBytesName = strResourceName;
}
}
///////////////////////////////////////////////////////////////
//
// CPerfStatDebugTableImpl::UpdateLine
//
// Add/update a line by a string key.
//
///////////////////////////////////////////////////////////////
void CPerfStatDebugTableImpl::UpdateLine ( const SString& strKey, int iLifeTimeMs, ... )
{
LOCK_SCOPE ( m_CS );
SLineInfo& info = MapGet( m_LineMap, strKey );
info.strCellList.clear ();
// Get cells
va_list vl;
va_start ( vl, iLifeTimeMs );
while ( true )
{
char* szText = va_arg ( vl, char* );
if ( !szText )
break;
info.strCellList.push_back ( szText );
}
va_end ( vl );
if ( info.strCellList.empty () )
info.strCellList.push_back ( "" );
// Update end time
info.bHasEndTime = ( iLifeTimeMs > 0 );
if ( info.bHasEndTime )
info.endTickCount = CTickCount::Now ( true ) + CTickCount ( (long long)iLifeTimeMs );
}
void LokInsert(LokStruct *Data, LokInfo *Lok)
{ char *Name;
LokInfo *OldLok;
Name = LokInfoGetName(Lok);
if (strlen(Name) > 0)
{
OldLok = (LokInfo *)MapGet(LokGetLokDb(Data), (MapKeyType)Name);
if (OldLok != (LokInfo *)NULL)
{
if (!LokIsEqual(OldLok, Lok))
{
LokSetIsChanged(Data, TRUE);
memcpy(OldLok, Lok, sizeof(LokInfo));
}
LokInfoSetIsDeleted(OldLok, FALSE);
}
else
{
OldLok = (LokInfo *)malloc(sizeof(LokInfo));
if (OldLok != (LokInfo *)NULL)
{
LokSetIsChanged(Data, TRUE);
memcpy(OldLok, Lok, sizeof(LokInfo));
LokInfoSetIsDeleted(OldLok, FALSE);
MapSet(LokGetLokDb(Data),
(MapKeyType)LokInfoGetName(OldLok),
(MapDataType)OldLok);
LokSetNumLoks(Data, LokGetNumLoks(Data) + 1);
}
}
}
}
// Get a clump which has been loaded to replace the specified model id
RpClump* CClientDFF::GetLoadedClump(ushort usModelId)
{
if (usModelId == 0)
return NULL;
SLoadedClumpInfo& info = MapGet(m_LoadedClumpInfoMap, usModelId);
if (!info.bTriedLoad)
{
info.bTriedLoad = true;
// Make sure previous model+collision is loaded
m_pManager->GetModelRequestManager()->RequestBlocking(usModelId, "CClientDFF::LoadDFF");
// Attempt loading it
if (!m_bIsRawData) // We have file
{
if (g_pCore->GetNetwork()->CheckFile("dff", m_strDffFilename))
{
g_pClientGame->GetResourceManager()->ValidateResourceFile(m_strDffFilename, CBuffer());
info.pClump = g_pGame->GetRenderWare()->ReadDFF(m_strDffFilename, CBuffer(), usModelId, CClientVehicleManager::IsValidModel(usModelId));
}
}
else // We have raw data
{
info.pClump = g_pGame->GetRenderWare()->ReadDFF(NULL, m_RawDataBuffer, usModelId, CClientVehicleManager::IsValidModel(usModelId));
// Remove raw data from memory (can only do one replace when using raw data)
m_RawDataBuffer.Clear();
}
}
return info.pClump;
}
void DebugDestroyCount ( const SString& strName )
{
SDebugCountInfo& info = MapGet ( ms_DebugCountMap, strName );
info.iCount--;
if ( info.iCount < 0 )
OutputDebugLine ( SString ( "[InstanceCount] Count is negative (%d) for %s", info.iCount, *strName ) );
}
///////////////////////////////////////////////////////////////
//
// CPerfStatEventPacketUsageImpl::UpdateEventUsageOut
//
//
//
///////////////////////////////////////////////////////////////
void CPerfStatEventPacketUsageImpl::UpdateEventUsageOut ( const char* szName, uint uiNumPlayers )
{
if ( !m_bEnabled )
return;
SEventUsage& usage = MapGet( m_EventUsageLiveMap, szName );
usage.iTotal += uiNumPlayers;
usage.iEventOut += uiNumPlayers;
}
///////////////////////////////////////////////////////////////
//
// CPerfStatEventPacketUsageImpl::UpdateElementDataUsageRelayed
//
//
//
///////////////////////////////////////////////////////////////
void CPerfStatEventPacketUsageImpl::UpdateElementDataUsageRelayed ( const char* szName, uint uiNumPlayers, uint uiSize )
{
if ( !m_bEnabled )
return;
SEventUsage& usage = MapGet( m_EventUsageLiveMap, szName );
usage.iTotal += uiNumPlayers;
usage.iElementDataRelay += uiNumPlayers;
}
void DebugCreateCount ( const SString& strName )
{
SDebugCountInfo& info = MapGet ( ms_DebugCountMap, strName );
info.iCount++;
if ( info.iCount > info.iHigh )
{
info.iHigh = info.iCount;
OutputDebugLine ( SString ( "[InstanceCount] New high of %d for %s", info.iCount, *strName ) );
}
}
void LokMarkDeleted(LokStruct *Data, char *Name)
{ LokInfo *Lok;
Lok = (LokInfo *)MapGet(LokGetLokDb(Data), (MapKeyType)Name);
if (Lok != (LokInfo *)NULL)
{
LokInfoSetIsDeleted(Lok, TRUE);
LokSetNumLoks(Data, LokGetNumLoks(Data) - 1);
}
}
void ConfigAddStrVal(ConfigStruct *Data, CfgStrValues ValueTyp, char *Value)
{ char *p;
IniValue *ValuePtr;
switch (ValueTyp)
{
case CfgIfaceVal:
p = INI_STR_IFACE;
break;
case CfgAddrVal:
p = INI_STR_ADDRESS;
break;
case CfgCanIfVal:
p = INI_STR_CAN_IFACE;
break;
case CfgPathVal:
p = INI_STR_CS2_PATH;
break;
case CfgUdpBcVal:
p = INI_STR_UDP_BC;
break;
case CfgStartVal:
p = INI_STR_START;
break;
case CfgWakeUpS88:
p = INI_STR_WAKEUP_S88;
break;
case CfgGpioS88:
p = INI_STR_GPIO_S88;
break;
case CfgHideMs2Val:
p = INI_STR_HIDE_MS2;
break;
case CfgSerialLineVal:
p = INI_STR_SERIAL_LINE;
break;
}
ValuePtr = (IniValue *)MapGet(ConfigGetConfig(Data), (MapKeyType)p);
if (ValuePtr == (IniValue *)NULL)
{
ValuePtr = malloc(sizeof(IniValue));
ValuePtr->DataType = IniParsString;
ValuePtr->IntValue = 0;
strcpy(ValuePtr->StringValue, Value);
MapSet(ConfigGetConfig(Data), (MapKeyType)strdup(p),
(MapDataType)ValuePtr);
}
else
{
ValuePtr->DataType = IniParsString;
ValuePtr->IntValue = 0;
strcpy(ValuePtr->StringValue, Value);
}
}
void Cs2CfgDataSetLen(Cs2CfgData *Data, unsigned int CanHash,
unsigned long Length)
{ Cs2CfgEntry *Entry;
Entry = (Cs2CfgEntry *)MapGet(Cs2CfgDataGetCfgDatas(Data),
(MapKeyType)CanHash);
if (Entry != (Cs2CfgEntry *)NULL)
{
Cs2CfgEntrySetCfgLength(Entry, Length);
}
}
void FsStatInsert(FahrstrasseStruct *Data, FahrstrasseInfo *Fahrstrasse)
{ int Id;
FahrstrasseInfo *OldFahrstrasse;
Id = FahrstrasseInfoGetId(Fahrstrasse);
OldFahrstrasse = (FahrstrasseInfo *)MapGet(FahrstrasseGetFahrstrasseDb(Data),
(MapKeyType)Id);
if (OldFahrstrasse != (FahrstrasseInfo *)NULL)
{
FahrstrasseInfoSetOn(OldFahrstrasse,
FahrstrasseInfoGetOn(Fahrstrasse));
}
}
BOOL Cs2CfgDataAllRead(Cs2CfgData *Data, unsigned int CanHash)
{ Cs2CfgEntry *Entry;
Entry = (Cs2CfgEntry *)MapGet(Cs2CfgDataGetCfgDatas(Data),
(MapKeyType)CanHash);
if (Entry != (Cs2CfgEntry *)NULL)
{
return(Cs2CfgEntryGetCfgHaveRead(Entry) >= Cs2CfgEntryGetCfgLength(Entry));
}
else
{
return(FALSE);
}
}
unsigned long Cs2CfgDataGetLen(Cs2CfgData *Data, unsigned int CanHash)
{ Cs2CfgEntry *Entry;
Entry = (Cs2CfgEntry *)MapGet(Cs2CfgDataGetCfgDatas(Data),
(MapKeyType)CanHash);
if (Entry != (Cs2CfgEntry *)NULL)
{
return(Cs2CfgEntryGetCfgHaveRead(Entry));
}
else
{
return(0);
}
}
BOOL Cs2CfgDataGetIsCompressed(Cs2CfgData *Data, unsigned int CanHash)
{ Cs2CfgEntry *Entry;
Entry = (Cs2CfgEntry *)MapGet(Cs2CfgDataGetCfgDatas(Data),
(MapKeyType)CanHash);
if (Entry != (Cs2CfgEntry *)NULL)
{
return(Cs2CfgEntryGetIsZlibCompressed(Entry));
}
else
{
return(TRUE);
}
}
char *Cs2CfgDataGetBuf(Cs2CfgData *Data, unsigned int CanHash)
{ Cs2CfgEntry *Entry;
Entry = (Cs2CfgEntry *)MapGet(Cs2CfgDataGetCfgDatas(Data),
(MapKeyType)CanHash);
if (Entry != (Cs2CfgEntry *)NULL)
{
return(Cs2CfgEntryGetCfgBuffer(Entry));
}
else
{
return((char *)NULL);
}
}
///////////////////////////////////////////////////////////////
//
// CPerfStatFunctionTimingImpl::UpdateTiming
//
//
//
///////////////////////////////////////////////////////////////
void CPerfStatFunctionTimingImpl::UpdateTiming ( const char* szFunctionName, TIMEUS timeUs )
{
if ( !m_bIsActive )
return;
// Ignore any single calls over lowest threshold from any viewer
if ( timeUs < m_PeakUsThresh )
return;
float fTimeMs = timeUs * ( 1 / 1000.f );
// Record the timing
SFunctionTimingInfo& item = MapGet ( m_TimingMap, szFunctionName );
item.now5s.uiNumCalls++;
item.now5s.fTotalMs += fTimeMs;
item.now5s.fPeakMs = Max ( item.now5s.fPeakMs, fTimeMs );
}
BOOL Cs2CfgDataNextBuf(Cs2CfgData *Data, unsigned int CanHash, char *Buf)
{ Cs2CfgEntry *Entry;
Entry = (Cs2CfgEntry *)MapGet(Cs2CfgDataGetCfgDatas(Data),
(MapKeyType)CanHash);
if (Entry != (Cs2CfgEntry *)NULL)
{
memcpy(Cs2CfgEntryGetCfgBuffer(Entry) + Cs2CfgEntryGetCfgHaveRead(Entry),
Buf, 8);
Cs2CfgEntrySetCfgHaveRead(Entry, Cs2CfgEntryGetCfgHaveRead(Entry) + 8);
return(Cs2CfgEntryGetCfgHaveRead(Entry) >= Cs2CfgEntryGetCfgLength(Entry));
}
else
{
return(FALSE);
}
}
void Cs2CfgDataEnd(Cs2CfgData *Data, unsigned int CanHash)
{ Cs2CfgEntry *Entry;
Entry = (Cs2CfgEntry *)MapGet(Cs2CfgDataGetCfgDatas(Data),
(MapKeyType)CanHash);
if (Entry != (Cs2CfgEntry *)NULL)
{
Cs2CfgEntrySetCfgLength(Entry, 0);
Cs2CfgEntrySetCfgHaveRead(Entry, 0l);
if (Cs2CfgEntryGetCfgBuffer(Entry) != (char *)NULL)
{
free(Cs2CfgEntryGetCfgBuffer(Entry));
Cs2CfgEntrySetCfgBuffer(Entry, (char *)NULL);
}
MapDel(Cs2CfgDataGetCfgDatas(Data), (MapKeyType)CanHash);
}
}
char *ConfigGetStrVal(ConfigStruct *Data, CfgStrValues Value)
{ IniValue *CfgWert;
char *p;
switch (Value)
{
case CfgIfaceVal:
p = INI_STR_IFACE;
break;
case CfgAddrVal:
p = INI_STR_ADDRESS;
break;
case CfgCanIfVal:
p = INI_STR_CAN_IFACE;
break;
case CfgPathVal:
p = INI_STR_CS2_PATH;
break;
case CfgUdpBcVal:
p = INI_STR_UDP_BC;
break;
case CfgStartVal:
p = INI_STR_START;
break;
case CfgWakeUpS88:
p = INI_STR_WAKEUP_S88;
break;
case CfgGpioS88:
p = INI_STR_GPIO_S88;
break;
case CfgHideMs2Val:
p = INI_STR_HIDE_MS2;
break;
case CfgSerialLineVal:
p = INI_STR_SERIAL_LINE;
break;
}
CfgWert = (IniValue *)MapGet(ConfigGetConfig(Data), (MapKeyType)p);
if (CfgWert != (IniValue *)NULL)
return(CfgWert->StringValue);
else
return(EmptyString);
}
CanMemberInfo *CanMemberSearch(CanMemberStruct *Data, unsigned long Uid)
{
return((CanMemberInfo *)MapGet(CanMemberGetCanMemberDb(Data),
(MapKeyType)Uid));
}
int EscValue::GetFieldInt(const char *id) const
{
return HasNumberField(id) ? MapGet(id).GetInt() : 0;
}
BOOL IniParsReadFile(IniParsStruct *Data, Map *CfgValues)
{ int Token, i;
BOOL Ret;
IniValue *ValuePtr;
Ret = TRUE;
do {
Token = Scan(IniParsGetScanner(Data));
if (Token == EofSy)
{
}
else if (Token == HashSy)
{
ScanUeberlesen(IniParsGetScanner(Data));
Token = Scan(IniParsGetScanner(Data));
}
else
{
i = 0;
while ((i < IniParsGetAnzKeywords(Data)) &&
(IniParsGetKeywords(Data)[i].Symbol != Token))
{
i++;
}
if (i < IniParsGetAnzKeywords(Data))
{
Token = Scan(IniParsGetScanner(Data));
if ((IniParsGetKeywords(Data)[i].DataType == IniParsString) &&
(Token == ZeichenkettenSy))
{
ValuePtr = (IniValue *)MapGet(CfgValues,
(MapKeyType)IniParsGetKeywords(Data)[i].Keyword);
if (ValuePtr == (IniValue *)NULL)
{
ValuePtr = malloc(sizeof(IniValue));
ValuePtr->DataType = IniParsString;
ValuePtr->IntValue = 0;
ScanString(IniParsGetScanner(Data), ValuePtr->StringValue);
MapSet(CfgValues,
(MapKeyType *)strdup(IniParsGetKeywords(Data)[i].Keyword),
(MapDataType)ValuePtr);
}
else
{
ValuePtr->DataType = IniParsString;
ValuePtr->IntValue = 0;
ScanString(IniParsGetScanner(Data), ValuePtr->StringValue);
}
}
else if ((IniParsGetKeywords(Data)[i].DataType == IniParsInt) &&
(Token == GzahlSy))
{
ValuePtr = (IniValue *)MapGet(CfgValues,
(MapKeyType)IniParsGetKeywords(Data)[i].Keyword);
if (ValuePtr == (IniValue *)NULL)
{
ValuePtr = malloc(sizeof(IniValue));
ValuePtr->DataType = IniParsInt;
ValuePtr->IntValue = ScanGanz(IniParsGetScanner(Data));
ValuePtr->StringValue[0] = '\0';
MapSet(CfgValues,
(MapKeyType)strdup(IniParsGetKeywords(Data)[i].Keyword),
(MapDataType)ValuePtr);
}
else
{
ValuePtr->DataType = IniParsInt;
ValuePtr->IntValue = ScanGanz(IniParsGetScanner(Data));
ValuePtr->StringValue[0] = '\0';
}
}
else
{
Ret = FALSE;
}
}
else
{
Token = Scan(IniParsGetScanner(Data));
Ret = FALSE;
}
Token = Scan(IniParsGetScanner(Data));
if (Token == HashSy)
{
ScanUeberlesen(IniParsGetScanner(Data));
Token = Scan(IniParsGetScanner(Data));
}
}
} while (Token != EofSy);
return(Ret);
}
///////////////////////////////////////////////////////////////
//
// CStatEvents::Sample
//
//
//
///////////////////////////////////////////////////////////////
void CStatEvents::Sample ( SStatCollection& m_StatCollection )
{
// For each clock, make a count
// For each clock/unclock pair, add the time
//
// Put data from input buffer into a SFrameCollection as events
//
SFrameCollection frameCollection;
TIMEUS baseTimeStamp = 0;
{
for ( int i = 0 ; i < m_BufferPos ; i++ )
{
SItem& item = m_ItemBufferArray[i];
const char* szSection = item.szSection;
const char* szName = item.szName;
if ( baseTimeStamp == 0 )
baseTimeStamp = item.timeStamp;
// Get SFrameSection for section
SFrameSection& frameSection = MapGet ( frameCollection, szSection );
frameSection.szSectionName = szSection;
// Get SFrameEventList for name
SFrameEventList& frameEvents = MapGet ( frameSection, szName );
frameEvents.szEventListName = szName;
// Append event
frameEvents.push_back ( SFrameEvent ( item.type, item.timeStamp ) );
}
}
// Clear input buffer
ClearBuffer( false );
//
// Put events into a SStatCollection
//
m_StatCollection.clear ();
// For each FrameSection
std::map <SString,SFrameSection> ::iterator itCollection = frameCollection.begin ();
for ( ; itCollection != frameCollection.end () ; itCollection++ )
{
const SString& strSectionName = itCollection->first;
SFrameSection& frameSection = itCollection->second;
// For each FrameEventList
std::map <SString,SFrameEventList> ::iterator itSection = frameSection.begin ();
for ( ; itSection != frameSection.end () ; itSection++ )
{
const SString& strItemName = itSection->first;
SFrameEventList& frameEvents = itSection->second;
int iFakeHits = CloseOpenEvents ( frameEvents, frameSection.szSectionName, frameEvents.szEventListName );
ValidateEventList ( frameEvents );
int iHitCount = frameEvents.size() / 2 - iFakeHits;
float fTotalMs = 0;
// Do each SFrameEvent
std::vector<SFrameEvent> ::const_iterator itEvents = frameEvents.begin ();
for ( ; itEvents != frameEvents.end () ; )
{
const SFrameEvent& StartEvent = *itEvents++;
if ( itEvents == frameEvents.end () )
break;
const SFrameEvent& EndEvent = *itEvents++;
if ( StartEvent.type != STATS_CLOCK || EndEvent.type != STATS_UNCLOCK )
{
// Error
fTotalMs = 999;
continue;
}
float StartMs = ( StartEvent.timeStamp - baseTimeStamp ) * ( 1 / 1000.0f ); // TIMEUS to ms
float EndMs = ( EndEvent.timeStamp - baseTimeStamp ) * ( 1 / 1000.0f );
float LengthMs = EndMs-StartMs;
fTotalMs += LengthMs;
}
// Add an item into SStatCollection
SStatSection& section = MapGet ( m_StatCollection, strSectionName );
SStatItem& item = MapGet ( section, strItemName );
item.iCounter += iHitCount;
item.fMs += fTotalMs;
}
}
}
GleisbildInfo *GleisbildSearch(GleisbildStruct *Data, int Id)
{
return((GleisbildInfo *)MapGet(GleisbildGetGleisbildDb(Data),
(MapKeyType)Id));
}
int main() {
Stack st;
int val;
st.top = NULL;
/* Stack test */
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
StackPush(&st, 5);
StackPush(&st, 6);
StackPush(&st, 7);
while ((val = StackPop(&st)) != -1)
printf("%d\n", val);
/* Hashmap test */
Map map;
MapInit(&map);
MapInsert(&map, "1>", 1);
MapInsert(&map, "2>", 2);
MapInsert(&map, "3>", 3);
MapInsert(&map, "4>", 4);
MapInsert(&map, "5>", 5);
MapInsert(&map, "6>", 6);
MapInsert(&map, "7>", 7);
MapInsert(&map, "8>", 8);
MapInsert(&map, "9>", 9);
printf("%d\n", MapGet(&map, "1>"));
printf("%d\n", MapGet(&map, "2>"));
printf("%d\n", MapGet(&map, "3>"));
printf("%d\n", MapGet(&map, "4>"));
printf("%d\n", MapGet(&map, "5>"));
printf("%d\n", MapGet(&map, "6>"));
printf("%d\n", MapGet(&map, "7>"));
printf("%d\n", MapGet(&map, "8>"));
printf("%d\n", MapGet(&map, "9>"));
MapRemove(&map, "1>");
printf("%d\n", MapGet(&map, "1>"));
MapInsert(&map, "2>", 22);
printf("%d\n", MapGet(&map, "2>"));
MapRemove(&map, "2>");
printf("%d\n", MapGet(&map, "2>"));
return 0;
}
///////////////////////////////////////////////////////////////
//
// CStatResults::FrameEnd
//
// Save all stats in a ResultCollection
//
///////////////////////////////////////////////////////////////
void CStatResults::FrameEnd ( void )
{
CLOCK( "Profiling", "Compile stats" );
SStatResultCollection& collection = m_CollectionCombo;
bool bClearMax = false;
float fNextLength = (float)GetSecondCount () - m_fNextMaxClearTime;
if ( fNextLength >= 2.0f )
{
bClearMax = true;
m_fNextMaxClearTime = (float)GetSecondCount ();
}
// Clear max time thing
for ( std::map < std::string, SStatResultSection > :: iterator itSection = collection.begin () ; itSection != collection.end () ; itSection++ )
{
SStatResultSection& section = itSection->second;
for ( std::map < std::string, SStatResultItem > :: iterator itItem = section.begin () ; itItem != section.end () ; itItem++ )
{
SStatResultItem& item = itItem->second;
item.iCounter = 0;
item.fMs = 0;
if ( bClearMax )
{
item.fMsMax = item.fMsMaxNext;
item.fMsMaxNext = 0;
item.fMsTotal = item.fMsTotalAcc;
item.fMsTotalPercent = item.fMsTotalAcc / fNextLength * 0.1f;
item.fMsTotalAcc = 0;
item.iCounterTotal = item.iCounterTotalAcc;
item.iCounterTotalAcc = 0;
}
}
}
// Retrieve stats from g_StatEvents
{
SStatCollection collectionSrc;
g_StatEvents.Sample ( collectionSrc );
const SStatCollection* pCollectionSrc = &collectionSrc;
// Merge collections
// Merge section maps
for ( std::map < std::string, SStatSection > :: const_iterator itSectionSrc = pCollectionSrc->begin () ; itSectionSrc != pCollectionSrc->end () ; itSectionSrc++ )
{
const std::string& strSectionNameSrc = itSectionSrc->first;
const SStatSection& sectionSrc = itSectionSrc->second;
// Merge sections
SStatResultSection& sectionCombo = MapGet ( m_CollectionCombo, strSectionNameSrc );
// Merge item maps
for ( std::map < std::string, SStatItem > :: const_iterator itItemSrc = sectionSrc.begin () ; itItemSrc != sectionSrc.end () ; itItemSrc++ )
{
const std::string& strItemNameSrc = itItemSrc->first;
const SStatItem& itemSrc = itItemSrc->second;
// Merge item
SStatResultItem& itemCombo = MapGet ( sectionCombo, strItemNameSrc );
itemCombo.iCounter += itemSrc.iCounter;
itemCombo.fMs += itemSrc.fMs;
}
}
}
// Update some counters and stuff
for ( std::map < std::string, SStatResultSection > :: iterator itSection = collection.begin () ; itSection != collection.end () ; itSection++ )
{
SStatResultSection& section = itSection->second;
for ( std::map < std::string, SStatResultItem > :: iterator itItem = section.begin () ; itItem != section.end () ; itItem++ )
{
SStatResultItem& item = itItem->second;
item.fMsMaxNext = Max ( item.fMsMaxNext, item.fMs );
item.fMsTotalAcc += item.fMs;
item.iCounterTotalAcc += item.iCounter;
}
}
UNCLOCK( "Profiling", "Compile stats" );
}
///////////////////////////////////////////////////////////////
//
// CModelCacheManagerImpl::UpdateModelCaching
//
///////////////////////////////////////////////////////////////
void CModelCacheManagerImpl::UpdateModelCaching ( const std::map < ushort, float >& newNeedCacheList, std::map < ushort, SModelCacheInfo >& currentCacheInfoMap, uint uiMaxCachedAllowed )
{
// Update some flags and remove info for uncached and unneeded
for ( std::map < ushort, SModelCacheInfo >::iterator iter = currentCacheInfoMap.begin () ; iter != currentCacheInfoMap.end () ; )
{
const ushort usModelId = iter->first;
SModelCacheInfo& info = iter->second;
info.bIsModelLoadedByGame = GetModelRefCount ( usModelId ) > ( info.bIsModelCachedHere ? 1 : 0 );
if ( !info.bIsModelLoadedByGame && !info.bIsModelCachedHere )
{
if ( ( m_TickCountNow - info.lastNeeded ).ToInt () > 1000 )
{
// Not loaded, cached or needed for 1 second, so remove info
currentCacheInfoMap.erase ( iter++ );
continue;
}
}
++iter;
}
// Update current from new needed
for ( std::map < ushort, float >::const_iterator iter = newNeedCacheList.begin () ; iter != newNeedCacheList.end () ; ++iter )
{
SModelCacheInfo& info = MapGet ( currentCacheInfoMap, iter->first );
info.fClosestDistSq = iter->second;
info.lastNeeded = m_TickCountNow;
if ( info.firstNeeded.ToInt () == 0 )
info.firstNeeded = m_TickCountNow;
}
uint uiNumModelsCachedHereOnly = 0;
std::map < uint, ushort > maybeUncacheUnneededList;
std::map < uint, ushort > maybeUncacheNeededList;
std::map < uint, ushort > maybeCacheList;
// Update active
for ( std::map < ushort, SModelCacheInfo >::iterator iter = currentCacheInfoMap.begin () ; iter != currentCacheInfoMap.end () ; ++iter )
{
const ushort usModelId = iter->first;
SModelCacheInfo& info = iter->second;
if ( info.bIsModelLoadedByGame )
{
info.lastNeeded = m_TickCountNow;
// Add cache ref here so when game tries to unload the model, we can keep it loaded
if ( !info.bIsModelCachedHere )
{
AddModelRefCount ( usModelId );
info.bIsModelCachedHere = true;
}
}
else
{
if ( info.bIsModelCachedHere )
{
uiNumModelsCachedHereOnly++;
// Update cached models that could be uncached
uint uiTicksSinceLastNeeded = ( m_TickCountNow - info.lastNeeded ).ToInt ();
if ( uiTicksSinceLastNeeded > 0 )
MapSet ( maybeUncacheUnneededList, uiTicksSinceLastNeeded, usModelId );
else
MapSet ( maybeUncacheNeededList, (int)info.fClosestDistSq, usModelId );
}
else
{
if ( info.lastNeeded == m_TickCountNow )
{
// Update uncached models that could be cached
uint uiTicksSinceFirstNeeded = ( m_TickCountNow - info.firstNeeded ).ToInt ();
MapSet ( maybeCacheList, uiTicksSinceFirstNeeded, usModelId );
}
}
}
}
// If at or above cache limit, try to uncache unneeded first
if ( uiNumModelsCachedHereOnly >= uiMaxCachedAllowed && !maybeUncacheUnneededList.empty () )
{
const ushort usModelId = maybeUncacheUnneededList.rbegin ()->second;
SModelCacheInfo* pInfo = MapFind ( currentCacheInfoMap, usModelId );
assert ( pInfo );
assert ( pInfo->bIsModelCachedHere );
SubModelRefCount ( usModelId );
pInfo->bIsModelCachedHere = false;
MapRemove ( currentCacheInfoMap, usModelId );
OutputDebugLine ( SString ( "[Cache] End caching model %d (UncacheUnneeded)", usModelId ) );
}
else
if ( uiNumModelsCachedHereOnly > uiMaxCachedAllowed && !maybeUncacheNeededList.empty () )
{
// Only uncache from the needed list if above limit
// Uncache furthest away model
const ushort usModelId = maybeUncacheNeededList.rbegin ()->second;
SModelCacheInfo* pInfo = MapFind ( currentCacheInfoMap, usModelId );
assert ( pInfo );
assert ( pInfo->bIsModelCachedHere );
SubModelRefCount ( usModelId );
pInfo->bIsModelCachedHere = false;
MapRemove ( currentCacheInfoMap, usModelId );
OutputDebugLine ( SString ( "[Cache] End caching model %d (UncacheNeeded)", usModelId ) );
}
// Cache if room
if ( !maybeCacheList.empty () && uiNumModelsCachedHereOnly < uiMaxCachedAllowed )
{
// Cache one which has been waiting the longest
const ushort usModelId = maybeCacheList.rbegin ()->second;
SModelCacheInfo* pInfo = MapFind ( currentCacheInfoMap, usModelId );
assert ( pInfo );
assert ( !pInfo->bIsModelCachedHere );
AddModelRefCount ( usModelId );
pInfo->bIsModelCachedHere = true;
OutputDebugLine ( SString ( "[Cache] Start caching model %d", usModelId ) );
}
}
