using System.IO;
|
using UnityEngine;
|
using UnityEditor;
|
using UnityEditor.MemoryProfiler;
|
using Newtonsoft.Json;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System;
|
using System.Reflection;
|
using Newtonsoft.Json.Serialization;
|
|
#if UNITY_5_5_OR_NEWER
|
using Profiler = UnityEngine.Profiling.Profiler;
|
#else
|
using Profiler = UnityEngine.Profiler;
|
#endif
|
|
public static class PackedMemorySnapshotUtility
|
{
|
|
private static string previousDirectory = null;
|
|
public static void SaveToFile(PackedMemorySnapshot snapshot)
|
{
|
var filePath = EditorUtility.SaveFilePanel("Save Snapshot", previousDirectory, "MemorySnapshot", "memsnap3");
|
if(string.IsNullOrEmpty(filePath))
|
return;
|
|
previousDirectory = Path.GetDirectoryName(filePath);
|
SaveToFile(filePath, snapshot);
|
}
|
|
static void SaveToFile(string filePath, PackedMemorySnapshot snapshot)
|
{
|
// Saving snapshots using JsonUtility, instead of BinaryFormatter, is significantly faster.
|
// I cancelled saving a memory snapshot that is saving using BinaryFormatter after 24 hours.
|
// Saving the same memory snapshot using JsonUtility.ToJson took 20 seconds only.
|
|
Debug.LogFormat("Saving...");
|
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
|
Profiler.BeginSample("PackedMemorySnapshotUtility.SaveToFile");
|
stopwatch.Start();
|
|
string fileExtension = Path.GetExtension(filePath);
|
if (string.Equals(fileExtension, ".memsnap", System.StringComparison.OrdinalIgnoreCase)) {
|
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
|
using (Stream stream = File.Open(filePath, FileMode.Create)) {
|
bf.Serialize(stream, snapshot);
|
}
|
} else if (string.Equals(fileExtension, ".memsnap2", System.StringComparison.OrdinalIgnoreCase)) {
|
var json = JsonUtility.ToJson(snapshot);
|
File.WriteAllText(filePath, json);
|
} else { // memsnap3 + default
|
// Stream writing -- will not to exhaust memory (for large snapshots)
|
using (TextWriter writer = File.CreateText(filePath)) {
|
var errors = new List<string>();
|
var serializer = getSerializer(errors);
|
serializer.Serialize(writer, snapshot);
|
logErrors(errors);
|
}
|
}
|
|
stopwatch.Stop();
|
Profiler.EndSample();
|
Debug.LogFormat("Saving took {0}ms", stopwatch.ElapsedMilliseconds);
|
}
|
|
public static PackedMemorySnapshot LoadFromFile()
|
{
|
var filePath = EditorUtility.OpenFilePanelWithFilters("Load Snapshot", previousDirectory, new[] { "Snapshots", "memsnap3,memsnap2,memsnap" });
|
if(string.IsNullOrEmpty(filePath))
|
return null;
|
|
previousDirectory = Path.GetDirectoryName(filePath);
|
Debug.LogFormat("Loading \"{0}\"", filePath);
|
var packedSnapshot = LoadFromFile(filePath);
|
Debug.LogFormat("Completed loading \"{0}\"", filePath);
|
return packedSnapshot;
|
}
|
|
static PackedMemorySnapshot LoadFromFile(string filePath)
|
{
|
Debug.LogFormat("Loading...");
|
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
|
PackedMemorySnapshot result;
|
string fileExtension = Path.GetExtension(filePath);
|
|
if (string.Equals(fileExtension, ".memsnap3", System.StringComparison.OrdinalIgnoreCase)) {
|
Profiler.BeginSample("PackedMemorySnapshotUtility.LoadFromFile(litjson)");
|
stopwatch.Start();
|
|
using (TextReader reader = File.OpenText(filePath)) {
|
var errors = new List<string>();
|
var serializer = getSerializer(errors);
|
result = (PackedMemorySnapshot) serializer.Deserialize(reader, typeof(PackedMemorySnapshot));
|
logErrors(errors);
|
}
|
|
stopwatch.Stop();
|
Profiler.EndSample();
|
}
|
else if(string.Equals(fileExtension, ".memsnap2", System.StringComparison.OrdinalIgnoreCase))
|
{
|
Profiler.BeginSample("PackedMemorySnapshotUtility.LoadFromFile(json)");
|
stopwatch.Start();
|
|
var json = File.ReadAllText(filePath);
|
result = JsonUtility.FromJson<PackedMemorySnapshot>(json);
|
|
stopwatch.Stop();
|
Profiler.EndSample();
|
}
|
else if(string.Equals(fileExtension, ".memsnap", System.StringComparison.OrdinalIgnoreCase))
|
{
|
Profiler.BeginSample("PackedMemorySnapshotUtility.LoadFromFile(binary)");
|
stopwatch.Start();
|
|
var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
|
using(Stream stream = File.Open(filePath, FileMode.Open))
|
{
|
result = binaryFormatter.Deserialize(stream) as PackedMemorySnapshot;
|
}
|
|
stopwatch.Stop();
|
Profiler.EndSample();
|
}
|
else
|
{
|
Debug.LogErrorFormat("MemoryProfiler: Unrecognized memory snapshot format '{0}'.", filePath);
|
result = null;
|
}
|
|
Debug.LogFormat("Loading took {0}ms", stopwatch.ElapsedMilliseconds);
|
return result;
|
}
|
|
private static JsonSerializer getSerializer(List<string> errors) {
|
JsonSerializer serializer = new JsonSerializer();
|
serializer.ContractResolver = new MyContractResolver();
|
serializer.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
|
serializer.MissingMemberHandling = MissingMemberHandling.Error;
|
serializer.Error += (object sender, Newtonsoft.Json.Serialization.ErrorEventArgs args) => {
|
errors.Add(string.Format("'{1}' from '{0}'", sender, args.ErrorContext.Error.Message));
|
};
|
// Enable this to get detailed logging
|
//serializer.TraceWriter = new FilteringTraceLogWriter("typeDescriptions");
|
return serializer;
|
}
|
|
private static void logErrors(List<string> errors) {
|
if (0 < errors.Count) {
|
var last = Mathf.Min(20, errors.Count); // might be very large, just do the first 20
|
var sb = new StringBuilder();
|
for (int i = 0; i < last; i++) {
|
sb.AppendLine(errors[i]);
|
}
|
UnityEngine.Debug.Log(sb.ToString());
|
}
|
}
|
|
private sealed class MyContractResolver : Newtonsoft.Json.Serialization.DefaultContractResolver {
|
|
public MyContractResolver() : base() {
|
IgnoreSerializableAttribute = false; // Use SerializableAttribute to determine what to serialize!
|
}
|
|
}
|
|
private class FilteringTraceLogWriter : Newtonsoft.Json.Serialization.ITraceWriter {
|
|
private readonly string pattern;
|
|
public FilteringTraceLogWriter() : this(null) {
|
}
|
|
public FilteringTraceLogWriter(string pattern) {
|
this.pattern = pattern;
|
}
|
|
public System.Diagnostics.TraceLevel LevelFilter {
|
get { return System.Diagnostics.TraceLevel.Verbose; }
|
}
|
|
private static readonly LogType[] logTypeFromTraceLevel = new LogType[] {
|
LogType.Log, // off -- it's handled elsewhere
|
LogType.Error, // error
|
LogType.Warning, // warning
|
LogType.Log, // info
|
LogType.Log, // verbose
|
};
|
|
public void Trace(System.Diagnostics.TraceLevel level, string message, Exception ex) {
|
if (System.Diagnostics.TraceLevel.Off == level || null != pattern) {
|
if (!message.Contains(pattern)) { // Skip if not pattern
|
return;
|
}
|
}
|
|
UnityEngine.Debug.logger.Log(logTypeFromTraceLevel[(int) level], message);
|
if (null != ex) {
|
UnityEngine.Debug.LogException(ex);
|
}
|
}
|
}
|
|
}
|
