jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

move threads out of system (#20674)

Browse source 
* 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 2022-10-30 00:11:40 +08:00 • committed by GitHub
commit 1dab8ba334
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 424 additions and 390 deletions
Download patch file Download diff file Expand all files Collapse all files

234
lib/std/private/syslocks.nim Normal file
View 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
View 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.}

276
lib/std/threads.nim Normal file
View file

@ -0,0 +1,276 @@
#
#
# 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.
##
## 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)
import std/private/[threadtypes]
export Thread
import system/ansi_c
when defined(nimPreviewSlimSystem):
import std/assertions
when defined(genode):
import genode/env
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
when defined(gcDestructors):
proc allocThreadStorage(size: int): pointer =
result = c_malloc(csize_t size)
zeroMem(result, size)
else:
template allocThreadStorage(size: untyped): untyped = allocShared0(size)
#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>
""".}
# 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.
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.
nimThreadDestructionHandlers.add handler
{.push stack_trace:off.}
when defined(windows):
proc threadProcWrapper[TArg](closure: pointer): int32 {.stdcall.} =
nimThreadProcWrapperBody(closure)
# implicitly return 0
elif defined(genode):
proc threadProcWrapper[TArg](closure: pointer) {.noconv.} =
nimThreadProcWrapperBody(closure)
else:
proc threadProcWrapper[TArg](closure: pointer): pointer {.noconv.} =
nimThreadProcWrapperBody(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 system/threadids