From aa64f94f5e4dd6bc8c530cf66da0075fa3d85e5e Mon Sep 17 00:00:00 2001
From: Antonis Geralis <b3lievem@yandex.com>
Date: Sun, 24 Sep 2023 12:12:59 +0300
Subject: [PATCH 1/3] New synchronization primitives

---
 tests/tbarrier.nim      |  28 ++++++++++
 tests/tonce.nim         |  12 +++++
 tests/tonce2.nim        |  35 ++++++++++++
 tests/trwlock.nim       |  29 ++++++++++
 tests/trwlock1.nim      |  31 +++++++++++
 tests/tsemaphore.nim    |  40 ++++++++++++++
 tests/tsemaphore1.nim   |  28 ++++++++++
 threading/barrier.nim   |  88 ++++++++++++++++++++++++++++++
 threading/once.nim      |  76 ++++++++++++++++++++++++++
 threading/rwlock.nim    | 115 ++++++++++++++++++++++++++++++++++++++++
 threading/semaphore.nim |  84 +++++++++++++++++++++++++++++
 11 files changed, 566 insertions(+)
 create mode 100644 tests/tbarrier.nim
 create mode 100644 tests/tonce.nim
 create mode 100644 tests/tonce2.nim
 create mode 100644 tests/trwlock.nim
 create mode 100644 tests/trwlock1.nim
 create mode 100644 tests/tsemaphore.nim
 create mode 100644 tests/tsemaphore1.nim
 create mode 100644 threading/barrier.nim
 create mode 100644 threading/once.nim
 create mode 100644 threading/rwlock.nim
 create mode 100644 threading/semaphore.nim

diff --git a/tests/tbarrier.nim b/tests/tbarrier.nim
new file mode 100644
index 0000000..d70b03c
--- /dev/null
+++ b/tests/tbarrier.nim
@@ -0,0 +1,28 @@
+import threading/barrier, std/[os, strformat]
+
+const
+  numThreads = 10
+  numIters = 100
+
+var
+  barrier: Barrier
+  phases: array[numThreads, int]
+  threads: array[numThreads, Thread[int]]
+
+proc routine(id: int) =
+  for i in 0 ..< numIters:
+    phases[id] = i
+    if (id + i) mod numThreads == 0:
+      sleep 1
+    wait barrier
+    for j in 0 ..< numThreads:
+      assert phases[j] == i, &"{id} in phase {i} sees {j} in phase {phases[j]}"
+    wait barrier
+
+proc testBarrier =
+  init barrier, numThreads
+  for i in 0 ..< numThreads:
+    createThread(threads[i], routine, i)
+  joinThreads(threads)
+
+testBarrier()
diff --git a/tests/tonce.nim b/tests/tonce.nim
new file mode 100644
index 0000000..321a443
--- /dev/null
+++ b/tests/tonce.nim
@@ -0,0 +1,12 @@
+import threading/once
+
+var o: Once
+proc smokeOnce() =
+  init o
+  var a = 0
+  o.once(a += 1)
+  assert a == 1
+  o.once(a += 1)
+  assert a == 1
+
+smokeOnce()
diff --git a/tests/tonce2.nim b/tests/tonce2.nim
new file mode 100644
index 0000000..181d677
--- /dev/null
+++ b/tests/tonce2.nim
@@ -0,0 +1,35 @@
+import threading/once
+
+const
+  numThreads = 10
+  maxIters = 1000
+
+type
+  Singleton = object
+    data: int
+
+var
+  threads: array[numThreads, Thread[void]]
+  counter = 1
+  instance: ptr Singleton
+  o: Once
+
+proc getInstance(): ptr Singleton =
+  once(o):
+    instance = createSharedU(Singleton)
+    instance.data = counter
+    inc counter
+  result = instance
+
+proc routine {.thread.} =
+  for i in 1 .. maxIters:
+    assert getInstance().data == 1
+
+proc main =
+  init o
+  for i in 0 ..< numThreads:
+    createThread(threads[i], routine)
+  joinThreads(threads)
+  deallocShared(instance)
+
+main()
diff --git a/tests/trwlock.nim b/tests/trwlock.nim
new file mode 100644
index 0000000..37bc3ec
--- /dev/null
+++ b/tests/trwlock.nim
@@ -0,0 +1,29 @@
+import threading/rwlock, std/os
+
+const
+  numThreads = 10
+  numIters = 100
+
+var
+  rw: RwLock
+  data = 0
+  threads: array[numThreads, Thread[void]]
+
+proc routine =
+  for i in 0..<numIters:
+    writeWith rw:
+      let tmp = data
+      data = -1
+      sleep 1
+      data = tmp + 1
+
+proc frob =
+  init rw
+  for i in 0..<numThreads:
+    createThread(threads[i], routine)
+  for i in 0..<numIters:
+    readWith(rw, assert data >= 0)
+  joinThreads(threads)
+  assert data == numIters * numThreads
+
+frob()
diff --git a/tests/trwlock1.nim b/tests/trwlock1.nim
new file mode 100644
index 0000000..8bf7e26
--- /dev/null
+++ b/tests/trwlock1.nim
@@ -0,0 +1,31 @@
+import threading/rwlock, std/[random, os]
+
+const
+  numThreads = 10
+  numIters = 100
+
+var
+  rw: RwLock
+  data = 0
+  threads: array[numThreads, Thread[void]]
+
+proc routine =
+  var r = initRand(getThreadId())
+  for i in 0..<numIters:
+    if r.rand(1.0) <= 1 / numThreads:
+      writeWith rw:
+        let tmp = data
+        data = -1
+        sleep 1
+        data = tmp + 1
+    else:
+      readWith rw:
+        assert data >= 0
+
+proc frob =
+  init rw
+  for i in 0..<numThreads:
+    createThread(threads[i], routine)
+  joinThreads(threads)
+
+frob()
diff --git a/tests/tsemaphore.nim b/tests/tsemaphore.nim
new file mode 100644
index 0000000..0a29416
--- /dev/null
+++ b/tests/tsemaphore.nim
@@ -0,0 +1,40 @@
+import threading/semaphore, std/strformat
+
+const
+  bufSize = 16
+  numIters = 1000
+
+var
+  thr1, thr2: Thread[void]
+  buf: array[bufSize, int]
+  head, tail = 0
+  chars, spaces: Semaphore
+
+template next(current: untyped): untyped = (current + 1) and bufSize - 1
+
+proc producer =
+  for i in 0 ..< numIters:
+    wait spaces
+    assert buf[head] <= i, &"Constraint: recv_{buf[tail]} < send_{i}+{bufSize}"
+    buf[head] = i
+    head = next(head)
+    signal chars
+
+proc consumer =
+  for i in 0 ..< numIters:
+    wait chars
+    assert buf[tail] == i, &"Constraint: send_{buf[tail]} < recv_{i}"
+    buf[tail] = i + bufSize
+    tail = next(tail)
+    signal spaces
+
+proc testSemaphore =
+  init chars
+  init spaces, bufSize
+
+  createThread(thr1, producer)
+  createThread(thr2, consumer)
+  joinThread(thr1)
+  joinThread(thr2)
+
+testSemaphore()
diff --git a/tests/tsemaphore1.nim b/tests/tsemaphore1.nim
new file mode 100644
index 0000000..f9e4f94
--- /dev/null
+++ b/tests/tsemaphore1.nim
@@ -0,0 +1,28 @@
+import threading/semaphore
+
+var
+  semS, semT: Semaphore
+  aArrived, cArrived = false
+  thread: Thread[void]
+
+proc routine =
+  # Section C
+  cArrived = true
+  signal semT
+  wait semS
+  # Section D
+  assert aArrived, "Constraint: Section A precedes D"
+
+proc testRendezvous =
+  init semS
+  init semT
+  createThread(thread, routine)
+  # Section A
+  aArrived = true
+  signal semS
+  wait semT
+  # Section B
+  assert cArrived, "Constraint: Section C precedes B"
+  joinThread thread
+
+testRendezvous()
diff --git a/threading/barrier.nim b/threading/barrier.nim
new file mode 100644
index 0000000..c53b928
--- /dev/null
+++ b/threading/barrier.nim
@@ -0,0 +1,88 @@
+#
+#
+#            Nim's Runtime Library
+#        (c) Copyright 2023 Nim contributors
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+
+## Barrier for Nim.
+
+runnableExamples:
+
+  import std / os
+
+  var phases: array[10, int]
+  var b = createBarrier(10)
+
+  proc worker(id: int) =
+    for i in 0 ..< 100:
+      phases[id] = i
+      if (id + i) mod 10 == 0:
+        sleep 1
+      wait b
+      for j in 0 ..< 10:
+        assert phases[j] == i
+      wait b
+
+  var threads: array[10, Thread[int]]
+  for i in 0..<10:
+    createThread(threads[i], worker, i)
+
+  joinThreads(threads)
+
+
+import std / locks
+
+type
+  Barrier* = object
+    ## A barrier is a synchronization mechanism that allows a set of threads to
+    ## all wait for each other to reach a common point. Barriers are useful in
+    ## programs involving a fixed-size party of cooperating threads that must
+    ## occasionally wait for each other. The barrier is called a cyclic barrier
+    ## if it can be reused after the waiting threads are released.
+    ##
+    ## The barrier is initialized for a given number of threads. Each thread
+    ## that calls `wait` on the barrier will block until all the threads have
+    ## made that call. At this point, the barrier is reset to its initial state
+    ## and all threads are released.
+    c: Cond
+    L: Lock
+    required: int # number of threads needed for the barrier to continue
+    left: int # current barrier count, number of threads still needed.
+    cycle: uint # generation count
+
+when defined(nimAllowNonVarDestructor):
+  proc `=destroy`*(b: Barrier) {.inline.} =
+    let x = addr(b)
+    deinitCond(x.c)
+    deinitLock(x.L)
+else:
+  proc `=destroy`*(b: var Barrier) {.inline.} =
+    deinitCond(b.c)
+    deinitLock(b.L)
+
+proc `=sink`*(dest: var Barrier; src: Barrier) {.error.}
+proc `=copy`*(dest: var Barrier; src: Barrier) {.error.}
+
+proc createBarrier*(parties: Natural): Barrier =
+  result = default(Barrier)
+  result.required = parties
+  result.left = parties
+  initCond(result.c)
+  initLock(result.L)
+
+proc wait*(b: var Barrier) =
+  ## Wait for all threads to reach the barrier. When the last thread reaches
+  ## the barrier, all threads are released.
+  acquire(b.L)
+  dec b.left
+  if b.left == 0:
+    inc b.cycle
+    b.left = b.required
+    broadcast(b.c)
+  else:
+    let cycle = b.cycle
+    while cycle == b.cycle:
+      wait(b.c, b.L)
+  release(b.L)
diff --git a/threading/once.nim b/threading/once.nim
new file mode 100644
index 0000000..6543edb
--- /dev/null
+++ b/threading/once.nim
@@ -0,0 +1,76 @@
+#
+#
+#            Nim's Runtime Library
+#        (c) Copyright 2023 Nim contributors
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+
+## Once for Nim.
+
+runnableExamples:
+
+  type
+    Singleton = object
+      data: int
+
+  var
+    counter = 1
+    instance: ptr Singleton
+    o = createOnce()
+
+  proc getInstance(): ptr Singleton =
+    once(o):
+      instance = createSharedU(Singleton)
+      instance.data = counter
+      inc counter
+    result = instance
+
+  proc worker {.thread.} =
+    for i in 1..1000:
+      assert getInstance().data == 1
+
+  var threads: array[10, Thread[void]]
+  for i in 0..<10:
+    createThread(threads[i], worker)
+  joinThreads(threads)
+  deallocShared(instance)
+
+
+import std / [locks, atomics]
+
+type
+  Once* = object
+    ## Once is a type that allows you to execute a block of code exactly once.
+    ## The first call to `once` will execute the block of code and all other
+    ## calls will be ignored.
+    L: Lock
+    finished: Atomic[bool]
+
+when defined(nimAllowNonVarDestructor):
+  proc `=destroy`*(o: Once) {.inline.} =
+    let x = addr(o)
+    deinitLock(x.L)
+else:
+  proc `=destroy`*(o: var Once) {.inline.} =
+    deinitLock(o.L)
+
+proc `=sink`*(dest: var Once; source: Once) {.error.}
+proc `=copy`*(dest: var Once; source: Once) {.error.}
+
+proc createOnce*(): Once =
+  result = default(Once)
+  initLock(result.L)
+
+template once*(o: Once, body: untyped) =
+  ## Executes `body` exactly once.
+  if not o.finished.load(moAcquire):
+    acquire(o.L)
+    try:
+      if not o.finished.load(moRelaxed):
+        try:
+          body
+        finally:
+          o.finished.store(true, moRelease)
+    finally:
+      release(o.L)
diff --git a/threading/rwlock.nim b/threading/rwlock.nim
new file mode 100644
index 0000000..561d35a
--- /dev/null
+++ b/threading/rwlock.nim
@@ -0,0 +1,115 @@
+#
+#
+#            Nim's Runtime Library
+#        (c) Copyright 2023 Nim contributors
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+
+## Readers-writer lock for Nim.
+
+runnableExamples:
+
+  import std / os
+
+  var rw = createRwLock()
+  var data = 0
+
+  proc worker =
+    for i in 0..<100:
+      writeWith rw:
+        let tmp = data
+        data = -1
+        sleep 1
+        data = tmp + 1
+
+  var threads: array[10, Thread[void]]
+  for i in 0..<10:
+    createThread(threads[i], worker)
+  for i in 0..<100:
+    readWith(rw, assert data >= 0)
+  joinThreads(threads)
+  assert data == 1000
+
+
+import std / locks
+
+type
+  RwLock* = object
+    ## Readers-writer lock. Multiple readers can acquire the lock at the same
+    ## time, but only one writer can acquire the lock at a time.
+    readPhase: Cond
+    writePhase: Cond
+    L: Lock
+    counter: int # can be in three states: free = 0, reading > 0, writing = -1
+
+when defined(nimAllowNonVarDestructor):
+  proc `=destroy`*(rw: RwLock) {.inline.} =
+    let x = addr(rw)
+    deinitCond(x.readPhase)
+    deinitCond(x.writePhase)
+    deinitLock(x.L)
+else:
+  proc `=destroy`*(rw: var RwLock) {.inline.} =
+    deinitCond(rw.readPhase)
+    deinitCond(rw.writePhase)
+    deinitLock(rw.L)
+
+proc `=sink`*(dest: var RwLock; source: RwLock) {.error.}
+proc `=copy`*(dest: var RwLock; source: RwLock) {.error.}
+
+proc createRwLock*(): RwLock =
+  result = default(RwLock)
+  initCond(result.readPhase)
+  initCond(result.writePhase)
+  initLock(result.L)
+
+proc beginRead*(rw: var RwLock) =
+  ## Acquire a read lock.
+  acquire(rw.L)
+  while rw.counter == -1:
+    wait(rw.readPhase, rw.L)
+  inc rw.counter
+  release(rw.L)
+
+proc beginWrite*(rw: var RwLock) =
+  ## Acquire a write lock.
+  acquire(rw.L)
+  while rw.counter != 0:
+    wait(rw.writePhase, rw.L)
+  rw.counter = -1
+  release(rw.L)
+
+proc endRead*(rw: var RwLock) {.inline.} =
+  ## Release a read lock.
+  acquire(rw.L)
+  dec rw.counter
+  if rw.counter == 0:
+    rw.writePhase.signal()
+  release(rw.L)
+
+proc endWrite*(rw: var RwLock) {.inline.} =
+  ## Release a write lock.
+  acquire(rw.L)
+  rw.counter = 0
+  rw.readPhase.broadcast()
+  rw.writePhase.signal()
+  release(rw.L)
+
+template readWith*(a: RwLock, body: untyped) =
+  ## Acquire a read lock and execute `body`. Release the lock afterwards.
+  beginRead(a)
+  {.locks: [a].}:
+    try:
+      body
+    finally:
+      endRead(a)
+
+template writeWith*(a: RwLock, body: untyped) =
+  ## Acquire a write lock and execute `body`. Release the lock afterwards.
+  beginWrite(a)
+  {.locks: [a].}:
+    try:
+      body
+    finally:
+      endWrite(a)
diff --git a/threading/semaphore.nim b/threading/semaphore.nim
new file mode 100644
index 0000000..b47191c
--- /dev/null
+++ b/threading/semaphore.nim
@@ -0,0 +1,84 @@
+#
+#
+#            Nim's Runtime Library
+#        (c) Copyright 2023 Nim contributors
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+
+## Semaphore for Nim.
+
+runnableExamples:
+
+  import std / os
+
+  var arrived = createSemaphore(2)
+
+  proc worker(i: int) =
+    echo i, " starts"
+    wait arrived
+    sleep 1
+    echo i, " progresses"
+    signal arrived
+
+  var threads: array[4, Thread[int]]
+  for i in 0..<4:
+    createThread(threads[i], worker, i)
+  joinThreads(threads)
+
+
+import std/locks
+
+type
+  Semaphore* = object
+    ## A semaphore is a synchronization primitive that controls access to a
+    ## shared resource through the use of a counter. If the counter is greater
+    ## than zero, then access is allowed. If it is zero, then access is denied.
+    ## What the access is depends on the use of the semaphore.
+    ##
+    ## Semaphores are typically used to limit the number of threads than can
+    ## access some (physical or logical) resource.
+    ##
+    ## Semaphores are of two types: counting semaphores and binary semaphores.
+    ## Counting semaphores can take non-negative integer values to indicate the
+    ## number of units of a particular resource that are available. Binary
+    ## semaphores can only take the values 0 and 1 and are used to implement
+    ## locks.
+    c: Cond
+    L: Lock
+    counter: int
+
+when defined(nimAllowNonVarDestructor):
+  proc `=destroy`*(s: Semaphore) {.inline.} =
+    let x = addr(s)
+    deinitCond(x.c)
+    deinitLock(x.L)
+else:
+  proc `=destroy`*(s: var Semaphore) {.inline.} =
+    deinitCond(s.c)
+    deinitLock(s.L)
+
+proc `=sink`*(dest: var Semaphore; src: Semaphore) {.error.}
+proc `=copy`*(dest: var Semaphore; src: Semaphore) {.error.}
+
+proc createSemaphore*(count: Natural = 0): Semaphore =
+  result = default(Semaphore)
+  result.counter = count
+  initCond(result.c)
+  initLock(result.L)
+
+proc wait*(s: var Semaphore) =
+  ## Wait for the semaphore to be signaled. If the semaphore's counter is zero,
+  ## wait blocks until it becomes greater than zero.
+  acquire(s.L)
+  while s.counter <= 0:
+    wait(s.c, s.L)
+  dec s.counter
+  release(s.L)
+
+proc signal*(s: var Semaphore) {.inline.} =
+  ## Signal the semaphore.
+  acquire(s.L)
+  inc s.counter
+  signal(s.c)
+  release(s.L)

From a909a467645ff995ead4bce72c754edc264ac910 Mon Sep 17 00:00:00 2001
From: Antonis Geralis <b3lievem@yandex.com>
Date: Sun, 24 Sep 2023 12:35:31 +0300
Subject: [PATCH 2/3] fix tests

---
 tests/tbarrier.nim    | 23 +++++++++++------------
 tests/tonce.nim       |  3 +--
 tests/tonce2.nim      | 13 ++++++-------
 tests/trwlock.nim     | 17 ++++++++---------
 tests/trwlock1.nim    | 15 +++++++--------
 tests/tsemaphore.nim  | 22 ++++++++++------------
 tests/tsemaphore1.nim |  4 +---
 7 files changed, 44 insertions(+), 53 deletions(-)

diff --git a/tests/tbarrier.nim b/tests/tbarrier.nim
index d70b03c..34c373f 100644
--- a/tests/tbarrier.nim
+++ b/tests/tbarrier.nim
@@ -1,27 +1,26 @@
 import threading/barrier, std/[os, strformat]
 
 const
-  numThreads = 10
-  numIters = 100
+  NumThreads = 10
+  NumIters = 100
 
 var
-  barrier: Barrier
-  phases: array[numThreads, int]
-  threads: array[numThreads, Thread[int]]
+  b = createBarrier(NumThreads)
+  phases: array[NumThreads, int]
+  threads: array[NumThreads, Thread[int]]
 
 proc routine(id: int) =
-  for i in 0 ..< numIters:
+  for i in 0..<NumIters:
     phases[id] = i
-    if (id + i) mod numThreads == 0:
+    if (id + i) mod NumThreads == 0:
       sleep 1
-    wait barrier
-    for j in 0 ..< numThreads:
+    wait b
+    for j in 0..<NumThreads:
       assert phases[j] == i, &"{id} in phase {i} sees {j} in phase {phases[j]}"
-    wait barrier
+    wait b
 
 proc testBarrier =
-  init barrier, numThreads
-  for i in 0 ..< numThreads:
+  for i in 0..<NumThreads:
     createThread(threads[i], routine, i)
   joinThreads(threads)
 
diff --git a/tests/tonce.nim b/tests/tonce.nim
index 321a443..8a01e1f 100644
--- a/tests/tonce.nim
+++ b/tests/tonce.nim
@@ -1,8 +1,7 @@
 import threading/once
 
-var o: Once
+var o = createOnce()
 proc smokeOnce() =
-  init o
   var a = 0
   o.once(a += 1)
   assert a == 1
diff --git a/tests/tonce2.nim b/tests/tonce2.nim
index 181d677..f8fb156 100644
--- a/tests/tonce2.nim
+++ b/tests/tonce2.nim
@@ -1,18 +1,18 @@
 import threading/once
 
 const
-  numThreads = 10
-  maxIters = 1000
+  NumThreads = 10
+  NumIters = 1000
 
 type
   Singleton = object
     data: int
 
 var
-  threads: array[numThreads, Thread[void]]
+  threads: array[NumThreads, Thread[void]]
   counter = 1
   instance: ptr Singleton
-  o: Once
+  o = createOnce()
 
 proc getInstance(): ptr Singleton =
   once(o):
@@ -22,12 +22,11 @@ proc getInstance(): ptr Singleton =
   result = instance
 
 proc routine {.thread.} =
-  for i in 1 .. maxIters:
+  for i in 1..NumIters:
     assert getInstance().data == 1
 
 proc main =
-  init o
-  for i in 0 ..< numThreads:
+  for i in 0..<NumThreads:
     createThread(threads[i], routine)
   joinThreads(threads)
   deallocShared(instance)
diff --git a/tests/trwlock.nim b/tests/trwlock.nim
index 37bc3ec..dce4dad 100644
--- a/tests/trwlock.nim
+++ b/tests/trwlock.nim
@@ -1,16 +1,16 @@
 import threading/rwlock, std/os
 
 const
-  numThreads = 10
-  numIters = 100
+  NumThreads = 10
+  NumIters = 100
 
 var
-  rw: RwLock
+  rw = createRwLock()
   data = 0
-  threads: array[numThreads, Thread[void]]
+  threads: array[NumThreads, Thread[void]]
 
 proc routine =
-  for i in 0..<numIters:
+  for i in 0..<NumIters:
     writeWith rw:
       let tmp = data
       data = -1
@@ -18,12 +18,11 @@ proc routine =
       data = tmp + 1
 
 proc frob =
-  init rw
-  for i in 0..<numThreads:
+  for i in 0..<NumThreads:
     createThread(threads[i], routine)
-  for i in 0..<numIters:
+  for i in 0..<NumIters:
     readWith(rw, assert data >= 0)
   joinThreads(threads)
-  assert data == numIters * numThreads
+  assert data == NumIters * NumThreads
 
 frob()
diff --git a/tests/trwlock1.nim b/tests/trwlock1.nim
index 8bf7e26..6e826a2 100644
--- a/tests/trwlock1.nim
+++ b/tests/trwlock1.nim
@@ -1,18 +1,18 @@
 import threading/rwlock, std/[random, os]
 
 const
-  numThreads = 10
-  numIters = 100
+  NumThreads = 10
+  NumIters = 100
 
 var
-  rw: RwLock
+  rw = createRwLock()
   data = 0
-  threads: array[numThreads, Thread[void]]
+  threads: array[NumThreads, Thread[void]]
 
 proc routine =
   var r = initRand(getThreadId())
-  for i in 0..<numIters:
-    if r.rand(1.0) <= 1 / numThreads:
+  for i in 0..<NumIters:
+    if r.rand(1.0) <= 1 / NumThreads:
       writeWith rw:
         let tmp = data
         data = -1
@@ -23,8 +23,7 @@ proc routine =
         assert data >= 0
 
 proc frob =
-  init rw
-  for i in 0..<numThreads:
+  for i in 0..<NumThreads:
     createThread(threads[i], routine)
   joinThreads(threads)
 
diff --git a/tests/tsemaphore.nim b/tests/tsemaphore.nim
index 0a29416..43c43b0 100644
--- a/tests/tsemaphore.nim
+++ b/tests/tsemaphore.nim
@@ -1,37 +1,35 @@
 import threading/semaphore, std/strformat
 
 const
-  bufSize = 16
-  numIters = 1000
+  BufSize = 16
+  NumIters = 1000
 
 var
   thr1, thr2: Thread[void]
-  buf: array[bufSize, int]
+  buf: array[BufSize, int]
   head, tail = 0
-  chars, spaces: Semaphore
+  chars = createSemaphore()
+  spaces = createSemaphore(BufSize)
 
-template next(current: untyped): untyped = (current + 1) and bufSize - 1
+template next(current: untyped): untyped = (current + 1) and BufSize - 1
 
 proc producer =
-  for i in 0 ..< numIters:
+  for i in 0..<NumIters:
     wait spaces
-    assert buf[head] <= i, &"Constraint: recv_{buf[tail]} < send_{i}+{bufSize}"
+    assert buf[head] <= i, &"Constraint: recv_{buf[tail]} < send_{i}+{BufSize}"
     buf[head] = i
     head = next(head)
     signal chars
 
 proc consumer =
-  for i in 0 ..< numIters:
+  for i in 0..<NumIters:
     wait chars
     assert buf[tail] == i, &"Constraint: send_{buf[tail]} < recv_{i}"
-    buf[tail] = i + bufSize
+    buf[tail] = i + BufSize
     tail = next(tail)
     signal spaces
 
 proc testSemaphore =
-  init chars
-  init spaces, bufSize
-
   createThread(thr1, producer)
   createThread(thr2, consumer)
   joinThread(thr1)
diff --git a/tests/tsemaphore1.nim b/tests/tsemaphore1.nim
index f9e4f94..ad35d31 100644
--- a/tests/tsemaphore1.nim
+++ b/tests/tsemaphore1.nim
@@ -1,7 +1,7 @@
 import threading/semaphore
 
 var
-  semS, semT: Semaphore
+  semS, semT = createSemaphore()
   aArrived, cArrived = false
   thread: Thread[void]
 
@@ -14,8 +14,6 @@ proc routine =
   assert aArrived, "Constraint: Section A precedes D"
 
 proc testRendezvous =
-  init semS
-  init semT
   createThread(thread, routine)
   # Section A
   aArrived = true

From d0c8c50cc6bfbb64818c8ff64050cb12ac1f460d Mon Sep 17 00:00:00 2001
From: Antonis Geralis <b3lievem@yandex.com>
Date: Sun, 24 Sep 2023 12:47:34 +0300
Subject: [PATCH 3/3] algo variant from wiki implemented saves 144-112=32bytes

---
 threading/rwlock.nim | 39 ++++++++++++++++++---------------------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/threading/rwlock.nim b/threading/rwlock.nim
index 561d35a..22cfaef 100644
--- a/threading/rwlock.nim
+++ b/threading/rwlock.nim
@@ -38,21 +38,19 @@ type
   RwLock* = object
     ## Readers-writer lock. Multiple readers can acquire the lock at the same
     ## time, but only one writer can acquire the lock at a time.
-    readPhase: Cond
-    writePhase: Cond
+    c: Cond
     L: Lock
-    counter: int # can be in three states: free = 0, reading > 0, writing = -1
+    activeReaders, waitingWriters: int
+    activeWriter: bool
 
 when defined(nimAllowNonVarDestructor):
   proc `=destroy`*(rw: RwLock) {.inline.} =
     let x = addr(rw)
-    deinitCond(x.readPhase)
-    deinitCond(x.writePhase)
+    deinitCond(x.c)
     deinitLock(x.L)
 else:
   proc `=destroy`*(rw: var RwLock) {.inline.} =
-    deinitCond(rw.readPhase)
-    deinitCond(rw.writePhase)
+    deinitCond(rw.c)
     deinitLock(rw.L)
 
 proc `=sink`*(dest: var RwLock; source: RwLock) {.error.}
@@ -60,40 +58,39 @@ proc `=copy`*(dest: var RwLock; source: RwLock) {.error.}
 
 proc createRwLock*(): RwLock =
   result = default(RwLock)
-  initCond(result.readPhase)
-  initCond(result.writePhase)
+  initCond(result.c)
   initLock(result.L)
 
 proc beginRead*(rw: var RwLock) =
   ## Acquire a read lock.
   acquire(rw.L)
-  while rw.counter == -1:
-    wait(rw.readPhase, rw.L)
-  inc rw.counter
+  while rw.waitingWriters > 0 or rw.activeWriter:
+    wait(rw.c, rw.L)
+  inc rw.activeReaders
   release(rw.L)
 
 proc beginWrite*(rw: var RwLock) =
   ## Acquire a write lock.
   acquire(rw.L)
-  while rw.counter != 0:
-    wait(rw.writePhase, rw.L)
-  rw.counter = -1
+  inc rw.waitingWriters
+  while rw.activeReaders > 0 or rw.activeWriter:
+    wait(rw.c, rw.L)
+  dec rw.waitingWriters
+  rw.activeWriter = true
   release(rw.L)
 
 proc endRead*(rw: var RwLock) {.inline.} =
   ## Release a read lock.
   acquire(rw.L)
-  dec rw.counter
-  if rw.counter == 0:
-    rw.writePhase.signal()
+  dec rw.activeReaders
+  rw.c.broadcast()
   release(rw.L)
 
 proc endWrite*(rw: var RwLock) {.inline.} =
   ## Release a write lock.
   acquire(rw.L)
-  rw.counter = 0
-  rw.readPhase.broadcast()
-  rw.writePhase.signal()
+  rw.activeWriter = false
+  rw.c.broadcast()
   release(rw.L)
 
 template readWith*(a: RwLock, body: untyped) =