Cache Builder design pattern implemented

Author: AleksaMCode

CacheSimulation/Cache.cs

@@ -57,64 +57,63 @@ public class Cache
         public int SetIndexLength { get; set; } = 0;
         public CacheConfiguration CacheConfig { get; set; }
 
-        public readonly int NumberOfSets;
-        public readonly int SetSize;
+        public int NumberOfSets;
+        public int SetSize;
 
         public string RamFileName { get; set; }
         public string TraceFileName { get; set; }
 
         private List<int> fifoIndexQueue { get; set; }
 
-        private readonly SecureRandom csprng;
+        private SecureRandom csprng;
 
         /// <summary>
         /// Index of the latest cache entry.
         /// </summary>
         private int lifoIndex { get; set; }
 
-        public Cache((string ramFileName, int size, int associativity) cacheInfo, CacheConfiguration config)
+        public Cache(string ramFileName, CacheConfiguration config)
         {
-            if (config.BlockSize >= cacheInfo.size)
+            RamFileName = ramFileName;
+            CacheConfig = config;
+        }
+
+        public void CreateCache()
+        {
+            if (CacheConfig.BlockSize >= Size)
             {
-                throw new Exception($"Size of the cache line ({config.BlockSize} B) can't be larger than the total cache size ({cacheInfo.size} B).");
+                throw new Exception($"Size of the cache line ({CacheConfig.BlockSize} B) can't be larger than the total cache size ({Size} B).");
             }
 
-            RamFileName = cacheInfo.ramFileName;
-
             // Explanation for this check implementation https://stackoverflow.com/questions/2751593/how-to-determine-if-a-decimal-double-is-an-integer .
-            if (!CheckNumberForPowerOfTwo(config.BlockSize))
+            if (!CheckNumberForPowerOfTwo(CacheConfig.BlockSize))
             {
                 throw new Exception("Block size is not a power of 2.");
             }
-            else if (!CheckNumberForPowerOfTwo(cacheInfo.associativity))
+            else if (!CheckNumberForPowerOfTwo(Associativity))
             {
                 throw new Exception("Associativity is not a power of 2.");
             }
 
-            Size = cacheInfo.size;
-
-            // Add cache config information.
-            CacheConfig = config;
-
             NumberOfLines = Size / CacheConfig.BlockSize;
 
-            if (cacheInfo.associativity > NumberOfLines)
+            if (Associativity > NumberOfLines)
             {
-                throw new Exception($"The cache with {NumberOfLines}-lines can't be {cacheInfo.associativity}-way set-associative.");
+                throw new Exception($"The cache with {NumberOfLines}-lines can't be {Associativity}-way set-associative.");
             }
 
-            SetSize = Associativity = cacheInfo.associativity;
+            SetSize = Associativity;
 
             NumberOfSets = Size / (SetSize * CacheConfig.BlockSize);
             BlockOffsetLength = (int)Math.Ceiling(Math.Log(CacheConfig.BlockSize, 2));
             SetIndexLength = (int)Math.Ceiling(Math.Log(Size / (SetSize * CacheConfig.BlockSize), 2));
 
 
-            if (config.ReplacementPolicy == ReplacementPolicy.FirstInFirstOut)
+            if (CacheConfig.ReplacementPolicy == ReplacementPolicy.FirstInFirstOut)
             {
                 fifoIndexQueue = new List<int>();
             }
-            else if (config.ReplacementPolicy == ReplacementPolicy.RandomReplacement)
+            else if (CacheConfig.ReplacementPolicy == ReplacementPolicy.RandomReplacement)
             {
                 csprng = new(new DigestRandomGenerator(new Sha256Digest()));
                 csprng.SetSeed(DateTime.Now.Ticks);
@@ -153,7 +152,7 @@ public Instruction TraceLineParser(string line)
             }
         }
 
-        public void CreateColdCache()
+        private void CreateColdCache()
         {
             CacheEntries = new List<CacheEntry>();
             for (var i = 0; i < NumberOfLines; ++i)

CacheSimulation/CacheBuilder.cs

@@ -0,0 +1,38 @@
+namespace CacheSimulation
+{
+    public class CacheBuilder : ICacheBuilder
+    {
+        private readonly string ramFileName;
+        private readonly CacheConfiguration config;
+        private int size;
+        private int associativity;
+
+        public CacheBuilder(string ramFileName, CacheConfiguration config)
+        {
+            this.ramFileName = ramFileName;
+            this.config = config;
+        }
+
+        public void Size(int size)
+        {
+            this.size = size;
+        }
+
+        public void Associativity(int associativity)
+        {
+            this.associativity = associativity;
+        }
+
+        public Cache Build()
+        {
+            var cache = new Cache(ramFileName, config)
+            {
+                Size = size,
+                Associativity = associativity
+            };
+            cache.CreateCache();
+
+            return cache;
+        }
+    }
+}

CacheSimulation/CacheSimulation.csproj

@@ -46,6 +46,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Cache.cs" />
+    <Compile Include="CacheBuilder.cs" />
     <Compile Include="CacheConfiguration.cs" />
     <Compile Include="CacheConfigurationBuilder.cs" />
     <Compile Include="CacheEntry.cs" />

CacheSimulator/CPU.cs

@@ -7,14 +7,14 @@ public class CPU
     {
         private List<CpuCore> cores { get; set; }
 
-        public CPU((string ramFileName, int size, int associativity) cacheInfo, CacheConfiguration config, int numberOfCores)
+        public CPU(CacheBuilder cacheBuilder, int numberOfCores)
         {
             cores = new List<CpuCore>(numberOfCores);
 
             //CPU cores initialization.
             for (var i = 0; i < numberOfCores; ++i)
             {
-                cores.Add(new CpuCore(cacheInfo, config));
+                cores.Add(new CpuCore(cacheBuilder));
             }
         }
 

CacheSimulator/CpuCore.cs

@@ -9,9 +9,9 @@ public class CpuCore
     {
         private Cache L1d;
 
-        public CpuCore((string ramFileName, int size, int associativity) cacheInfo, CacheConfiguration config)
+        public CpuCore(CacheBuilder cacheBuilder)
         {
-            L1d = new Cache(cacheInfo, config);
+            L1d = cacheBuilder.Build();
         }
 
         public string ExecuteTraceLine(string traceLine, int traceIndex, int coreNumber)

CacheSimulator/MainWindow.xaml.cs

@@ -75,20 +75,17 @@ private async void StartSimulation(object sender, RoutedEventArgs e)
 
             try
             {
-                var size = Int32.Parse(cacheSize.Text);
-
-                var associativity = GetCacheAssociativity(size, GetCacheLineSize());
                 var numberOfCores = GetNumberOfCores();
 
                 if (numberOfCores > 128)
                 {
                     numberOfCores = 128;
                 }
 
-                // Build cache config information.
-                var cacheConfigBuilder = GetCacheConfigBuilder();
+                // Get cache builder.
+                var cacheBuilder = GetCacheBuilder();
 
-                cpu = new CPU((ramFileFullPath, size, associativity), cacheConfigBuilder.Build(), numberOfCores);
+                cpu = new CPU(cacheBuilder, numberOfCores);
 
                 logLines.Append($"Simulation {numberOfSimulation++}\n");
 
@@ -220,6 +217,20 @@ private CacheConfigurationBuilder GetCacheConfigBuilder()
             return cacheConfigBuilder;
         }
 
+        private CacheBuilder GetCacheBuilder()
+        {
+            var cacheConfigBuilder = GetCacheConfigBuilder();
+            var cacheBuilder = new CacheBuilder(ramFileFullPath, cacheConfigBuilder.Build());
+
+            var size = Int32.Parse(cacheSize.Text);
+            var associativity = GetCacheAssociativity(size, GetCacheLineSize());
+
+            cacheBuilder.Size(size);
+            cacheBuilder.Associativity(associativity);
+
+            return cacheBuilder;
+        }
+
         private void StopSimulation(object sender, RoutedEventArgs e)
         {
             if (!isRunning || isCancelRequested)