diff options
Diffstat (limited to 'src')
20 files changed, 706 insertions, 821 deletions
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ArgumentParser.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ArgumentParser.cs index 40691a3e..9c7082c9 100644 --- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ArgumentParser.cs +++ b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ArgumentParser.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections; using System.Collections.Generic; using System.Globalization; @@ -32,13 +32,6 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands /// <param name="index">The zero-based index of the element to get.</param> public string this[int index] => this.Args[index]; - /// <summary>A method which parses a string argument into the given value.</summary> - /// <typeparam name="T">The expected argument type.</typeparam> - /// <param name="input">The argument to parse.</param> - /// <param name="output">The parsed value.</param> - /// <returns>Returns whether the argument was successfully parsed.</returns> - public delegate bool ParseDelegate<T>(string input, out T output); - /********* ** Public methods @@ -114,19 +107,6 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands return true; } - public bool IsDecimal(int index) - { - if (!this.TryGet(index, "", out string raw, false)) - return false; - - if (!decimal.TryParse(raw, NumberStyles.Number, CultureInfo.InvariantCulture, out decimal value)) - { - return false; - } - - return true; - } - /// <summary>Try to read a decimal argument.</summary> /// <param name="index">The argument index.</param> /// <param name="name">The argument name for error messages.</param> diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/PerformanceCounterCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/PerformanceCounterCommand.cs index 2260296b..820f1939 100644 --- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/PerformanceCounterCommand.cs +++ b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/PerformanceCounterCommand.cs @@ -7,24 +7,13 @@ using StardewModdingAPI.Framework.PerformanceCounter; namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other { - // ReSharper disable once UnusedType.Global + /// <summary>A set of commands which displays or configures performance monitoring.</summary> internal class PerformanceCounterCommand : TrainerCommand { - /// <summary>The command names and aliases</summary> - private readonly Dictionary<SubCommand, string[]> SubCommandNames = new Dictionary<SubCommand, string[]>() - { - {SubCommand.Summary, new[] {"summary", "sum", "s"}}, - {SubCommand.Detail, new[] {"detail", "d"}}, - {SubCommand.Reset, new[] {"reset", "r"}}, - {SubCommand.Trigger, new[] {"trigger"}}, - {SubCommand.Enable, new[] {"enable"}}, - {SubCommand.Disable, new[] {"disable"}}, - {SubCommand.Examples, new[] {"examples"}}, - {SubCommand.Concepts, new[] {"concepts"}}, - {SubCommand.Help, new[] {"help"}}, - }; - - /// <summary>The available commands enum</summary> + /********* + ** Fields + *********/ + /// <summary>The available commands.</summary> private enum SubCommand { Summary, @@ -33,16 +22,16 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other Trigger, Enable, Disable, - Examples, - Help, - Concepts, - None + Help } + + /********* + ** Public methods + *********/ /// <summary>Construct an instance.</summary> - public PerformanceCounterCommand() : base("pc", PerformanceCounterCommand.GetDescription()) - { - } + public PerformanceCounterCommand() + : base("performance", PerformanceCounterCommand.GetDescription()) { } /// <summary>Handle the command.</summary> /// <param name="monitor">Writes messages to the console and log file.</param> @@ -50,92 +39,94 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other /// <param name="args">The command arguments.</param> public override void Handle(IMonitor monitor, string command, ArgumentParser args) { - if (args.TryGet(0, "command", out string subCommandString, false)) + // parse args + SubCommand subcommand = SubCommand.Summary; { - SubCommand subSubCommand = this.ParseCommandString(subCommandString); - - switch (subSubCommand) + if (args.TryGet(0, "command", out string subcommandStr, false) && !Enum.TryParse(subcommandStr, ignoreCase: true, out subcommand)) { - case SubCommand.Summary: - this.HandleSummarySubCommand(monitor, args); - break; - case SubCommand.Detail: - this.HandleDetailSubCommand(monitor, args); - break; - case SubCommand.Reset: - this.HandleResetSubCommand(monitor, args); - break; - case SubCommand.Trigger: - this.HandleTriggerSubCommand(monitor, args); - break; - case SubCommand.Examples: - break; - case SubCommand.Concepts: - this.OutputHelp(monitor, SubCommand.Concepts); - break; - case SubCommand.Enable: - SCore.PerformanceCounterManager.EnableTracking = true; - monitor.Log("Performance counter tracking is now enabled", LogLevel.Info); - break; - case SubCommand.Disable: - SCore.PerformanceCounterManager.EnableTracking = false; - monitor.Log("Performance counter tracking is now disabled", LogLevel.Info); - break; - case SubCommand.Help: - if (args.TryGet(1, "command", out string commandString)) - this.OutputHelp(monitor, this.ParseCommandString(commandString)); - break; - default: - this.LogUsageError(monitor, $"Unknown command {subCommandString}"); - break; + this.LogUsageError(monitor, $"Unknown command {subcommandStr}"); + return; } } - else - this.HandleSummarySubCommand(monitor, args); + + // handle + switch (subcommand) + { + case SubCommand.Summary: + this.HandleSummarySubCommand(monitor, args); + break; + + case SubCommand.Detail: + this.HandleDetailSubCommand(monitor, args); + break; + + case SubCommand.Reset: + this.HandleResetSubCommand(monitor, args); + break; + + case SubCommand.Trigger: + this.HandleTriggerSubCommand(monitor, args); + break; + + case SubCommand.Enable: + SCore.PerformanceMonitor.EnableTracking = true; + monitor.Log("Performance counter tracking is now enabled", LogLevel.Info); + break; + + case SubCommand.Disable: + SCore.PerformanceMonitor.EnableTracking = false; + monitor.Log("Performance counter tracking is now disabled", LogLevel.Info); + break; + + case SubCommand.Help: + this.OutputHelp(monitor, args.TryGet(1, "command", out _) ? subcommand : null as SubCommand?); + break; + + default: + this.LogUsageError(monitor, $"Unknown command {subcommand}"); + break; + } } + + /********* + ** Private methods + *********/ /// <summary>Handles the summary sub command.</summary> /// <param name="monitor">Writes messages to the console and log file.</param> /// <param name="args">The command arguments.</param> private void HandleSummarySubCommand(IMonitor monitor, ArgumentParser args) { - IEnumerable<PerformanceCounterCollection> data; - if (!args.TryGet(1, "mode", out string mode, false)) - { mode = "important"; - } + IEnumerable<PerformanceCounterCollection> data = SCore.PerformanceMonitor.GetCollections(); switch (mode) { case null: case "important": - data = SCore.PerformanceCounterManager.PerformanceCounterCollections.Where(p => p.IsImportant); + data = data.Where(p => p.IsPerformanceCritical); break; + case "all": - data = SCore.PerformanceCounterManager.PerformanceCounterCollections; break; + default: - data = SCore.PerformanceCounterManager.PerformanceCounterCollections.Where(p => - p.Name.ToLowerInvariant().Contains(mode.ToLowerInvariant())); + data = data.Where(p => p.Name.ToLowerInvariant().Contains(mode.ToLowerInvariant())); break; } double? threshold = null; - if (args.TryGetDecimal(2, "threshold", out decimal t, false)) - { - threshold = (double?) t; - } - - StringBuilder sb = new StringBuilder(); + threshold = (double?)t; TimeSpan interval = TimeSpan.FromSeconds(60); - sb.AppendLine($"Summary over the last {interval.TotalSeconds} seconds:"); - sb.AppendLine(this.GetTableString( + StringBuilder report = new StringBuilder(); + report.AppendLine($"Summary over the last {interval.TotalSeconds} seconds:"); + report.AppendLine(this.GetTableString( data: data, - header: new[] {"Collection", "Avg Calls/s", "Avg Exec Time (Game)", "Avg Exec Time (Mods)", "Avg Exec Time (Game+Mods)", "Peak Exec Time"}, + header: new[] { "Collection", "Avg Calls/s", "Avg Exec Time (Game)", "Avg Exec Time (Mods)", "Avg Exec Time (Game+Mods)", "Peak Exec Time" }, getRow: item => new[] { item.Name, @@ -148,7 +139,7 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other true )); - monitor.Log(sb.ToString(), LogLevel.Info); + monitor.Log(report.ToString(), LogLevel.Info); } /// <summary>Handles the detail sub command.</summary> @@ -163,26 +154,16 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other if (args.TryGet(1, "collection", out string collectionName)) { - collections.AddRange(SCore.PerformanceCounterManager.PerformanceCounterCollections.Where( - collection => collection.Name.ToLowerInvariant().Contains(collectionName.ToLowerInvariant()))); + collections.AddRange(SCore.PerformanceMonitor.GetCollections().Where(collection => collection.Name.ToLowerInvariant().Contains(collectionName.ToLowerInvariant()))); - if (args.IsDecimal(2) && args.TryGetDecimal(2, "threshold", out decimal value, false)) - { - thresholdMilliseconds = (double?) value; - } - else - { - if (args.TryGet(2, "source", out string sourceName, false)) - { - sourceFilter = sourceName; - } - } + if (args.Count >= 2 && decimal.TryParse(args[2], out _) && args.TryGetDecimal(2, "threshold", out decimal value, false)) + thresholdMilliseconds = (double?)value; + else if (args.TryGet(2, "source", out string sourceName, false)) + sourceFilter = sourceName; } foreach (PerformanceCounterCollection c in collections) - { this.OutputPerformanceCollectionDetail(monitor, c, averageInterval, thresholdMilliseconds, sourceFilter); - } } /// <summary>Handles the trigger sub command.</summary> @@ -197,46 +178,44 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other case "list": this.OutputAlertTriggers(monitor); break; + case "collection": if (args.TryGet(2, "name", out string collectionName)) { if (args.TryGetDecimal(3, "threshold", out decimal threshold)) { - if (args.TryGet(4, "source", out string source, false)) - { - this.ConfigureAlertTrigger(monitor, collectionName, source, threshold); - } - else - { - this.ConfigureAlertTrigger(monitor, collectionName, null, threshold); - } + if (!args.TryGet(4, "source", out string source, required: false)) + source = null; + this.ConfigureAlertTrigger(monitor, collectionName, source, threshold); } } break; + case "pause": - SCore.PerformanceCounterManager.PauseAlerts = true; - monitor.Log($"Alerts are now paused.", LogLevel.Info); + SCore.PerformanceMonitor.PauseAlerts = true; + monitor.Log("Alerts are now paused.", LogLevel.Info); break; + case "resume": - SCore.PerformanceCounterManager.PauseAlerts = false; - monitor.Log($"Alerts are now resumed.", LogLevel.Info); + SCore.PerformanceMonitor.PauseAlerts = false; + monitor.Log("Alerts are now resumed.", LogLevel.Info); break; + case "dump": this.OutputAlertTriggers(monitor, true); break; + case "clear": this.ClearAlertTriggers(monitor); break; + default: this.LogUsageError(monitor, $"Unknown mode {mode}. See 'pc help trigger' for usage."); break; } - } else - { this.OutputAlertTriggers(monitor); - } } /// <summary>Sets up an an alert trigger.</summary> @@ -246,7 +225,7 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other /// <param name="threshold">The trigger threshold, or 0 to remove.</param> private void ConfigureAlertTrigger(IMonitor monitor, string collectionName, string sourceName, decimal threshold) { - foreach (PerformanceCounterCollection collection in SCore.PerformanceCounterManager.PerformanceCounterCollections) + foreach (PerformanceCounterCollection collection in SCore.PerformanceMonitor.GetCollections()) { if (collection.Name.ToLowerInvariant().Equals(collectionName.ToLowerInvariant())) { @@ -255,8 +234,8 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other if (threshold != 0) { collection.EnableAlerts = true; - collection.AlertThresholdMilliseconds = (double) threshold; - monitor.Log($"Set up alert triggering for '{collectionName}' with '{this.FormatMilliseconds((double?) threshold)}'", LogLevel.Info); + collection.AlertThresholdMilliseconds = (double)threshold; + monitor.Log($"Set up alert triggering for '{collectionName}' with '{this.FormatMilliseconds((double?)threshold)}'", LogLevel.Info); } else { @@ -275,14 +254,11 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other if (threshold != 0) { performanceCounter.Value.EnableAlerts = true; - performanceCounter.Value.AlertThresholdMilliseconds = (double) threshold; - monitor.Log($"Set up alert triggering for '{sourceName}' in collection '{collectionName}' with '{this.FormatMilliseconds((double?) threshold)}", LogLevel.Info); + performanceCounter.Value.AlertThresholdMilliseconds = (double)threshold; + monitor.Log($"Set up alert triggering for '{sourceName}' in collection '{collectionName}' with '{this.FormatMilliseconds((double?)threshold)}", LogLevel.Info); } else - { performanceCounter.Value.EnableAlerts = false; - } - return; } } @@ -302,7 +278,7 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other private void ClearAlertTriggers(IMonitor monitor) { int clearedTriggers = 0; - foreach (PerformanceCounterCollection collection in SCore.PerformanceCounterManager.PerformanceCounterCollections) + foreach (PerformanceCounterCollection collection in SCore.PerformanceMonitor.GetCollections()) { if (collection.EnableAlerts) { @@ -329,92 +305,75 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other /// <param name="asDump">True to dump the triggers as commands.</param> private void OutputAlertTriggers(IMonitor monitor, bool asDump = false) { - StringBuilder sb = new StringBuilder(); - sb.AppendLine("Configured triggers:"); - sb.AppendLine(); - var collectionTriggers = new List<(string collectionName, double threshold)>(); - var sourceTriggers = new List<(string collectionName, string sourceName, double threshold)>(); + StringBuilder report = new StringBuilder(); + report.AppendLine("Configured triggers:"); + report.AppendLine(); + var collectionTriggers = new List<CollectionTrigger>(); + var sourceTriggers = new List<SourceTrigger>(); - foreach (PerformanceCounterCollection collection in SCore.PerformanceCounterManager.PerformanceCounterCollections) + foreach (PerformanceCounterCollection collection in SCore.PerformanceMonitor.GetCollections()) { if (collection.EnableAlerts) - { - collectionTriggers.Add((collection.Name, collection.AlertThresholdMilliseconds)); - } + collectionTriggers.Add(new CollectionTrigger(collection.Name, collection.AlertThresholdMilliseconds)); - sourceTriggers.AddRange(from performanceCounter in - collection.PerformanceCounters where performanceCounter.Value.EnableAlerts - select (collection.Name, performanceCounter.Value.Source, performanceCounter.Value.AlertThresholdMilliseconds)); + sourceTriggers.AddRange( + from counter in collection.PerformanceCounters + where counter.Value.EnableAlerts + select new SourceTrigger(collection.Name, counter.Value.Source, counter.Value.AlertThresholdMilliseconds) + ); } if (collectionTriggers.Count > 0) { - sb.AppendLine("Collection Triggers:"); - sb.AppendLine(); + report.AppendLine("Collection Triggers:"); + report.AppendLine(); if (asDump) { foreach (var item in collectionTriggers) - { - sb.AppendLine($"pc trigger {item.collectionName} {item.threshold}"); - } + report.AppendLine($"pc trigger {item.CollectionName} {item.Threshold}"); } else { - sb.AppendLine(this.GetTableString( + report.AppendLine(this.GetTableString( data: collectionTriggers, - header: new[] {"Collection", "Threshold"}, - getRow: item => new[] - { - item.collectionName, - this.FormatMilliseconds(item.threshold) - }, + header: new[] { "Collection", "Threshold" }, + getRow: item => new[] { item.CollectionName, this.FormatMilliseconds(item.Threshold) }, true )); } - sb.AppendLine(); + report.AppendLine(); } else - { - sb.AppendLine("No collection triggers."); - } + report.AppendLine("No collection triggers."); if (sourceTriggers.Count > 0) { - sb.AppendLine("Source Triggers:"); - sb.AppendLine(); + report.AppendLine("Source Triggers:"); + report.AppendLine(); if (asDump) { - foreach (var item in sourceTriggers) - { - sb.AppendLine($"pc trigger {item.collectionName} {item.threshold} {item.sourceName}"); - } + foreach (SourceTrigger item in sourceTriggers) + report.AppendLine($"pc trigger {item.CollectionName} {item.Threshold} {item.SourceName}"); } else { - sb.AppendLine(this.GetTableString( + report.AppendLine(this.GetTableString( data: sourceTriggers, - header: new[] {"Collection", "Source", "Threshold"}, - getRow: item => new[] - { - item.collectionName, - item.sourceName, - this.FormatMilliseconds(item.threshold) - }, + header: new[] { "Collection", "Source", "Threshold" }, + getRow: item => new[] { item.CollectionName, item.SourceName, this.FormatMilliseconds(item.Threshold) }, true )); } - sb.AppendLine(); + report.AppendLine(); } else - { - sb.AppendLine("No source triggers."); - } + report.AppendLine("No source triggers."); - monitor.Log(sb.ToString(), LogLevel.Info); + monitor.Log(report.ToString(), LogLevel.Info); } /// <summary>Handles the reset sub command.</summary> @@ -422,25 +381,25 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other /// <param name="args">The command arguments.</param> private void HandleResetSubCommand(IMonitor monitor, ArgumentParser args) { - if (args.TryGet(1, "type", out string type, false, new []{"category", "source"})) + if (args.TryGet(1, "type", out string type, false, new[] { "category", "source" })) { args.TryGet(2, "name", out string name); switch (type) { case "category": - SCore.PerformanceCounterManager.ResetCollection(name); + SCore.PerformanceMonitor.ResetCollection(name); monitor.Log($"All performance counters for category {name} are now cleared.", LogLevel.Info); break; case "source": - SCore.PerformanceCounterManager.ResetSource(name); + SCore.PerformanceMonitor.ResetSource(name); monitor.Log($"All performance counters for source {name} are now cleared.", LogLevel.Info); break; } } else { - SCore.PerformanceCounterManager.Reset(); + SCore.PerformanceMonitor.Reset(); monitor.Log("All performance counters are now cleared.", LogLevel.Info); } } @@ -455,7 +414,7 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other private void OutputPerformanceCollectionDetail(IMonitor monitor, PerformanceCounterCollection collection, TimeSpan averageInterval, double? thresholdMilliseconds, string sourceFilter = null) { - StringBuilder sb = new StringBuilder($"Performance Counter for {collection.Name}:\n\n"); + StringBuilder report = new StringBuilder($"Performance Counter for {collection.Name}:\n\n"); List<KeyValuePair<string, PerformanceCounter>> data = collection.PerformanceCounters.ToList(); @@ -466,15 +425,13 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other } if (thresholdMilliseconds != null) - { data = data.Where(p => p.Value.GetAverage(averageInterval) >= thresholdMilliseconds).ToList(); - } if (data.Any()) { - sb.AppendLine(this.GetTableString( + report.AppendLine(this.GetTableString( data: data, - header: new[] {"Mod", $"Avg Exec Time (last {(int) averageInterval.TotalSeconds}s)", "Last Exec Time", "Peak Exec Time", $"Peak Exec Time (last {(int) averageInterval.TotalSeconds}s)"}, + header: new[] { "Mod", $"Avg Exec Time (last {(int)averageInterval.TotalSeconds}s)", "Last Exec Time", "Peak Exec Time", $"Peak Exec Time (last {(int)averageInterval.TotalSeconds}s)" }, getRow: item => new[] { item.Key, @@ -488,28 +445,13 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other } else { - sb.Clear(); - sb.AppendLine($"Performance Counter for {collection.Name}: none."); - } - - monitor.Log(sb.ToString(), LogLevel.Info); - } - - /// <summary>Parses a command string and returns the associated command.</summary> - /// <param name="commandString">The command string</param> - /// <returns>The parsed command.</returns> - private SubCommand ParseCommandString(string commandString) - { - foreach (var i in this.SubCommandNames.Where(i => - i.Value.Any(str => str.Equals(commandString, StringComparison.InvariantCultureIgnoreCase)))) - { - return i.Key; + report.Clear(); + report.AppendLine($"Performance Counter for {collection.Name}: none."); } - return SubCommand.None; + monitor.Log(report.ToString(), LogLevel.Info); } - /// <summary>Formats the given milliseconds value into a string format. Optionally /// allows a threshold to return "-" if the value is less than the threshold.</summary> /// <param name="milliseconds">The milliseconds to format. Returns "-" if null</param> @@ -518,175 +460,212 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other private string FormatMilliseconds(double? milliseconds, double? thresholdMilliseconds = null) { if (milliseconds == null || (thresholdMilliseconds != null && milliseconds < thresholdMilliseconds)) - { return "-"; - } - return ((double) milliseconds).ToString("F2"); + return ((double)milliseconds).ToString("F2"); } /// <summary>Shows detailed help for a specific sub command.</summary> - /// <param name="monitor">The output monitor</param> - /// <param name="subCommand">The sub command</param> - private void OutputHelp(IMonitor monitor, SubCommand subCommand) + /// <param name="monitor">The output monitor.</param> + /// <param name="subcommand">The subcommand.</param> + private void OutputHelp(IMonitor monitor, SubCommand? subcommand) { - StringBuilder sb = new StringBuilder(); - sb.AppendLine(); + StringBuilder report = new StringBuilder(); + report.AppendLine(); - switch (subCommand) + switch (subcommand) { - case SubCommand.Concepts: - sb.AppendLine("A performance counter is a metric which measures execution time. Each performance"); - sb.AppendLine("counter consists of:"); - sb.AppendLine(); - sb.AppendLine(" - A source, which typically is a mod or the game itself."); - sb.AppendLine(" - A ring buffer which stores the data points (execution time and time when it was executed)"); - sb.AppendLine(); - sb.AppendLine("A set of performance counters is organized in a collection to group various areas."); - sb.AppendLine("Per default, collections for all game events [1] are created."); - sb.AppendLine(); - sb.AppendLine("Example:"); - sb.AppendLine(); - sb.AppendLine("The performance counter collection named 'Display.Rendered' contains one performance"); - sb.AppendLine("counters when the game executes the 'Display.Rendered' event, and one additional"); - sb.AppendLine("performance counter for each mod which handles the 'Display.Rendered' event."); - sb.AppendLine(); - sb.AppendLine("[1] https://stardewvalleywiki.com/Modding:Modder_Guide/APIs/Events"); - break; case SubCommand.Detail: - sb.AppendLine("Usage: pc detail <collection> <source>"); - sb.AppendLine(" pc detail <collection> <threshold>"); - sb.AppendLine(); - sb.AppendLine("Displays details for a specific collection."); - sb.AppendLine(); - sb.AppendLine("Arguments:"); - sb.AppendLine(" <collection> Required. The full or partial name of the collection to display."); - sb.AppendLine(" <source> Optional. The full or partial name of the source."); - sb.AppendLine(" <threshold> Optional. The threshold in milliseconds. Any average execution time below that"); - sb.AppendLine(" threshold is not reported."); - sb.AppendLine(); - sb.AppendLine("Examples:"); - sb.AppendLine("pc detail Display.Rendering Displays all performance counters for the 'Display.Rendering' collection"); - sb.AppendLine("pc detail Display.Rendering Pathoschild.ChestsAnywhere Displays the 'Display.Rendering' performance counter for 'Pathoschild.ChestsAnywhere'"); - sb.AppendLine("pc detail Display.Rendering 5 Displays the 'Display.Rendering' performance counters exceeding an average of 5ms"); + report.AppendLine("Usage: pc detail <collection> <source>"); + report.AppendLine(" pc detail <collection> <threshold>"); + report.AppendLine(); + report.AppendLine("Displays details for a specific collection."); + report.AppendLine(); + report.AppendLine("Arguments:"); + report.AppendLine(" <collection> Required. The full or partial name of the collection to display."); + report.AppendLine(" <source> Optional. The full or partial name of the source."); + report.AppendLine(" <threshold> Optional. The threshold in milliseconds. Any average execution time below that"); + report.AppendLine(" threshold is not reported."); + report.AppendLine(); + report.AppendLine("Examples:"); + report.AppendLine("pc detail Display.Rendering Displays all performance counters for the 'Display.Rendering' collection"); + report.AppendLine("pc detail Display.Rendering Pathoschild.ChestsAnywhere Displays the 'Display.Rendering' performance counter for 'Pathoschild.ChestsAnywhere'"); + report.AppendLine("pc detail Display.Rendering 5 Displays the 'Display.Rendering' performance counters exceeding an average of 5ms"); break; + case SubCommand.Summary: - sb.AppendLine("Usage: pc summary <mode|name> <threshold>"); - sb.AppendLine(); - sb.AppendLine("Displays the performance counter summary."); - sb.AppendLine(); - sb.AppendLine("Arguments:"); - sb.AppendLine(" <mode> Optional. Defaults to 'important' if omitted. Specifies one of these modes:"); - sb.AppendLine(" - all Displays performance counters from all collections"); - sb.AppendLine(" - important Displays only important performance counter collections"); - sb.AppendLine(); - sb.AppendLine(" <name> Optional. Only shows performance counter collections matching the given name"); - sb.AppendLine(" <threshold> Optional. Hides the actual execution time if it is below this threshold"); - sb.AppendLine(); - sb.AppendLine("Examples:"); - sb.AppendLine("pc summary all Shows all events"); - sb.AppendLine("pc summary all 5 Shows all events"); - sb.AppendLine("pc summary Display.Rendering Shows only the 'Display.Rendering' collection"); + report.AppendLine("Usage: pc summary <mode|name> <threshold>"); + report.AppendLine(); + report.AppendLine("Displays the performance counter summary."); + report.AppendLine(); + report.AppendLine("Arguments:"); + report.AppendLine(" <mode> Optional. Defaults to 'important' if omitted. Specifies one of these modes:"); + report.AppendLine(" - all Displays performance counters from all collections"); + report.AppendLine(" - important Displays only important performance counter collections"); + report.AppendLine(); + report.AppendLine(" <name> Optional. Only shows performance counter collections matching the given name"); + report.AppendLine(" <threshold> Optional. Hides the actual execution time if it is below this threshold"); + report.AppendLine(); + report.AppendLine("Examples:"); + report.AppendLine("pc summary all Shows all events"); + report.AppendLine("pc summary all 5 Shows all events"); + report.AppendLine("pc summary Display.Rendering Shows only the 'Display.Rendering' collection"); break; + case SubCommand.Trigger: - sb.AppendLine("Usage: pc trigger <mode>"); - sb.AppendLine("Usage: pc trigger collection <collectionName> <threshold>"); - sb.AppendLine("Usage: pc trigger collection <collectionName> <threshold> <sourceName>"); - sb.AppendLine(); - sb.AppendLine("Manages alert triggers."); - sb.AppendLine(); - sb.AppendLine("Arguments:"); - sb.AppendLine(" <mode> Optional. Specifies if a specific source or a specific collection should be triggered."); - sb.AppendLine(" - list Lists current triggers"); - sb.AppendLine(" - collection Sets up a trigger for a collection"); - sb.AppendLine(" - clear Clears all trigger entries"); - sb.AppendLine(" - pause Pauses triggering of alerts"); - sb.AppendLine(" - resume Resumes triggering of alerts"); - sb.AppendLine(" - dump Dumps all triggers as commands for copy and paste"); - sb.AppendLine(" Defaults to 'list' if not specified."); - sb.AppendLine(); - sb.AppendLine(" <collectionName> Required if the mode 'collection' is specified."); - sb.AppendLine(" Specifies the name of the collection to be triggered. Must be an exact match."); - sb.AppendLine(); - sb.AppendLine(" <sourceName> Optional. Specifies the name of a specific source. Must be an exact match."); - sb.AppendLine(); - sb.AppendLine(" <threshold> Required if the mode 'collection' is specified."); - sb.AppendLine(" Specifies the threshold in milliseconds (fractions allowed)."); - sb.AppendLine(" Specify '0' to remove the threshold."); - sb.AppendLine(); - sb.AppendLine("Examples:"); - sb.AppendLine(); - sb.AppendLine("pc trigger collection Display.Rendering 10"); - sb.AppendLine(" Sets up an alert trigger which writes on the console if the execution time of all performance counters in"); - sb.AppendLine(" the 'Display.Rendering' collection exceed 10 milliseconds."); - sb.AppendLine(); - sb.AppendLine("pc trigger collection Display.Rendering 5 Pathoschild.ChestsAnywhere"); - sb.AppendLine(" Sets up an alert trigger to write on the console if the execution time of Pathoschild.ChestsAnywhere in"); - sb.AppendLine(" the 'Display.Rendering' collection exceed 5 milliseconds."); - sb.AppendLine(); - sb.AppendLine("pc trigger collection Display.Rendering 0"); - sb.AppendLine(" Removes the threshold previously defined from the collection. Note that source-specific thresholds are left intact."); - sb.AppendLine(); - sb.AppendLine("pc trigger clear"); - sb.AppendLine(" Clears all previously setup alert triggers."); + report.AppendLine("Usage: pc trigger <mode>"); + report.AppendLine("Usage: pc trigger collection <collectionName> <threshold>"); + report.AppendLine("Usage: pc trigger collection <collectionName> <threshold> <sourceName>"); + report.AppendLine(); + report.AppendLine("Manages alert triggers."); + report.AppendLine(); + report.AppendLine("Arguments:"); + report.AppendLine(" <mode> Optional. Specifies if a specific source or a specific collection should be triggered."); + report.AppendLine(" - list Lists current triggers"); + report.AppendLine(" - collection Sets up a trigger for a collection"); + report.AppendLine(" - clear Clears all trigger entries"); + report.AppendLine(" - pause Pauses triggering of alerts"); + report.AppendLine(" - resume Resumes triggering of alerts"); + report.AppendLine(" - dump Dumps all triggers as commands for copy and paste"); + report.AppendLine(" Defaults to 'list' if not specified."); + report.AppendLine(); + report.AppendLine(" <collectionName> Required if the mode 'collection' is specified."); + report.AppendLine(" Specifies the name of the collection to be triggered. Must be an exact match."); + report.AppendLine(); + report.AppendLine(" <sourceName> Optional. Specifies the name of a specific source. Must be an exact match."); + report.AppendLine(); + report.AppendLine(" <threshold> Required if the mode 'collection' is specified."); + report.AppendLine(" Specifies the threshold in milliseconds (fractions allowed)."); + report.AppendLine(" Specify '0' to remove the threshold."); + report.AppendLine(); + report.AppendLine("Examples:"); + report.AppendLine(); + report.AppendLine("pc trigger collection Display.Rendering 10"); + report.AppendLine(" Sets up an alert trigger which writes on the console if the execution time of all performance counters in"); + report.AppendLine(" the 'Display.Rendering' collection exceed 10 milliseconds."); + report.AppendLine(); + report.AppendLine("pc trigger collection Display.Rendering 5 Pathoschild.ChestsAnywhere"); + report.AppendLine(" Sets up an alert trigger to write on the console if the execution time of Pathoschild.ChestsAnywhere in"); + report.AppendLine(" the 'Display.Rendering' collection exceed 5 milliseconds."); + report.AppendLine(); + report.AppendLine("pc trigger collection Display.Rendering 0"); + report.AppendLine(" Removes the threshold previously defined from the collection. Note that source-specific thresholds are left intact."); + report.AppendLine(); + report.AppendLine("pc trigger clear"); + report.AppendLine(" Clears all previously setup alert triggers."); break; + case SubCommand.Reset: - sb.AppendLine("Usage: pc reset <type> <name>"); - sb.AppendLine(); - sb.AppendLine("Resets performance counters."); - sb.AppendLine(); - sb.AppendLine("Arguments:"); - sb.AppendLine(" <type> Optional. Specifies if a collection or source should be reset."); - sb.AppendLine(" If omitted, all performance counters are reset."); - sb.AppendLine(); - sb.AppendLine(" - source Clears performance counters for a specific source"); - sb.AppendLine(" - collection Clears performance counters for a specific collection"); - sb.AppendLine(); - sb.AppendLine(" <name> Required if a <type> is given. Specifies the name of either the collection"); - sb.AppendLine(" or the source. The name must be an exact match."); - sb.AppendLine(); - sb.AppendLine("Examples:"); - sb.AppendLine("pc reset Resets all performance counters"); - sb.AppendLine("pc reset source Pathoschild.ChestsAnywhere Resets all performance for the source named Pathoschild.ChestsAnywhere"); - sb.AppendLine("pc reset collection Display.Rendering Resets all performance for the collection named Display.Rendering"); + report.AppendLine("Usage: pc reset <type> <name>"); + report.AppendLine(); + report.AppendLine("Resets performance counters."); + report.AppendLine(); + report.AppendLine("Arguments:"); + report.AppendLine(" <type> Optional. Specifies if a collection or source should be reset."); + report.AppendLine(" If omitted, all performance counters are reset."); + report.AppendLine(); + report.AppendLine(" - source Clears performance counters for a specific source"); + report.AppendLine(" - collection Clears performance counters for a specific collection"); + report.AppendLine(); + report.AppendLine(" <name> Required if a <type> is given. Specifies the name of either the collection"); + report.AppendLine(" or the source. The name must be an exact match."); + report.AppendLine(); + report.AppendLine("Examples:"); + report.AppendLine("pc reset Resets all performance counters"); + report.AppendLine("pc reset source Pathoschild.ChestsAnywhere Resets all performance for the source named Pathoschild.ChestsAnywhere"); + report.AppendLine("pc reset collection Display.Rendering Resets all performance for the collection named Display.Rendering"); break; } - sb.AppendLine(); - monitor.Log(sb.ToString(), LogLevel.Info); + report.AppendLine(); + monitor.Log(report.ToString(), LogLevel.Info); } /// <summary>Get the command description.</summary> private static string GetDescription() { - StringBuilder sb = new StringBuilder(); - - sb.AppendLine("Displays and configures performance counters."); - sb.AppendLine(); - sb.AppendLine("A performance counter records the invocation time of in-game events being"); - sb.AppendLine("processed by mods or the game itself. See 'concepts' for a detailed explanation."); - sb.AppendLine(); - sb.AppendLine("Usage: pc <command> <action>"); - sb.AppendLine(); - sb.AppendLine("Commands:"); - sb.AppendLine(); - sb.AppendLine(" summary|sum|s Displays a summary of important or all collections"); - sb.AppendLine(" detail|d Shows performance counter information for a given collection"); - sb.AppendLine(" reset|r Resets the performance counters"); - sb.AppendLine(" trigger Configures alert triggers"); - sb.AppendLine(" enable Enables performance counter recording"); - sb.AppendLine(" disable Disables performance counter recording"); - sb.AppendLine(" examples Displays various examples"); - sb.AppendLine(" concepts Displays an explanation of the performance counter concepts"); - sb.AppendLine(" help Displays verbose help for the available commands"); - sb.AppendLine(); - sb.AppendLine("To get help for a specific command, use 'pc help <command>', for example:"); - sb.AppendLine("pc help summary"); - sb.AppendLine(); - sb.AppendLine("Defaults to summary if no command is given."); - sb.AppendLine(); - - return sb.ToString(); + StringBuilder report = new StringBuilder(); + + report.AppendLine("Displays or configures performance monitoring for diagnose issues."); + report.AppendLine(); + report.AppendLine("A 'performance counter' is a metric which measures execution time across a range of time for a source (e.g. a mod)."); + report.AppendLine("A set of performance counters is organized in a collection to group various areas."); + report.AppendLine("For example, the performance counter collection named 'Display.Rendered' contains one performance"); + report.AppendLine("counter when the game executes the 'Display.Rendered' event, and another counter for each mod which handles it."); + report.AppendLine(); + report.AppendLine("Usage: pc <command> <action>"); + report.AppendLine(); + report.AppendLine("Commands:"); + report.AppendLine(); + report.AppendLine(" summary Show a summary of collections."); + report.AppendLine(" detail Show a summary for a given collection."); + report.AppendLine(" reset Reset all performance counters."); + report.AppendLine(" trigger Configure alert triggers."); + report.AppendLine(" enable Enable performance counter recording."); + report.AppendLine(" disable Disable performance counter recording."); + report.AppendLine(" help Show verbose help for the available commands."); + report.AppendLine(); + report.AppendLine("To get help for a specific command, use 'pc help <command>', for example:"); + report.AppendLine("pc help summary"); + report.AppendLine(); + report.AppendLine("Defaults to summary if no command is given."); + report.AppendLine(); + + return report.ToString(); + } + + + /********* + ** Private models + *********/ + /// <summary>An alert trigger for a collection.</summary> + private class CollectionTrigger + { + /********* + ** Accessors + *********/ + /// <summary>The collection name.</summary> + public string CollectionName { get; } + + /// <summary>The trigger threshold.</summary> + public double Threshold { get; } + + + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> + /// <param name="collectionName">The collection name.</param> + /// <param name="threshold">The trigger threshold.</param> + public CollectionTrigger(string collectionName, double threshold) + { + this.CollectionName = collectionName; + this.Threshold = threshold; + } + } + + /// <summary>An alert triggered for a source.</summary> + private class SourceTrigger : CollectionTrigger + { + /********* + ** Accessors + *********/ + /// <summary>The source name.</summary> + public string SourceName { get; } + + + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> + /// <param name="collectionName">The collection name.</param> + /// <param name="sourceName">The source name.</param> + /// <param name="threshold">The trigger threshold.</param> + public SourceTrigger(string collectionName, string sourceName, double threshold) + : base(collectionName, threshold) + { + this.SourceName = sourceName; + } } } } diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/TrainerCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/TrainerCommand.cs index 8f0d89ba..2b562a08 100644 --- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/TrainerCommand.cs +++ b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/TrainerCommand.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Linq; @@ -66,7 +66,7 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands /// <param name="data">The data to display.</param> /// <param name="header">The table header.</param> /// <param name="getRow">Returns a set of fields for a data value.</param> - /// <param name="rightAlign">True to right-align the data, false for left-align. Default false.</param> + /// <param name="rightAlign">Whether to right-align the data.</param> protected string GetTableString<T>(IEnumerable<T> data, string[] header, Func<T, string[]> getRow, bool rightAlign = false) { // get table data @@ -93,19 +93,11 @@ namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands }; lines.AddRange(rows); - if (rightAlign) - { - return string.Join( - Environment.NewLine, - lines.Select(line => string.Join(" | ", line.Select((field, i) => field.PadLeft(widths[i], ' ')).ToArray()) - ) - ); - } - return string.Join( Environment.NewLine, - lines.Select(line => string.Join(" | ", line.Select((field, i) => field.PadRight(widths[i], ' ')).ToArray()) - ) + lines.Select(line => string.Join(" | ", + line.Select((field, i) => rightAlign ? field.PadRight(widths[i], ' ') : field.PadLeft(widths[i], ' ')) + )) ); } } diff --git a/src/SMAPI.Mods.ConsoleCommands/SMAPI.Mods.ConsoleCommands.csproj b/src/SMAPI.Mods.ConsoleCommands/SMAPI.Mods.ConsoleCommands.csproj index f073ac21..ce35bf73 100644 --- a/src/SMAPI.Mods.ConsoleCommands/SMAPI.Mods.ConsoleCommands.csproj +++ b/src/SMAPI.Mods.ConsoleCommands/SMAPI.Mods.ConsoleCommands.csproj @@ -67,10 +67,6 @@ </None> </ItemGroup> - <ItemGroup> - <PackageReference Include="System.ValueTuple" Version="4.5.0" /> - </ItemGroup> - <Import Project="..\SMAPI.Internal\SMAPI.Internal.projitems" Label="Shared" /> <Import Project="..\..\build\common.targets" /> diff --git a/src/SMAPI/Constants.cs b/src/SMAPI/Constants.cs index 76cb6f89..67c7b576 100644 --- a/src/SMAPI/Constants.cs +++ b/src/SMAPI/Constants.cs @@ -55,7 +55,7 @@ namespace StardewModdingAPI /// <summary>The URL of the SMAPI home page.</summary> internal const string HomePageUrl = "https://smapi.io"; - /// <summary>The URL of the SMAPI home page.</summary> + /// <summary>The default performance counter name for unknown event handlers.</summary> internal const string GamePerformanceCounterName = "<StardewValley>"; /// <summary>The absolute path to the folder containing SMAPI's internal files.</summary> @@ -103,6 +103,7 @@ namespace StardewModdingAPI /// <summary>The language code for non-translated mod assets.</summary> internal static LocalizedContentManager.LanguageCode DefaultLanguage { get; } = LocalizedContentManager.LanguageCode.en; + /********* ** Internal methods *********/ diff --git a/src/SMAPI/Framework/Events/EventManager.cs b/src/SMAPI/Framework/Events/EventManager.cs index 19a4dff8..50dcc9ef 100644 --- a/src/SMAPI/Framework/Events/EventManager.cs +++ b/src/SMAPI/Framework/Events/EventManager.cs @@ -1,4 +1,6 @@ +using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; +using System.Reflection; using StardewModdingAPI.Events; using StardewModdingAPI.Framework.PerformanceCounter; @@ -174,29 +176,32 @@ namespace StardewModdingAPI.Framework.Events /// <summary>Construct an instance.</summary> /// <param name="monitor">Writes messages to the log.</param> /// <param name="modRegistry">The mod registry with which to identify mods.</param> - /// <param name="performanceCounterManager">The performance counter manager.</param> - public EventManager(IMonitor monitor, ModRegistry modRegistry, PerformanceCounterManager performanceCounterManager) + /// <param name="performanceMonitor">Tracks performance metrics.</param> + public EventManager(IMonitor monitor, ModRegistry modRegistry, PerformanceMonitor performanceMonitor) { // create shortcut initializers - ManagedEvent<TEventArgs> ManageEventOf<TEventArgs>(string typeName, string eventName) => new ManagedEvent<TEventArgs>($"{typeName}.{eventName}", monitor, modRegistry, performanceCounterManager); + ManagedEvent<TEventArgs> ManageEventOf<TEventArgs>(string typeName, string eventName, bool isPerformanceCritical = false) + { + return new ManagedEvent<TEventArgs>($"{typeName}.{eventName}", monitor, modRegistry, performanceMonitor, isPerformanceCritical); + } // init events (new) this.MenuChanged = ManageEventOf<MenuChangedEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.MenuChanged)); - this.Rendering = ManageEventOf<RenderingEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.Rendering)); - this.Rendered = ManageEventOf<RenderedEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.Rendered)); - this.RenderingWorld = ManageEventOf<RenderingWorldEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderingWorld)); - this.RenderedWorld = ManageEventOf<RenderedWorldEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderedWorld)); - this.RenderingActiveMenu = ManageEventOf<RenderingActiveMenuEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderingActiveMenu)); - this.RenderedActiveMenu = ManageEventOf<RenderedActiveMenuEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderedActiveMenu)); - this.RenderingHud = ManageEventOf<RenderingHudEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderingHud)); - this.RenderedHud = ManageEventOf<RenderedHudEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderedHud)); + this.Rendering = ManageEventOf<RenderingEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.Rendering), isPerformanceCritical: true); + this.Rendered = ManageEventOf<RenderedEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.Rendered), isPerformanceCritical: true); + this.RenderingWorld = ManageEventOf<RenderingWorldEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderingWorld), isPerformanceCritical: true); + this.RenderedWorld = ManageEventOf<RenderedWorldEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderedWorld), isPerformanceCritical: true); + this.RenderingActiveMenu = ManageEventOf<RenderingActiveMenuEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderingActiveMenu), isPerformanceCritical: true); + this.RenderedActiveMenu = ManageEventOf<RenderedActiveMenuEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderedActiveMenu), isPerformanceCritical: true); + this.RenderingHud = ManageEventOf<RenderingHudEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderingHud), isPerformanceCritical: true); + this.RenderedHud = ManageEventOf<RenderedHudEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.RenderedHud), isPerformanceCritical: true); this.WindowResized = ManageEventOf<WindowResizedEventArgs>(nameof(IModEvents.Display), nameof(IDisplayEvents.WindowResized)); this.GameLaunched = ManageEventOf<GameLaunchedEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.GameLaunched)); - this.UpdateTicking = ManageEventOf<UpdateTickingEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.UpdateTicking)); - this.UpdateTicked = ManageEventOf<UpdateTickedEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.UpdateTicked)); - this.OneSecondUpdateTicking = ManageEventOf<OneSecondUpdateTickingEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.OneSecondUpdateTicking)); - this.OneSecondUpdateTicked = ManageEventOf<OneSecondUpdateTickedEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.OneSecondUpdateTicked)); + this.UpdateTicking = ManageEventOf<UpdateTickingEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.UpdateTicking), isPerformanceCritical: true); + this.UpdateTicked = ManageEventOf<UpdateTickedEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.UpdateTicked), isPerformanceCritical: true); + this.OneSecondUpdateTicking = ManageEventOf<OneSecondUpdateTickingEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.OneSecondUpdateTicking), isPerformanceCritical: true); + this.OneSecondUpdateTicked = ManageEventOf<OneSecondUpdateTickedEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.OneSecondUpdateTicked), isPerformanceCritical: true); this.SaveCreating = ManageEventOf<SaveCreatingEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.SaveCreating)); this.SaveCreated = ManageEventOf<SaveCreatedEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.SaveCreated)); this.Saving = ManageEventOf<SavingEventArgs>(nameof(IModEvents.GameLoop), nameof(IGameLoopEvents.Saving)); @@ -209,7 +214,7 @@ namespace StardewModdingAPI.Framework.Events this.ButtonPressed = ManageEventOf<ButtonPressedEventArgs>(nameof(IModEvents.Input), nameof(IInputEvents.ButtonPressed)); this.ButtonReleased = ManageEventOf<ButtonReleasedEventArgs>(nameof(IModEvents.Input), nameof(IInputEvents.ButtonReleased)); - this.CursorMoved = ManageEventOf<CursorMovedEventArgs>(nameof(IModEvents.Input), nameof(IInputEvents.CursorMoved)); + this.CursorMoved = ManageEventOf<CursorMovedEventArgs>(nameof(IModEvents.Input), nameof(IInputEvents.CursorMoved), isPerformanceCritical: true); this.MouseWheelScrolled = ManageEventOf<MouseWheelScrolledEventArgs>(nameof(IModEvents.Input), nameof(IInputEvents.MouseWheelScrolled)); this.PeerContextReceived = ManageEventOf<PeerContextReceivedEventArgs>(nameof(IModEvents.Multiplayer), nameof(IMultiplayerEvents.PeerContextReceived)); @@ -230,8 +235,15 @@ namespace StardewModdingAPI.Framework.Events this.TerrainFeatureListChanged = ManageEventOf<TerrainFeatureListChangedEventArgs>(nameof(IModEvents.World), nameof(IWorldEvents.TerrainFeatureListChanged)); this.LoadStageChanged = ManageEventOf<LoadStageChangedEventArgs>(nameof(IModEvents.Specialized), nameof(ISpecializedEvents.LoadStageChanged)); - this.UnvalidatedUpdateTicking = ManageEventOf<UnvalidatedUpdateTickingEventArgs>(nameof(IModEvents.Specialized), nameof(ISpecializedEvents.UnvalidatedUpdateTicking)); - this.UnvalidatedUpdateTicked = ManageEventOf<UnvalidatedUpdateTickedEventArgs>(nameof(IModEvents.Specialized), nameof(ISpecializedEvents.UnvalidatedUpdateTicked)); + this.UnvalidatedUpdateTicking = ManageEventOf<UnvalidatedUpdateTickingEventArgs>(nameof(IModEvents.Specialized), nameof(ISpecializedEvents.UnvalidatedUpdateTicking), isPerformanceCritical: true); + this.UnvalidatedUpdateTicked = ManageEventOf<UnvalidatedUpdateTickedEventArgs>(nameof(IModEvents.Specialized), nameof(ISpecializedEvents.UnvalidatedUpdateTicked), isPerformanceCritical: true); + } + + /// <summary>Get all managed events.</summary> + public IEnumerable<IManagedEvent> GetAllEvents() + { + foreach (FieldInfo field in this.GetType().GetFields()) + yield return (IManagedEvent)field.GetValue(this); } } } diff --git a/src/SMAPI/Framework/Events/IManagedEvent.cs b/src/SMAPI/Framework/Events/IManagedEvent.cs index 04476866..e4e3ca08 100644 --- a/src/SMAPI/Framework/Events/IManagedEvent.cs +++ b/src/SMAPI/Framework/Events/IManagedEvent.cs @@ -1,7 +1,15 @@ namespace StardewModdingAPI.Framework.Events { + /// <summary>Metadata for an event raised by SMAPI.</summary> internal interface IManagedEvent { - string GetName(); + /********* + ** Accessors + *********/ + /// <summary>A human-readable name for the event.</summary> + string EventName { get; } + + /// <summary>Whether the event is typically called at least once per second.</summary> + bool IsPerformanceCritical { get; } } } diff --git a/src/SMAPI/Framework/Events/ManagedEvent.cs b/src/SMAPI/Framework/Events/ManagedEvent.cs index dfdd7449..60e5c599 100644 --- a/src/SMAPI/Framework/Events/ManagedEvent.cs +++ b/src/SMAPI/Framework/Events/ManagedEvent.cs @@ -1,13 +1,13 @@ using System; using System.Collections.Generic; using System.Linq; -using PerformanceCounterManager = StardewModdingAPI.Framework.PerformanceCounter.PerformanceCounterManager; +using StardewModdingAPI.Framework.PerformanceCounter; namespace StardewModdingAPI.Framework.Events { /// <summary>An event wrapper which intercepts and logs errors in handler code.</summary> /// <typeparam name="TEventArgs">The event arguments type.</typeparam> - internal class ManagedEvent<TEventArgs>: IManagedEvent + internal class ManagedEvent<TEventArgs> : IManagedEvent { /********* ** Fields @@ -15,9 +15,6 @@ namespace StardewModdingAPI.Framework.Events /// <summary>The underlying event.</summary> private event EventHandler<TEventArgs> Event; - /// <summary>A human-readable name for the event.</summary> - private readonly string EventName; - /// <summary>Writes messages to the log.</summary> private readonly IMonitor Monitor; @@ -30,8 +27,19 @@ namespace StardewModdingAPI.Framework.Events /// <summary>The cached invocation list.</summary> private EventHandler<TEventArgs>[] CachedInvocationList; - /// <summary>The performance counter manager.</summary> - private readonly PerformanceCounterManager PerformanceCounterManager; + /// <summary>Tracks performance metrics.</summary> + private readonly PerformanceMonitor PerformanceMonitor; + + + /********* + ** Accessors + *********/ + /// <summary>A human-readable name for the event.</summary> + public string EventName { get; } + + /// <summary>Whether the event is typically called at least once per second.</summary> + public bool IsPerformanceCritical { get; } + /********* ** Public methods @@ -40,19 +48,15 @@ namespace StardewModdingAPI.Framework.Events /// <param name="eventName">A human-readable name for the event.</param> /// <param name="monitor">Writes messages to the log.</param> /// <param name="modRegistry">The mod registry with which to identify mods.</param> - /// <param name="performanceCounterManager">The performance counter manager</param> - public ManagedEvent(string eventName, IMonitor monitor, ModRegistry modRegistry, PerformanceCounterManager performanceCounterManager) + /// <param name="performanceMonitor">Tracks performance metrics.</param> + /// <param name="isPerformanceCritical">Whether the event is typically called at least once per second.</param> + public ManagedEvent(string eventName, IMonitor monitor, ModRegistry modRegistry, PerformanceMonitor performanceMonitor, bool isPerformanceCritical = false) { this.EventName = eventName; this.Monitor = monitor; this.ModRegistry = modRegistry; - this.PerformanceCounterManager = performanceCounterManager; - } - - /// <summary>Gets the event name.</summary> - public string GetName() - { - return this.EventName; + this.PerformanceMonitor = performanceMonitor; + this.IsPerformanceCritical = isPerformanceCritical; } /// <summary>Get whether anything is listening to the event.</summary> @@ -93,22 +97,20 @@ namespace StardewModdingAPI.Framework.Events return; - this.PerformanceCounterManager.BeginTrackInvocation(this.EventName); - - foreach (EventHandler<TEventArgs> handler in this.CachedInvocationList) + this.PerformanceMonitor.Track(this.EventName, () => { - try - { - this.PerformanceCounterManager.Track(this.EventName, this.GetModNameForPerformanceCounters(handler), - () => handler.Invoke(null, args)); - } - catch (Exception ex) + foreach (EventHandler<TEventArgs> handler in this.CachedInvocationList) { - this.LogError(handler, ex); + try + { + this.PerformanceMonitor.Track(this.EventName, this.GetModNameForPerformanceCounters(handler), () => handler.Invoke(null, args)); + } + catch (Exception ex) + { + this.LogError(handler, ex); + } } - } - - this.PerformanceCounterManager.EndTrackInvocation(this.EventName); + }); } /// <summary>Raise the event and notify all handlers.</summary> @@ -139,18 +141,17 @@ namespace StardewModdingAPI.Framework.Events /********* ** Private methods *********/ - + /// <summary>Get the mod name for a given event handler to display in performance monitoring reports.</summary> + /// <param name="handler">The event handler.</param> private string GetModNameForPerformanceCounters(EventHandler<TEventArgs> handler) { IModMetadata mod = this.GetSourceMod(handler); - if (mod == null) - { return Constants.GamePerformanceCounterName; - } - - return mod.HasManifest() ? mod.Manifest.UniqueID : mod.DisplayName; + return mod.HasManifest() + ? mod.Manifest.UniqueID + : mod.DisplayName; } /// <summary>Track an event handler.</summary> diff --git a/src/SMAPI/Framework/PerformanceCounter/AlertContext.cs b/src/SMAPI/Framework/PerformanceCounter/AlertContext.cs index 63f0a5ed..76c472e1 100644 --- a/src/SMAPI/Framework/PerformanceCounter/AlertContext.cs +++ b/src/SMAPI/Framework/PerformanceCounter/AlertContext.cs @@ -3,13 +3,20 @@ namespace StardewModdingAPI.Framework.PerformanceCounter /// <summary>The context for an alert.</summary> internal struct AlertContext { + /********* + ** Accessors + *********/ /// <summary>The source which triggered the alert.</summary> - public readonly string Source; + public string Source { get; } /// <summary>The elapsed milliseconds.</summary> - public readonly double Elapsed; + public double Elapsed { get; } - /// <summary>Creates a new alert context.</summary> + + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> /// <param name="source">The source which triggered the alert.</param> /// <param name="elapsed">The elapsed milliseconds.</param> public AlertContext(string source, double elapsed) @@ -18,6 +25,7 @@ namespace StardewModdingAPI.Framework.PerformanceCounter this.Elapsed = elapsed; } + /// <summary>Get a human-readable text form of this instance.</summary> public override string ToString() { return $"{this.Source}: {this.Elapsed:F2}ms"; diff --git a/src/SMAPI/Framework/PerformanceCounter/AlertEntry.cs b/src/SMAPI/Framework/PerformanceCounter/AlertEntry.cs index b87d8642..494f34a9 100644 --- a/src/SMAPI/Framework/PerformanceCounter/AlertEntry.cs +++ b/src/SMAPI/Framework/PerformanceCounter/AlertEntry.cs @@ -1,28 +1,33 @@ -using System.Collections.Generic; - namespace StardewModdingAPI.Framework.PerformanceCounter { /// <summary>A single alert entry.</summary> internal struct AlertEntry { + /********* + ** Accessors + *********/ /// <summary>The collection in which the alert occurred.</summary> - public readonly PerformanceCounterCollection Collection; + public PerformanceCounterCollection Collection { get; } /// <summary>The actual execution time in milliseconds.</summary> - public readonly double ExecutionTimeMilliseconds; + public double ExecutionTimeMilliseconds { get; } + + /// <summary>The configured alert threshold in milliseconds.</summary> + public double ThresholdMilliseconds { get; } - /// <summary>The configured alert threshold. </summary> - public readonly double ThresholdMilliseconds; + /// <summary>The sources involved in exceeding the threshold.</summary> + public AlertContext[] Context { get; } - /// <summary>The context list, which records all sources involved in exceeding the threshold.</summary> - public readonly List<AlertContext> Context; - /// <summary>Creates a new alert entry.</summary> - /// <param name="collection">The source collection in which the alert occurred.</param> + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> + /// <param name="collection">The collection in which the alert occurred.</param> /// <param name="executionTimeMilliseconds">The actual execution time in milliseconds.</param> - /// <param name="thresholdMilliseconds">The configured threshold in milliseconds.</param> - /// <param name="context">A list of AlertContext to record which sources were involved</param> - public AlertEntry(PerformanceCounterCollection collection, double executionTimeMilliseconds, double thresholdMilliseconds, List<AlertContext> context) + /// <param name="thresholdMilliseconds">The configured alert threshold in milliseconds.</param> + /// <param name="context">The sources involved in exceeding the threshold.</param> + public AlertEntry(PerformanceCounterCollection collection, double executionTimeMilliseconds, double thresholdMilliseconds, AlertContext[] context) { this.Collection = collection; this.ExecutionTimeMilliseconds = executionTimeMilliseconds; diff --git a/src/SMAPI/Framework/PerformanceCounter/EventPerformanceCounterCollection.cs b/src/SMAPI/Framework/PerformanceCounter/EventPerformanceCounterCollection.cs deleted file mode 100644 index 4690c512..00000000 --- a/src/SMAPI/Framework/PerformanceCounter/EventPerformanceCounterCollection.cs +++ /dev/null @@ -1,16 +0,0 @@ -using StardewModdingAPI.Framework.Events; - -namespace StardewModdingAPI.Framework.PerformanceCounter -{ - /// <summary>Represents a performance counter collection specific to game events.</summary> - internal class EventPerformanceCounterCollection: PerformanceCounterCollection - { - /// <summary>Creates a new event performance counter collection.</summary> - /// <param name="manager">The performance counter manager.</param> - /// <param name="event">The ManagedEvent.</param> - /// <param name="isImportant">If the event is flagged as important.</param> - public EventPerformanceCounterCollection(PerformanceCounterManager manager, IManagedEvent @event, bool isImportant) : base(manager, @event.GetName(), isImportant) - { - } - } -} diff --git a/src/SMAPI/Framework/PerformanceCounter/PeakEntry.cs b/src/SMAPI/Framework/PerformanceCounter/PeakEntry.cs index 95dc11f4..abb29541 100644 --- a/src/SMAPI/Framework/PerformanceCounter/PeakEntry.cs +++ b/src/SMAPI/Framework/PerformanceCounter/PeakEntry.cs @@ -1,20 +1,31 @@ using System; -using System.Collections.Generic; namespace StardewModdingAPI.Framework.PerformanceCounter { + /// <summary>A peak invocation time.</summary> internal struct PeakEntry { + /********* + ** Accessors + *********/ /// <summary>The actual execution time in milliseconds.</summary> - public readonly double ExecutionTimeMilliseconds; + public double ExecutionTimeMilliseconds { get; } - /// <summary>The DateTime when the entry occured.</summary> - public DateTime EventTime; + /// <summary>When the entry occurred.</summary> + public DateTime EventTime { get; } - /// <summary>The context list, which records all sources involved in exceeding the threshold.</summary> - public readonly List<AlertContext> Context; + /// <summary>The sources involved in exceeding the threshold.</summary> + public AlertContext[] Context { get; } - public PeakEntry(double executionTimeMilliseconds, DateTime eventTime, List<AlertContext> context) + + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> + /// <param name="executionTimeMilliseconds">The actual execution time in milliseconds.</param> + /// <param name="eventTime">When the entry occurred.</param> + /// <param name="context">The sources involved in exceeding the threshold.</param> + public PeakEntry(double executionTimeMilliseconds, DateTime eventTime, AlertContext[] context) { this.ExecutionTimeMilliseconds = executionTimeMilliseconds; this.EventTime = eventTime; diff --git a/src/SMAPI/Framework/PerformanceCounter/PerformanceCounter.cs b/src/SMAPI/Framework/PerformanceCounter/PerformanceCounter.cs index e9dfcb14..0fb6482d 100644 --- a/src/SMAPI/Framework/PerformanceCounter/PerformanceCounter.cs +++ b/src/SMAPI/Framework/PerformanceCounter/PerformanceCounter.cs @@ -1,23 +1,32 @@ using System; +using System.Collections.Generic; using System.Linq; -using Cyotek.Collections.Generic; +using Harmony; namespace StardewModdingAPI.Framework.PerformanceCounter { + /// <summary>Tracks metadata about a particular code event.</summary> internal class PerformanceCounter { + /********* + ** Fields + *********/ /// <summary>The size of the ring buffer.</summary> - private const int MAX_ENTRIES = 16384; + private readonly int MaxEntries = 16384; /// <summary>The collection to which this performance counter belongs.</summary> private readonly PerformanceCounterCollection ParentCollection; - /// <summary>The circular buffer which stores all performance counter entries</summary> - private readonly CircularBuffer<PerformanceCounterEntry> _counter; + /// <summary>The performance counter entries.</summary> + private readonly Stack<PerformanceCounterEntry> Entries; - /// <summary>The peak execution time</summary> + /// <summary>The entry with the highest execution time.</summary> private PerformanceCounterEntry? PeakPerformanceCounterEntry; + + /********* + ** Accessors + *********/ /// <summary>The name of the source.</summary> public string Source { get; } @@ -27,118 +36,90 @@ namespace StardewModdingAPI.Framework.PerformanceCounter /// <summary>If alerting is enabled or not</summary> public bool EnableAlerts { get; set; } + + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> + /// <param name="parentCollection">The collection to which this performance counter belongs.</param> + /// <param name="source">The name of the source.</param> public PerformanceCounter(PerformanceCounterCollection parentCollection, string source) { this.ParentCollection = parentCollection; this.Source = source; - this._counter = new CircularBuffer<PerformanceCounterEntry>(PerformanceCounter.MAX_ENTRIES); + this.Entries = new Stack<PerformanceCounterEntry>(this.MaxEntries); } - /// <summary>Adds a new performance counter entry to the list. Updates the peak entry and adds an alert if - /// monitoring is enabled and the execution time exceeds the threshold.</summary> + /// <summary>Add a performance counter entry to the list, update monitoring, and raise alerts if needed.</summary> /// <param name="entry">The entry to add.</param> public void Add(PerformanceCounterEntry entry) { - this._counter.Put(entry); - - if (this.EnableAlerts && entry.ElapsedMilliseconds > this.AlertThresholdMilliseconds) - this.ParentCollection.AddAlert(entry.ElapsedMilliseconds, this.AlertThresholdMilliseconds, - new AlertContext(this.Source, entry.ElapsedMilliseconds)); + // add entry + if (this.Entries.Count > this.MaxEntries) + this.Entries.Pop(); + this.Entries.Add(entry); - if (this.PeakPerformanceCounterEntry == null) + // update metrics + if (this.PeakPerformanceCounterEntry == null || entry.ElapsedMilliseconds > this.PeakPerformanceCounterEntry.Value.ElapsedMilliseconds) this.PeakPerformanceCounterEntry = entry; - else - { - if (entry.ElapsedMilliseconds > this.PeakPerformanceCounterEntry.Value.ElapsedMilliseconds) - this.PeakPerformanceCounterEntry = entry; - } + + // raise alert + if (this.EnableAlerts && entry.ElapsedMilliseconds > this.AlertThresholdMilliseconds) + this.ParentCollection.AddAlert(entry.ElapsedMilliseconds, this.AlertThresholdMilliseconds, new AlertContext(this.Source, entry.ElapsedMilliseconds)); } - /// <summary>Clears all performance counter entries and resets the peak entry.</summary> + /// <summary>Clear all performance counter entries and monitoring.</summary> public void Reset() { - this._counter.Clear(); + this.Entries.Clear(); this.PeakPerformanceCounterEntry = null; } - /// <summary>Returns the peak entry.</summary> - /// <returns>The peak entry.</returns> + /// <summary>Get the peak entry.</summary> public PerformanceCounterEntry? GetPeak() { return this.PeakPerformanceCounterEntry; } - /// <summary>Returns the peak entry.</summary> - /// <returns>The peak entry.</returns> - public PerformanceCounterEntry? GetPeak(TimeSpan range, DateTime? relativeTo = null) + /// <summary>Get the entry with the highest execution time.</summary> + /// <param name="range">The time range to search.</param> + /// <param name="endTime">The end time for the <paramref name="range"/>, or null for the current time.</param> + public PerformanceCounterEntry? GetPeak(TimeSpan range, DateTime? endTime = null) { - if (this._counter.IsEmpty) - return null; - - if (relativeTo == null) - relativeTo = DateTime.UtcNow; - - DateTime start = relativeTo.Value.Subtract(range); - - var entries = this._counter.Where(x => (x.EventTime >= start) && (x.EventTime <= relativeTo)).ToList(); - - if (!entries.Any()) - return null; + endTime ??= DateTime.UtcNow; + DateTime startTime = endTime.Value.Subtract(range); - return entries.OrderByDescending(x => x.ElapsedMilliseconds).First(); + return this.Entries + .Where(entry => entry.EventTime >= startTime && entry.EventTime <= endTime) + .OrderByDescending(x => x.ElapsedMilliseconds) + .FirstOrDefault(); } - /// <summary>Resets the peak entry.</summary> - public void ResetPeak() - { - this.PeakPerformanceCounterEntry = null; - } - - /// <summary>Returns the last entry added to the list.</summary> - /// <returns>The last entry</returns> + /// <summary>Get the last entry added to the list.</summary> public PerformanceCounterEntry? GetLastEntry() { - if (this._counter.IsEmpty) + if (this.Entries.Count == 0) return null; - return this._counter.PeekLast(); + return this.Entries.Peek(); } - /// <summary>Returns the average execution time of all entries.</summary> - /// <returns>The average execution time in milliseconds.</returns> - public double GetAverage() + /// <summary>Get the average over a given time span.</summary> + /// <param name="range">The time range to search.</param> + /// <param name="endTime">The end time for the <paramref name="range"/>, or null for the current time.</param> + public double GetAverage(TimeSpan range, DateTime? endTime = null) { - if (this._counter.IsEmpty) - return 0; - - return this._counter.Average(p => p.ElapsedMilliseconds); - } - - /// <summary>Returns the average over a given time span.</summary> - /// <param name="range">The time range to retrieve.</param> - /// <param name="relativeTo">The DateTime from which to start the average. Defaults to DateTime.UtcNow if null</param> - /// <returns>The average execution time in milliseconds.</returns> - /// <remarks> - /// The relativeTo parameter specifies from which point in time the range is subtracted. Example: - /// If DateTime is set to 60 seconds ago, and the range is set to 60 seconds, the method would return - /// the average between all entries between 120s ago and 60s ago. - /// </remarks> - public double GetAverage(TimeSpan range, DateTime? relativeTo = null) - { - if (this._counter.IsEmpty) - return 0; - - if (relativeTo == null) - relativeTo = DateTime.UtcNow; - - DateTime start = relativeTo.Value.Subtract(range); - - var entries = this._counter.Where(x => (x.EventTime >= start) && (x.EventTime <= relativeTo)).ToList(); + endTime ??= DateTime.UtcNow; + DateTime startTime = endTime.Value.Subtract(range); - if (!entries.Any()) - return 0; + double[] entries = this.Entries + .Where(entry => entry.EventTime >= startTime && entry.EventTime <= endTime) + .Select(p => p.ElapsedMilliseconds) + .ToArray(); - return entries.Average(x => x.ElapsedMilliseconds); + return entries.Length > 0 + ? entries.Average() + : 0; } } } diff --git a/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterCollection.cs b/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterCollection.cs index f469eceb..bd13a36e 100644 --- a/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterCollection.cs +++ b/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterCollection.cs @@ -2,153 +2,129 @@ using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; -using Cyotek.Collections.Generic; namespace StardewModdingAPI.Framework.PerformanceCounter { internal class PerformanceCounterCollection { - /// <summary>The size of the ring buffer.</summary> - private const int MAX_ENTRIES = 16384; + /********* + ** Fields + *********/ + /// <summary>The number of peak invocations to keep.</summary> + private readonly int MaxEntries = 16384; - /// <summary>The list of triggered performance counters.</summary> + /// <summary>The sources involved in exceeding alert thresholds.</summary> private readonly List<AlertContext> TriggeredPerformanceCounters = new List<AlertContext>(); /// <summary>The stopwatch used to track the invocation time.</summary> private readonly Stopwatch InvocationStopwatch = new Stopwatch(); /// <summary>The performance counter manager.</summary> - private readonly PerformanceCounterManager PerformanceCounterManager; + private readonly PerformanceMonitor PerformanceMonitor; - /// <summary>Holds the time to calculate the average calls per second.</summary> + /// <summary>The time to calculate average calls per second.</summary> private DateTime CallsPerSecondStart = DateTime.UtcNow; - /// <summary>The number of invocations of this collection.</summary> + /// <summary>The number of invocations.</summary> private long CallCount; - /// <summary>The circular buffer which stores all peak invocations</summary> - private readonly CircularBuffer<PeakEntry> PeakInvocations; + /// <summary>The peak invocations.</summary> + private readonly Stack<PeakEntry> PeakInvocations; + + /********* + ** Accessors + *********/ /// <summary>The associated performance counters.</summary> public IDictionary<string, PerformanceCounter> PerformanceCounters { get; } = new Dictionary<string, PerformanceCounter>(); /// <summary>The name of this collection.</summary> public string Name { get; } - /// <summary>Flag if this collection is important (used for the console summary command).</summary> - public bool IsImportant { get; } + /// <summary>Whether the source is typically invoked at least once per second.</summary> + public bool IsPerformanceCritical { get; } /// <summary>The alert threshold in milliseconds.</summary> public double AlertThresholdMilliseconds { get; set; } - /// <summary>If alerting is enabled or not</summary> + /// <summary>Whether alerts are enabled.</summary> public bool EnableAlerts { get; set; } - public PerformanceCounterCollection(PerformanceCounterManager performanceCounterManager, string name, bool isImportant) + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> + /// <param name="performanceMonitor">The performance counter manager.</param> + /// <param name="name">The name of this collection.</param> + /// <param name="isPerformanceCritical">Whether the source is typically invoked at least once per second.</param> + public PerformanceCounterCollection(PerformanceMonitor performanceMonitor, string name, bool isPerformanceCritical = false) { - this.PeakInvocations = new CircularBuffer<PeakEntry>(PerformanceCounterCollection.MAX_ENTRIES); + this.PeakInvocations = new Stack<PeakEntry>(this.MaxEntries); this.Name = name; - this.PerformanceCounterManager = performanceCounterManager; - this.IsImportant = isImportant; + this.PerformanceMonitor = performanceMonitor; + this.IsPerformanceCritical = isPerformanceCritical; } - public PerformanceCounterCollection(PerformanceCounterManager performanceCounterManager, string name) - { - this.PeakInvocations = new CircularBuffer<PeakEntry>(PerformanceCounterCollection.MAX_ENTRIES); - this.PerformanceCounterManager = performanceCounterManager; - this.Name = name; - } - - /// <summary>Tracks a single invocation for a named source.</summary> + /// <summary>Track a single invocation for a named source.</summary> /// <param name="source">The name of the source.</param> /// <param name="entry">The entry.</param> public void Track(string source, PerformanceCounterEntry entry) { + // add entry if (!this.PerformanceCounters.ContainsKey(source)) this.PerformanceCounters.Add(source, new PerformanceCounter(this, source)); - this.PerformanceCounters[source].Add(entry); + // raise alert if (this.EnableAlerts) this.TriggeredPerformanceCounters.Add(new AlertContext(source, entry.ElapsedMilliseconds)); } - /// <summary>Returns the average execution time for all non-game internal sources.</summary> - /// <returns>The average execution time in milliseconds</returns> - public double GetModsAverageExecutionTime() - { - return this.PerformanceCounters.Where(p => - p.Key != Constants.GamePerformanceCounterName).Sum(p => p.Value.GetAverage()); - } - - /// <summary>Returns the average execution time for all non-game internal sources.</summary> + /// <summary>Get the average execution time for all non-game internal sources in milliseconds.</summary> /// <param name="interval">The interval for which to get the average, relative to now</param> - /// <returns>The average execution time in milliseconds</returns> public double GetModsAverageExecutionTime(TimeSpan interval) { - return this.PerformanceCounters.Where(p => - p.Key != Constants.GamePerformanceCounterName).Sum(p => p.Value.GetAverage(interval)); - } - - /// <summary>Returns the overall average execution time.</summary> - /// <returns>The average execution time in milliseconds</returns> - public double GetAverageExecutionTime() - { - return this.PerformanceCounters.Sum(p => p.Value.GetAverage()); + return this.PerformanceCounters + .Where(entry => entry.Key != Constants.GamePerformanceCounterName) + .Sum(entry => entry.Value.GetAverage(interval)); } - /// <summary>Returns the overall average execution time.</summary> + /// <summary>Get the overall average execution time in milliseconds.</summary> /// <param name="interval">The interval for which to get the average, relative to now</param> - /// <returns>The average execution time in milliseconds</returns> public double GetAverageExecutionTime(TimeSpan interval) { - return this.PerformanceCounters.Sum(p => p.Value.GetAverage(interval)); + return this.PerformanceCounters + .Sum(entry => entry.Value.GetAverage(interval)); } - /// <summary>Returns the average execution time for game-internal sources.</summary> - /// <returns>The average execution time in milliseconds</returns> - public double GetGameAverageExecutionTime() - { - if (this.PerformanceCounters.TryGetValue(Constants.GamePerformanceCounterName, out PerformanceCounter gameExecTime)) - return gameExecTime.GetAverage(); - - return 0; - } - - /// <summary>Returns the average execution time for game-internal sources.</summary> - /// <returns>The average execution time in milliseconds</returns> + /// <summary>Get the average execution time for game-internal sources in milliseconds.</summary> public double GetGameAverageExecutionTime(TimeSpan interval) { - if (this.PerformanceCounters.TryGetValue(Constants.GamePerformanceCounterName, out PerformanceCounter gameExecTime)) - return gameExecTime.GetAverage(interval); - - return 0; + return this.PerformanceCounters.TryGetValue(Constants.GamePerformanceCounterName, out PerformanceCounter gameExecTime) + ? gameExecTime.GetAverage(interval) + : 0; } - /// <summary>Returns the peak execution time</summary> - /// <param name="interval">The interval for which to get the peak, relative to <paramref name="relativeTo"/></param> - /// <param name="relativeTo">The DateTime which the <paramref name="interval"/> is relative to, or DateTime.Now if not given</param> - /// <returns>The peak execution time</returns> - public double GetPeakExecutionTime(TimeSpan range, DateTime? relativeTo = null) + /// <summary>Get the peak execution time in milliseconds.</summary> + /// <param name="range">The time range to search.</param> + /// <param name="endTime">The end time for the <paramref name="range"/>, or null for the current time.</param> + public double GetPeakExecutionTime(TimeSpan range, DateTime? endTime = null) { - if (this.PeakInvocations.IsEmpty) + if (this.PeakInvocations.Count == 0) return 0; - if (relativeTo == null) - relativeTo = DateTime.UtcNow; - - DateTime start = relativeTo.Value.Subtract(range); - - var entries = this.PeakInvocations.Where(x => (x.EventTime >= start) && (x.EventTime <= relativeTo)).ToList(); + endTime ??= DateTime.UtcNow; + DateTime startTime = endTime.Value.Subtract(range); - if (!entries.Any()) - return 0; - - return entries.OrderByDescending(x => x.ExecutionTimeMilliseconds).First().ExecutionTimeMilliseconds; + return this.PeakInvocations + .Where(entry => entry.EventTime >= startTime && entry.EventTime <= endTime) + .OrderByDescending(x => x.ExecutionTimeMilliseconds) + .Select(p => p.ExecutionTimeMilliseconds) + .FirstOrDefault(); } - /// <summary>Begins tracking the invocation of this collection.</summary> + /// <summary>Start tracking the invocation of this collection.</summary> public void BeginTrackInvocation() { this.TriggeredPerformanceCounters.Clear(); @@ -158,60 +134,58 @@ namespace StardewModdingAPI.Framework.PerformanceCounter this.CallCount++; } - /// <summary>Ends tracking the invocation of this collection. Also records an alert if alerting is enabled - /// and the invocation time exceeds the threshold.</summary> + /// <summary>End tracking the invocation of this collection, and raise an alert if needed.</summary> public void EndTrackInvocation() { this.InvocationStopwatch.Stop(); - this.PeakInvocations.Put( - new PeakEntry(this.InvocationStopwatch.Elapsed.TotalMilliseconds, - DateTime.UtcNow, - this.TriggeredPerformanceCounters)); - - if (!this.EnableAlerts) return; + // add invocation + if (this.PeakInvocations.Count >= this.MaxEntries) + this.PeakInvocations.Pop(); + this.PeakInvocations.Push(new PeakEntry(this.InvocationStopwatch.Elapsed.TotalMilliseconds, DateTime.UtcNow, this.TriggeredPerformanceCounters.ToArray())); - if (this.InvocationStopwatch.Elapsed.TotalMilliseconds >= this.AlertThresholdMilliseconds) - this.AddAlert(this.InvocationStopwatch.Elapsed.TotalMilliseconds, - this.AlertThresholdMilliseconds, this.TriggeredPerformanceCounters); + // raise alert + if (this.EnableAlerts && this.InvocationStopwatch.Elapsed.TotalMilliseconds >= this.AlertThresholdMilliseconds) + this.AddAlert(this.InvocationStopwatch.Elapsed.TotalMilliseconds, this.AlertThresholdMilliseconds, this.TriggeredPerformanceCounters.ToArray()); } - /// <summary>Adds an alert.</summary> + /// <summary>Add an alert.</summary> /// <param name="executionTimeMilliseconds">The execution time in milliseconds.</param> /// <param name="thresholdMilliseconds">The configured threshold.</param> - /// <param name="alerts">The list of alert contexts.</param> - public void AddAlert(double executionTimeMilliseconds, double thresholdMilliseconds, List<AlertContext> alerts) + /// <param name="alerts">The sources involved in exceeding the threshold.</param> + public void AddAlert(double executionTimeMilliseconds, double thresholdMilliseconds, AlertContext[] alerts) { - this.PerformanceCounterManager.AddAlert(new AlertEntry(this, executionTimeMilliseconds, - thresholdMilliseconds, alerts)); + this.PerformanceMonitor.AddAlert( + new AlertEntry(this, executionTimeMilliseconds, thresholdMilliseconds, alerts) + ); } - /// <summary>Adds an alert for a single AlertContext</summary> + /// <summary>Add an alert.</summary> /// <param name="executionTimeMilliseconds">The execution time in milliseconds.</param> /// <param name="thresholdMilliseconds">The configured threshold.</param> - /// <param name="alert">The context</param> + /// <param name="alert">The source involved in exceeding the threshold.</param> public void AddAlert(double executionTimeMilliseconds, double thresholdMilliseconds, AlertContext alert) { - this.AddAlert(executionTimeMilliseconds, thresholdMilliseconds, new List<AlertContext>() {alert}); + this.AddAlert(executionTimeMilliseconds, thresholdMilliseconds, new[] { alert }); } - /// <summary>Resets the calls per second counter.</summary> + /// <summary>Reset the calls per second counter.</summary> public void ResetCallsPerSecond() { this.CallCount = 0; this.CallsPerSecondStart = DateTime.UtcNow; } - /// <summary>Resets all performance counters in this collection.</summary> + /// <summary>Reset all performance counters in this collection.</summary> public void Reset() { this.PeakInvocations.Clear(); - foreach (var i in this.PerformanceCounters) - i.Value.Reset(); + foreach (var counter in this.PerformanceCounters) + counter.Value.Reset(); } - /// <summary>Resets the performance counter for a specific source.</summary> - /// <param name="source">The source name</param> + /// <summary>Reset the performance counter for a specific source.</summary> + /// <param name="source">The source name.</param> public void ResetSource(string source) { foreach (var i in this.PerformanceCounters) @@ -219,15 +193,13 @@ namespace StardewModdingAPI.Framework.PerformanceCounter i.Value.Reset(); } - /// <summary>Returns the average calls per second.</summary> - /// <returns>The average calls per second.</returns> + /// <summary>Get the average calls per second.</summary> public long GetAverageCallsPerSecond() { - long runtimeInSeconds = (long) DateTime.UtcNow.Subtract(this.CallsPerSecondStart).TotalSeconds; - - if (runtimeInSeconds == 0) return 0; - - return this.CallCount / runtimeInSeconds; + long runtimeInSeconds = (long)DateTime.UtcNow.Subtract(this.CallsPerSecondStart).TotalSeconds; + return runtimeInSeconds > 0 + ? this.CallCount / runtimeInSeconds + : 0; } } } diff --git a/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterEntry.cs b/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterEntry.cs index a50fce7d..a1d78fc8 100644 --- a/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterEntry.cs +++ b/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterEntry.cs @@ -2,13 +2,29 @@ using System; namespace StardewModdingAPI.Framework.PerformanceCounter { - /// <summary>A single performance counter entry. Records the DateTime of the event and the elapsed millisecond.</summary> + /// <summary>A single performance counter entry.</summary> internal struct PerformanceCounterEntry { - /// <summary>The DateTime when the entry occured.</summary> - public DateTime EventTime; + /********* + ** Accessors + *********/ + /// <summary>When the entry occurred.</summary> + public DateTime EventTime { get; } - /// <summary>The elapsed milliseconds</summary> - public double ElapsedMilliseconds; + /// <summary>The elapsed milliseconds.</summary> + public double ElapsedMilliseconds { get; } + + + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> + /// <param name="eventTime">When the entry occurred.</param> + /// <param name="elapsedMilliseconds">The elapsed milliseconds.</param> + public PerformanceCounterEntry(DateTime eventTime, double elapsedMilliseconds) + { + this.EventTime = eventTime; + this.ElapsedMilliseconds = elapsedMilliseconds; + } } } diff --git a/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterManager.cs b/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterManager.cs index bd964442..81e4e468 100644 --- a/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterManager.cs +++ b/src/SMAPI/Framework/PerformanceCounter/PerformanceCounterManager.cs @@ -7,12 +7,14 @@ using StardewModdingAPI.Framework.Events; namespace StardewModdingAPI.Framework.PerformanceCounter { - internal class PerformanceCounterManager + /// <summary>Tracks performance metrics.</summary> + internal class PerformanceMonitor { - public HashSet<PerformanceCounterCollection> PerformanceCounterCollections = new HashSet<PerformanceCounterCollection>(); - + /********* + ** Fields + *********/ /// <summary>The recorded alerts.</summary> - private readonly List<AlertEntry> Alerts = new List<AlertEntry>(); + private readonly IList<AlertEntry> Alerts = new List<AlertEntry>(); /// <summary>The monitor for output logging.</summary> private readonly IMonitor Monitor; @@ -20,62 +22,64 @@ namespace StardewModdingAPI.Framework.PerformanceCounter /// <summary>The invocation stopwatch.</summary> private readonly Stopwatch InvocationStopwatch = new Stopwatch(); - /// <summary>Specifies if alerts should be paused.</summary> + /// <summary>The underlying performance counter collections.</summary> + private readonly IDictionary<string, PerformanceCounterCollection> Collections = new Dictionary<string, PerformanceCounterCollection>(StringComparer.InvariantCultureIgnoreCase); + + + /********* + ** Accessors + *********/ + /// <summary>Whether alerts are paused.</summary> public bool PauseAlerts { get; set; } - /// <summary>Specifies if performance counter tracking should be enabled.</summary> + /// <summary>Whether performance counter tracking is enabled.</summary> public bool EnableTracking { get; set; } - /// <summary>Constructs a performance counter manager.</summary> + + /********* + ** Public methods + *********/ + /// <summary>Construct an instance.</summary> /// <param name="monitor">The monitor for output logging.</param> - public PerformanceCounterManager(IMonitor monitor) + public PerformanceMonitor(IMonitor monitor) { this.Monitor = monitor; } - /// <summary>Resets all performance counters in all collections.</summary> + /// <summary>Reset all performance counters in all collections.</summary> public void Reset() { - foreach (PerformanceCounterCollection collection in this.PerformanceCounterCollections) - { + foreach (PerformanceCounterCollection collection in this.Collections.Values) collection.Reset(); - } - - foreach (var eventPerformanceCounter in - this.PerformanceCounterCollections.SelectMany(performanceCounter => performanceCounter.PerformanceCounters)) - { - eventPerformanceCounter.Value.Reset(); - } } - /// <summary>Begins tracking the invocation for a collection.</summary> - /// <param name="collectionName">The collection name</param> - public void BeginTrackInvocation(string collectionName) + /// <summary>Track the invocation time for a collection.</summary> + /// <param name="collectionName">The name of the collection.</param> + /// <param name="action">The action to execute and track.</param> + public void Track(string collectionName, Action action) { if (!this.EnableTracking) { + action(); return; } - this.GetOrCreateCollectionByName(collectionName).BeginTrackInvocation(); - } - - /// <summary>Ends tracking the invocation for a collection.</summary> - /// <param name="collectionName"></param> - public void EndTrackInvocation(string collectionName) - { - if (!this.EnableTracking) + PerformanceCounterCollection collection = this.GetOrCreateCollectionByName(collectionName); + collection.BeginTrackInvocation(); + try { - return; + action(); + } + finally + { + collection.EndTrackInvocation(); } - - this.GetOrCreateCollectionByName(collectionName).EndTrackInvocation(); } - /// <summary>Tracks a single performance counter invocation in a specific collection.</summary> + /// <summary>Track a single performance counter invocation in a specific collection.</summary> /// <param name="collectionName">The name of the collection.</param> /// <param name="sourceName">The name of the source.</param> - /// <param name="action">The action to execute and track invocation time for.</param> + /// <param name="action">The action to execute and track.</param> public void Track(string collectionName, string sourceName, Action action) { if (!this.EnableTracking) @@ -84,6 +88,7 @@ namespace StardewModdingAPI.Framework.PerformanceCounter return; } + PerformanceCounterCollection collection = this.GetOrCreateCollectionByName(collectionName); DateTime eventTime = DateTime.UtcNow; this.InvocationStopwatch.Reset(); this.InvocationStopwatch.Start(); @@ -95,79 +100,50 @@ namespace StardewModdingAPI.Framework.PerformanceCounter finally { this.InvocationStopwatch.Stop(); - - this.GetOrCreateCollectionByName(collectionName).Track(sourceName, new PerformanceCounterEntry - { - EventTime = eventTime, - ElapsedMilliseconds = this.InvocationStopwatch.Elapsed.TotalMilliseconds - }); + collection.Track(sourceName, new PerformanceCounterEntry(eventTime, this.InvocationStopwatch.Elapsed.TotalMilliseconds)); } } - /// <summary>Gets a collection by name.</summary> - /// <param name="name">The name of the collection.</param> - /// <returns>The collection or null if none was found.</returns> - private PerformanceCounterCollection GetCollectionByName(string name) - { - return this.PerformanceCounterCollections.FirstOrDefault(collection => collection.Name == name); - } - - /// <summary>Gets a collection by name and creates it if it doesn't exist.</summary> - /// <param name="name">The name of the collection.</param> - /// <returns>The collection.</returns> - private PerformanceCounterCollection GetOrCreateCollectionByName(string name) - { - PerformanceCounterCollection collection = this.GetCollectionByName(name); - - if (collection != null) return collection; - - collection = new PerformanceCounterCollection(this, name); - this.PerformanceCounterCollections.Add(collection); - - return collection; - } - - /// <summary>Resets the performance counters for a specific collection.</summary> + /// <summary>Reset the performance counters for a specific collection.</summary> /// <param name="name">The collection name.</param> public void ResetCollection(string name) { - foreach (PerformanceCounterCollection performanceCounterCollection in - this.PerformanceCounterCollections.Where(performanceCounterCollection => - performanceCounterCollection.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase))) + if (this.Collections.TryGetValue(name, out PerformanceCounterCollection collection)) { - performanceCounterCollection.ResetCallsPerSecond(); - performanceCounterCollection.Reset(); + collection.ResetCallsPerSecond(); + collection.Reset(); } } - /// <summary>Resets performance counters for a specific source.</summary> + /// <summary>Reset performance counters for a specific source.</summary> /// <param name="name">The name of the source.</param> public void ResetSource(string name) { - foreach (PerformanceCounterCollection performanceCounterCollection in this.PerformanceCounterCollections) + foreach (PerformanceCounterCollection performanceCounterCollection in this.Collections.Values) performanceCounterCollection.ResetSource(name); } /// <summary>Print any queued alerts.</summary> public void PrintQueuedAlerts() { - if (this.Alerts.Count == 0) return; + if (this.Alerts.Count == 0) + return; - StringBuilder sb = new StringBuilder(); + StringBuilder report = new StringBuilder(); foreach (AlertEntry alert in this.Alerts) { - sb.AppendLine($"{alert.Collection.Name} took {alert.ExecutionTimeMilliseconds:F2}ms (exceeded threshold of {alert.ThresholdMilliseconds:F2}ms)"); + report.AppendLine($"{alert.Collection.Name} took {alert.ExecutionTimeMilliseconds:F2}ms (exceeded threshold of {alert.ThresholdMilliseconds:F2}ms)"); foreach (AlertContext context in alert.Context.OrderByDescending(p => p.Elapsed)) - sb.AppendLine(context.ToString()); + report.AppendLine(context.ToString()); } this.Alerts.Clear(); - this.Monitor.Log(sb.ToString(), LogLevel.Error); + this.Monitor.Log(report.ToString(), LogLevel.Error); } - /// <summary>Adds an alert to the queue.</summary> + /// <summary>Add an alert to the queue.</summary> /// <param name="entry">The alert to add.</param> public void AddAlert(AlertEntry entry) { @@ -175,68 +151,34 @@ namespace StardewModdingAPI.Framework.PerformanceCounter this.Alerts.Add(entry); } - /// <summary>Initialized the default performance counter collections.</summary> + /// <summary>Initialize the default performance counter collections.</summary> /// <param name="eventManager">The event manager.</param> public void InitializePerformanceCounterCollections(EventManager eventManager) { - this.PerformanceCounterCollections = new HashSet<PerformanceCounterCollection>() + foreach (IManagedEvent @event in eventManager.GetAllEvents()) + this.Collections[@event.EventName] = new PerformanceCounterCollection(this, @event.EventName, @event.IsPerformanceCritical); + } + + /// <summary>Get the underlying performance counters.</summary> + public IEnumerable<PerformanceCounterCollection> GetCollections() + { + return this.Collections.Values; + } + + + /********* + ** Public methods + *********/ + /// <summary>Get a collection by name and creates it if it doesn't exist.</summary> + /// <param name="name">The name of the collection.</param> + private PerformanceCounterCollection GetOrCreateCollectionByName(string name) + { + if (!this.Collections.TryGetValue(name, out PerformanceCounterCollection collection)) { - new EventPerformanceCounterCollection(this, eventManager.MenuChanged, false), - - // Rendering Events - new EventPerformanceCounterCollection(this, eventManager.Rendering, false), - new EventPerformanceCounterCollection(this, eventManager.Rendered, true), - new EventPerformanceCounterCollection(this, eventManager.RenderingWorld, false), - new EventPerformanceCounterCollection(this, eventManager.RenderedWorld, true), - new EventPerformanceCounterCollection(this, eventManager.RenderingActiveMenu, false), - new EventPerformanceCounterCollection(this, eventManager.RenderedActiveMenu, true), - new EventPerformanceCounterCollection(this, eventManager.RenderingHud, false), - new EventPerformanceCounterCollection(this, eventManager.RenderedHud, true), - - new EventPerformanceCounterCollection(this, eventManager.WindowResized, false), - new EventPerformanceCounterCollection(this, eventManager.GameLaunched, false), - new EventPerformanceCounterCollection(this, eventManager.UpdateTicking, true), - new EventPerformanceCounterCollection(this, eventManager.UpdateTicked, true), - new EventPerformanceCounterCollection(this, eventManager.OneSecondUpdateTicking, true), - new EventPerformanceCounterCollection(this, eventManager.OneSecondUpdateTicked, true), - - new EventPerformanceCounterCollection(this, eventManager.SaveCreating, false), - new EventPerformanceCounterCollection(this, eventManager.SaveCreated, false), - new EventPerformanceCounterCollection(this, eventManager.Saving, false), - new EventPerformanceCounterCollection(this, eventManager.Saved, false), - - new EventPerformanceCounterCollection(this, eventManager.DayStarted, false), - new EventPerformanceCounterCollection(this, eventManager.DayEnding, false), - - new EventPerformanceCounterCollection(this, eventManager.TimeChanged, true), - - new EventPerformanceCounterCollection(this, eventManager.ReturnedToTitle, false), - - new EventPerformanceCounterCollection(this, eventManager.ButtonPressed, true), - new EventPerformanceCounterCollection(this, eventManager.ButtonReleased, true), - new EventPerformanceCounterCollection(this, eventManager.CursorMoved, true), - new EventPerformanceCounterCollection(this, eventManager.MouseWheelScrolled, true), - - new EventPerformanceCounterCollection(this, eventManager.PeerContextReceived, false), - new EventPerformanceCounterCollection(this, eventManager.ModMessageReceived, false), - new EventPerformanceCounterCollection(this, eventManager.PeerDisconnected, false), - new EventPerformanceCounterCollection(this, eventManager.InventoryChanged, true), - new EventPerformanceCounterCollection(this, eventManager.LevelChanged, false), - new EventPerformanceCounterCollection(this, eventManager.Warped, false), - - new EventPerformanceCounterCollection(this, eventManager.LocationListChanged, false), - new EventPerformanceCounterCollection(this, eventManager.BuildingListChanged, false), - new EventPerformanceCounterCollection(this, eventManager.LocationListChanged, false), - new EventPerformanceCounterCollection(this, eventManager.DebrisListChanged, true), - new EventPerformanceCounterCollection(this, eventManager.LargeTerrainFeatureListChanged, true), - new EventPerformanceCounterCollection(this, eventManager.NpcListChanged, false), - new EventPerformanceCounterCollection(this, eventManager.ObjectListChanged, true), - new EventPerformanceCounterCollection(this, eventManager.ChestInventoryChanged, true), - new EventPerformanceCounterCollection(this, eventManager.TerrainFeatureListChanged, true), - new EventPerformanceCounterCollection(this, eventManager.LoadStageChanged, false), - new EventPerformanceCounterCollection(this, eventManager.UnvalidatedUpdateTicking, false), - new EventPerformanceCounterCollection(this, eventManager.UnvalidatedUpdateTicked, false), - }; + collection = new PerformanceCounterCollection(this, name); + this.Collections[name] = collection; + } + return collection; } } } diff --git a/src/SMAPI/Framework/SCore.cs b/src/SMAPI/Framework/SCore.cs index af7513e3..ac89587e 100644 --- a/src/SMAPI/Framework/SCore.cs +++ b/src/SMAPI/Framework/SCore.cs @@ -23,6 +23,7 @@ using StardewModdingAPI.Framework.Models; using StardewModdingAPI.Framework.ModHelpers; using StardewModdingAPI.Framework.ModLoading; using StardewModdingAPI.Framework.Patching; +using StardewModdingAPI.Framework.PerformanceCounter; using StardewModdingAPI.Framework.Reflection; using StardewModdingAPI.Framework.Serialization; using StardewModdingAPI.Patches; @@ -33,7 +34,6 @@ using StardewModdingAPI.Toolkit.Serialization; using StardewModdingAPI.Toolkit.Utilities; using StardewValley; using Object = StardewValley.Object; -using PerformanceCounterManager = StardewModdingAPI.Framework.PerformanceCounter.PerformanceCounterManager; using ThreadState = System.Threading.ThreadState; namespace StardewModdingAPI.Framework @@ -135,8 +135,8 @@ namespace StardewModdingAPI.Framework internal static DeprecationManager DeprecationManager { get; private set; } /// <summary>Manages performance counters.</summary> - /// <remarks>This is initialized after the game starts. This is accessed directly because it's not part of the normal class model.</remarks> - internal static PerformanceCounterManager PerformanceCounterManager { get; private set; } + /// <remarks>This is initialized after the game starts. This is non-private for use by Console Commands.</remarks> + internal static PerformanceMonitor PerformanceMonitor { get; private set; } /********* @@ -167,9 +167,9 @@ namespace StardewModdingAPI.Framework }; this.MonitorForGame = this.GetSecondaryMonitor("game"); - SCore.PerformanceCounterManager = new PerformanceCounterManager(this.Monitor); - this.EventManager = new EventManager(this.Monitor, this.ModRegistry, SCore.PerformanceCounterManager); - SCore.PerformanceCounterManager.InitializePerformanceCounterCollections(this.EventManager); + SCore.PerformanceMonitor = new PerformanceMonitor(this.Monitor); + this.EventManager = new EventManager(this.Monitor, this.ModRegistry, SCore.PerformanceMonitor); + SCore.PerformanceMonitor.InitializePerformanceCounterCollections(this.EventManager); SCore.DeprecationManager = new DeprecationManager(this.Monitor, this.ModRegistry); @@ -248,7 +248,7 @@ namespace StardewModdingAPI.Framework jsonHelper: this.Toolkit.JsonHelper, modRegistry: this.ModRegistry, deprecationManager: SCore.DeprecationManager, - performanceCounterManager: SCore.PerformanceCounterManager, + performanceMonitor: SCore.PerformanceMonitor, onGameInitialized: this.InitializeAfterGameStart, onGameExiting: this.Dispose, cancellationToken: this.CancellationToken, @@ -1307,6 +1307,7 @@ namespace StardewModdingAPI.Framework this.ReloadTranslations(this.ModRegistry.GetAll(contentPacks: false)); this.Monitor.Log("Reloaded translation files for all mods. This only affects new translations the mods fetch; if they cached some text, it may not be updated.", LogLevel.Info); break; + default: throw new NotSupportedException($"Unrecognized core SMAPI command '{name}'."); } diff --git a/src/SMAPI/Framework/SGame.cs b/src/SMAPI/Framework/SGame.cs index 266e2e6f..352859ec 100644 --- a/src/SMAPI/Framework/SGame.cs +++ b/src/SMAPI/Framework/SGame.cs @@ -59,7 +59,8 @@ namespace StardewModdingAPI.Framework /// <summary>Manages deprecation warnings.</summary> private readonly DeprecationManager DeprecationManager; - private readonly PerformanceCounterManager PerformanceCounterManager; + /// <summary>Tracks performance metrics.</summary> + private readonly PerformanceMonitor PerformanceMonitor; /// <summary>The maximum number of consecutive attempts SMAPI should make to recover from a draw error.</summary> private readonly Countdown DrawCrashTimer = new Countdown(60); // 60 ticks = roughly one second @@ -155,12 +156,12 @@ namespace StardewModdingAPI.Framework /// <param name="jsonHelper">Encapsulates SMAPI's JSON file parsing.</param> /// <param name="modRegistry">Tracks the installed mods.</param> /// <param name="deprecationManager">Manages deprecation warnings.</param> - /// <param name="performanceCounterManager">Manages performance monitoring.</param> + /// <param name="performanceMonitor">Tracks performance metrics.</param> /// <param name="onGameInitialized">A callback to invoke after the game finishes initializing.</param> /// <param name="onGameExiting">A callback to invoke when the game exits.</param> /// <param name="cancellationToken">Propagates notification that SMAPI should exit.</param> /// <param name="logNetworkTraffic">Whether to log network traffic.</param> - internal SGame(Monitor monitor, IMonitor monitorForGame, Reflector reflection, Translator translator, EventManager eventManager, JsonHelper jsonHelper, ModRegistry modRegistry, DeprecationManager deprecationManager, PerformanceCounterManager performanceCounterManager, Action onGameInitialized, Action onGameExiting, CancellationTokenSource cancellationToken, bool logNetworkTraffic) + internal SGame(Monitor monitor, IMonitor monitorForGame, Reflector reflection, Translator translator, EventManager eventManager, JsonHelper jsonHelper, ModRegistry modRegistry, DeprecationManager deprecationManager, PerformanceMonitor performanceMonitor, Action onGameInitialized, Action onGameExiting, CancellationTokenSource cancellationToken, bool logNetworkTraffic) { this.OnLoadingFirstAsset = SGame.ConstructorHack.OnLoadingFirstAsset; SGame.ConstructorHack = null; @@ -180,7 +181,7 @@ namespace StardewModdingAPI.Framework this.Reflection = reflection; this.Translator = translator; this.DeprecationManager = deprecationManager; - this.PerformanceCounterManager = performanceCounterManager; + this.PerformanceMonitor = performanceMonitor; this.OnGameInitialized = onGameInitialized; this.OnGameExiting = onGameExiting; Game1.input = new SInputState(); @@ -312,7 +313,7 @@ namespace StardewModdingAPI.Framework try { this.DeprecationManager.PrintQueued(); - this.PerformanceCounterManager.PrintQueuedAlerts(); + this.PerformanceMonitor.PrintQueuedAlerts(); /********* ** First-tick initialization diff --git a/src/SMAPI/Program.cs b/src/SMAPI/Program.cs index 933590d3..c26ae29a 100644 --- a/src/SMAPI/Program.cs +++ b/src/SMAPI/Program.cs @@ -11,7 +11,7 @@ using StardewModdingAPI.Framework; using StardewModdingAPI.Toolkit.Utilities; [assembly: InternalsVisibleTo("SMAPI.Tests")] -[assembly: InternalsVisibleTo("ConsoleCommands")] +[assembly: InternalsVisibleTo("ConsoleCommands")] // for performance monitoring commands [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")] // Moq for unit testing namespace StardewModdingAPI { diff --git a/src/SMAPI/SMAPI.csproj b/src/SMAPI/SMAPI.csproj index 0bc290ac..3bb73295 100644 --- a/src/SMAPI/SMAPI.csproj +++ b/src/SMAPI/SMAPI.csproj @@ -15,12 +15,7 @@ <ApplicationIcon>icon.ico</ApplicationIcon> </PropertyGroup> - <PropertyGroup Condition=" '$(Configuration)' == 'Release' "> - <DefineConstants>SMAPI_FOR_WINDOWS</DefineConstants> - </PropertyGroup> - <ItemGroup> - <PackageReference Include="Cyotek.CircularBuffer" Version="1.0.2" /> <PackageReference Include="LargeAddressAware" Version="1.0.3" /> <PackageReference Include="Lib.Harmony" Version="1.2.0.1" /> <PackageReference Include="Mono.Cecil" Version="0.11.1" /> |