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
|
|
@ -11,6 +11,7 @@
|
|||
{.push profiler:off.}
|
||||
|
||||
include osalloc
|
||||
import std/private/syslocks
|
||||
|
||||
template track(op, address, size) =
|
||||
when defined(memTracker):
|
||||
|
|
|
|||
|
|
@ -139,6 +139,8 @@
|
|||
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
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
#
|
||||
|
||||
# "Stack GC" for embedded devices or ultra performance requirements.
|
||||
import std/private/syslocks
|
||||
|
||||
when defined(memProfiler):
|
||||
proc nimProfile(requestedSize: int) {.benign.}
|
||||
|
|
|
|||
|
|
@ -1,234 +0,0 @@
|
|||
#
|
||||
#
|
||||
# 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)
|
||||
|
||||
when insideRLocksModule:
|
||||
let 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.}
|
||||
|
||||
else:
|
||||
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.}
|
||||
107
lib/system/threadimpl.nim
Normal file
107
lib/system/threadimpl.nim
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
var
|
||||
nimThreadDestructionHandlers* {.rtlThreadVar.}: seq[proc () {.closure, gcsafe, raises: [].}]
|
||||
when not defined(boehmgc) and not hasSharedHeap and not defined(gogc) and not defined(gcRegions):
|
||||
proc deallocOsPages() {.rtl, raises: [].}
|
||||
proc threadTrouble() {.raises: [], gcsafe.}
|
||||
# create for the main thread. Note: do not insert this data into the list
|
||||
# of all threads; it's not to be stopped etc.
|
||||
when not defined(useNimRtl):
|
||||
#when not defined(createNimRtl): initStackBottom()
|
||||
when declared(initGC):
|
||||
initGC()
|
||||
when not emulatedThreadVars:
|
||||
type ThreadType {.pure.} = enum
|
||||
None = 0,
|
||||
NimThread = 1,
|
||||
ForeignThread = 2
|
||||
var
|
||||
threadType {.rtlThreadVar.}: ThreadType
|
||||
|
||||
threadType = ThreadType.NimThread
|
||||
|
||||
when defined(gcDestructors):
|
||||
proc allocThreadStorage(size: int): pointer =
|
||||
result = c_malloc(csize_t size)
|
||||
zeroMem(result, size)
|
||||
|
||||
proc deallocThreadStorage(p: pointer) = c_free(p)
|
||||
else:
|
||||
template allocThreadStorage(size: untyped): untyped = allocShared0(size)
|
||||
template deallocThreadStorage(p: pointer) = deallocShared(p)
|
||||
|
||||
template afterThreadRuns() =
|
||||
for i in countdown(nimThreadDestructionHandlers.len-1, 0):
|
||||
nimThreadDestructionHandlers[i]()
|
||||
|
||||
when defined(boehmgc):
|
||||
type GCStackBaseProc = proc(sb: pointer, t: pointer) {.noconv.}
|
||||
proc boehmGC_call_with_stack_base(sbp: GCStackBaseProc, p: pointer)
|
||||
{.importc: "GC_call_with_stack_base", boehmGC.}
|
||||
proc boehmGC_register_my_thread(sb: pointer)
|
||||
{.importc: "GC_register_my_thread", boehmGC.}
|
||||
proc boehmGC_unregister_my_thread()
|
||||
{.importc: "GC_unregister_my_thread", boehmGC.}
|
||||
|
||||
proc threadProcWrapDispatch[TArg](sb: pointer, thrd: pointer) {.noconv, raises: [].} =
|
||||
boehmGC_register_my_thread(sb)
|
||||
try:
|
||||
let thrd = cast[ptr Thread[TArg]](thrd)
|
||||
when TArg is void:
|
||||
thrd.dataFn()
|
||||
else:
|
||||
thrd.dataFn(thrd.data)
|
||||
except:
|
||||
threadTrouble()
|
||||
finally:
|
||||
afterThreadRuns()
|
||||
boehmGC_unregister_my_thread()
|
||||
else:
|
||||
proc threadProcWrapDispatch[TArg](thrd: ptr Thread[TArg]) {.raises: [].} =
|
||||
try:
|
||||
when TArg is void:
|
||||
thrd.dataFn()
|
||||
else:
|
||||
when defined(nimV2):
|
||||
thrd.dataFn(thrd.data)
|
||||
else:
|
||||
var x: TArg
|
||||
deepCopy(x, thrd.data)
|
||||
thrd.dataFn(x)
|
||||
except:
|
||||
threadTrouble()
|
||||
finally:
|
||||
afterThreadRuns()
|
||||
when hasAllocStack:
|
||||
deallocThreadStorage(thrd.rawStack)
|
||||
|
||||
proc threadProcWrapStackFrame[TArg](thrd: ptr Thread[TArg]) {.raises: [].} =
|
||||
when defined(boehmgc):
|
||||
boehmGC_call_with_stack_base(threadProcWrapDispatch[TArg], thrd)
|
||||
elif not defined(nogc) and not defined(gogc) and not defined(gcRegions) and not usesDestructors:
|
||||
var p {.volatile.}: pointer
|
||||
# init the GC for refc/markandsweep
|
||||
nimGC_setStackBottom(addr(p))
|
||||
when declared(initGC):
|
||||
initGC()
|
||||
when declared(threadType):
|
||||
threadType = ThreadType.NimThread
|
||||
threadProcWrapDispatch[TArg](thrd)
|
||||
when declared(deallocOsPages): deallocOsPages()
|
||||
else:
|
||||
threadProcWrapDispatch(thrd)
|
||||
|
||||
template nimThreadProcWrapperBody*(closure: untyped): untyped =
|
||||
var thrd = cast[ptr Thread[TArg]](closure)
|
||||
var core = thrd.core
|
||||
when declared(globalsSlot): threadVarSetValue(globalsSlot, thrd.core)
|
||||
threadProcWrapStackFrame(thrd)
|
||||
# Since an unhandled exception terminates the whole process (!), there is
|
||||
# no need for a ``try finally`` here, nor would it be correct: The current
|
||||
# exception is tried to be re-raised by the code-gen after the ``finally``!
|
||||
# However this is doomed to fail, because we already unmapped every heap
|
||||
# page!
|
||||
|
||||
# mark as not running anymore:
|
||||
thrd.core = nil
|
||||
thrd.dataFn = nil
|
||||
deallocThreadStorage(cast[pointer](core))
|
||||
|
|
@ -1,82 +1,32 @@
|
|||
import std/private/threadtypes
|
||||
|
||||
when defined(windows):
|
||||
type
|
||||
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".}
|
||||
|
||||
type
|
||||
ThreadVarSlot = distinct int32
|
||||
|
||||
when true:
|
||||
proc threadVarAlloc(): ThreadVarSlot {.
|
||||
importc: "TlsAlloc", stdcall, header: "<windows.h>".}
|
||||
proc threadVarSetValue(dwTlsIndex: ThreadVarSlot, lpTlsValue: pointer) {.
|
||||
importc: "TlsSetValue", stdcall, header: "<windows.h>".}
|
||||
proc tlsGetValue(dwTlsIndex: ThreadVarSlot): pointer {.
|
||||
importc: "TlsGetValue", stdcall, header: "<windows.h>".}
|
||||
proc threadVarAlloc(): ThreadVarSlot {.
|
||||
importc: "TlsAlloc", stdcall, header: "<windows.h>".}
|
||||
proc threadVarSetValue(dwTlsIndex: ThreadVarSlot, lpTlsValue: pointer) {.
|
||||
importc: "TlsSetValue", stdcall, header: "<windows.h>".}
|
||||
proc tlsGetValue(dwTlsIndex: ThreadVarSlot): pointer {.
|
||||
importc: "TlsGetValue", stdcall, header: "<windows.h>".}
|
||||
|
||||
proc getLastError(): uint32 {.
|
||||
importc: "GetLastError", stdcall, header: "<windows.h>".}
|
||||
proc setLastError(x: uint32) {.
|
||||
importc: "SetLastError", stdcall, header: "<windows.h>".}
|
||||
proc getLastError(): uint32 {.
|
||||
importc: "GetLastError", stdcall, header: "<windows.h>".}
|
||||
proc setLastError(x: uint32) {.
|
||||
importc: "SetLastError", stdcall, header: "<windows.h>".}
|
||||
|
||||
proc threadVarGetValue(dwTlsIndex: ThreadVarSlot): pointer =
|
||||
let realLastError = getLastError()
|
||||
result = tlsGetValue(dwTlsIndex)
|
||||
setLastError(realLastError)
|
||||
else:
|
||||
proc threadVarAlloc(): ThreadVarSlot {.
|
||||
importc: "TlsAlloc", stdcall, dynlib: "kernel32".}
|
||||
proc threadVarSetValue(dwTlsIndex: ThreadVarSlot, lpTlsValue: pointer) {.
|
||||
importc: "TlsSetValue", stdcall, dynlib: "kernel32".}
|
||||
proc threadVarGetValue(dwTlsIndex: ThreadVarSlot): pointer {.
|
||||
importc: "TlsGetValue", stdcall, dynlib: "kernel32".}
|
||||
|
||||
proc setThreadAffinityMask(hThread: SysThread, dwThreadAffinityMask: uint) {.
|
||||
importc: "SetThreadAffinityMask", stdcall, header: "<windows.h>".}
|
||||
proc threadVarGetValue(dwTlsIndex: ThreadVarSlot): pointer =
|
||||
let realLastError = getLastError()
|
||||
result = tlsGetValue(dwTlsIndex)
|
||||
setLastError(realLastError)
|
||||
|
||||
elif defined(genode):
|
||||
import genode/env
|
||||
const
|
||||
GenodeHeader = "genode_cpp/threads.h"
|
||||
type
|
||||
SysThread* {.importcpp: "Nim::SysThread",
|
||||
header: GenodeHeader, final, pure.} = object
|
||||
GenodeThreadProc = proc (x: pointer) {.noconv.}
|
||||
ThreadVarSlot = int
|
||||
|
||||
proc initThread(s: var SysThread,
|
||||
env: GenodeEnv,
|
||||
stackSize: culonglong,
|
||||
entry: GenodeThreadProc,
|
||||
arg: pointer,
|
||||
affinity: cuint) {.
|
||||
importcpp: "#.initThread(@)".}
|
||||
type
|
||||
ThreadVarSlot = int
|
||||
|
||||
proc threadVarAlloc(): ThreadVarSlot = 0
|
||||
|
||||
|
|
@ -113,62 +63,18 @@ else:
|
|||
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]
|
||||
ThreadVarSlot {.importc: "pthread_key_t",
|
||||
header: "<sys/types.h>".} = distinct cuint
|
||||
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
|
||||
ThreadVarSlot {.importc: "pthread_key_t",
|
||||
header: "<pthread.h>".} = cint
|
||||
else:
|
||||
type
|
||||
SysThread* {.importc: "pthread_t", header: "<sys/types.h>".} = int
|
||||
Pthread_attr {.importc: "pthread_attr_t",
|
||||
header: "<sys/types.h>".} = object
|
||||
ThreadVarSlot {.importc: "pthread_key_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.}
|
||||
|
||||
proc pthread_getspecific(a1: ThreadVarSlot): pointer {.
|
||||
importc: "pthread_getspecific", header: pthreadh.}
|
||||
|
|
@ -188,59 +94,13 @@ else:
|
|||
proc threadVarGetValue(s: ThreadVarSlot): pointer {.inline.} =
|
||||
result = pthread_getspecific(s)
|
||||
|
||||
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")
|
||||
|
||||
when emulatedThreadVars:
|
||||
# the compiler generates this proc for us, so that we can get the size of
|
||||
# the thread local var block; we use this only for sanity checking though
|
||||
proc nimThreadVarsSize(): int {.noconv, importc: "NimThreadVarsSize".}
|
||||
|
||||
# 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
|
||||
|
||||
|
||||
when emulatedThreadVars:
|
||||
var globalsSlot: ThreadVarSlot
|
||||
|
|
|
|||
|
|
@ -1,390 +0,0 @@
|
|||
#
|
||||
#
|
||||
# Nim's Runtime Library
|
||||
# (c) Copyright 2012 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
#
|
||||
|
||||
## Thread support for Nim.
|
||||
##
|
||||
## **Note**: This is part of the system module. Do not import it directly.
|
||||
## To activate thread support you need to compile
|
||||
## with the `--threads:on`:option: command line switch.
|
||||
##
|
||||
## Nim's memory model for threads is quite different from other common
|
||||
## programming languages (C, Pascal): Each thread has its own
|
||||
## (garbage collected) heap and sharing of memory is restricted. This helps
|
||||
## to prevent race conditions and improves efficiency. See `the manual for
|
||||
## details of this memory model <manual.html#threads>`_.
|
||||
##
|
||||
## Examples
|
||||
## ========
|
||||
##
|
||||
## .. code-block:: Nim
|
||||
##
|
||||
## import std/locks
|
||||
##
|
||||
## var
|
||||
## thr: array[0..4, Thread[tuple[a,b: int]]]
|
||||
## L: Lock
|
||||
##
|
||||
## proc threadFunc(interval: tuple[a,b: int]) {.thread.} =
|
||||
## for i in interval.a..interval.b:
|
||||
## acquire(L) # lock stdout
|
||||
## echo i
|
||||
## release(L)
|
||||
##
|
||||
## initLock(L)
|
||||
##
|
||||
## for i in 0..high(thr):
|
||||
## createThread(thr[i], threadFunc, (i*10, i*10+5))
|
||||
## joinThreads(thr)
|
||||
##
|
||||
## deinitLock(L)
|
||||
|
||||
when not declared(ThisIsSystem):
|
||||
{.error: "You must not import this module explicitly".}
|
||||
|
||||
when defined(nimPreviewSlimSystem):
|
||||
import std/assertions
|
||||
|
||||
const
|
||||
hasAllocStack = defined(zephyr) # maybe freertos too?
|
||||
|
||||
when defined(gcDestructors):
|
||||
proc allocThreadStorage(size: int): pointer =
|
||||
result = c_malloc(csize_t size)
|
||||
zeroMem(result, size)
|
||||
|
||||
proc deallocThreadStorage(p: pointer) = c_free(p)
|
||||
else:
|
||||
template allocThreadStorage(size: untyped): untyped = allocShared0(size)
|
||||
template deallocThreadStorage(p: pointer) = deallocShared(p)
|
||||
|
||||
when hasAllocStack or defined(zephyr) or defined(freertos):
|
||||
const
|
||||
nimThreadStackSize {.intdefine.} = 8192
|
||||
nimThreadStackGuard {.intdefine.} = 128
|
||||
|
||||
StackGuardSize = nimThreadStackGuard
|
||||
ThreadStackSize = nimThreadStackSize - nimThreadStackGuard
|
||||
else:
|
||||
const
|
||||
StackGuardSize = 4096
|
||||
ThreadStackMask =
|
||||
when defined(genode):
|
||||
1024*64*sizeof(int)-1
|
||||
else:
|
||||
1024*256*sizeof(int)-1
|
||||
|
||||
ThreadStackSize = ThreadStackMask+1 - StackGuardSize
|
||||
|
||||
#const globalsSlot = ThreadVarSlot(0)
|
||||
#sysAssert checkSlot.int == globalsSlot.int
|
||||
|
||||
# Zephyr doesn't include this properly without some help
|
||||
when defined(zephyr):
|
||||
{.emit: """/*INCLUDESECTION*/
|
||||
#include <pthread.h>
|
||||
""".}
|
||||
|
||||
# create for the main thread. Note: do not insert this data into the list
|
||||
# of all threads; it's not to be stopped etc.
|
||||
when not defined(useNimRtl):
|
||||
#when not defined(createNimRtl): initStackBottom()
|
||||
when declared(initGC):
|
||||
initGC()
|
||||
when not emulatedThreadVars:
|
||||
type ThreadType {.pure.} = enum
|
||||
None = 0,
|
||||
NimThread = 1,
|
||||
ForeignThread = 2
|
||||
var
|
||||
threadType {.rtlThreadVar.}: ThreadType
|
||||
|
||||
threadType = ThreadType.NimThread
|
||||
|
||||
# We jump through some hops here to ensure that Nim thread procs can have
|
||||
# the Nim calling convention. This is needed because thread procs are
|
||||
# ``stdcall`` on Windows and ``noconv`` on UNIX. Alternative would be to just
|
||||
# use ``stdcall`` since it is mapped to ``noconv`` on UNIX anyway.
|
||||
|
||||
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.}
|
||||
|
||||
var
|
||||
threadDestructionHandlers {.rtlThreadVar.}: seq[proc () {.closure, gcsafe, raises: [].}]
|
||||
|
||||
proc onThreadDestruction*(handler: proc () {.closure, gcsafe, raises: [].}) =
|
||||
## Registers a *thread local* handler that is called at the thread's
|
||||
## destruction.
|
||||
##
|
||||
## A thread is destructed when the `.thread` proc returns
|
||||
## normally or when it raises an exception. Note that unhandled exceptions
|
||||
## in a thread nevertheless cause the whole process to die.
|
||||
threadDestructionHandlers.add handler
|
||||
|
||||
template afterThreadRuns() =
|
||||
for i in countdown(threadDestructionHandlers.len-1, 0):
|
||||
threadDestructionHandlers[i]()
|
||||
|
||||
when not defined(boehmgc) and not hasSharedHeap and not defined(gogc) and not defined(gcRegions):
|
||||
proc deallocOsPages() {.rtl, raises: [].}
|
||||
|
||||
proc threadTrouble() {.raises: [], gcsafe.}
|
||||
## defined in system/excpt.nim
|
||||
|
||||
when defined(boehmgc):
|
||||
type GCStackBaseProc = proc(sb: pointer, t: pointer) {.noconv.}
|
||||
proc boehmGC_call_with_stack_base(sbp: GCStackBaseProc, p: pointer)
|
||||
{.importc: "GC_call_with_stack_base", boehmGC.}
|
||||
proc boehmGC_register_my_thread(sb: pointer)
|
||||
{.importc: "GC_register_my_thread", boehmGC.}
|
||||
proc boehmGC_unregister_my_thread()
|
||||
{.importc: "GC_unregister_my_thread", boehmGC.}
|
||||
|
||||
proc threadProcWrapDispatch[TArg](sb: pointer, thrd: pointer) {.noconv, raises: [].} =
|
||||
boehmGC_register_my_thread(sb)
|
||||
try:
|
||||
let thrd = cast[ptr Thread[TArg]](thrd)
|
||||
when TArg is void:
|
||||
thrd.dataFn()
|
||||
else:
|
||||
thrd.dataFn(thrd.data)
|
||||
except:
|
||||
threadTrouble()
|
||||
finally:
|
||||
afterThreadRuns()
|
||||
boehmGC_unregister_my_thread()
|
||||
else:
|
||||
proc threadProcWrapDispatch[TArg](thrd: ptr Thread[TArg]) {.raises: [].} =
|
||||
try:
|
||||
when TArg is void:
|
||||
thrd.dataFn()
|
||||
else:
|
||||
when defined(nimV2):
|
||||
thrd.dataFn(thrd.data)
|
||||
else:
|
||||
var x: TArg
|
||||
deepCopy(x, thrd.data)
|
||||
thrd.dataFn(x)
|
||||
except:
|
||||
threadTrouble()
|
||||
finally:
|
||||
afterThreadRuns()
|
||||
when hasAllocStack:
|
||||
deallocThreadStorage(thrd.rawStack)
|
||||
|
||||
proc threadProcWrapStackFrame[TArg](thrd: ptr Thread[TArg]) {.raises: [].} =
|
||||
when defined(boehmgc):
|
||||
boehmGC_call_with_stack_base(threadProcWrapDispatch[TArg], thrd)
|
||||
elif not defined(nogc) and not defined(gogc) and not defined(gcRegions) and not usesDestructors:
|
||||
var p {.volatile.}: pointer
|
||||
# init the GC for refc/markandsweep
|
||||
nimGC_setStackBottom(addr(p))
|
||||
initGC()
|
||||
when declared(threadType):
|
||||
threadType = ThreadType.NimThread
|
||||
threadProcWrapDispatch[TArg](thrd)
|
||||
when declared(deallocOsPages): deallocOsPages()
|
||||
else:
|
||||
threadProcWrapDispatch(thrd)
|
||||
|
||||
template threadProcWrapperBody(closure: untyped): untyped =
|
||||
var thrd = cast[ptr Thread[TArg]](closure)
|
||||
var core = thrd.core
|
||||
when declared(globalsSlot): threadVarSetValue(globalsSlot, thrd.core)
|
||||
threadProcWrapStackFrame(thrd)
|
||||
# Since an unhandled exception terminates the whole process (!), there is
|
||||
# no need for a ``try finally`` here, nor would it be correct: The current
|
||||
# exception is tried to be re-raised by the code-gen after the ``finally``!
|
||||
# However this is doomed to fail, because we already unmapped every heap
|
||||
# page!
|
||||
|
||||
# mark as not running anymore:
|
||||
thrd.core = nil
|
||||
thrd.dataFn = nil
|
||||
deallocThreadStorage(cast[pointer](core))
|
||||
|
||||
{.push stack_trace:off.}
|
||||
when defined(windows):
|
||||
proc threadProcWrapper[TArg](closure: pointer): int32 {.stdcall.} =
|
||||
threadProcWrapperBody(closure)
|
||||
# implicitly return 0
|
||||
elif defined(genode):
|
||||
proc threadProcWrapper[TArg](closure: pointer) {.noconv.} =
|
||||
threadProcWrapperBody(closure)
|
||||
else:
|
||||
proc threadProcWrapper[TArg](closure: pointer): pointer {.noconv.} =
|
||||
threadProcWrapperBody(closure)
|
||||
{.pop.}
|
||||
|
||||
proc running*[TArg](t: Thread[TArg]): bool {.inline.} =
|
||||
## Returns true if `t` is running.
|
||||
result = t.dataFn != nil
|
||||
|
||||
proc handle*[TArg](t: Thread[TArg]): SysThread {.inline.} =
|
||||
## Returns the thread handle of `t`.
|
||||
result = t.sys
|
||||
|
||||
when hostOS == "windows":
|
||||
const MAXIMUM_WAIT_OBJECTS = 64
|
||||
|
||||
proc joinThread*[TArg](t: Thread[TArg]) {.inline.} =
|
||||
## Waits for the thread `t` to finish.
|
||||
discard waitForSingleObject(t.sys, -1'i32)
|
||||
|
||||
proc joinThreads*[TArg](t: varargs[Thread[TArg]]) =
|
||||
## Waits for every thread in `t` to finish.
|
||||
var a: array[MAXIMUM_WAIT_OBJECTS, SysThread]
|
||||
var k = 0
|
||||
while k < len(t):
|
||||
var count = min(len(t) - k, MAXIMUM_WAIT_OBJECTS)
|
||||
for i in 0..(count - 1): a[i] = t[i + k].sys
|
||||
discard waitForMultipleObjects(int32(count),
|
||||
cast[ptr SysThread](addr(a)), 1, -1)
|
||||
inc(k, MAXIMUM_WAIT_OBJECTS)
|
||||
|
||||
elif defined(genode):
|
||||
proc joinThread*[TArg](t: Thread[TArg]) {.importcpp.}
|
||||
## Waits for the thread `t` to finish.
|
||||
|
||||
proc joinThreads*[TArg](t: varargs[Thread[TArg]]) =
|
||||
## Waits for every thread in `t` to finish.
|
||||
for i in 0..t.high: joinThread(t[i])
|
||||
|
||||
else:
|
||||
proc joinThread*[TArg](t: Thread[TArg]) {.inline.} =
|
||||
## Waits for the thread `t` to finish.
|
||||
discard pthread_join(t.sys, nil)
|
||||
|
||||
proc joinThreads*[TArg](t: varargs[Thread[TArg]]) =
|
||||
## Waits for every thread in `t` to finish.
|
||||
for i in 0..t.high: joinThread(t[i])
|
||||
|
||||
when false:
|
||||
# XXX a thread should really release its heap here somehow:
|
||||
proc destroyThread*[TArg](t: var Thread[TArg]) =
|
||||
## Forces the thread `t` to terminate. This is potentially dangerous if
|
||||
## you don't have full control over `t` and its acquired resources.
|
||||
when hostOS == "windows":
|
||||
discard TerminateThread(t.sys, 1'i32)
|
||||
else:
|
||||
discard pthread_cancel(t.sys)
|
||||
when declared(registerThread): unregisterThread(addr(t))
|
||||
t.dataFn = nil
|
||||
## if thread `t` already exited, `t.core` will be `null`.
|
||||
if not isNil(t.core):
|
||||
deallocThreadStorage(t.core)
|
||||
t.core = nil
|
||||
|
||||
when hostOS == "windows":
|
||||
proc createThread*[TArg](t: var Thread[TArg],
|
||||
tp: proc (arg: TArg) {.thread, nimcall.},
|
||||
param: TArg) =
|
||||
## Creates a new thread `t` and starts its execution.
|
||||
##
|
||||
## Entry point is the proc `tp`.
|
||||
## `param` is passed to `tp`. `TArg` can be `void` if you
|
||||
## don't need to pass any data to the thread.
|
||||
t.core = cast[PGcThread](allocThreadStorage(sizeof(GcThread)))
|
||||
|
||||
when TArg isnot void: t.data = param
|
||||
t.dataFn = tp
|
||||
when hasSharedHeap: t.core.stackSize = ThreadStackSize
|
||||
var dummyThreadId: int32
|
||||
t.sys = createThread(nil, ThreadStackSize, threadProcWrapper[TArg],
|
||||
addr(t), 0'i32, dummyThreadId)
|
||||
if t.sys <= 0:
|
||||
raise newException(ResourceExhaustedError, "cannot create thread")
|
||||
|
||||
proc pinToCpu*[Arg](t: var Thread[Arg]; cpu: Natural) =
|
||||
## Pins a thread to a `CPU`:idx:.
|
||||
##
|
||||
## In other words sets a thread's `affinity`:idx:.
|
||||
## If you don't know what this means, you shouldn't use this proc.
|
||||
setThreadAffinityMask(t.sys, uint(1 shl cpu))
|
||||
|
||||
elif defined(genode):
|
||||
var affinityOffset: cuint = 1
|
||||
## CPU affinity offset for next thread, safe to roll-over.
|
||||
|
||||
proc createThread*[TArg](t: var Thread[TArg],
|
||||
tp: proc (arg: TArg) {.thread, nimcall.},
|
||||
param: TArg) =
|
||||
t.core = cast[PGcThread](allocThreadStorage(sizeof(GcThread)))
|
||||
|
||||
when TArg isnot void: t.data = param
|
||||
t.dataFn = tp
|
||||
when hasSharedHeap: t.stackSize = ThreadStackSize
|
||||
t.sys.initThread(
|
||||
runtimeEnv,
|
||||
ThreadStackSize.culonglong,
|
||||
threadProcWrapper[TArg], addr(t), affinityOffset)
|
||||
inc affinityOffset
|
||||
|
||||
proc pinToCpu*[Arg](t: var Thread[Arg]; cpu: Natural) =
|
||||
{.hint: "cannot change Genode thread CPU affinity after initialization".}
|
||||
discard
|
||||
|
||||
else:
|
||||
proc createThread*[TArg](t: var Thread[TArg],
|
||||
tp: proc (arg: TArg) {.thread, nimcall.},
|
||||
param: TArg) =
|
||||
## Creates a new thread `t` and starts its execution.
|
||||
##
|
||||
## Entry point is the proc `tp`. `param` is passed to `tp`.
|
||||
## `TArg` can be `void` if you
|
||||
## don't need to pass any data to the thread.
|
||||
t.core = cast[PGcThread](allocThreadStorage(sizeof(GcThread)))
|
||||
|
||||
when TArg isnot void: t.data = param
|
||||
t.dataFn = tp
|
||||
when hasSharedHeap: t.core.stackSize = ThreadStackSize
|
||||
var a {.noinit.}: Pthread_attr
|
||||
doAssert pthread_attr_init(a) == 0
|
||||
when hasAllocStack:
|
||||
var
|
||||
rawstk = allocThreadStorage(ThreadStackSize + StackGuardSize)
|
||||
stk = cast[pointer](cast[uint](rawstk) + StackGuardSize)
|
||||
let setstacksizeResult = pthread_attr_setstack(addr a, stk, ThreadStackSize)
|
||||
t.rawStack = rawstk
|
||||
else:
|
||||
let setstacksizeResult = pthread_attr_setstacksize(a, ThreadStackSize)
|
||||
|
||||
when not defined(ios):
|
||||
# This fails on iOS
|
||||
doAssert(setstacksizeResult == 0)
|
||||
if pthread_create(t.sys, a, threadProcWrapper[TArg], addr(t)) != 0:
|
||||
raise newException(ResourceExhaustedError, "cannot create thread")
|
||||
doAssert pthread_attr_destroy(a) == 0
|
||||
|
||||
proc pinToCpu*[Arg](t: var Thread[Arg]; cpu: Natural) =
|
||||
## Pins a thread to a `CPU`:idx:.
|
||||
##
|
||||
## In other words sets a thread's `affinity`:idx:.
|
||||
## If you don't know what this means, you shouldn't use this proc.
|
||||
when not defined(macosx):
|
||||
var s {.noinit.}: CpuSet
|
||||
cpusetZero(s)
|
||||
cpusetIncl(cpu.cint, s)
|
||||
setAffinity(t.sys, csize_t(sizeof(s)), s)
|
||||
|
||||
proc createThread*(t: var Thread[void], tp: proc () {.thread, nimcall.}) =
|
||||
createThread[void](t, tp)
|
||||
|
||||
when not defined(gcOrc):
|
||||
include threadids
|
||||
Loading…
Add table
Add a link
Reference in a new issue