blob: 4d440602725dccb1b046e897d2b355f7ee4cd325 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using Microsoft.Win32.SafeHandles;
using System;
using System.Diagnostics;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Threading;
namespace Internal.Runtime.Augments
{
public sealed partial class RuntimeThread
{
// Event signaling that the thread has stopped
private ManualResetEvent _stopped;
private readonly WaitSubsystem.ThreadWaitInfo _waitInfo;
internal WaitSubsystem.ThreadWaitInfo WaitInfo => _waitInfo;
private void PlatformSpecificInitialize()
{
RuntimeImports.RhSetThreadExitCallback(AddrofIntrinsics.AddrOf<Action>(OnThreadExit));
}
// Platform-specific initialization of foreign threads, i.e. threads not created by Thread.Start
private void PlatformSpecificInitializeExistingThread()
{
_stopped = new ManualResetEvent(false);
}
/// <summary>
/// Callers must ensure to clear and return the array after use
/// </summary>
internal SafeWaitHandle[] RentWaitedSafeWaitHandleArray(int requiredCapacity)
{
Debug.Assert(this == CurrentThread);
Debug.Assert(!ReentrantWaitsEnabled); // due to this, no need to actually rent and return the array
_waitedSafeWaitHandles.VerifyElementsAreDefault();
_waitedSafeWaitHandles.EnsureCapacity(requiredCapacity);
return _waitedSafeWaitHandles.Items;
}
internal void ReturnWaitedSafeWaitHandleArray(SafeWaitHandle[] waitedSafeWaitHandles)
{
Debug.Assert(this == CurrentThread);
Debug.Assert(!ReentrantWaitsEnabled); // due to this, no need to actually rent and return the array
Debug.Assert(waitedSafeWaitHandles == _waitedSafeWaitHandles.Items);
}
private ThreadPriority GetPriorityLive()
{
return ThreadPriority.Normal;
}
private bool SetPriorityLive(ThreadPriority priority)
{
return true;
}
[NativeCallable]
private static void OnThreadExit()
{
RuntimeThread currentThread = t_currentThread;
if (currentThread != null)
{
// Inform the wait subsystem that the thread is exiting. For instance, this would abandon any mutexes locked by
// the thread.
WaitSubsystem.OnThreadExiting(currentThread);
// Set the Stopped bit and signal the current thread as stopped
int state = currentThread._threadState;
if ((state & (int)(ThreadState.Stopped | ThreadState.Aborted)) == 0)
{
currentThread.SetThreadStateBit(ThreadState.Stopped);
}
currentThread._stopped.Set();
}
}
private ThreadState GetThreadState() => (ThreadState)_threadState;
private bool JoinInternal(int millisecondsTimeout)
{
// This method assumes the thread has been started
Debug.Assert(!GetThreadStateBit(ThreadState.Unstarted) || (millisecondsTimeout == 0));
SafeWaitHandle waitHandle = _stopped.SafeWaitHandle;
// If an OS thread is terminated and its Thread object is resurrected, waitHandle may be finalized and closed
if (waitHandle.IsClosed)
{
return true;
}
// Prevent race condition with the finalizer
try
{
waitHandle.DangerousAddRef();
}
catch (ObjectDisposedException)
{
return true;
}
try
{
return _stopped.WaitOne(millisecondsTimeout);
}
finally
{
waitHandle.DangerousRelease();
}
}
private bool CreateThread(GCHandle thisThreadHandle)
{
// Create the Stop event before starting the thread to make sure
// it is ready to be signaled at thread shutdown time.
// This also avoids OOM after creating the thread.
_stopped = new ManualResetEvent(false);
if (!Interop.Sys.RuntimeThread_CreateThread((IntPtr)_maxStackSize,
AddrofIntrinsics.AddrOf<Interop.Sys.ThreadProc>(ThreadEntryPoint), (IntPtr)thisThreadHandle))
{
return false;
}
// CoreCLR ignores OS errors while setting the priority, so do we
SetPriorityLive(_priority);
return true;
}
/// <summary>
/// This is an entry point for managed threads created by application
/// </summary>
[NativeCallable]
private static IntPtr ThreadEntryPoint(IntPtr parameter)
{
StartThread(parameter);
return IntPtr.Zero;
}
public void Interrupt() => WaitSubsystem.Interrupt(this);
internal static void UninterruptibleSleep0() => WaitSubsystem.UninterruptibleSleep0();
private static void SleepInternal(int millisecondsTimeout) => WaitSubsystem.Sleep(millisecondsTimeout);
internal const bool ReentrantWaitsEnabled = false;
internal static void SuppressReentrantWaits()
{
throw new PlatformNotSupportedException();
}
internal static void RestoreReentrantWaits()
{
throw new PlatformNotSupportedException();
}
private static int ComputeCurrentProcessorId()
{
int processorId = Interop.Sys.SchedGetCpu();
// sched_getcpu doesn't exist on all platforms. On those it doesn't exist on, the shim
// returns -1. As a fallback in that case and to spread the threads across the buckets
// by default, we use the current managed thread ID as a proxy.
if (processorId < 0) processorId = Environment.CurrentManagedThreadId;
return processorId;
}
}
}
|
