Beispiel #1
0
        protected override void OnProfilingFinished(BaseProfilerResult <ProfilerCategory> result)
        {
            var frameMs                   = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.Frame, 0);
            var lockMs                    = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.Lock, 0);
            var updateMs                  = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.Update, 0);
            var updateNetworkMs           = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.UpdateNetwork, 0);
            var updateReplMs              = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.UpdateReplication, 0);
            var updateSessionCompsMs      = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.UpdateSessionComponents, 0);
            var updateSessionCompsAllMs   = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.UpdateSessionComponentsAll, 0);
            var updateSessionCompsOtherMs = updateSessionCompsAllMs - updateSessionCompsMs;
            var updateGpsMs               = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.UpdateGps, 0);
            var updateParallelWaitMs      = (float)result.GetMainThreadTickMsOrElse(ProfilerCategory.UpdateParallelWait, 0);
            var updateOtherMs             = updateMs - updateNetworkMs - updateReplMs - updateSessionCompsAllMs - updateGpsMs - updateParallelWaitMs;

            TorchInfluxDbWriter
            .Measurement("profiler_game_loop")
            .Field("frame", frameMs / result.TotalFrameCount)
            .Field("wait", lockMs / result.TotalFrameCount)
            .Field("update", updateMs / result.TotalFrameCount)
            .Field("update_network", updateNetworkMs / result.TotalFrameCount)
            .Field("update_replication", updateReplMs / result.TotalFrameCount)
            .Field("update_session_components", updateSessionCompsMs / result.TotalFrameCount)
            .Field("update_session_components_all", updateSessionCompsAllMs / result.TotalFrameCount)
            .Field("update_session_components_other", updateSessionCompsOtherMs / result.TotalFrameCount)
            .Field("update_gps", updateGpsMs / result.TotalFrameCount)
            .Field("update_parallel_wait", updateParallelWaitMs / result.TotalFrameCount)
            .Field("update_other", updateOtherMs / result.TotalFrameCount)
            .Write();
        }
Beispiel #2
0
        public void OnInterval(int intervalsSinceStart)
        {
            if (intervalsSinceStart % 600 != 0)
            {
                return;
            }

            var voxels = MyEntities
                         .GetEntities()
                         .Select(e => e as MyVoxelBase)
                         .Where(e => e != null)
                         .Where(e => !e.Closed)
                         .ToArray();

            var planets       = voxels.OfType <MyPlanet>().ToArray();
            var asteroidCount = voxels.Length - planets.Length;

            TorchInfluxDbWriter
            .Measurement("voxels_asteroids_total")
            .Field("count", asteroidCount)
            .Write();

            TorchInfluxDbWriter
            .Measurement("voxels_planets_total")
            .Field("count", planets.Length)
            .Write();
        }
        protected override void OnProfilingFinished(BaseProfilerResult <IMyFaction> result)
        {
            // get online players per faction
            var onlineFactions = new Dictionary <string, int>();
            var onlinePlayers  = MySession.Static.Players.GetOnlinePlayers();

            foreach (var onlinePlayer in onlinePlayers)
            {
                var faction = MySession.Static.Factions.TryGetPlayerFaction(onlinePlayer.PlayerId());
                if (faction == null)
                {
                    continue;
                }

                onlineFactions.Increment(faction.Tag);
            }

            foreach (var(faction, entity) in result.GetTopEntities())
            {
                onlineFactions.TryGetValue(faction.Tag, out var onlinePlayerCount);
                onlinePlayerCount = Math.Max(1, onlinePlayerCount); // fix zero division
                var mainMs          = entity.MainThreadTime / result.TotalFrameCount;
                var mainMsPerMember = mainMs / onlinePlayerCount;

                TorchInfluxDbWriter
                .Measurement("profiler_factions")
                .Tag("faction_tag", faction.Tag)
                .Field("main_ms", mainMs)
                .Field("main_ms_per_member", mainMsPerMember)
                .Write();
            }
        }
Beispiel #4
0
        public void OnInterval(int intervalsSinceStart)
        {
            var simSpeed = Sync.ServerSimulationRatio;

            _simSpeeds[intervalsSinceStart % _simSpeeds.Length] = simSpeed;

            if (intervalsSinceStart < _config.FirstIgnoredSeconds)
            {
                return;
            }
            if (intervalsSinceStart % IntervalsPerWrite != 0)
            {
                return;
            }

            var maxSimSpeed = _simSpeeds.Max();
            var minSimSpeed = _simSpeeds.Min();
            var avgSimSpeed = _simSpeeds.Average();

            TorchInfluxDbWriter
            .Measurement("server_sync")
            .Field("sim_speed", avgSimSpeed)
            .Field("sim_speed_min", minSimSpeed)
            .Field("sim_speed_max", maxSimSpeed)
            .Write();
        }
Beispiel #5
0
        public void OnInterval(int intervalsSinceStart)
        {
            if (!_config.Enabled)
            {
                return;
            }
            if (intervalsSinceStart % 20 != 0)
            {
                return;
            }

            var continents    = new Dictionary <string, int>();
            var countries     = new Dictionary <string, int>();
            var onlinePlayers = MySession.Static.Players.GetOnlinePlayers().ToArray();

            foreach (var onlinePlayer in onlinePlayers)
            {
                if (onlinePlayer == null)
                {
                    return;
                }

                var steamId = onlinePlayer.SteamId();
                if (_ipLocations.TryGetValue(steamId, out var ipLocation))
                {
                    // null when localhost
                    continents.Increment(ipLocation.ContinentName ?? "<unknown>");
                    countries.Increment(ipLocation.CountryName ?? "<unknown>");
                }
                else
                {
                    // update `_ipLocations` (for next interval)
                    LoadIpLocation(steamId).Forget(Log);
                }
            }

            foreach (var(continentName, count) in continents)
            {
                Log.Trace($"writing continent data: '{continentName}'");

                TorchInfluxDbWriter
                .Measurement("players_continents")
                .Tag("continent_name", continentName)
                .Field("online_player_count", count)
                .Write();
            }

            foreach (var(countryName, count) in countries)
            {
                Log.Trace($"writing country data: '{countryName}'");

                TorchInfluxDbWriter
                .Measurement("players_countries")
                .Tag("country_name", countryName)
                .Field("online_player_count", count)
                .Write();
            }
        }
Beispiel #6
0
        public void OnInterval(int intervalsSinceStart)
        {
            if (intervalsSinceStart < _config.FirstIgnoredSeconds)
            {
                return;
            }
            if (intervalsSinceStart % 10 != 0)
            {
                return;
            }

            const long GB = 1024 * 1024 * 1024;

            _process.Refresh();

            // https://docs.microsoft.com/en-us/dotnet/api/system.gc.gettotalmemory
            // [...] the best available approximation of the number of bytes currently allocated in managed memory.
            var heap = (float)GC.GetTotalMemory(false) / GB;

            // https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.privatememorysize64
            //  [...] the current size of memory used by the process, in bytes, that cannot be shared with other processes.
            var privat = (float)_process.PrivateMemorySize64 / GB;

            // https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.workingset64
            // [...] the current size of working set memory used by the process.
            // [...] the set of memory pages currently visible to the process in physical RAM memory.
            // [...] includes both shared and private data.
            var workingSet = (float)_process.WorkingSet64 / GB;

            // https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.nonpagedsystemmemorysize64
            // [...]  the current size of nonpaged system memory used by the process.
            var nonPagedSys = (float)_process.NonpagedSystemMemorySize64 / GB;

            // https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.pagedsystemmemorysize64
            // [...] the current size of pageable system memory used by the process.
            var pagedSys = (float)_process.PagedSystemMemorySize64 / GB;

            // https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.pagedmemorysize64
            // [...] the current size of memory in the virtual memory paging file used by the process.
            var pagedVirtual = (float)_process.PagedMemorySize64 / GB;

            // https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.virtualmemorysize64
            // [...] the current size of virtual memory used by the process.
            var virt = (float)_process.VirtualMemorySize64 / GB;

            TorchInfluxDbWriter
            .Measurement("resource")
            .Field("heap", heap)
            .Field("private", privat)
            .Field("working_set", workingSet)
            .Field("non_paged_sys", nonPagedSys)
            .Field("paged_sys", pagedSys)
            .Field("paged_virtual", pagedVirtual)
            .Field("virtual", virt)
            .Write();
        }
 protected override void OnProfilingFinished(BaseProfilerResult <Type> result)
 {
     foreach (var(type, entry) in result.GetTopEntities(MaxDisplayCount))
     {
         TorchInfluxDbWriter
         .Measurement("profiler_block_types")
         .Tag("block_type", type.Name)
         .Field("main_ms", (float)entry.MainThreadTime / result.TotalFrameCount)
         .Write();
     }
 }
Beispiel #8
0
 protected override void OnProfilingFinished(BaseProfilerResult <string> result)
 {
     foreach (var(name, entity) in result.GetTopEntities())
     {
         TorchInfluxDbWriter
         .Measurement("profiler_method_names")
         .Tag("method_name", name)
         .Field("ms", (float)entity.MainThreadTime / result.TotalFrameCount)
         .Write();
     }
 }
 protected override void OnProfilingFinished(BaseProfilerResult <MyCubeGrid> result)
 {
     foreach (var(grid, entity) in result.GetTopEntities(MaxDisplayCount))
     {
         TorchInfluxDbWriter
         .Measurement("profiler")
         .Tag("grid_name", GridToResultText(grid))
         .Field("main_ms", (float)entity.MainThreadTime / result.TotalFrameCount)
         .Write();
     }
 }
 protected override void OnProfilingFinished(BaseProfilerResult <string> result)
 {
     foreach (var(methodName, entry) in result.GetTopEntities())
     {
         var eventName = methodName.Split('#')[1];
         TorchInfluxDbWriter
         .Measurement("profiler_network_events")
         .Tag("site_name", eventName)
         .Field("main_ms", (float)entry.MainThreadTime / result.TotalFrameCount)
         .Write();
     }
 }
Beispiel #11
0
        protected override void OnProfilingFinished(BaseProfilerResult <MyIdentity> result)
        {
            foreach (var(player, entity) in result.GetTopEntities(10))
            {
                var playerName = player.DisplayName;
                var steamId    = MySession.Static.Players.TryGetSteamId(player.IdentityId);
                playerName = _nameConflictSolver.GetSafeName(playerName, steamId);

                var mainMs = entity.MainThreadTime / result.TotalFrameCount;

                TorchInfluxDbWriter
                .Measurement("profiler_players")
                .Tag("player_name", playerName)
                .Field("main_ms", mainMs)
                .Write();
            }
        }
Beispiel #12
0
        protected override void OnProfilingFinished(BaseProfilerResult <MySessionComponentBase> result)
        {
            foreach (var(comp, entity) in result.GetTopEntities())
            {
                var ms = (float)entity.MainThreadTime / result.TotalFrameCount;

                var type = comp.GetType();
                var name = _myConfig.MonitorSessionComponentNamespace
                    ? $"{type.Namespace}/{type.Name}"
                    : type.Name;

                TorchInfluxDbWriter
                .Measurement("profiler_game_loop_session_components")
                .Tag("comp_name", name)
                .Field("main_ms", ms)
                .Write();
            }
        }
Beispiel #13
0
        public void OnInterval(int intervalsSinceStart)
        {
            if (intervalsSinceStart < _config.FirstIgnoredSeconds)
            {
                return;
            }
            if (intervalsSinceStart % 10 != 0)
            {
                return;
            }

            var count = MyEntities.GetEntities().Count(e => e is MyFloatingObject);

            TorchInfluxDbWriter
            .Measurement("floating_objects")
            .Field("count", count)
            .Write();
        }
Beispiel #14
0
        protected override void OnProfilingFinished(BaseProfilerResult <MyProgrammableBlock> result)
        {
            foreach (var(pb, entity) in result.GetTopEntities(MaxDisplayCount))
            {
                var grid = pb?.GetParentEntityOfType <MyCubeGrid>();
                if (grid == null)
                {
                    return;
                }

                var gridName = _nameConflictSolver.GetSafeName(grid.DisplayName, grid.EntityId);
                var mainMs   = (float)entity.MainThreadTime / result.TotalFrameCount;

                TorchInfluxDbWriter
                .Measurement("profiler_scripts")
                .Tag("grid_name", gridName)
                .Field("main_ms", mainMs)
                .Write();
            }
        }
Beispiel #15
0
        void ProcessResult(BaseProfilerResult <HkWorld> result)
        {
            foreach (var(world, entity) in result.GetTopEntities(_physicsConfig.PhysicsMaxClusterCount))
            {
                // this usually doesn't happen but just in case
                if (!TryGetHeaviestGrid(world, out var heaviestGrid))
                {
                    continue;
                }

                heaviestGrid.BigOwners.TryGetFirst(out var ownerId);
                var faction    = MySession.Static.Factions.GetPlayerFaction(ownerId);
                var factionTag = faction?.Tag ?? "<n/a>";
                var gridName   = heaviestGrid.DisplayName.OrNull() ?? "<no name>";
                var mainMs     = entity.MainThreadTime / result.TotalFrameCount;

                TorchInfluxDbWriter
                .Measurement("profiler_physics_grids")
                .Tag("grid", $"[{factionTag}] {gridName}")
                .Field("main_ms", mainMs)
                .Write();
            }
        }
Beispiel #16
0
        public void OnInterval(int intervalsSinceStart)
        {
            if (intervalsSinceStart % IntervalSecs != 0)
            {
                return;
            }

            var onlinePlayers = MySession.Static.Players.GetOnlinePlayers().ToArray();
            var factionList   = MySession.Static.Factions.Factions.Values;
            var factions      = new Dictionary <string, int>();

            foreach (var onlinePlayer in onlinePlayers)
            {
                if (onlinePlayer == null)
                {
                    continue;
                }

                var playerId = onlinePlayer.PlayerId();
                var steamId  = onlinePlayer.SteamId();
                if (steamId == 0)
                {
                    continue;
                }

                _playerOnlineTimeDb.IncrementPlayerOnlineTime(steamId, (double)IntervalSecs / 3600);
                var onlineTime = _playerOnlineTimeDb.GetPlayerOnlineTime(steamId);

                var faction    = factionList.FirstOrDefault(f => f.Members.ContainsKey(playerId));
                var factionTag = faction?.Tag ?? "<single>";
                factions.Increment(factionTag);

                var playerName = onlinePlayer.DisplayName;
                playerName = _nameConflictSolver.GetSafeName(playerName, steamId);

                TorchInfluxDbWriter
                .Measurement("players_players")
                .Tag("steam_id", $"{steamId}")
                .Tag("player_name", playerName)
                .Tag("faction_tag", factionTag)
                .Field("is_online", 1)
                .Field("online_time", onlineTime)
                .Write();
            }

            foreach (var(factionTag, onlineMemberCount) in factions)
            {
                TorchInfluxDbWriter
                .Measurement("players_factions")
                .Tag("faction_tag", factionTag)
                .Field("online_member_count", onlineMemberCount)
                .Write();
            }

            var totalOnlineTime = _playerOnlineTimeDb.GetTotalOnlineTime();

            TorchInfluxDbWriter
            .Measurement("server")
            .Field("players", onlinePlayers.Length)
            .Field("online_time", totalOnlineTime)
            .Write();

            _playerOnlineTimeDb.WriteToDb();
        }
        public void OnInterval(int intervalsSinceStart)
        {
            if (intervalsSinceStart < _config.FirstIgnoredSeconds)
            {
                return;
            }
            if (intervalsSinceStart % 60 != 0)
            {
                return;
            }

            var allGroups = MyCubeGridGroups.Static.Logical.Groups
                            .Select(g => g.Nodes.Select(n => n.NodeData).ToArray())
                            .ToArray();

            var allGrids = allGroups.SelectMany(g => g).ToArray();

            //total
            {
                var totalBlockCount = allGrids.Sum(g => g.BlocksCount);

                TorchInfluxDbWriter
                .Measurement("blocks_all")
                .Field("block_count", totalBlockCount)
                .Write();
            }

            // per grid
            {
                var gridBlockCounts = new Dictionary <long, int>();
                foreach (var grid in allGrids)
                {
                    gridBlockCounts.Increment(grid.EntityId);
                }

                var topGridBlockCounts = gridBlockCounts.OrderByDescending(p => p.Value).Take(MaxMonitoredCount);
                var gridNames          = allGrids.ToDictionary(p => p.EntityId, p => p.DisplayName);
                foreach (var(gridId, blockCount) in topGridBlockCounts)
                {
                    var gridName = gridNames[gridId];

                    TorchInfluxDbWriter
                    .Measurement("blocks_grids")
                    .Tag("name", gridName.Replace("\\", "-"))
                    .Field("block_count", blockCount)
                    .Write();
                }
            }

            // per player/faction
            {
                var playerBlockCounts  = new Dictionary <long, int>();
                var factionBlockCounts = new Dictionary <string, int>();

                foreach (var grid in allGrids)
                {
                    foreach (var block in grid.CubeBlocks)
                    {
                        var ownerId = GetOwnerId(block);
                        playerBlockCounts.Increment(ownerId);
                    }
                }

                var topPlayerBlockCounts = playerBlockCounts.OrderByDescending(p => p.Value).Take(MaxMonitoredCount);
                var playerNames          = MySession.Static.Players.GetAllIdentities().ToDictionary(id => id.IdentityId, id => id.DisplayName);
                playerNames[0] = "<nobody>";
                foreach (var(id, blockCount) in topPlayerBlockCounts)
                {
                    if (!playerNames.TryGetValue(id, out var playerName))
                    {
                        continue;
                    }

                    TorchInfluxDbWriter
                    .Measurement("blocks_players")
                    .Tag("name", playerName.Replace("\\", "-"))
                    .Field("block_count", blockCount)
                    .Write();
                }

                foreach (var(idId, blockCount) in playerBlockCounts)
                {
                    var faction = MySession.Static.Factions.TryGetPlayerFaction(idId);
                    if (faction == null)
                    {
                        continue;
                    }

                    factionBlockCounts.Increment(faction.Name, blockCount);
                }

                var topFactionBlockCounts = factionBlockCounts.OrderByDescending(p => p.Value).Take(MaxMonitoredCount);
                foreach (var(factionName, blockCount) in topFactionBlockCounts)
                {
                    TorchInfluxDbWriter
                    .Measurement("blocks_factions")
                    .Tag("name", factionName.Replace("\\", "-"))
                    .Field("block_count", blockCount)
                    .Write();
                }

                playerBlockCounts.Clear();
                factionBlockCounts.Clear();
            }
        }