From 69abc8b64954206da6ffe5fc40a1142b39777762 Mon Sep 17 00:00:00 2001
From: flywind <xzsflywind@gmail.com>
Date: Mon, 7 Jun 2021 23:20:46 +0800
Subject: [PATCH] add std/mutexes

---
 changelog.md              |  2 +
 lib/std/mutexes.nim       | 90 +++++++++++++++++++++++++++++++++++++++
 tests/stdlib/tmutexes.nim | 49 +++++++++++++++++++++
 3 files changed, 141 insertions(+)
 create mode 100644 lib/std/mutexes.nim
 create mode 100644 tests/stdlib/tmutexes.nim

diff --git a/changelog.md b/changelog.md
index 1050e4916e..8487f43f4b 100644
--- a/changelog.md
+++ b/changelog.md
@@ -335,6 +335,8 @@
 
 - Added setCurrentException for JS backend.
 
+- Added `std/mutexes`.
+
 ## Language changes
 
 - `nimscript` now handles `except Exception as e`.
diff --git a/lib/std/mutexes.nim b/lib/std/mutexes.nim
new file mode 100644
index 0000000000..e4e25ea440
--- /dev/null
+++ b/lib/std/mutexes.nim
@@ -0,0 +1,90 @@
+#
+#
+#            Nim's Runtime Library
+#        (c) Copyright 2021 Nim Contributors
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## This module contains Nim's support for mutexes. It provides basic
+## destructors supports.
+
+runnableExamples("--threads:on --gc:orc"):
+  type
+    PassObj = object
+      id: int
+
+    Pass = ptr PassObj
+
+  proc worker(p: Pass) {.thread.} =
+    var m: Mutex
+    init(m)
+    acquire(m)
+    inc p.id
+    release(m)
+    # After leaving the function scope, 
+    # the resource owned by `m` is freed.
+
+  var p = cast[Pass](allocShared0(sizeof(PassObj)))
+  var ts = newSeq[Thread[Pass]](10)
+  for i in 0..<ts.len:
+    createThread(ts[i], worker, p)
+
+  joinThreads(ts)
+  assert p.id == 10
+
+
+import locks, rlocks
+
+type
+  Mutex* = object ## Mutex; whether this is re-entrant
+                  ## or not is unspecified.
+    lock: Lock
+
+  ReentrantMutex* = object ## Reentrant Mutex.
+    lock: RLock
+
+proc init*(mutex: var Mutex) {.inline.} =
+  ## Initializes the given mutex.
+  initLock(mutex.lock)
+
+proc `=copy`*(x: var Mutex, y: Mutex) {.error.}
+
+proc `=destroy`*(mutex: var Mutex) {.inline.} =
+  ## Frees the resources associated with the mutex.
+  deinitLock(mutex.lock)
+
+proc tryAcquire*(mutex: var Mutex): bool {.inline.} =
+  ## Tries to acquire the given mutex. Returns `true` on success.
+  result = tryAcquire(mutex.lock)
+
+proc acquire*(mutex: var Mutex) {.inline.} =
+  ## Acquires the given mutex.
+  acquire(mutex.lock)
+
+proc release*(mutex: var Mutex) {.inline.} =
+  ## Releases the given mutex.
+  release(mutex.lock)
+
+proc init*(mutex: var ReentrantMutex) {.inline.} =
+  ## Initializes the given mutex.
+  initRLock(mutex.lock)
+
+proc `=copy`*(x: var ReentrantMutex, y: ReentrantMutex) {.error.}
+
+proc `=destroy`*(mutex: var ReentrantMutex) {.inline.} =
+  ## Frees the resources associated with the mutex.
+  deinitRlock(mutex.lock)
+
+proc tryAcquire*(mutex: var ReentrantMutex): bool {.inline.} =
+  ## Tries to acquire the given mutex. Returns `true` on success.
+  result = tryAcquire(mutex.lock)
+
+proc acquire*(mutex: var ReentrantMutex) {.inline.} =
+  ## Acquires the given mutex.
+  acquire(mutex.lock)
+
+proc release*(mutex: var ReentrantMutex) {.inline.} =
+  ## Releases the given mutex.
+  release(mutex.lock)
diff --git a/tests/stdlib/tmutexes.nim b/tests/stdlib/tmutexes.nim
new file mode 100644
index 0000000000..1ad2d7635e
--- /dev/null
+++ b/tests/stdlib/tmutexes.nim
@@ -0,0 +1,49 @@
+discard """
+  matrix: "--threads:on --gc:refc; --threads:on --gc:orc"
+"""
+
+import std/mutexes
+
+type
+  PassObj = object
+    id: int
+
+  Pass = ptr PassObj
+
+block:
+  proc worker(p: Pass) {.thread.} =
+    var m: Mutex
+    init(m)
+    acquire(m)
+    inc p.id
+    release(m)
+    # After leaving the function scope, 
+    # the resource owned by `m` is freed.
+
+  var p = cast[Pass](allocShared0(sizeof(PassObj)))
+  var ts = newSeq[Thread[Pass]](10)
+  for i in 0..<ts.len:
+    createThread(ts[i], worker, p)
+
+  joinThreads(ts)
+  doAssert p.id == 10
+
+block:
+  proc worker(p: Pass) {.thread.} =
+    var m: ReentrantMutex
+    init(m)
+    acquire(m)
+    acquire(m)
+    inc p.id
+    release(m)
+    release(m)
+    # After leaving the function scope, 
+    # the resource owned by `m` is freed.
+
+  var p = cast[Pass](allocShared0(sizeof(PassObj)))
+  var ts = newSeq[Thread[Pass]](10)
+  for i in 0..<ts.len:
+    createThread(ts[i], worker, p)
+
+  joinThreads(ts)
+  doAssert p.id == 10