mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2025-12-28 17:04:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

include std/private/syslocks

Browse Source
This commit is contained in:
ringabout
2025-12-17 19:14:49 +08:00
parent c71854756a
commit d79c04151f
8 changed files with 56 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/core/locks.nim
View File

@@ -18,7 +18,7 @@ when not compileOption("threads") and not defined(nimdoc):
when false: # fix #12330
{.error: "Locks requires --threads:on option.".}
import std/private/syslocks
include std/private/syslocks
type
Lock* = SysLock ## Nim lock; whether this is re-entrant

2
lib/core/rlocks.nim
View File

@@ -16,7 +16,7 @@ when not compileOption("threads") and not defined(nimdoc):
# so they can replace each other seamlessly.
{.error: "Rlocks requires --threads:on option.".}
import std/private/syslocks
include std/private/syslocks
type
RLock* = SysLock ## Nim lock, re-entrant

104
lib/std/private/syslocks.nim
View File

@@ -15,7 +15,7 @@ when defined(windows):
type
Handle = int
SysLock* {.importc: "CRITICAL_SECTION",
SysLock {.importc: "CRITICAL_SECTION",
header: "<windows.h>", final, pure, byref.} = object # CRITICAL_SECTION in WinApi
DebugInfo: pointer
LockCount: int32
@@ -24,10 +24,10 @@ when defined(windows):
LockSemaphore: int
SpinCount: int
SysCond* {.importc: "RTL_CONDITION_VARIABLE", header: "<windows.h>", byref.} = object
SysCond {.importc: "RTL_CONDITION_VARIABLE", header: "<windows.h>", byref.} = object
thePtr {.importc: "Ptr".} : Handle
proc initSysLock*(L: var SysLock) {.importc: "InitializeCriticalSection",
proc initSysLock(L: var SysLock) {.importc: "InitializeCriticalSection",
header: "<windows.h>".}
## Initializes the lock `L`.
@@ -35,18 +35,18 @@ when defined(windows):
header: "<windows.h>".}
## Tries to acquire the lock `L`.
proc tryAcquireSys*(L: var SysLock): bool {.inline.} =
proc tryAcquireSys(L: var SysLock): bool {.inline.} =
result = tryAcquireSysAux(L) != 0'i32
proc acquireSys*(L: var SysLock) {.importc: "EnterCriticalSection",
proc acquireSys(L: var SysLock) {.importc: "EnterCriticalSection",
header: "<windows.h>".}
## Acquires the lock `L`.
proc releaseSys*(L: var SysLock) {.importc: "LeaveCriticalSection",
proc releaseSys(L: var SysLock) {.importc: "LeaveCriticalSection",
header: "<windows.h>".}
## Releases the lock `L`.
proc deinitSys*(L: SysLock) {.importc: "DeleteCriticalSection",
proc deinitSys(L: SysLock) {.importc: "DeleteCriticalSection",
header: "<windows.h>".}
proc initializeConditionVariable(
@@ -60,41 +60,41 @@ when defined(windows):
): int32 {.stdcall, noSideEffect, dynlib: "kernel32", importc: "SleepConditionVariableCS".}
proc signalSysCond*(hEvent: var SysCond) {.stdcall, noSideEffect,
proc signalSysCond(hEvent: var SysCond) {.stdcall, noSideEffect,
dynlib: "kernel32", importc: "WakeConditionVariable".}
proc broadcastSysCond*(hEvent: var SysCond) {.stdcall, noSideEffect,
proc broadcastSysCond(hEvent: var SysCond) {.stdcall, noSideEffect,
dynlib: "kernel32", importc: "WakeAllConditionVariable".}
proc initSysCond*(cond: var SysCond) {.inline.} =
proc initSysCond(cond: var SysCond) {.inline.} =
initializeConditionVariable(cond)
proc deinitSysCond*(cond: SysCond) {.inline.} =
proc deinitSysCond(cond: SysCond) {.inline.} =
discard
proc waitSysCond*(cond: var SysCond, lock: var SysLock) =
proc waitSysCond(cond: var SysCond, lock: var SysLock) =
discard sleepConditionVariableCS(cond, lock, -1'i32)
elif defined(genode):
const
Header = "genode_cpp/syslocks.h"
type
SysLock* {.importcpp: "Nim::SysLock", pure, final,
SysLock {.importcpp: "Nim::SysLock", pure, final,
header: Header.} = object
SysCond* {.importcpp: "Nim::SysCond", pure, final,
SysCond {.importcpp: "Nim::SysCond", pure, final,
header: Header.} = object
proc initSysLock*(L: var SysLock) = discard
proc deinitSys*(L: SysLock) = discard
proc acquireSys*(L: var SysLock) {.noSideEffect, importcpp.}
proc tryAcquireSys*(L: var SysLock): bool {.noSideEffect, importcpp.}
proc releaseSys*(L: var SysLock) {.noSideEffect, importcpp.}
proc initSysLock(L: var SysLock) = discard
proc deinitSys(L: SysLock) = discard
proc acquireSys(L: var SysLock) {.noSideEffect, importcpp.}
proc tryAcquireSys(L: var SysLock): bool {.noSideEffect, importcpp.}
proc releaseSys(L: var SysLock) {.noSideEffect, importcpp.}
proc initSysCond*(L: var SysCond) = discard
proc deinitSysCond*(L: SysCond) = discard
proc waitSysCond*(cond: var SysCond, lock: var SysLock) {.
proc initSysCond(L: var SysCond) = discard
proc deinitSysCond(L: SysCond) = discard
proc waitSysCond(cond: var SysCond, lock: var SysLock) {.
noSideEffect, importcpp.}
proc signalSysCond*(cond: var SysCond) {.
proc signalSysCond(cond: var SysCond) {.
noSideEffect, importcpp.}
proc broadcastSysCond*(cond: var SysCond) {.
proc broadcastSysCond(cond: var SysCond) {.
noSideEffect, importcpp.}
else:
@@ -105,7 +105,7 @@ else:
when defined(linux) and defined(amd64):
abi: array[40 div sizeof(clong), clong]
SysLockAttr* {.importc: "pthread_mutexattr_t", pure, final
SysLockAttr {.importc: "pthread_mutexattr_t", pure, final
header: """#include <sys/types.h>
#include <pthread.h>""".} = object
when defined(linux) and defined(amd64):
@@ -143,8 +143,8 @@ else:
# to prevent this once and for all, we're doing an extra malloc when
# initializing the primitive.
type
SysLock* = ptr SysLockObj
SysCond* = ptr SysCondObj
SysLock = ptr SysLockObj
SysCond = ptr SysCondObj
when not declared(c_malloc):
proc c_malloc(size: csize_t): pointer {.
@@ -152,42 +152,42 @@ else:
proc c_free(p: pointer) {.
importc: "free", header: "<stdlib.h>".}
proc initSysLock*(L: var SysLock, attr: ptr SysLockAttr = nil) =
proc initSysLock(L: var SysLock, attr: ptr SysLockAttr = nil) =
L = cast[SysLock](c_malloc(csize_t(sizeof(SysLockObj))))
initSysLockAux(L[], attr)
proc deinitSys*(L: SysLock) =
proc deinitSys(L: SysLock) =
deinitSysAux(L[])
c_free(L)
template acquireSys*(L: var SysLock) =
template acquireSys(L: var SysLock) =
acquireSysAux(L[])
template tryAcquireSys*(L: var SysLock): bool =
template tryAcquireSys(L: var SysLock): bool =
tryAcquireSysAux(L[]) == 0'i32
template releaseSys*(L: var SysLock) =
template releaseSys(L: var SysLock) =
releaseSysAux(L[])
else:
type
SysLock* = SysLockObj
SysCond* = SysCondObj
SysLock = SysLockObj
SysCond = SysCondObj
template initSysLock*(L: var SysLock, attr: ptr SysLockAttr = nil) =
template initSysLock(L: var SysLock, attr: ptr SysLockAttr = nil) =
initSysLockAux(L, attr)
template deinitSys*(L: SysLock) =
template deinitSys(L: SysLock) =
deinitSysAux(L)
template acquireSys*(L: var SysLock) =
template acquireSys(L: var SysLock) =
acquireSysAux(L)
template tryAcquireSys*(L: var SysLock): bool =
template tryAcquireSys(L: var SysLock): bool =
tryAcquireSysAux(L) == 0'i32
template releaseSys*(L: var SysLock) =
template releaseSys(L: var SysLock) =
releaseSysAux(L)
# rlocks
var SysLockType_Reentrant* {.importc: "PTHREAD_MUTEX_RECURSIVE",
var SysLockType_Reentrant {.importc: "PTHREAD_MUTEX_RECURSIVE",
header: "<pthread.h>".}: SysLockType
proc initSysLockAttr*(a: var SysLockAttr) {.
proc initSysLockAttr(a: var SysLockAttr) {.
importc: "pthread_mutexattr_init", header: "<pthread.h>", noSideEffect.}
proc setSysLockType*(a: var SysLockAttr, t: SysLockType) {.
proc setSysLockType(a: var SysLockAttr, t: SysLockType) {.
importc: "pthread_mutexattr_settype", header: "<pthread.h>", noSideEffect.}
# locks
@@ -204,31 +204,31 @@ else:
importc: "pthread_cond_broadcast", header: "<pthread.h>", noSideEffect.}
when defined(ios):
proc initSysCond*(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
proc initSysCond(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
cond = cast[SysCond](c_malloc(csize_t(sizeof(SysCondObj))))
initSysCondAux(cond[], cond_attr)
proc deinitSysCond*(cond: SysCond) =
proc deinitSysCond(cond: SysCond) =
deinitSysCondAux(cond[])
c_free(cond)
template waitSysCond*(cond: var SysCond, lock: var SysLock) =
template waitSysCond(cond: var SysCond, lock: var SysLock) =
discard waitSysCondAux(cond[], lock[])
template signalSysCond*(cond: var SysCond) =
template signalSysCond(cond: var SysCond) =
signalSysCondAux(cond[])
template broadcastSysCond*(cond: var SysCond) =
template broadcastSysCond(cond: var SysCond) =
broadcastSysCondAux(cond[])
else:
template initSysCond*(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
template initSysCond(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
initSysCondAux(cond, cond_attr)
template deinitSysCond*(cond: SysCond) =
template deinitSysCond(cond: SysCond) =
deinitSysCondAux(cond)
template waitSysCond*(cond: var SysCond, lock: var SysLock) =
template waitSysCond(cond: var SysCond, lock: var SysLock) =
discard waitSysCondAux(cond, lock)
template signalSysCond*(cond: var SysCond) =
template signalSysCond(cond: var SysCond) =
signalSysCondAux(cond)
template broadcastSysCond*(cond: var SysCond) =
template broadcastSysCond(cond: var SysCond) =
broadcastSysCondAux(cond)
{.pop.}

2
lib/system.nim
View File

@@ -1660,7 +1660,7 @@ when notJSnotNims:
{.push stackTrace: off.}
when not defined(js) and hasThreadSupport and hostOS != "standalone":
import std/private/syslocks
include std/private/syslocks
include "system/threadlocalstorage"
when not defined(js) and defined(nimV2):

1
lib/system/alloc.nim
View File

@@ -11,7 +11,6 @@
{.push profiler:off.}
include osalloc
import std/private/syslocks
template track(op, address, size) =
when defined(memTracker):

2
lib/system/channels_builtin.nim
View File

@@ -143,8 +143,6 @@
when not declared(ThisIsSystem):
{.error: "You must not import this module explicitly".}
import std/private/syslocks
type
pbytes = ptr UncheckedArray[byte]
RawChannel {.pure, final.} = object ## msg queue for a thread

1
lib/system/gc_regions.nim
View File

@@ -9,7 +9,6 @@
{.push raises: [], gcsafe.}
# "Stack GC" for embedded devices or ultra performance requirements.
import std/private/syslocks
when defined(memProfiler):
proc nimProfile(requestedSize: int) {.benign.}

1
tools/kochdocs.nim
View File

@@ -157,6 +157,7 @@ lib/std/sha1.nim
lib/pure/htmlparser.nim
lib/std/private/schubfach.nim
lib/std/private/dragonbox.nim
lib/std/private/syslocks.nim
""".splitWhitespace()
officialPackagesList = """