From a149de885cb17b87503ae1c106416590317534f2 Mon Sep 17 00:00:00 2001
From: Alex Zenla <alex@edera.dev>
Date: Sun, 1 Sep 2024 19:41:22 -0400
Subject: [PATCH 1/3] Parallelize chunk generation using fan-out pattern.

---
 Sources/Voxelotl/World.swift | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/Sources/Voxelotl/World.swift b/Sources/Voxelotl/World.swift
index 33984d9..11d81b4 100644
--- a/Sources/Voxelotl/World.swift
+++ b/Sources/Voxelotl/World.swift
@@ -62,15 +62,31 @@ public class World {
   func generate(width: Int, height: Int, depth: Int, seed: UInt64) {
     self._generator.reset(seed: seed)
     let orig = SIMD3(width, height, depth) / 2
+
+    var localChunks: [SIMD3<Int>: Chunk] = [:]
+    let localChunksLock = NSLock()
+    let queue = OperationQueue()
+    queue.qualityOfService = .userInitiated
     for z in 0..<depth {
       for y in 0..<height {
         for x in 0..<width {
           let chunkID = SIMD3(x, y, z) &- orig
-          self._chunks[chunkID] = self._generator.makeChunk(id: chunkID)
-          self._chunkDamage.insert(chunkID)
+          queue.addOperation {
+            let chunk = self._generator.makeChunk(id: chunkID)
+            localChunksLock.lock()
+            defer {
+              localChunksLock.unlock()
+            }
+            localChunks[chunkID] = chunk
+          }
         }
       }
     }
+    queue.waitUntilAllOperationsAreFinished()
+    for (chunkID, chunk) in localChunks {
+      self._chunks[chunkID] = chunk
+      self._chunkDamage.insert(chunkID)
+    }
   }
 
   func generate(chunkID: ChunkID) {

From 65af0b321dfbd27a41ebec9ea8660a3237ce5fa7 Mon Sep 17 00:00:00 2001
From: Alex Zenla <alex@edera.dev>
Date: Sun, 1 Sep 2024 22:30:47 -0400
Subject: [PATCH 2/3] implement a safe concurrent dictionary

---
 Sources/Voxelotl/CMakeLists.txt               |  4 +
 .../Common/ConcurrentDictionary.swift         | 73 +++++++++++++++++++
 Sources/Voxelotl/World.swift                  |  7 +-
 3 files changed, 78 insertions(+), 6 deletions(-)
 create mode 100644 Sources/Voxelotl/Common/ConcurrentDictionary.swift

diff --git a/Sources/Voxelotl/CMakeLists.txt b/Sources/Voxelotl/CMakeLists.txt
index ec4b1c8..a4cee82 100644
--- a/Sources/Voxelotl/CMakeLists.txt
+++ b/Sources/Voxelotl/CMakeLists.txt
@@ -7,6 +7,9 @@ add_executable(Voxelotl MACOSX_BUNDLE
   shadertypes.h
   shader.metal
 
+  # Common library
+  Common/ConcurrentDictionary.swift
+
   # Maths library
   Math/FloatExtensions.swift
   Math/IntegerExtensions.swift
@@ -98,6 +101,7 @@ set_source_files_properties(test.png PROPERTIES MACOSX_PACKAGE_LOCATION Resource
 
 #TODO: should use TREE mode as documented in https://cmake.org/cmake/help/latest/command/source_group.html
 source_group("Resources" FILES Assets.xcassets test.png)
+source_group("Source Files\\Common" REGULAR_EXPRESSION "Common/")
 source_group("Source Files" REGULAR_EXPRESSION "\\.(swift|metal)$")
 source_group("Source Files\\Random" REGULAR_EXPRESSION "Random/")
 source_group("Source Files\\Math" REGULAR_EXPRESSION "Math/")
diff --git a/Sources/Voxelotl/Common/ConcurrentDictionary.swift b/Sources/Voxelotl/Common/ConcurrentDictionary.swift
new file mode 100644
index 0000000..3a1907e
--- /dev/null
+++ b/Sources/Voxelotl/Common/ConcurrentDictionary.swift
@@ -0,0 +1,73 @@
+import Foundation
+
+public class ConcurrentDictionary<V: Hashable, T>: Collection {
+  private var inner: [V : T]
+  private var lock: NSLock = .init()
+
+  public var keys: Dictionary<V, T>.Keys {
+    self.locked {
+      inner.keys
+    }
+  }
+
+  public var values: Dictionary<V, T>.Values {
+      self.locked {
+        self.inner.values
+      }
+  }
+
+  public var startIndex: Dictionary<V, T>.Index {
+      self.locked {
+          self.inner.startIndex
+      }
+  }
+
+  public var endIndex: Dictionary<V, T>.Index {
+      self.locked {
+          self.inner.endIndex
+      }
+  }
+
+  public init(inner: [V:T]) {
+    self.inner = inner
+  }
+
+  public convenience init() {
+    self.init(inner: [:])
+  }
+
+  public func index(after i: Dictionary<V, T>.Index) -> Dictionary<V, T>.Index {
+    self.locked {
+      self.inner.index(after: i)
+    }
+  }
+
+  public subscript(key: V) -> T? {
+      set(newValue) {
+          self.locked {
+            self.inner[key] = newValue
+          }
+      }
+
+      get {
+        self.locked {
+          self.inner[key]
+        }
+      }
+  }
+
+  public subscript(index: Dictionary<V, T>.Index) -> Dictionary<V, T>.Element {
+      self.locked {
+        self.inner[index]
+      }
+  }
+
+  fileprivate func locked<X>(_ perform: () -> X) -> X {
+    self.lock.lock()
+    defer {
+      self.lock.unlock()
+    }
+    let value = perform()
+    return value
+  }
+}
diff --git a/Sources/Voxelotl/World.swift b/Sources/Voxelotl/World.swift
index 11d81b4..4f95a43 100644
--- a/Sources/Voxelotl/World.swift
+++ b/Sources/Voxelotl/World.swift
@@ -63,8 +63,7 @@ public class World {
     self._generator.reset(seed: seed)
     let orig = SIMD3(width, height, depth) / 2
 
-    var localChunks: [SIMD3<Int>: Chunk] = [:]
-    let localChunksLock = NSLock()
+    let localChunks = ConcurrentDictionary<SIMD3<Int>, Chunk>()
     let queue = OperationQueue()
     queue.qualityOfService = .userInitiated
     for z in 0..<depth {
@@ -73,10 +72,6 @@ public class World {
           let chunkID = SIMD3(x, y, z) &- orig
           queue.addOperation {
             let chunk = self._generator.makeChunk(id: chunkID)
-            localChunksLock.lock()
-            defer {
-              localChunksLock.unlock()
-            }
             localChunks[chunkID] = chunk
           }
         }

From 2e4a7a10df266eaf007c63555b330b862fa0bd60 Mon Sep 17 00:00:00 2001
From: a dinosaur <dino@a-dinosaur.com>
Date: Mon, 2 Sep 2024 18:28:36 +1000
Subject: [PATCH 3/3] use chunkid typealias for clarity in concurrent worldgen

---
 Sources/Voxelotl/World.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/Voxelotl/World.swift b/Sources/Voxelotl/World.swift
index 4f95a43..b1517ff 100644
--- a/Sources/Voxelotl/World.swift
+++ b/Sources/Voxelotl/World.swift
@@ -63,7 +63,7 @@ public class World {
     self._generator.reset(seed: seed)
     let orig = SIMD3(width, height, depth) / 2
 
-    let localChunks = ConcurrentDictionary<SIMD3<Int>, Chunk>()
+    let localChunks = ConcurrentDictionary<ChunkID, Chunk>()
     let queue = OperationQueue()
     queue.qualityOfService = .userInitiated
     for z in 0..<depth {