move threads out of system (#20674)
* move syslocks first * progress * clean up * go on * clean up * clean up * add imports syslocks * remove documentation * public deallocOsPages * fixes genode * fixes more * fixes boehmGC * cover more cases * fixes cyclic deps * fixes genode * cleanup * unpublic fields * cleanup * clean up
This commit is contained in:
ringabout
GitHub
parent
a51ed90c5d
commit
1dab8ba334
15 changed files with 424 additions and 390 deletions
234
lib/std/private/syslocks.nim
Normal file
234
lib/std/private/syslocks.nim
Normal file
|
|
@ -0,0 +1,234 @@
|
|||
#
|
||||
#
|
||||
# Nim's Runtime Library
|
||||
# (c) Copyright 2012 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
#
|
||||
|
||||
# Low level system locks and condition vars.
|
||||
|
||||
{.push stackTrace: off.}
|
||||
|
||||
when defined(windows):
|
||||
type
|
||||
Handle = int
|
||||
|
||||
SysLock* {.importc: "CRITICAL_SECTION",
|
||||
header: "<windows.h>", final, pure.} = object # CRITICAL_SECTION in WinApi
|
||||
DebugInfo: pointer
|
||||
LockCount: int32
|
||||
RecursionCount: int32
|
||||
OwningThread: int
|
||||
LockSemaphore: int
|
||||
SpinCount: int
|
||||
|
||||
SysCond* {.importc: "RTL_CONDITION_VARIABLE", header: "<windows.h>".} = object
|
||||
thePtr {.importc: "ptr".} : Handle
|
||||
|
||||
proc initSysLock*(L: var SysLock) {.importc: "InitializeCriticalSection",
|
||||
header: "<windows.h>".}
|
||||
## Initializes the lock `L`.
|
||||
|
||||
proc tryAcquireSysAux(L: var SysLock): int32 {.importc: "TryEnterCriticalSection",
|
||||
header: "<windows.h>".}
|
||||
## Tries to acquire the lock `L`.
|
||||
|
||||
proc tryAcquireSys*(L: var SysLock): bool {.inline.} =
|
||||
result = tryAcquireSysAux(L) != 0'i32
|
||||
|
||||
proc acquireSys*(L: var SysLock) {.importc: "EnterCriticalSection",
|
||||
header: "<windows.h>".}
|
||||
## Acquires the lock `L`.
|
||||
|
||||
proc releaseSys*(L: var SysLock) {.importc: "LeaveCriticalSection",
|
||||
header: "<windows.h>".}
|
||||
## Releases the lock `L`.
|
||||
|
||||
proc deinitSys*(L: var SysLock) {.importc: "DeleteCriticalSection",
|
||||
header: "<windows.h>".}
|
||||
|
||||
proc initializeConditionVariable(
|
||||
conditionVariable: var SysCond
|
||||
) {.stdcall, noSideEffect, dynlib: "kernel32", importc: "InitializeConditionVariable".}
|
||||
|
||||
proc sleepConditionVariableCS(
|
||||
conditionVariable: var SysCond,
|
||||
PCRITICAL_SECTION: var SysLock,
|
||||
dwMilliseconds: int
|
||||
): int32 {.stdcall, noSideEffect, dynlib: "kernel32", importc: "SleepConditionVariableCS".}
|
||||
|
||||
|
||||
proc signalSysCond*(hEvent: var SysCond) {.stdcall, noSideEffect,
|
||||
dynlib: "kernel32", importc: "WakeConditionVariable".}
|
||||
|
||||
proc broadcastSysCond*(hEvent: var SysCond) {.stdcall, noSideEffect,
|
||||
dynlib: "kernel32", importc: "WakeAllConditionVariable".}
|
||||
|
||||
proc initSysCond*(cond: var SysCond) {.inline.} =
|
||||
initializeConditionVariable(cond)
|
||||
proc deinitSysCond*(cond: var SysCond) {.inline.} =
|
||||
discard
|
||||
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,
|
||||
header: Header.} = object
|
||||
SysCond* {.importcpp: "Nim::SysCond", pure, final,
|
||||
header: Header.} = object
|
||||
|
||||
proc initSysLock*(L: var SysLock) = discard
|
||||
proc deinitSys*(L: var 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: var SysCond) = discard
|
||||
proc waitSysCond*(cond: var SysCond, lock: var SysLock) {.
|
||||
noSideEffect, importcpp.}
|
||||
proc signalSysCond*(cond: var SysCond) {.
|
||||
noSideEffect, importcpp.}
|
||||
proc broadcastSysCond*(cond: var SysCond) {.
|
||||
noSideEffect, importcpp.}
|
||||
|
||||
else:
|
||||
type
|
||||
SysLockObj {.importc: "pthread_mutex_t", pure, final,
|
||||
header: """#include <sys/types.h>
|
||||
#include <pthread.h>""".} = object
|
||||
when defined(linux) and defined(amd64):
|
||||
abi: array[40 div sizeof(clong), clong]
|
||||
|
||||
SysLockAttr* {.importc: "pthread_mutexattr_t", pure, final
|
||||
header: """#include <sys/types.h>
|
||||
#include <pthread.h>""".} = object
|
||||
when defined(linux) and defined(amd64):
|
||||
abi: array[4 div sizeof(cint), cint] # actually a cint
|
||||
|
||||
SysCondObj {.importc: "pthread_cond_t", pure, final,
|
||||
header: """#include <sys/types.h>
|
||||
#include <pthread.h>""".} = object
|
||||
when defined(linux) and defined(amd64):
|
||||
abi: array[48 div sizeof(clonglong), clonglong]
|
||||
|
||||
SysCondAttr {.importc: "pthread_condattr_t", pure, final
|
||||
header: """#include <sys/types.h>
|
||||
#include <pthread.h>""".} = object
|
||||
when defined(linux) and defined(amd64):
|
||||
abi: array[4 div sizeof(cint), cint] # actually a cint
|
||||
|
||||
SysLockType = distinct cint
|
||||
|
||||
proc initSysLockAux(L: var SysLockObj, attr: ptr SysLockAttr) {.
|
||||
importc: "pthread_mutex_init", header: "<pthread.h>", noSideEffect.}
|
||||
proc deinitSysAux(L: var SysLockObj) {.noSideEffect,
|
||||
importc: "pthread_mutex_destroy", header: "<pthread.h>".}
|
||||
|
||||
proc acquireSysAux(L: var SysLockObj) {.noSideEffect,
|
||||
importc: "pthread_mutex_lock", header: "<pthread.h>".}
|
||||
proc tryAcquireSysAux(L: var SysLockObj): cint {.noSideEffect,
|
||||
importc: "pthread_mutex_trylock", header: "<pthread.h>".}
|
||||
|
||||
proc releaseSysAux(L: var SysLockObj) {.noSideEffect,
|
||||
importc: "pthread_mutex_unlock", header: "<pthread.h>".}
|
||||
|
||||
when defined(ios):
|
||||
# iOS will behave badly if sync primitives are moved in memory. In order
|
||||
# to prevent this once and for all, we're doing an extra malloc when
|
||||
# initializing the primitive.
|
||||
type
|
||||
SysLock* = ptr SysLockObj
|
||||
SysCond* = ptr SysCondObj
|
||||
|
||||
when not declared(c_malloc):
|
||||
proc c_malloc(size: csize_t): pointer {.
|
||||
importc: "malloc", header: "<stdlib.h>".}
|
||||
proc c_free(p: pointer) {.
|
||||
importc: "free", header: "<stdlib.h>".}
|
||||
|
||||
proc initSysLock*(L: var SysLock, attr: ptr SysLockAttr = nil) =
|
||||
L = cast[SysLock](c_malloc(csize_t(sizeof(SysLockObj))))
|
||||
initSysLockAux(L[], attr)
|
||||
|
||||
proc deinitSys*(L: var SysLock) =
|
||||
deinitSysAux(L[])
|
||||
c_free(L)
|
||||
|
||||
template acquireSys*(L: var SysLock) =
|
||||
acquireSysAux(L[])
|
||||
template tryAcquireSys*(L: var SysLock): bool =
|
||||
tryAcquireSysAux(L[]) == 0'i32
|
||||
template releaseSys*(L: var SysLock) =
|
||||
releaseSysAux(L[])
|
||||
else:
|
||||
type
|
||||
SysLock* = SysLockObj
|
||||
SysCond* = SysCondObj
|
||||
|
||||
template initSysLock*(L: var SysLock, attr: ptr SysLockAttr = nil) =
|
||||
initSysLockAux(L, attr)
|
||||
template deinitSys*(L: var SysLock) =
|
||||
deinitSysAux(L)
|
||||
template acquireSys*(L: var SysLock) =
|
||||
acquireSysAux(L)
|
||||
template tryAcquireSys*(L: var SysLock): bool =
|
||||
tryAcquireSysAux(L) == 0'i32
|
||||
template releaseSys*(L: var SysLock) =
|
||||
releaseSysAux(L)
|
||||
|
||||
# rlocks
|
||||
var SysLockType_Reentrant* {.importc: "PTHREAD_MUTEX_RECURSIVE",
|
||||
header: "<pthread.h>".}: SysLockType
|
||||
proc initSysLockAttr*(a: var SysLockAttr) {.
|
||||
importc: "pthread_mutexattr_init", header: "<pthread.h>", noSideEffect.}
|
||||
proc setSysLockType*(a: var SysLockAttr, t: SysLockType) {.
|
||||
importc: "pthread_mutexattr_settype", header: "<pthread.h>", noSideEffect.}
|
||||
|
||||
# locks
|
||||
proc initSysCondAux(cond: var SysCondObj, cond_attr: ptr SysCondAttr = nil) {.
|
||||
importc: "pthread_cond_init", header: "<pthread.h>", noSideEffect.}
|
||||
proc deinitSysCondAux(cond: var SysCondObj) {.noSideEffect,
|
||||
importc: "pthread_cond_destroy", header: "<pthread.h>".}
|
||||
|
||||
proc waitSysCondAux(cond: var SysCondObj, lock: var SysLockObj): cint {.
|
||||
importc: "pthread_cond_wait", header: "<pthread.h>", noSideEffect.}
|
||||
proc signalSysCondAux(cond: var SysCondObj) {.
|
||||
importc: "pthread_cond_signal", header: "<pthread.h>", noSideEffect.}
|
||||
proc broadcastSysCondAux(cond: var SysCondObj) {.
|
||||
importc: "pthread_cond_broadcast", header: "<pthread.h>", noSideEffect.}
|
||||
|
||||
when defined(ios):
|
||||
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: var SysCond) =
|
||||
deinitSysCondAux(cond[])
|
||||
c_free(cond)
|
||||
|
||||
template waitSysCond*(cond: var SysCond, lock: var SysLock) =
|
||||
discard waitSysCondAux(cond[], lock[])
|
||||
template signalSysCond*(cond: var SysCond) =
|
||||
signalSysCondAux(cond[])
|
||||
template broadcastSysCond*(cond: var SysCond) =
|
||||
broadcastSysCondAux(cond[])
|
||||
else:
|
||||
template initSysCond*(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
|
||||
initSysCondAux(cond, cond_attr)
|
||||
template deinitSysCond*(cond: var SysCond) =
|
||||
deinitSysCondAux(cond)
|
||||
|
||||
template waitSysCond*(cond: var SysCond, lock: var SysLock) =
|
||||
discard waitSysCondAux(cond, lock)
|
||||
template signalSysCond*(cond: var SysCond) =
|
||||
signalSysCondAux(cond)
|
||||
template broadcastSysCond*(cond: var SysCond) =
|
||||
broadcastSysCondAux(cond)
|
||||
|
||||
{.pop.}
|
||||
176
lib/std/private/threadtypes.nim
Normal file
176
lib/std/private/threadtypes.nim
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
include system/inclrtl
|
||||
|
||||
const hasSharedHeap* = defined(boehmgc) or defined(gogc) # don't share heaps; every thread has its own
|
||||
|
||||
when defined(windows):
|
||||
type
|
||||
Handle* = int
|
||||
SysThread* = Handle
|
||||
WinThreadProc* = proc (x: pointer): int32 {.stdcall.}
|
||||
|
||||
proc createThread*(lpThreadAttributes: pointer, dwStackSize: int32,
|
||||
lpStartAddress: WinThreadProc,
|
||||
lpParameter: pointer,
|
||||
dwCreationFlags: int32,
|
||||
lpThreadId: var int32): SysThread {.
|
||||
stdcall, dynlib: "kernel32", importc: "CreateThread".}
|
||||
|
||||
proc winSuspendThread*(hThread: SysThread): int32 {.
|
||||
stdcall, dynlib: "kernel32", importc: "SuspendThread".}
|
||||
|
||||
proc winResumeThread*(hThread: SysThread): int32 {.
|
||||
stdcall, dynlib: "kernel32", importc: "ResumeThread".}
|
||||
|
||||
proc waitForSingleObject*(hHandle: SysThread, dwMilliseconds: int32): int32 {.
|
||||
stdcall, dynlib: "kernel32", importc: "WaitForSingleObject".}
|
||||
|
||||
proc waitForMultipleObjects*(nCount: int32,
|
||||
lpHandles: ptr SysThread,
|
||||
bWaitAll: int32,
|
||||
dwMilliseconds: int32): int32 {.
|
||||
stdcall, dynlib: "kernel32", importc: "WaitForMultipleObjects".}
|
||||
|
||||
proc terminateThread*(hThread: SysThread, dwExitCode: int32): int32 {.
|
||||
stdcall, dynlib: "kernel32", importc: "TerminateThread".}
|
||||
|
||||
proc setThreadAffinityMask*(hThread: SysThread, dwThreadAffinityMask: uint) {.
|
||||
importc: "SetThreadAffinityMask", stdcall, header: "<windows.h>".}
|
||||
|
||||
elif defined(genode):
|
||||
const
|
||||
GenodeHeader* = "genode_cpp/threads.h"
|
||||
type
|
||||
SysThread* {.importcpp: "Nim::SysThread",
|
||||
header: GenodeHeader, final, pure.} = object
|
||||
GenodeThreadProc* = proc (x: pointer) {.noconv.}
|
||||
|
||||
proc initThread*(s: var SysThread,
|
||||
env: GenodeEnv,
|
||||
stackSize: culonglong,
|
||||
entry: GenodeThreadProc,
|
||||
arg: pointer,
|
||||
affinity: cuint) {.
|
||||
importcpp: "#.initThread(@)".}
|
||||
|
||||
|
||||
else:
|
||||
when not (defined(macosx) or defined(haiku)):
|
||||
{.passl: "-pthread".}
|
||||
|
||||
when not defined(haiku):
|
||||
{.passc: "-pthread".}
|
||||
|
||||
const
|
||||
schedh = "#define _GNU_SOURCE\n#include <sched.h>"
|
||||
pthreadh* = "#define _GNU_SOURCE\n#include <pthread.h>"
|
||||
|
||||
when not declared(Time):
|
||||
when defined(linux):
|
||||
type Time = clong
|
||||
else:
|
||||
type Time = int
|
||||
|
||||
when (defined(linux) or defined(nintendoswitch)) and defined(amd64):
|
||||
type
|
||||
SysThread* {.importc: "pthread_t",
|
||||
header: "<sys/types.h>" .} = distinct culong
|
||||
Pthread_attr* {.importc: "pthread_attr_t",
|
||||
header: "<sys/types.h>".} = object
|
||||
abi: array[56 div sizeof(clong), clong]
|
||||
elif defined(openbsd) and defined(amd64):
|
||||
type
|
||||
SysThread* {.importc: "pthread_t", header: "<pthread.h>".} = object
|
||||
Pthread_attr* {.importc: "pthread_attr_t",
|
||||
header: "<pthread.h>".} = object
|
||||
else:
|
||||
type
|
||||
SysThread* {.importc: "pthread_t", header: "<sys/types.h>".} = int
|
||||
Pthread_attr* {.importc: "pthread_attr_t",
|
||||
header: "<sys/types.h>".} = object
|
||||
type
|
||||
Timespec* {.importc: "struct timespec", header: "<time.h>".} = object
|
||||
tv_sec*: Time
|
||||
tv_nsec*: clong
|
||||
|
||||
proc pthread_attr_init*(a1: var Pthread_attr): cint {.
|
||||
importc, header: pthreadh.}
|
||||
proc pthread_attr_setstack*(a1: ptr Pthread_attr, a2: pointer, a3: int): cint {.
|
||||
importc, header: pthreadh.}
|
||||
proc pthread_attr_setstacksize*(a1: var Pthread_attr, a2: int): cint {.
|
||||
importc, header: pthreadh.}
|
||||
proc pthread_attr_destroy*(a1: var Pthread_attr): cint {.
|
||||
importc, header: pthreadh.}
|
||||
|
||||
proc pthread_create*(a1: var SysThread, a2: var Pthread_attr,
|
||||
a3: proc (x: pointer): pointer {.noconv.},
|
||||
a4: pointer): cint {.importc: "pthread_create",
|
||||
header: pthreadh.}
|
||||
proc pthread_join*(a1: SysThread, a2: ptr pointer): cint {.
|
||||
importc, header: pthreadh.}
|
||||
|
||||
proc pthread_cancel*(a1: SysThread): cint {.
|
||||
importc: "pthread_cancel", header: pthreadh.}
|
||||
|
||||
type CpuSet* {.importc: "cpu_set_t", header: schedh.} = object
|
||||
when defined(linux) and defined(amd64):
|
||||
abi: array[1024 div (8 * sizeof(culong)), culong]
|
||||
|
||||
proc cpusetZero*(s: var CpuSet) {.importc: "CPU_ZERO", header: schedh.}
|
||||
proc cpusetIncl*(cpu: cint; s: var CpuSet) {.
|
||||
importc: "CPU_SET", header: schedh.}
|
||||
|
||||
when defined(android):
|
||||
# libc of android doesn't implement pthread_setaffinity_np,
|
||||
# it exposes pthread_gettid_np though, so we can use that in combination
|
||||
# with sched_setaffinity to set the thread affinity.
|
||||
type Pid* {.importc: "pid_t", header: "<sys/types.h>".} = int32 # From posix_other.nim
|
||||
|
||||
proc setAffinityTID*(tid: Pid; setsize: csize_t; s: var CpuSet) {.
|
||||
importc: "sched_setaffinity", header: schedh.}
|
||||
|
||||
proc pthread_gettid_np*(thread: SysThread): Pid {.
|
||||
importc: "pthread_gettid_np", header: pthreadh.}
|
||||
|
||||
proc setAffinity*(thread: SysThread; setsize: csize_t; s: var CpuSet) =
|
||||
setAffinityTID(pthread_gettid_np(thread), setsize, s)
|
||||
else:
|
||||
proc setAffinity*(thread: SysThread; setsize: csize_t; s: var CpuSet) {.
|
||||
importc: "pthread_setaffinity_np", header: pthreadh.}
|
||||
|
||||
|
||||
const
|
||||
emulatedThreadVars* = compileOption("tlsEmulation")
|
||||
# we preallocate a fixed size for thread local storage, so that no heap
|
||||
# allocations are needed. Currently less than 16K are used on a 64bit machine.
|
||||
# We use `float` for proper alignment:
|
||||
const nimTlsSize {.intdefine.} = 16000
|
||||
type
|
||||
ThreadLocalStorage* = array[0..(nimTlsSize div sizeof(float)), float]
|
||||
PGcThread* = ptr GcThread
|
||||
GcThread* {.pure, inheritable.} = object
|
||||
when emulatedThreadVars:
|
||||
tls*: ThreadLocalStorage
|
||||
else:
|
||||
nil
|
||||
when hasSharedHeap:
|
||||
next*, prev*: PGcThread
|
||||
stackBottom*, stackTop*: pointer
|
||||
stackSize*: int
|
||||
else:
|
||||
nil
|
||||
|
||||
const hasAllocStack* = defined(zephyr) # maybe freertos too?
|
||||
|
||||
type
|
||||
Thread*[TArg] = object
|
||||
core*: PGcThread
|
||||
sys*: SysThread
|
||||
when TArg is void:
|
||||
dataFn*: proc () {.nimcall, gcsafe.}
|
||||
else:
|
||||
dataFn*: proc (m: TArg) {.nimcall, gcsafe.}
|
||||
data*: TArg
|
||||
when hasAllocStack:
|
||||
rawStack*: pointer
|
||||
|
||||
proc `=copy`*[TArg](x: var Thread[TArg], y: Thread[TArg]) {.error.}
|
||||
Loading…
Add table
Add a link
Reference in a new issue