First asmdef debug iteration

Author: Bullrich

AsmdefDebug.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using AssemblyDebugger;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEngine;
+
+
+// Based on https://gist.github.com/karljj1/9c6cce803096b5cd4511cf0819ff517b
+[InitializeOnLoad]
+public class AsmdefDebug
+{
+    internal const string CompilationReportEditorPref = "CompilationReportKey";
+    internal const string LogEnabledPref = "AsmdefDebugLogKey";
+
+    private static readonly int ScriptAssembliesPathLen = "Library/ScriptAssemblies/".Length;
+    private static readonly CompilationReport CompilationReport = new CompilationReport();
+    private static readonly Dictionary<string, DateTime> StartTimes = new Dictionary<string, DateTime>();
+    internal static TimeSpan AssemblyReloadTime { get; private set; }
+
+    private static double compilationTotalTime;
+
+#if !IGNORE_ASMDEF_DEBUG
+    static AsmdefDebug()
+    {
+        CompilationPipeline.assemblyCompilationStarted += CompilationPipelineOnAssemblyCompilationStarted;
+        CompilationPipeline.assemblyCompilationFinished += CompilationPipelineOnAssemblyCompilationFinished;
+        AssemblyReloadEvents.beforeAssemblyReload += AssemblyReloadEventsOnBeforeAssemblyReload;
+        AssemblyReloadEvents.afterAssemblyReload += AssemblyReloadEventsOnAfterAssemblyReload;
+    }
+#endif
+
+    private static void CompilationPipelineOnAssemblyCompilationStarted(string assembly)
+    {
+        StartTimes[assembly] = DateTime.UtcNow;
+    }
+
+    private static void CompilationPipelineOnAssemblyCompilationFinished(string assembly, CompilerMessage[] arg2)
+    {
+        var timeSpan = DateTime.UtcNow - StartTimes[assembly];
+        compilationTotalTime += timeSpan.TotalMilliseconds;
+        var assemblyTime = (timeSpan.TotalMilliseconds / 1000);
+        var assemblyName = assembly.Substring(ScriptAssembliesPathLen, assembly.Length - ScriptAssembliesPathLen);
+        CompilationReport.assemblyCompilations.Add(new AssemblyCompilation(assemblyName, assemblyTime));
+    }
+
+    private static void AssemblyReloadEventsOnBeforeAssemblyReload()
+    {
+        var totalCompilationTimeSeconds = compilationTotalTime / 1000f;
+        CompilationReport.compilationTotalTime = totalCompilationTimeSeconds;
+        CompilationReport.reloadEventTimes = DateTime.UtcNow.ToBinary();
+        EditorPrefs.SetString(CompilationReportEditorPref, JsonUtility.ToJson(CompilationReport));
+    }
+
+    private static void AssemblyReloadEventsOnAfterAssemblyReload()
+    {
+        var reportJson = EditorPrefs.GetString(CompilationReportEditorPref);
+        if (string.IsNullOrEmpty(reportJson))
+        {
+            return;
+        }
+
+        var report = JsonUtility.FromJson<CompilationReport>(reportJson);
+
+        var date = DateTime.FromBinary(report.reloadEventTimes);
+        AssemblyReloadTime = DateTime.UtcNow - date;
+
+        if (!EditorPrefs.GetBool(LogEnabledPref, true))
+        {
+            return;
+        } 
+
+        var totalTimeSeconds = report.compilationTotalTime + AssemblyReloadTime.TotalSeconds;
+        if (report.assemblyCompilations != null && report.assemblyCompilations.Any())
+        {
+            var builder = new StringBuilder();
+            builder.AppendLine($"Compilation Report: {totalTimeSeconds:F2} seconds");
+            var orderedCompilations = report.assemblyCompilations.OrderBy(x => x.compilationTime).Reverse();
+            foreach (var assCom in orderedCompilations)
+            {
+                builder.AppendFormat("{0:0.00}s {1}\n", assCom.compilationTime, assCom.assemblyName);
+            }
+
+            builder.AppendFormat("Assembly Reload Time: {0}\n", AssemblyReloadTime.TotalSeconds);
+
+            Debug.Log(builder.ToString());
+        }
+    }
+}

AsmdefDebug.cs.meta

@@ -0,0 +1,85 @@
+using System;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Callbacks;
+using UnityEngine;
+
+namespace AssemblyDebugger
+{
+    public class AsmdefDebugWindow : EditorWindow
+    {
+        private static string reportJson;
+        private static CompilationReport report;
+        private bool logEnabled;
+
+        [MenuItem("Window/Assemblies Debugger")]
+        private static void Init()
+        {
+            var window = (AsmdefDebugWindow) GetWindow(typeof(AsmdefDebugWindow), false, "Assembly Debugger");
+            window.Show();
+        }
+
+#if !IGNORE_ASMDEF_DEBUG
+        [DidReloadScripts]
+#endif
+        private static void OnReload()
+        {
+            reportJson = EditorPrefs.GetString(AsmdefDebug.CompilationReportEditorPref);
+        }
+
+        private static CompilationReport GenerateReport(string json)
+        {
+            if (string.IsNullOrEmpty(json))
+            {
+                return null;
+            }
+
+            return JsonUtility.FromJson<CompilationReport>(json);
+        }
+
+        private void OnEnable()
+        {
+            logEnabled = EditorPrefs.GetBool(AsmdefDebug.LogEnabledPref, true);
+        }
+
+        private void OnGUI()
+        {
+            if (report == null)
+            {
+                report = GenerateReport(reportJson);
+            }
+
+            if (report == null)
+            {
+                EditorGUILayout.HelpBox(
+                    "No compilation report found. Modify a script to trigger a recompilation", MessageType.Warning);
+                return;
+            }
+
+            GUILayout.Label("Post Compilation Report", EditorStyles.boldLabel);
+
+            var date = DateTime.FromBinary(report.reloadEventTimes);
+            var totalTimeSeconds = report.compilationTotalTime + AsmdefDebug.AssemblyReloadTime.TotalSeconds;
+
+            EditorGUILayout.TextField("Compilation Report", $"{totalTimeSeconds:F2} seconds", EditorStyles.boldLabel);
+            var orderedCompilations = report.assemblyCompilations.OrderBy(x => x.compilationTime).Reverse();
+            foreach (var assCom in orderedCompilations)
+            {
+                EditorGUILayout.TextField(assCom.assemblyName, $"{assCom.compilationTime:0.00}s", EditorStyles.label);
+            }
+
+            EditorGUILayout.FloatField("Assembly Reload Time", (float) AsmdefDebug.AssemblyReloadTime.TotalSeconds,
+                EditorStyles.boldLabel);
+
+
+            GUILayout.Label("Print compilation time after reload", EditorStyles.boldLabel);
+            var enableLog = EditorGUILayout.Toggle("Use Debug.Log", logEnabled);
+
+            if (logEnabled != enableLog)
+            {
+                EditorPrefs.SetBool(AsmdefDebug.LogEnabledPref, enableLog);
+                logEnabled = enableLog;
+            }
+        }
+    }
+}

AsmdefDebugWindow.cs

@@ -0,0 +1,14 @@
+{
+    "name": "Assembly.Debugger",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": []
+}

AsmdefDebugWindow.cs.meta

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+
+namespace AssemblyDebugger
+{
+    [Serializable]
+    internal class CompilationReport
+    {
+        public CompilationReport()
+        {
+            assemblyCompilations = new List<AssemblyCompilation>();
+        }
+
+        public double compilationTotalTime;
+        public List<AssemblyCompilation> assemblyCompilations;
+        public long reloadEventTimes;
+    }
+
+    [Serializable]
+    internal class AssemblyCompilation
+    {
+        public AssemblyCompilation(string assemblyName, double compilationTime)
+        {
+            this.assemblyName = assemblyName;
+            this.compilationTime = compilationTime;
+        }
+
+        public double compilationTime;
+        public string assemblyName;
+    }
+}

Assembly.Debugger.asmdef

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Assembly.Debugger.asmdef.meta

@@ -0,0 +1,36 @@
+# Unity Assemblies Debugger
+
+Small utility to show the time it takes to compile each assembly after a reload.
+
+## Usage
+
+Just by installing this in your project it will load itself on every reload.
+
+If you want to see the report, you can open the utility window at `Window > Assemblies Debugger`.
+
+### Logs
+
+By default it will use the console to print the total reloading time.
+
+You can see an example log here:
+
+```
+Compilation Report: 4.14 seconds
+0.62s Unity.TextMeshPro.dll
+0.44s Unity.Analytics.DataPrivacy.dll
+0.44s Unity.PackageManagerUI.Editor.dll
+0.43s Assembly.Debugger.dll
+0.42s Unity.CollabProxy.Editor.dll
+0.30s Unity.TextMeshPro.Editor.dll
+0.24s Assembly-CSharp.dll
+Assembly Reload Time: 1.2500003
+```
+
+#### Disabling the logs
+
+If you wish to disable the logs, you can set this in the checkbox in the utility window.
+
+### Disabling whole plugin
+
+If, for some reason, you want to disable the plugin without removing it, you can add the Scripting Define Symbol 
+`IGNORE_ASMDEF_DEBUG` to your project and it will stop analyzing the reload times.

CompilationReport.cs

@@ -0,0 +1,34 @@
+{
+  "name": "dev.bullrich.asmdef-debug",
+  "version": "1.0.0",
+  "displayName": "Asmdef Debug",
+  "description": "Utility to debug the amount of time each assembly takes to reload",
+  "unity": "2018.4",
+  "unityRelease": "8f1",
+  "keywords": [
+    "asmdef",
+    "debug",
+    "unity"
+  ],
+  "homepage": "https://github.com/Bullrich/Unity-Assembly-Debugger/",
+  "bugs": {
+    "url": "https://github.com/Bullrich/Unity-Assembly-Debugger/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ssh://[email protected]:Bullrich/Unity-Assembly-Debugger.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Javier Bullrich",
+    "email": "[email protected]",
+    "url": "https://bullrich.dev"
+  },
+  "files": [
+    "*.md",
+    "*.meta",
+    "*.asmdef",
+    "*.xml",
+    "*.cs"
+  ]
+}