From d79c04151fc19940caf91073e63b50ca95b2335e Mon Sep 17 00:00:00 2001 From: ringabout <43030857+ringabout@users.noreply.github.com> Date: Wed, 17 Dec 2025 19:14:49 +0800 Subject: [PATCH] include std/private/syslocks --- lib/core/locks.nim | 2 +- lib/core/rlocks.nim | 2 +- lib/std/private/syslocks.nim | 104 ++++++++++++++++---------------- lib/system.nim | 2 +- lib/system/alloc.nim | 1 - lib/system/channels_builtin.nim | 2 - lib/system/gc_regions.nim | 1 - tools/kochdocs.nim | 1 + 8 files changed, 56 insertions(+), 59 deletions(-) diff --git a/lib/core/locks.nim b/lib/core/locks.nim index 5237274792..81ed1be345 100644 --- a/lib/core/locks.nim +++ b/lib/core/locks.nim @@ -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 diff --git a/lib/core/rlocks.nim b/lib/core/rlocks.nim index 5eea312257..e162a8c44b 100644 --- a/lib/core/rlocks.nim +++ b/lib/core/rlocks.nim @@ -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 diff --git a/lib/std/private/syslocks.nim b/lib/std/private/syslocks.nim index e19ec2c04d..0ca5dcb2b6 100644 --- a/lib/std/private/syslocks.nim +++ b/lib/std/private/syslocks.nim @@ -15,7 +15,7 @@ when defined(windows): type Handle = int - SysLock* {.importc: "CRITICAL_SECTION", + SysLock {.importc: "CRITICAL_SECTION", header: "", 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: "", byref.} = object + SysCond {.importc: "RTL_CONDITION_VARIABLE", header: "", byref.} = object thePtr {.importc: "Ptr".} : Handle - proc initSysLock*(L: var SysLock) {.importc: "InitializeCriticalSection", + proc initSysLock(L: var SysLock) {.importc: "InitializeCriticalSection", header: "".} ## Initializes the lock `L`. @@ -35,18 +35,18 @@ when defined(windows): header: "".} ## 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: "".} ## Acquires the lock `L`. - proc releaseSys*(L: var SysLock) {.importc: "LeaveCriticalSection", + proc releaseSys(L: var SysLock) {.importc: "LeaveCriticalSection", header: "".} ## Releases the lock `L`. - proc deinitSys*(L: SysLock) {.importc: "DeleteCriticalSection", + proc deinitSys(L: SysLock) {.importc: "DeleteCriticalSection", header: "".} 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 #include """.} = 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: "".} - 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: "".}: SysLockType - proc initSysLockAttr*(a: var SysLockAttr) {. + proc initSysLockAttr(a: var SysLockAttr) {. importc: "pthread_mutexattr_init", header: "", noSideEffect.} - proc setSysLockType*(a: var SysLockAttr, t: SysLockType) {. + proc setSysLockType(a: var SysLockAttr, t: SysLockType) {. importc: "pthread_mutexattr_settype", header: "", noSideEffect.} # locks @@ -204,31 +204,31 @@ else: importc: "pthread_cond_broadcast", header: "", 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.} diff --git a/lib/system.nim b/lib/system.nim index 65ad8824dc..5b0d1c0c45 100644 --- a/lib/system.nim +++ b/lib/system.nim @@ -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): diff --git a/lib/system/alloc.nim b/lib/system/alloc.nim index 4109348fc2..8a29b3bf30 100644 --- a/lib/system/alloc.nim +++ b/lib/system/alloc.nim @@ -11,7 +11,6 @@ {.push profiler:off.} include osalloc -import std/private/syslocks template track(op, address, size) = when defined(memTracker): diff --git a/lib/system/channels_builtin.nim b/lib/system/channels_builtin.nim index 1cc9443778..2123707301 100644 --- a/lib/system/channels_builtin.nim +++ b/lib/system/channels_builtin.nim @@ -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 diff --git a/lib/system/gc_regions.nim b/lib/system/gc_regions.nim index 0385e2963d..1045f4f85b 100644 --- a/lib/system/gc_regions.nim +++ b/lib/system/gc_regions.nim @@ -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.} diff --git a/tools/kochdocs.nim b/tools/kochdocs.nim index 9ef76b4960..dac19c822c 100644 --- a/tools/kochdocs.nim +++ b/tools/kochdocs.nim @@ -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 = """