/////////////////////////////////////////////////////////////// // // CPerfStatSqliteTimingImpl::UpdateSqliteTiming // // // /////////////////////////////////////////////////////////////// void CPerfStatSqliteTimingImpl::UpdateSqliteTiming(CRegistry* pRegistry, const char* szQuery, TIMEUS timeUs) { // Only record stats if requested if (GetTickCount64_() > m_llRecordStatsEndTime) return; CTimingInfo info; info.strQuery = szQuery; info.timeUs = timeUs; info.timeStamp = GetTickCount64_(); // Get resource name if (m_currentluaVM) if (CResource* pResource = g_pGame->GetResourceManager()->GetResourceFromLuaState(m_currentluaVM)) info.resourceName = pResource->GetName(); m_currentluaVM = NULL; // Use registry name if resource name empty if (info.resourceName.empty()) if (SString* pRegistryName = MapFind(m_RegistryMap, pRegistry)) info.resourceName = *pRegistryName; info.resourceName = info.resourceName.SplitRight("/", NULL, -1); m_TimingList.push_back(info); }
/////////////////////////////////////////////////////////////// // // CRemoteMasterServer::Refresh // // // /////////////////////////////////////////////////////////////// void CRemoteMasterServer::Refresh ( void ) { // If it's been less than a minute and we has data, don't send a new request if ( GetTickCount64_ () - m_llLastRefreshTime < 60000 && m_strStage == "hasdata" ) return; // Send new request m_strStage = "waitingreply"; m_llLastRefreshTime = GetTickCount64_ (); AddRef(); // Keep alive GetHTTP()->QueueFile( m_strURL, NULL, 0, NULL, 0, false, this, &CRemoteMasterServer::StaticDownloadFinished, false, 1 ); }
void CAccessControlListManager::ClearReadCache ( void ) { m_bReadCacheDirty = false; m_llLastTimeReadCacheCleared = GetTickCount64_ (); m_ReadCacheMap.clear (); m_uiGlobalRevision++; }
CPerModuleTickCount ( void ) { #ifdef _DEBUG m_TimeSinceUpdated.SetMaxIncrement ( 500 ); #endif m_ResultValue.Initialize ( GetTickCount64_ () ); }
void Update ( void ) { #ifdef _DEBUG m_TimeSinceUpdated.Reset (); #endif m_ResultValue.SetValue ( GetTickCount64_ () ); }
/////////////////////////////////////////////////////////////// // // CPerfStatEventPacketUsageImpl::MaybeRecordStats // // // /////////////////////////////////////////////////////////////// void CPerfStatEventPacketUsageImpl::MaybeRecordStats ( void ) { // Someone watching? if ( m_TimeSinceGetStats.Get () < 10000 ) { // Time for record update? // Copy and clear once every 5 seconds long long llTime = GetTickCount64_ (); if ( llTime >= m_llNextRecordTime ) { m_llNextRecordTime = std::max ( m_llNextRecordTime + 5000, llTime + 5000 / 10 * 9 ); // Copy into a list and sort m_EventUsageSortedList.clear(); for( std::map < SString, SEventUsage >::iterator iter = m_EventUsageLiveMap.begin() ; iter != m_EventUsageLiveMap.end() ; ++iter ) { iter->second.strName = iter->first; m_EventUsageSortedList.push_back( iter->second ); } std::sort ( m_EventUsageSortedList.begin (), m_EventUsageSortedList.end (), [](const SEventUsage& a, const SEventUsage& b) { return a.iTotal > b.iTotal; }); m_EventUsageLiveMap.clear(); } } else { m_bEnabled = false; } }
/////////////////////////////////////////////////////////////// // // CPerfStatPlayerPacketUsageImpl::DoPulse // // // /////////////////////////////////////////////////////////////// void CPerfStatPlayerPacketUsageImpl::DoPulse ( void ) { long long llTickCount = GetTickCount64_ (); long long llDelta = llTickCount - m_LastTickCount; if ( llDelta >= 1000 ) { UpdatePlayerPacketUsage(); m_LastTickCount = m_LastTickCount + 1000; m_LastTickCount = std::max ( m_LastTickCount, llTickCount - 1500 ); int flags = 0; m_SecondCounter++; if ( m_SecondCounter % 5 == 0 ) // 5 second flags |= 1; if ( m_SecondCounter % 60 == 0 ) // 60 seconds flags |= 2; if ( m_SecondCounter % (5*60) == 0 ) // 5 mins flags |= 4; if ( m_SecondCounter % (60*60) == 0 ) // 60 mins flags |= 8; m_AllPlayerPacketUsage.Pulse1s ( flags ); } }
void CPlayer::SetDamageInfo ( ElementID ElementID, unsigned char ucWeapon, unsigned char ucBodyPart ) { m_PlayerAttackerID = ElementID; m_ucAttackWeapon = ucWeapon; m_ucAttackBodyPart = ucBodyPart; m_llSetDamageInfoTime = GetTickCount64_ (); }
CConnectHistoryItem& CConnectHistory::GetHistoryItem ( const string& strIP ) { // Find existing map < string, CConnectHistoryItem >::iterator iter = m_HistoryItemMap.find ( strIP ); if ( iter == m_HistoryItemMap.end () ) { // Add if not found m_HistoryItemMap[strIP] = CConnectHistoryItem(); iter = m_HistoryItemMap.find ( strIP ); } #if MTA_DEBUG // Dump info const CConnectHistoryItem& historyItem = iter->second; if ( !historyItem.joinTimes.empty () ) { SString strInfo ( "IP:%s ", strIP.c_str () ); for ( unsigned int i = 0 ; i < historyItem.joinTimes.size () ; i++ ) { strInfo += SString ( "%u ", GetTickCount64_ () - historyItem.joinTimes[i] ); } strInfo += "\n"; OutputDebugString ( strInfo ); } #endif return iter->second; }
///////////////////////////////////////////////////////////// // // CDirect3DEvents9::CheckForScreenShot // // Take a screenshot if required and able // ///////////////////////////////////////////////////////////// void CDirect3DEvents9::CheckForScreenShot ( void ) { // Make a screenshot if needed if ( CCore::GetSingleton().bScreenShot && !CScreenShot::IsSaving () ) { // Max one screenshot per second if ( GetTickCount64_ () - ms_LastSaveTime < 1000 ) return; ms_LastSaveTime = GetTickCount64_ (); uint uiWidth = CDirect3DData::GetSingleton ().GetViewportWidth (); uint uiHeight = CDirect3DData::GetSingleton ().GetViewportHeight (); // Call the pre-screenshot function SString strFileName = CScreenShot::PreScreenShot (); // Try to get the screen data SString strError; if ( CGraphics::GetSingleton ().GetScreenGrabber ()->GetBackBufferPixels ( uiWidth, uiHeight, ms_ScreenShotBuffer, strError ) ) { // Validate data size uint uiDataSize = ms_ScreenShotBuffer.GetSize (); uint uiReqDataSize = uiWidth * uiHeight * 4; if ( uiDataSize == uiReqDataSize ) { // Start the save thread CScreenShot::BeginSave ( strFileName, ms_ScreenShotBuffer.GetData (), uiDataSize, uiWidth, uiHeight ); } else { g_pCore->GetConsole()->Printf ( _("Screenshot got %d bytes, but expected %d"), uiDataSize, uiReqDataSize ); strFileName = ""; } } else { g_pCore->GetConsole()->Print ( _("Screenshot failed") + SString( " (%s)", *strError ) ); strFileName = ""; } // Call the post-screenshot function CScreenShot::PostScreenShot ( strFileName ); CCore::GetSingleton().bScreenShot = false; } }
bool CLightsyncPacket::Write(NetBitStreamInterface& BitStream) const { bool bSyncPosition; if (Count() == 0) return false; for (std::vector<CPlayer*>::const_iterator iter = m_players.begin(); iter != m_players.end(); ++iter) { CPlayer* pPlayer = *iter; CPlayer::SLightweightSyncData& data = pPlayer->GetLightweightSyncData(); CVehicle* pVehicle = pPlayer->GetOccupiedVehicle(); // Find the difference between now and the time the position last changed for the player long long llTicksDifference = GetTickCount64_() - pPlayer->GetPositionLastChanged(); // Right we need to sync the position if there is no vehicle or he's in a vehicle and the difference between setPosition is less than or equal to the // slow sync rate i.e. make sure his position has been updated more than 0.001f in the last 1500ms plus a small margin for error (probably not needed). // This will ensure we only send positions when the position has changed. bSyncPosition = (!pVehicle || pPlayer->GetOccupiedVehicleSeat() == 0) && llTicksDifference <= g_TickRateSettings.iLightSync + 100; BitStream.Write(pPlayer->GetID()); BitStream.Write((unsigned char)pPlayer->GetSyncTimeContext()); unsigned short usLatency = pPlayer->GetPing(); BitStream.WriteCompressed(usLatency); BitStream.WriteBit(data.health.bSync); if (data.health.bSync) { SPlayerHealthSync health; health.data.fValue = pPlayer->GetHealth(); BitStream.Write(&health); SPlayerArmorSync armor; armor.data.fValue = pPlayer->GetArmor(); BitStream.Write(&armor); } BitStream.WriteBit(bSyncPosition); if (bSyncPosition) { SLowPrecisionPositionSync pos; pos.data.vecPosition = pPlayer->GetPosition(); BitStream.Write(&pos); bool bSyncVehicleHealth = data.vehicleHealth.bSync && pVehicle; BitStream.WriteBit(bSyncVehicleHealth); if (bSyncVehicleHealth) { SLowPrecisionVehicleHealthSync health; health.data.fValue = pVehicle->GetHealth(); BitStream.Write(&health); } } } return true; }
static ULONGLONG WINAPI GetTickCount64_resolve(void) { GetTickCount64_ = (GetTickCount64_func *)GetProcAddress(GetModuleHandle("kernel32.dll"), "GetTickCount64"); if (!GetTickCount64_) GetTickCount64_ = GetTickCount64_fallback; return GetTickCount64_(); }
void CClock::Set(unsigned char ucHour, unsigned char ucMinute) { // Calculate number of seconds from midnight unsigned long ulSecondsFromMidnight = ucHour * 60 + ucMinute; // Set the midnight time to our current time minus number of seconds since midnight according to the time we were given m_ullMidnightTime = GetTickCount64_() - ulSecondsFromMidnight * m_ulMinuteDuration; }
void CAccountManager::DoPulse(void) { // Save it only once in a while whenever something has changed if (m_bChangedSinceSaved && GetTickCount64_() > m_llLastTimeSaved + 15000) { // Save it Save(); } }
void CLightsyncManager::RegisterPlayer ( CPlayer* pPlayer ) { SEntry entry; entry.ullTime = GetTickCount64_ () + SLOW_SYNCRATE; entry.pPlayer = pPlayer; entry.eType = SYNC_PLAYER; entry.uiContext = 0; // Unused m_Queue.push_back ( entry ); }
void CPlayer::DoPulse ( void ) { if ( GetStatus () == STATUS_JOINED ) { m_pPlayerTextManager->Process (); if ( GetTickCount64_ () > m_llNearListUpdateTime + 300 ) UpdateOthersNearList (); } }
void CPlayer::ValidateDamageInfo ( void ) { if ( m_llSetDamageInfoTime + 100 < GetTickCount64_ () ) { // Reset if data is too old m_PlayerAttackerID = INVALID_ELEMENT_ID; m_ucAttackWeapon = 0xFF; m_ucAttackBodyPart = 0xFF; } }
void CAccessControlListManager::DoPulse ( void ) { // Clear cache every 12 hours or if dirty if ( m_bReadCacheDirty || GetTickCount64_ () - m_llLastTimeReadCacheCleared > 1000 * 60 * 60 * 12 ) ClearReadCache (); // Save when needed, but no more than once every 10 seconds if ( m_AutoSaveTimer.Get () > 10000 && m_bNeedsSave ) Save (); }
/////////////////////////////////////////////////////////////// // // CPerfStatPacketUsageImpl::DoPulse // // // /////////////////////////////////////////////////////////////// void CPerfStatPacketUsageImpl::DoPulse ( void ) { // Copy and clear once every 5 seconds long long llTime = GetTickCount64_ (); if ( llTime >= m_llNextRecordTime ) { m_llNextRecordTime = Max ( m_llNextRecordTime + 5000, llTime + 5000 / 10 * 9 ); RecordStats (); } }
/////////////////////////////////////////////////////////////// // // CPerfStatBandwidthReductionImpl::DoPulse // // // /////////////////////////////////////////////////////////////// void CPerfStatBandwidthReductionImpl::DoPulse ( void ) { long long llTime = GetTickCount64_ (); // Record once every 5 seconds if ( llTime >= m_llNextRecordTime ) { m_llNextRecordTime = Max ( m_llNextRecordTime + 5000, llTime + 5000 / 10 * 9 ); RecordStats (); } }
// Protect against a flood of server queries. // Send cached version unless player count has changed, or last re-cache is older than m_lLightMinInterval const std::string& ASE::QueryLightCached ( void ) { long long llTime = GetTickCount64_ (); unsigned int uiPlayerCount = m_pPlayerManager->CountJoined (); if ( uiPlayerCount != m_uiLightLastPlayerCount || llTime - m_llLightLastTime > m_lLightMinInterval || m_strLightCached == "" ) { m_strLightCached = QueryLight (); m_llLightLastTime = llTime; m_uiLightLastPlayerCount = uiPlayerCount; } return m_strLightCached; }
void CLightsyncManager::RegisterPlayer ( CPlayer* pPlayer ) { if ( pPlayer->IsBeingDeleted() ) return; SEntry entry; entry.ullTime = GetTickCount64_ (); entry.pPlayer = pPlayer; entry.eType = SYNC_PLAYER; entry.uiContext = 0; // Unused m_Queue.push_back ( entry ); }
void CClock::Get(unsigned char& ucHour, unsigned char& ucMinute) { // Grab how many seconds midnight was from now unsigned long long ullSecondsSinceMidnight = (GetTickCount64_() - m_ullMidnightTime) / m_ulMinuteDuration; // Grab how many hours that is ucMinute = static_cast<unsigned char>(ullSecondsSinceMidnight % 60); ullSecondsSinceMidnight /= 60; // What's left is the number of hours, limit it to 24 and return it ucHour = static_cast<unsigned char>(ullSecondsSinceMidnight % 24); }
/////////////////////////////////////////////////////////////// // // CPerfStatServerInfoImpl::DoPulse // // // /////////////////////////////////////////////////////////////// void CPerfStatServerInfoImpl::DoPulse() { long long llTime = GetTickCount64_(); UpdateThreadCPUTimes(m_MainThreadCPUTimes, &llTime); // Record once every 5 seconds if (llTime >= m_llNextRecordTime) { m_llNextRecordTime = std::max(m_llNextRecordTime + 5000, llTime + 5000 / 10 * 9); RecordStats(); } }
/////////////////////////////////////////////////////////////// // // CPerfStatSqliteTimingImpl::DoPulse // // // /////////////////////////////////////////////////////////////// void CPerfStatSqliteTimingImpl::DoPulse() { long long llTime = GetTickCount64_(); // Remove old stats while (m_TimingList.size()) { CTimingInfo& info = m_TimingList.front(); int iAgeSeconds = static_cast<int>((llTime - info.timeStamp) / 1000); if (iAgeSeconds < 2000 && m_TimingList.size() < 1000) break; m_TimingList.pop_front(); } }
// Add flood candidate connection attempt and return true if flooding is occurring bool CConnectHistory::AddConnect ( const string& strIP ) { // See if banned first if ( IsFlooding ( strIP ) ) return true; // Get history for this IP CConnectHistoryItem& historyItem = GetHistoryItem ( strIP ); // Add time of this allowed connection historyItem.joinTimes.push_back ( GetTickCount64_ () ); return false; }
// Check if IP is currently flooding bool CConnectHistory::IsFlooding ( const string& strIP ) { // Delete the expired entries RemoveExpired (); // Get history for this IP CConnectHistoryItem& historyItem = GetHistoryItem ( strIP ); // Check if inside ban time if ( GetTickCount64_ () < historyItem.llBanEndTime ) return true; // Check if too many connections if ( historyItem.joinTimes.size () > m_ulMaxConnections ) { // Begin timed ban historyItem.llBanEndTime = GetTickCount64_ () + m_ulBanLength; return true; } return false; }
void CRegistry::BeginAutomaticTransaction ( void ) { if ( !m_bInAutomaticTransaction ) { if ( m_llSuspendBatchingEndTime ) { if ( m_llSuspendBatchingEndTime > GetTickCount64_ () ) return; m_llSuspendBatchingEndTime = 0; } m_bInAutomaticTransaction = true; CRegistryResult dummy; QueryInternal ( "BEGIN TRANSACTION", &dummy ); } }
// Is it time to send a pure sync to every other player ? bool CPlayer::IsTimeForFarSync ( void ) { long long llTime = GetTickCount64_ (); if ( llTime > m_llNextFarSyncTime ) { int iSlowSyncRate = g_pBandwidthSettings->ZoneUpdateIntervals [ ZONE3 ]; m_llNextFarSyncTime = llTime + iSlowSyncRate; m_llNextFarSyncTime += rand () % ( 1 + iSlowSyncRate / 10 ); // Extra bit to help distribute the load // Calc stats int iNumPackets = m_FarPlayerList.size (); int iNumSkipped = ( iNumPackets * iSlowSyncRate - iNumPackets * 1000 ) / 1000; g_pStats->puresync.llSentPacketsByZone [ ZONE3 ] += iNumPackets; g_pStats->puresync.llSkippedPacketsByZone [ ZONE3 ] += iNumSkipped; return true; } return false; }
/////////////////////////////////////////////////////////////// // // CPerfStatSqliteTimingImpl::GetStats // // // /////////////////////////////////////////////////////////////// void CPerfStatSqliteTimingImpl::GetStats(CPerfStatResult* pResult, const std::map<SString, int>& optionMap, const SString& strFilter) { GetSqliteTimingStats(pResult, optionMap, strFilter); uint uiTicks = 1000 * 10; // 10 seconds long long llTime = GetTickCount64_(); m_llRecordStatsEndTime = llTime + uiTicks; // Update batching setting for (std::map<CRegistry*, SString>::iterator iter = m_RegistryMap.begin(); iter != m_RegistryMap.end(); ++iter) { if (m_bDisableBatching) iter->first->SuspendBatching(uiTicks); // Suspend batching else iter->first->SuspendBatching(0); // Unsuspend batching } }