refactor: Optimized & improved DosExecResult and DosFileOperationResult. (#2181)

* refactor: Optimized & improved DosExecResult and DosFileOperationResult.

- DosExecResult implements IEquatable<T> interface.
- DosExecResult added static cache for storing a subset of common error results.
- DosFileOperationResult implements IEquatable<T> interface.
- DosFileOperationResult added static cache for storing a subset of common error results and NoValue() result.
- DosFileOperationResult class is now sealed (was not possible to inherit before anyways).

* refactor: Optimized DosFileOperationResult.Value16 method.

- Cache the last 16-bit result for repeated results (useful for chained block read results).
- Also fixed potential thread safety issue in DosExecResult.Fail and DosFileOperationResult.Error methods introduced by previous commit.

Author: assumenothing

src/Spice86.Core/Emulator/OperatingSystem/Structures/DosExecResult.cs

@@ -1,12 +1,15 @@
 namespace Spice86.Core.Emulator.OperatingSystem.Structures;
 
 using Spice86.Core.Emulator.OperatingSystem.Enums;
-using Spice86.Shared.Emulator.Errors;
 
 /// <summary>
 /// Result of an INT 21h EXEC operation.
 /// </summary>
-public sealed class DosExecResult {
+public sealed class DosExecResult : IEquatable<DosExecResult?> {
+    // Cache the most common error codes into a fast lookup array.
+    private const int ErrorCacheLength = 20;
+    private static readonly DosExecResult?[] s_errorCache = new DosExecResult[ErrorCacheLength];
+
     private DosExecResult(bool success, DosErrorCode errorCode,
         ushort cs, ushort ip, ushort ss, ushort sp, ushort? ax = null, ushort? dx = null) {
         Success = success;
@@ -34,14 +37,49 @@ private DosExecResult(bool success, DosErrorCode errorCode,
     /// </summary>
     public ushort? DX { get; }
 
-    public static DosExecResult Fail(DosErrorCode code) => new(false, code, 0, 0, 0, 0);
+    public static DosExecResult Fail(DosErrorCode code) {
+        // Use cache for common error codes.
+        if ((int)code is >= 0 and < ErrorCacheLength) {
+            DosExecResult? errorCacheEntry = s_errorCache[(int)code];
+            if (errorCacheEntry is null) {
+                errorCacheEntry = NewErrorResult(code);
+                s_errorCache[(int)code] = errorCacheEntry;
+            }
+            return errorCacheEntry;
+        }
+
+        return NewErrorResult(code);
+
+        static DosExecResult NewErrorResult(DosErrorCode errorCode)
+            => new(success: false, errorCode: errorCode, cs: 0, ip: 0, ss: 0, sp: 0);
+    }
 
     public static DosExecResult SuccessExecute(ushort cs, ushort ip, ushort ss, ushort sp)
-        => new(true, DosErrorCode.NoError, cs, ip, ss, sp);
+        => new(success: true, DosErrorCode.NoError, cs, ip, ss, sp);
 
     public static DosExecResult SuccessLoadOnly(ushort cs, ushort ip, ushort ss, ushort sp)
-        => new(true, DosErrorCode.NoError, cs, ip, ss, sp);
+        => new(success: true, DosErrorCode.NoError, cs, ip, ss, sp);
 
     public static DosExecResult SuccessLoadOverlay()
-        => new(true, DosErrorCode.NoError, 0, 0, 0, 0, ax: 0, dx: 0);
+        => new(success: true, DosErrorCode.NoError, cs: 0, ip: 0, ss: 0, sp: 0, ax: 0, dx: 0);
+
+    public override bool Equals(object? obj) {
+        return Equals(obj as DosExecResult);
+    }
+
+    public bool Equals(DosExecResult? other) {
+        return other is not null &&
+               Success == other.Success &&
+               ErrorCode == other.ErrorCode &&
+               InitialCS == other.InitialCS &&
+               InitialIP == other.InitialIP &&
+               InitialSS == other.InitialSS &&
+               InitialSP == other.InitialSP &&
+               AX == other.AX &&
+               DX == other.DX;
+    }
+
+    public override int GetHashCode() {
+        return HashCode.Combine(Success, ErrorCode, InitialCS, InitialIP, InitialSS, InitialSP, AX, DX);
+    }
 }

src/Spice86.Core/Emulator/OperatingSystem/Structures/DosFileOperationResult.cs

@@ -2,12 +2,24 @@
 
 using Spice86.Core.Emulator.OperatingSystem.Enums;
 
+using System.Diagnostics;
+
 /// <summary>
 /// Represents the result of a DOS file operation, which could be an error or a value.
 /// </summary>
-public class DosFileOperationResult {
-    private readonly bool _error;
+public sealed class DosFileOperationResult : IEquatable<DosFileOperationResult?> {
+    // Cache the most common error codes into a fast lookup array.
+    private const int ErrorCacheLength = 20;
+    private static readonly DosFileOperationResult?[] s_errorCache = new DosFileOperationResult[ErrorCacheLength];
+
+    // Cache the common "no value" result to avoid extra allocations.
+    private static readonly DosFileOperationResult s_noValue = new(error: false, valueIsUint32: false, value: null);
+
+    // Cache the last UInt16 result (no error, reference count zero).
+    private static DosFileOperationResult? s_lastResult16;
+
     private readonly uint? _value;
+    private readonly bool _error;
     private readonly bool _valueIsUint32;
     private readonly byte _refCount;
 
@@ -33,15 +45,28 @@ private DosFileOperationResult(bool error, bool valueIsUint32, uint? value, byte
     /// <param name="errorCode">The error code.</param>
     /// <returns>A new instance of the class indicating an error.</returns>
     public static DosFileOperationResult Error(DosErrorCode errorCode) {
-        return new DosFileOperationResult(true, false, (uint?)errorCode);
+        // Use cache for common error codes.
+        if ((int)errorCode is >= 0 and < ErrorCacheLength) {
+            DosFileOperationResult? errorCacheEntry = s_errorCache[(int)errorCode];
+            if (errorCacheEntry is null) {
+                errorCacheEntry = NewErrorResult(errorCode);
+                s_errorCache[(int)errorCode] = errorCacheEntry;
+            }
+            return errorCacheEntry;
+        }
+
+        return NewErrorResult(errorCode);
+
+        static DosFileOperationResult NewErrorResult(DosErrorCode errorCode)
+            => new(error: true, valueIsUint32: false, value: (uint?)errorCode);
     }
 
     /// <summary>
     /// Returns a new instance of the class indicating no value.
     /// </summary>
     /// <returns>A new instance of the class indicating no value.</returns>
     public static DosFileOperationResult NoValue() {
-        return new DosFileOperationResult(false, false, null);
+        return s_noValue;
     }
 
     /// <summary>
@@ -50,7 +75,17 @@ public static DosFileOperationResult NoValue() {
     /// <param name="value">The 16-bit value.</param>
     /// <returns>A new instance of the class with a 16-bit value.</returns>
     public static DosFileOperationResult Value16(ushort value) {
-        return new DosFileOperationResult(false, false, value);
+        // Use last cached 16-bit result if possible.
+        DosFileOperationResult? lastResult = s_lastResult16;
+        if (lastResult?.Value == value) {
+            Debug.Assert(!lastResult.IsError);
+            Debug.Assert(!lastResult.IsValueIsUint32);
+            return lastResult;
+        }
+
+        lastResult = new DosFileOperationResult(error: false, valueIsUint32: false, value);
+        s_lastResult16 = lastResult;
+        return lastResult;
     }
 
     /// <summary>
@@ -59,7 +94,7 @@ public static DosFileOperationResult Value16(ushort value) {
     /// <param name="value">The 32-bit value.</param>
     /// <returns>A new instance of the class with a 32-bit value.</returns>
     public static DosFileOperationResult Value32(uint value) {
-        return new DosFileOperationResult(false, true, value);
+        return new DosFileOperationResult(error: false, valueIsUint32: true, value);
     }
 
     /// <summary>
@@ -68,7 +103,7 @@ public static DosFileOperationResult Value32(uint value) {
     /// <param name="refCount">The reference count from the System File Table.</param>
     /// <returns>A new instance of the class with a reference count.</returns>
     public static DosFileOperationResult NoValueWithRefCount(byte refCount) {
-        return new DosFileOperationResult(false, false, null, refCount);
+        return new DosFileOperationResult(error: false, valueIsUint32: false, value: null, refCount);
     }
 
     /// <summary>
@@ -90,4 +125,20 @@ public static DosFileOperationResult NoValueWithRefCount(byte refCount) {
     /// The number of handles associated with the file or device after a successful <see cref="DosFileManager.CloseFileOrDevice(ushort)"/> operation. Defaults to 0 for other DOS operations.
     /// </summary>
     public byte RefCount => _refCount;
-}
+
+    public override bool Equals(object? obj) {
+        return Equals(obj as DosFileOperationResult);
+    }
+
+    public bool Equals(DosFileOperationResult? other) {
+        return other is not null &&
+               Value == other.Value &&
+               IsError == other.IsError &&
+               IsValueIsUint32 == other.IsValueIsUint32 &&
+               RefCount == other.RefCount;
+    }
+
+    public override int GetHashCode() {
+        return HashCode.Combine(Value, IsError, IsValueIsUint32, RefCount);
+    }
+}