We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Threading \ Thread

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*=============================================================================
  16. **
  17. ** Class: Thread
  18. **
  19. **
  20. ** Purpose: Class for creating and managing a thread.
  21. **
  22. **
  23. =============================================================================*/
  25. namespace System.Threading
  26. {
  27.     using System.Threading;
  28.     using System.Runtime.InteropServices;
  29.     using System.Runtime.Remoting.Contexts;
  30.     using System.Runtime.Remoting.Messaging;
  31.     using System;
  32.     using System.Diagnostics;
  33.     using System.Security.Permissions;
  34.     using System.Security.Principal;
  35.     using System.Globalization;
  36.     using System.Collections.Generic;
  37.     using System.Runtime.Serialization;
  38.     using System.Runtime.CompilerServices;
  39.     using System.Runtime.ConstrainedExecution;
  40.     using System.Security;
  41.     using System.Runtime.Versioning;
  42.    
  43.     internal delegate object InternalCrossContextDelegate(object[] args);
  44.    
  45.     internal class ThreadHelper
  46.     {
  47.         Delegate _start;
  48.         object _startArg = null;
  49.         ExecutionContext _executionContext = null;
  50.         internal ThreadHelper(Delegate start)
  51.         {
  52.             _start = start;
  53.         }
  54.        
  55.         internal void SetExecutionContextHelper(ExecutionContext ec)
  56.         {
  57.             _executionContext = ec;
  58.         }
  59.         static internal ContextCallback _ccb = new ContextCallback(ThreadStart_Context);
  60.         static internal void ThreadStart_Context(object state)
  61.         {
  62.             ThreadHelper t = (ThreadHelper)state;
  63.             if (t._start is ThreadStart) {
  64.                 ((ThreadStart)t._start)();
  65.             }
  66.             else {
  67.                 ((ParameterizedThreadStart)t._start)(t._startArg);
  68.             }
  69.         }
  70.        
  71.         // call back helper
  72.         internal void ThreadStart(object obj)
  73.         {
  74.             _startArg = obj;
  75.             if (_executionContext != null) {
  76.                 ExecutionContext.Run(_executionContext, _ccb, (object)this);
  77.             }
  78.             else {
  79.                 ((ParameterizedThreadStart)_start)(obj);
  80.             }
  81.         }
  82.        
  83.         // call back helper
  84.         internal void ThreadStart()
  85.         {
  86.             if (_executionContext != null) {
  87.                 ExecutionContext.Run(_executionContext, _ccb, (object)this);
  88.             }
  89.             else {
  90.                 ((ThreadStart)_start)();
  91.             }
  92.         }
  93.     }
  94.    
  95.     // deliberately not [serializable]
  96.     [ClassInterface(ClassInterfaceType.None)]
  97.     [ComDefaultInterface(typeof(_Thread))]
  98.     [System.Runtime.InteropServices.ComVisible(true)]
  99.     public sealed class Thread : CriticalFinalizerObject, _Thread
  100.     {
  101. /*=========================================================================
  102.         ** Data accessed from managed code that needs to be defined in
  103.         ** ThreadBaseObject to maintain alignment between the two classes.
  104.         ** DON'T CHANGE THESE UNLESS YOU MODIFY ThreadBaseObject in vm\object.h
  105.         =========================================================================*/       
  106.         private Context m_Context;
  107.        
  108.         private ExecutionContext m_ExecutionContext;
  109.         // this call context follows the logical thread
  110.         private string m_Name;
  111.         private Delegate m_Delegate;
  112.         // Delegate
  113.         private object[][] m_ThreadStaticsBuckets;
  114.         // Holder for thread statics
  115.         private int[] m_ThreadStaticsBits;
  116.         // Bit-markers for slot availability
  117.         private CultureInfo m_CurrentCulture;
  118.         private CultureInfo m_CurrentUICulture;
  119.         private object m_ThreadStartArg;
  120.        
  121. /*=========================================================================
  122.         ** The base implementation of Thread is all native.  The following fields
  123.         ** should never be used in the C# code.  They are here to define the proper
  124.         ** space so the thread object may be allocated.  DON'T CHANGE THESE UNLESS
  125.         ** YOU MODIFY ThreadBaseObject in vm\object.h
  126.         =========================================================================*/       
  127.         #pragma warning disable 169
  128.         #pragma warning disable 414 // These fields are not used from managed.
  129.         // IntPtrs need to be together, and before ints, because IntPtrs are 64-bit
  130.         // fields on 64-bit platforms, where they will be sorted together.
  131.        
  132.         private IntPtr DONT_USE_InternalThread;
  133.         // Pointer
  134.         private int m_Priority;
  135.         // INT32
  136.         #pragma warning restore 414
  137.         #pragma warning restore 169
  138. /*=========================================================================
  139.         ** This manager is responsible for storing the global data that is
  140.         ** shared amongst all the thread local stores.
  141.         =========================================================================*/       
  142.         private static LocalDataStoreMgr s_LocalDataStoreMgr = null;
  143.         private static object s_SyncObject = new object();
  144.        
  145.         // Has to be in sync with THREAD_STATICS_BUCKET_SIZE in vm/threads.cpp
  146.         private const int STATICS_BUCKET_SIZE = 32;
  147.        
  148. /*=========================================================================
  149.         ** Creates a new Thread object which will begin execution at
  150.         ** start.ThreadStart on a new thread when the Start method is called.
  151.         **
  152.         ** Exceptions: ArgumentNullException if start == null.
  153.         =========================================================================*/       
  154.         public Thread(ThreadStart start)
  155.         {
  156.             if (start == null) {
  157.                 throw new ArgumentNullException("start");
  158.             }
  159.             SetStartHelper((Delegate)start, 0);
  160.             //0 will setup Thread with default stackSize
  161.         }
  162.        
  163.         public Thread(ThreadStart start, int maxStackSize)
  164.         {
  165.             if (start == null) {
  166.                 throw new ArgumentNullException("start");
  167.             }
  168.             if (0 > maxStackSize)
  169.                 throw new ArgumentOutOfRangeException("maxStackSize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  170.             SetStartHelper((Delegate)start, maxStackSize);
  171.         }
  172.         public Thread(ParameterizedThreadStart start)
  173.         {
  174.             if (start == null) {
  175.                 throw new ArgumentNullException("start");
  176.             }
  177.             SetStartHelper((Delegate)start, 0);
  178.         }
  179.        
  180.         public Thread(ParameterizedThreadStart start, int maxStackSize)
  181.         {
  182.             if (start == null) {
  183.                 throw new ArgumentNullException("start");
  184.             }
  185.             if (0 > maxStackSize)
  186.                 throw new ArgumentOutOfRangeException("maxStackSize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  187.             SetStartHelper((Delegate)start, maxStackSize);
  188.         }
  189.        
  190.         [ComVisible(false), MethodImplAttribute(MethodImplOptions.InternalCall)]
  191.         public override extern int GetHashCode();
  192.        
  193.         public extern int ManagedThreadId {
  194.             [MethodImplAttribute(MethodImplOptions.InternalCall)]
  195.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  196.             get;
  197.         }
  198.        
  199. /*=========================================================================
  200.         ** Spawns off a new thread which will begin executing at the ThreadStart
  201.         ** method on the IThreadable interface passed in the constructor. Once the
  202.         ** thread is dead, it cannot be restarted with another call to Start.
  203.         **
  204.         ** Exceptions: ThreadStateException if the thread has already been started.
  205.         =========================================================================*/       
  206.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  207.         public void Start()
  208.         {
  209.            
  210.             // Attach current thread's security principal object to the new
  211.             // thread. Be careful not to bind the current thread to a principal
  212.             // if it's not already bound.
  213.             if (m_Delegate != null) {
  214.                 ThreadHelper t = (ThreadHelper)(m_Delegate.Target);
  215.                 ExecutionContext ec = ExecutionContext.Capture();
  216.                 ExecutionContext.ClearSyncContext(ec);
  217.                 t.SetExecutionContextHelper(ec);
  218.             }
  219.             IPrincipal principal = (IPrincipal)CallContext.Principal;
  220.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  221.             StartInternal(principal, ref stackMark);
  222.         }
  223.        
  224.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  225.         public void Start(object parameter)
  226.         {
  227.             //In the case of a null delegate (second call to start on same thread)
  228.             // StartInternal method will take care of the error reporting
  229.             if (m_Delegate is ThreadStart) {
  230.                 //We expect the thread to be setup with a ParameterizedThreadStart
  231.                 // if this constructor is called.
  232.                 //If we got here then that wasn't the case
  233.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ThreadWrongThreadStart"));
  234.             }
  235.             m_ThreadStartArg = parameter;
  236.             Start();
  237.         }
  238.        
  239.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  240.         internal ExecutionContext GetExecutionContextNoCreate()
  241.         {
  242.             return m_ExecutionContext;
  243.         }
  244.        
  245.        
  246.        
  247.         public ExecutionContext ExecutionContext {
  248.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  249.             get {
  250.                 if (m_ExecutionContext == null && this == Thread.CurrentThread) {
  251.                     m_ExecutionContext = new ExecutionContext();
  252.                     m_ExecutionContext.Thread = this;
  253.                 }
  254.                 return m_ExecutionContext;
  255.             }
  256.         }
  257.        
  258.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  259.         internal void SetExecutionContext(ExecutionContext value)
  260.         {
  261.             m_ExecutionContext = value;
  262.             if (value != null)
  263.                 m_ExecutionContext.Thread = this;
  264.         }
  265.        
  266.        
  267.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  268.         private extern void StartInternal(IPrincipal principal, ref StackCrawlMark stackMark);
  269.        
  270.         /// <internalonly/>
  271.         [StrongNameIdentityPermissionAttribute(SecurityAction.LinkDemand, PublicKey = "0x00000000000000000400000000000000"), SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode), DynamicSecurityMethodAttribute()]
  272.         [Obsolete("Thread.SetCompressedStack is no longer supported. Please use the System.Threading.CompressedStack class")]
  273.         public void SetCompressedStack(CompressedStack stack)
  274.         {
  275.             throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ThreadAPIsNotSupported"));
  276.         }
  277.        
  278.         [MethodImplAttribute(MethodImplOptions.InternalCall), ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  279.         internal extern IntPtr SetAppDomainStack(SafeCompressedStackHandle csHandle);
  280.        
  281.         [MethodImplAttribute(MethodImplOptions.InternalCall), ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  282.         internal extern void RestoreAppDomainStack(IntPtr appDomainStack);
  283.        
  284.        
  285.         /// <internalonly/>
  286.         [StrongNameIdentityPermissionAttribute(SecurityAction.LinkDemand, PublicKey = "0x00000000000000000400000000000000"), SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  287.         [Obsolete("Thread.GetCompressedStack is no longer supported. Please use the System.Threading.CompressedStack class")]
  288.         public CompressedStack GetCompressedStack()
  289.         {
  290.             throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ThreadAPIsNotSupported"));
  291.         }
  292.        
  293.        
  294.         // Helper method to get a logical thread ID for StringBuilder (for
  295.         // correctness) and for FileStream's async code path (for perf, to
  296.         // avoid creating a Thread instance).
  297.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  298.         static internal extern IntPtr InternalGetCurrentThread();
  299.        
  300. /*=========================================================================
  301.         ** Raises a ThreadAbortException in the thread, which usually
  302.         ** results in the thread's death. The ThreadAbortException is a special
  303.         ** exception that is not catchable. The finally clauses of all try
  304.         ** statements will be executed before the thread dies. This includes the
  305.         ** finally that a thread might be executing at the moment the Abort is raised.
  306.         ** The thread is not stopped immediately--you must Join on the
  307.         ** thread to guarantee it has stopped.
  308.         ** It is possible for a thread to do an unbounded amount of computation in
  309.         ** the finally's and thus indefinitely delay the threads death.
  310.         ** If Abort() is called on a thread that has not been started, the thread
  311.         ** will abort when Start() is called.
  312.         ** If Abort is called twice on the same thread, a DuplicateThreadAbort
  313.         ** exception is thrown.
  314.         =========================================================================*/       
  315.        
  316.         [SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)]
  317.         public void Abort(object stateInfo)
  318.         {
  319.             // If two aborts come at the same time, it is possible that the state info
  320.             // gets set by one, and the actual abort gets delivered by another. But this
  321.             // is not distinguishable by an application.
  322.             // The accessor helper will only set the value if it isn't already set,
  323.             // and that particular bit of native code can test much faster than this
  324.             // code could, because testing might cause a cross-appdomain marshalling.
  325.             AbortReason = stateInfo;
  326.            
  327.             // Note: we demand ControlThread permission, then call AbortInternal directly
  328.             // rather than delegating to the Abort() function below. We do this to ensure
  329.             // that only callers with ControlThread are allowed to change the AbortReason
  330.             // of the thread. We call AbortInternal directly to avoid demanding the same
  331.             // permission twice.
  332.             AbortInternal();
  333.         }
  334.        
  335.         [SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)]
  336.         public void Abort()
  337.         {
  338.             AbortInternal();
  339.         }
  340.        
  341.         // Internal helper (since we can't place security demands on
  342.         // ecalls/fcalls).
  343.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  344.         private extern void AbortInternal();
  345.        
  346. /*=========================================================================
  347.         ** Resets a thread abort.
  348.         ** Should be called by trusted code only
  349.           =========================================================================*/       
  350.         [SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)]
  351.         public static void ResetAbort()
  352.         {
  353.             Thread thread = Thread.CurrentThread;
  354.             if ((thread.ThreadState & ThreadState.AbortRequested) == 0)
  355.                 throw new ThreadStateException(Environment.GetResourceString("ThreadState_NoAbortRequested"));
  356.             thread.ResetAbortNative();
  357.             thread.ClearAbortReason();
  358.         }
  359.        
  360.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  361.         private extern void ResetAbortNative();
  362.        
  363. /*=========================================================================
  364.         ** Suspends the thread. If the thread is already suspended, this call has
  365.         ** no effect.
  366.         **
  367.         ** Exceptions: ThreadStateException if the thread has not been started or
  368.         **            it is dead.
  369.         =========================================================================*/       
  370.         [Obsolete("Thread.Suspend has been deprecated. Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources. http://go.microsoft.com/fwlink/?linkid=14202", false)]
  371.         [SecurityPermission(SecurityAction.Demand, ControlThread = true)]
  372.         [SecurityPermission(SecurityAction.Demand, ControlThread = true)]
  373.         public void Suspend()
  374.         {
  375.             SuspendInternal();
  376.         }
  377.        
  378.         // Internal helper (since we can't place security demands on
  379.         // ecalls/fcalls).
  380.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  381.         private extern void SuspendInternal();
  382.        
  383. /*=========================================================================
  384.         ** Resumes a thread that has been suspended.
  385.         **
  386.         ** Exceptions: ThreadStateException if the thread has not been started or
  387.         **            it is dead or it isn't in the suspended state.
  388.         =========================================================================*/       
  389.         [Obsolete("Thread.Resume has been deprecated. Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources. http://go.microsoft.com/fwlink/?linkid=14202", false)]
  390.         [SecurityPermission(SecurityAction.Demand, ControlThread = true)]
  391.         public void Resume()
  392.         {
  393.             ResumeInternal();
  394.         }
  395.        
  396.         // Internal helper (since we can't place security demands on
  397.         // ecalls/fcalls).
  398.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  399.         private extern void ResumeInternal();
  400.        
  401. /*=========================================================================
  402.         ** Interrupts a thread that is inside a Wait(), Sleep() or Join().  If that
  403.         ** thread is not currently blocked in that manner, it will be interrupted
  404.         ** when it next begins to block.
  405.         =========================================================================*/       
  406.         [SecurityPermission(SecurityAction.Demand, ControlThread = true)]
  407.         public void Interrupt()
  408.         {
  409.             InterruptInternal();
  410.         }
  411.        
  412.         // Internal helper (since we can't place security demands on
  413.         // ecalls/fcalls).
  414.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  415.         private extern void InterruptInternal();
  416.        
  417. /*=========================================================================
  418.         ** Returns the priority of the thread.
  419.         **
  420.         ** Exceptions: ThreadStateException if the thread is dead.
  421.         =========================================================================*/       
  422.         public ThreadPriority Priority {
  423.             get { return (ThreadPriority)GetPriorityNative(); }
  424.             [HostProtection(SelfAffectingThreading = true)]
  425.             set { SetPriorityNative((int)value); }
  426.         }
  427.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  428.         private extern int GetPriorityNative();
  429.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  430.         private extern void SetPriorityNative(int priority);
  431.        
  432. /*=========================================================================
  433.         ** Returns true if the thread has been started and is not dead.
  434.         =========================================================================*/       
  435.         public bool IsAlive {
  436.             get { return IsAliveNative(); }
  437.         }
  438.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  439.         private extern bool IsAliveNative();
  440.        
  441. /*=========================================================================
  442.         ** Returns true if the thread is a threadpool thread.
  443.         =========================================================================*/       
  444.         public bool IsThreadPoolThread {
  445.             get { return IsThreadpoolThreadNative(); }
  446.         }
  447.        
  448.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  449.         private extern bool IsThreadpoolThreadNative();
  450.        
  451. /*=========================================================================
  452.         ** Waits for the thread to die.
  453.         **
  454.         ** Exceptions: ThreadInterruptedException if the thread is interrupted while waiting.
  455.         **            ThreadStateException if the thread has not been started yet.
  456.         =========================================================================*/       
  457.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  458.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  459.         private extern void JoinInternal();
  460.        
  461.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  462.         public void Join()
  463.         {
  464.             JoinInternal();
  465.         }
  466.        
  467. /*=========================================================================
  468.         ** Waits for the thread to die or for timeout milliseconds to elapse.
  469.         ** Returns true if the thread died, or false if the wait timed out. If
  470.         ** Timeout.Infinite is given as the parameter, no timeout will occur.
  471.         **
  472.         ** Exceptions: ArgumentException if timeout < 0.
  473.         **            ThreadInterruptedException if the thread is interrupted while waiting.
  474.         **            ThreadStateException if the thread has not been started yet.
  475.         =========================================================================*/       
  476.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  477.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  478.         private extern bool JoinInternal(int millisecondsTimeout);
  479.        
  480.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  481.         public bool Join(int millisecondsTimeout)
  482.         {
  483.             return JoinInternal(millisecondsTimeout);
  484.         }
  485.        
  486.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  487.         public bool Join(TimeSpan timeout)
  488.         {
  489.             long tm = (long)timeout.TotalMilliseconds;
  490.             if (tm < -1 || tm > (long)Int32.MaxValue)
  491.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  492.            
  493.             return Join((int)tm);
  494.         }
  495.        
  496. /*=========================================================================
  497.         ** Suspends the current thread for timeout milliseconds. If timeout == 0,
  498.         ** forces the thread to give up the remainer of its timeslice.  If timeout
  499.         ** == Timeout.Infinite, no timeout will occur.
  500.         **
  501.         ** Exceptions: ArgumentException if timeout < 0.
  502.         **            ThreadInterruptedException if the thread is interrupted while sleeping.
  503.         =========================================================================*/       
  504.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  505.         private static extern void SleepInternal(int millisecondsTimeout);
  506.        
  507.         public static void Sleep(int millisecondsTimeout)
  508.         {
  509.             SleepInternal(millisecondsTimeout);
  510.         }
  511.        
  512.         public static void Sleep(TimeSpan timeout)
  513.         {
  514.             long tm = (long)timeout.TotalMilliseconds;
  515.             if (tm < -1 || tm > (long)Int32.MaxValue)
  516.                 throw new ArgumentOutOfRangeException("timeout", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
  517.             Sleep((int)tm);
  518.         }
  519.        
  520.        
  521. /* wait for a length of time proportial to 'iterations'.  Each iteration is should
  522.           only take a few machine instructions.  Calling this API is preferable to coding
  523.           a explict busy loop because the hardware can be informed that it is busy waiting. */       
  524.        
  525.         [MethodImplAttribute(MethodImplOptions.InternalCall), HostProtection(Synchronization = true, ExternalThreading = true), ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  526.         private static extern void SpinWaitInternal(int iterations);
  527.        
  528.         [HostProtection(Synchronization = true, ExternalThreading = true), ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  529.         public static void SpinWait(int iterations)
  530.         {
  531.             SpinWaitInternal(iterations);
  532.         }
  533.        
  534.        
  535.         public static Thread CurrentThread {
  536.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  537.             get {
  538.                 Thread th;
  539.                 th = GetFastCurrentThreadNative();
  540.                 if (th == null)
  541.                     th = GetCurrentThreadNative();
  542.                 return th;
  543.             }
  544.         }
  545.         [MethodImplAttribute(MethodImplOptions.InternalCall), ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  546.         private static extern Thread GetCurrentThreadNative();
  547.         [MethodImplAttribute(MethodImplOptions.InternalCall), ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  548.         private static extern Thread GetFastCurrentThreadNative();
  549.        
  550.         private void SetStartHelper(Delegate start, int maxStackSize)
  551.         {
  552.             ThreadHelper threadStartCallBack = new ThreadHelper(start);
  553.             if (start is ThreadStart) {
  554.                 SetStart(new ThreadStart(threadStartCallBack.ThreadStart), maxStackSize);
  555.             }
  556.             else {
  557.                 SetStart(new ParameterizedThreadStart(threadStartCallBack.ThreadStart), maxStackSize);
  558.             }
  559.         }
  560.        
  561. /*=========================================================================
  562.         ** PRIVATE Sets the IThreadable interface for the thread. Assumes that
  563.         ** start != null.
  564.         =========================================================================*/       
  565.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  566.         private extern void SetStart(Delegate start, int maxStackSize);
  567.        
  568. /*=========================================================================
  569.         ** Clean up the thread when it goes away.
  570.         =========================================================================*/       
  571.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  572.         ~Thread()
  573.         {
  574.             // Delegate to the unmanaged portion.
  575.             InternalFinalize();
  576.         }
  577.        
  578.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  579.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  580.         private extern void InternalFinalize();
  581.        
  582.        
  583. /*=========================================================================
  584.         ** Return whether or not this thread is a background thread.  Background
  585.         ** threads do not affect when the Execution Engine shuts down.
  586.         **
  587.         ** Exceptions: ThreadStateException if the thread is dead.
  588.         =========================================================================*/       
  589.         public bool IsBackground {
  590.             get { return IsBackgroundNative(); }
  591.             [HostProtection(SelfAffectingThreading = true)]
  592.             set { SetBackgroundNative(value); }
  593.         }
  594.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  595.         private extern bool IsBackgroundNative();
  596.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  597.         private extern void SetBackgroundNative(bool isBackground);
  598.        
  599.        
  600. /*=========================================================================
  601.         ** Return the thread state as a consistent set of bits.  This is more
  602.         ** general then IsAlive or IsBackground.
  603.         =========================================================================*/       
  604.         public ThreadState ThreadState {
  605.             get { return (ThreadState)GetThreadStateNative(); }
  606.         }
  607.        
  608.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  609.         private extern int GetThreadStateNative();
  610.        
  611.        
  612. /*=========================================================================
  613.         ** Allocates an un-named data slot. The slot is allocated on ALL the
  614.         ** threads.
  615.         =========================================================================*/       
  616.         [HostProtection(SharedState = true, ExternalThreading = true)]
  617.         public static LocalDataStoreSlot AllocateDataSlot()
  618.         {
  619.             return LocalDataStoreManager.AllocateDataSlot();
  620.         }
  621.        
  622. /*=========================================================================
  623.         ** Allocates a named data slot. The slot is allocated on ALL the
  624.         ** threads.  Named data slots are "public" and can be manipulated by
  625.         ** anyone.
  626.         =========================================================================*/       
  627.         [HostProtection(SharedState = true, ExternalThreading = true)]
  628.         public static LocalDataStoreSlot AllocateNamedDataSlot(string name)
  629.         {
  630.             return LocalDataStoreManager.AllocateNamedDataSlot(name);
  631.         }
  632.        
  633. /*=========================================================================
  634.         ** Looks up a named data slot. If the name has not been used, a new slot is
  635.         ** allocated.  Named data slots are "public" and can be manipulated by
  636.         ** anyone.
  637.         =========================================================================*/       
  638.         [HostProtection(SharedState = true, ExternalThreading = true)]
  639.         public static LocalDataStoreSlot GetNamedDataSlot(string name)
  640.         {
  641.             return LocalDataStoreManager.GetNamedDataSlot(name);
  642.         }
  643.        
  644. /*=========================================================================
  645.         ** Frees a named data slot. The slot is allocated on ALL the
  646.         ** threads.  Named data slots are "public" and can be manipulated by
  647.         ** anyone.
  648.         =========================================================================*/       
  649.         [HostProtection(SharedState = true, ExternalThreading = true)]
  650.         public static void FreeNamedDataSlot(string name)
  651.         {
  652.             LocalDataStoreManager.FreeNamedDataSlot(name);
  653.         }
  654.        
  655. /*=========================================================================
  656.         ** Retrieves the value from the specified slot on the current thread, for that thread's current domain.
  657.         =========================================================================*/       
  658.         [HostProtection(SharedState = true, ExternalThreading = true)]
  659.         [ResourceExposure(ResourceScope.AppDomain)]
  660.         public static object GetData(LocalDataStoreSlot slot)
  661.         {
  662.             LocalDataStoreManager.ValidateSlot(slot);
  663.            
  664.             LocalDataStore dls = GetDomainLocalStore();
  665.             if (dls == null)
  666.                 return null;
  667.            
  668.             return dls.GetData(slot);
  669.         }
  670.        
  671. /*=========================================================================
  672.         ** Sets the data in the specified slot on the currently running thread, for that thread's current domain.
  673.         =========================================================================*/       
  674.         [HostProtection(SharedState = true, ExternalThreading = true)]
  675.         [ResourceExposure(ResourceScope.AppDomain)]
  676.         public static void SetData(LocalDataStoreSlot slot, object data)
  677.         {
  678.             LocalDataStore dls = GetDomainLocalStore();
  679.            
  680.             // Create new DLS if one hasn't been created for this domain for this thread
  681.             if (dls == null) {
  682.                 dls = LocalDataStoreManager.CreateLocalDataStore();
  683.                 SetDomainLocalStore(dls);
  684.             }
  685.            
  686.             dls.SetData(slot, data);
  687.         }
  688.        
  689.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  690.         [ResourceExposure(ResourceScope.AppDomain)]
  691.         private static extern LocalDataStore GetDomainLocalStore();
  692.        
  693.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  694.         [ResourceExposure(ResourceScope.AppDomain)]
  695.         private static extern void SetDomainLocalStore(LocalDataStore dls);
  696.        
  697. /***
  698.         * An appdomain has been unloaded - remove its DLS from the manager
  699.         */       
  700.         private static void RemoveDomainLocalStore(LocalDataStore dls)
  701.         {
  702.             if (dls != null)
  703.                 LocalDataStoreManager.DeleteLocalDataStore(dls);
  704.         }
  705.        
  706.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  707.         private static extern bool nativeGetSafeCulture(Thread t, int appDomainId, bool isUI, ref CultureInfo safeCulture);
  708.        
  709.         // As the culture can be customized object then we cannot hold any
  710.         // reference to it before we check if it is safe because the app domain
  711.         // owning this customized culture may get unloaded while executing this
  712.         // code. To achieve that we have to do the check using nativeGetSafeCulture
  713.         // as the thread cannot get interrupted during the FCALL.
  714.         // If the culture is safe (not customized or created in current app domain)
  715.         // then the FCALL will return a reference to that culture otherwise the
  716.         // FCALL will return failure. In case of failure we'll return the default culture.
  717.         // If the app domain owning a customized culture that is set to teh thread and this
  718.         // app domain get unloaded there is a code to clean up the culture from the thread
  719.         // using the code in AppDomain::ReleaseDomainStores.
  720.        
  721.         public CultureInfo CurrentUICulture {
  722.             get {
  723.                 // Fetch a local copy of m_CurrentUICulture to
  724.                 // avoid races that malicious user can introduce
  725.                 if (m_CurrentUICulture == null) {
  726.                     return CultureInfo.UserDefaultUICulture;
  727.                 }
  728.                
  729.                 CultureInfo culture = null;
  730.                
  731.                 if (!nativeGetSafeCulture(this, GetDomainID(), true, ref culture) || culture == null) {
  732.                     return CultureInfo.UserDefaultUICulture;
  733.                 }
  734.                
  735.                 return culture;
  736.             }
  737.            
  738.             [HostProtection(ExternalThreading = true)]
  739.             set {
  740.                 if (value == null) {
  741.                     throw new ArgumentNullException("value");
  742.                 }
  743.                
  744.                 //If they're trying to use a Culture with a name that we can't use in resource lookup,
  745.                 //don't even let them set it on the thread.
  746.                 CultureInfo.VerifyCultureName(value, true);
  747.                
  748.                 if (nativeSetThreadUILocale(value.LCID) == false) {
  749.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidResourceCultureName", value.Name));
  750.                 }
  751.                
  752.                 value.StartCrossDomainTracking();
  753.                 m_CurrentUICulture = value;
  754.             }
  755.         }
  756.        
  757.         // This returns the exposed context for a given context ID.
  758.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  759.         private static extern bool nativeSetThreadUILocale(int LCID);
  760.        
  761.         // As the culture can be customized object then we cannot hold any
  762.         // reference to it before we check if it is safe because the app domain
  763.         // owning this customized culture may get unloaded while executing this
  764.         // code. To achieve that we have to do the check using nativeGetSafeCulture
  765.         // as the thread cannot get interrupted during the FCALL.
  766.         // If the culture is safe (not customized or created in current app domain)
  767.         // then the FCALL will return a reference to that culture otherwise the
  768.         // FCALL will return failure. In case of failure we'll return the default culture.
  769.         // If the app domain owning a customized culture that is set to teh thread and this
  770.         // app domain get unloaded there is a code to clean up the culture from the thread
  771.         // using the code in AppDomain::ReleaseDomainStores.
  772.        
  773.         public CultureInfo CurrentCulture {
  774.             get {
  775.                 // Fetch a local copy of m_CurrentCulture to
  776.                 // avoid races that malicious user can introduce
  777.                 if (m_CurrentCulture == null) {
  778.                     return CultureInfo.UserDefaultCulture;
  779.                 }
  780.                
  781.                 CultureInfo culture = null;
  782.                
  783.                 if (!nativeGetSafeCulture(this, GetDomainID(), false, ref culture) || culture == null) {
  784.                     return CultureInfo.UserDefaultCulture;
  785.                 }
  786.                
  787.                 return culture;
  788.             }
  789.            
  790.             [SecurityPermission(SecurityAction.Demand, ControlThread = true)]
  791.             set {
  792.                 if (null == value) {
  793.                     throw new ArgumentNullException("value");
  794.                 }
  795.                 CultureInfo.CheckNeutral(value);
  796.                
  797.                 //If we can't set the nativeThreadLocale, we'll just let it stay
  798.                 //at whatever value it had before. This allows people who use
  799.                 //just managed code not to be limited by the underlying OS.
  800.                 CultureInfo.nativeSetThreadLocale(value.LCID);
  801.                
  802.                 value.StartCrossDomainTracking();
  803.                 m_CurrentCulture = value;
  804.             }
  805.         }
  806.        
  807. /*===============================================================
  808.         ====================== Thread Statics ===========================
  809.         ===============================================================*/       
  810.         private int ReserveSlot()
  811.         {
  812.             // This is called by the thread on itself so no need for locks
  813.             if (m_ThreadStaticsBuckets == null) {
  814.                 BCLDebug.Assert(STATICS_BUCKET_SIZE % 32 == 0, "STATICS_BUCKET_SIZE should be a multiple of 32");
  815.                
  816.                 // allocate bucket holder
  817.                 // do not publish the data until all the intialization is done, in case of asynchronized exceptions
  818.                 object[][] newBuckets = new object[1][];
  819.                 SetIsThreadStaticsArray(newBuckets);
  820.                
  821.                 // allocate the first bucket
  822.                 newBuckets[0] = new object[STATICS_BUCKET_SIZE];
  823.                 SetIsThreadStaticsArray(newBuckets[0]);
  824.                
  825.                 int[] newBits = new int[newBuckets.Length * STATICS_BUCKET_SIZE / 32];
  826.                
  827.                 // use memset!
  828.                 for (int i = 0; i < newBits.Length; i++) {
  829.                     newBits[i] = unchecked((int)4294967295u);
  830.                 }
  831.                
  832.                 // block the 0th position, we don't want any static to have
  833.                 // slot #0 (we use it to indicate invalid slot)
  834.                 newBits[0] &= ~1;
  835.                
  836.                 // also we clear the bit for slot #1, as that is the one we will be returning
  837.                 newBits[0] &= ~2;
  838.                
  839.                 // now publish the arrays
  840.                 // the write order matters here, because we check m_ThreadStaticsBuckets for initialization,
  841.                 // we should write it at the last
  842.                 m_ThreadStaticsBits = newBits;
  843.                 m_ThreadStaticsBuckets = newBuckets;
  844.                
  845.                 return 1;
  846.             }
  847.             int slot = FindSlot();
  848.            
  849.             // slot == 0 => all slots occupied
  850.             if (slot == 0) {
  851.                 // We need to expand. Allocate a new bucket
  852.                 int oldLength = m_ThreadStaticsBuckets.Length;
  853.                 int oldLengthBits = m_ThreadStaticsBits.Length;
  854.                
  855.                 int newLength = m_ThreadStaticsBuckets.Length + 1;
  856.                 object[][] newBuckets = new object[newLength][];
  857.                 SetIsThreadStaticsArray(newBuckets);
  858.                
  859.                 int newLengthBits = newLength * STATICS_BUCKET_SIZE / 32;
  860.                 int[] newBits = new int[newLengthBits];
  861.                
  862.                 // Copy old buckets into new holder
  863.                 Array.Copy(m_ThreadStaticsBuckets, newBuckets, m_ThreadStaticsBuckets.Length);
  864.                
  865.                 // Allocate new buckets
  866.                 for (int i = oldLength; i < newLength; i++) {
  867.                     newBuckets[i] = new object[STATICS_BUCKET_SIZE];
  868.                     SetIsThreadStaticsArray(newBuckets[i]);
  869.                 }
  870.                
  871.                
  872.                 // Copy old bits into new bit array
  873.                 Array.Copy(m_ThreadStaticsBits, newBits, m_ThreadStaticsBits.Length);
  874.                
  875.                 // Initalize new bits
  876.                 for (int i = oldLengthBits; i < newLengthBits; i++) {
  877.                     newBits[i] = unchecked((int)4294967295u);
  878.                 }
  879.                
  880.                 // Return the first slot in the expanded area
  881.                 newBits[oldLengthBits] &= ~1;
  882.                
  883.                 // warning: if exceptions happen between the two writes, we are in a corrupted state
  884.                 // but the chances are very low
  885.                 m_ThreadStaticsBits = newBits;
  886.                 m_ThreadStaticsBuckets = newBuckets;
  887.                
  888.                 return oldLength * STATICS_BUCKET_SIZE;
  889.             }
  890.             return slot;
  891.         }
  892.        
  893.         int FindSlot()
  894.         {
  895.             #if DEBUG
  896.             BCLDebug.Assert(m_ThreadStaticsBits != null, "m_ThreadStaticsBits must already be initialized");
  897.             if (m_ThreadStaticsBits.Length != 0) {
  898.                 BCLDebug.Assert(m_ThreadStaticsBuckets != null && m_ThreadStaticsBits.Length == m_ThreadStaticsBuckets.Length * STATICS_BUCKET_SIZE / 32, "m_ThreadStaticsBuckets must already be intialized");
  899.                 for (int j = 0; j < m_ThreadStaticsBuckets.Length; j++) {
  900.                     BCLDebug.Assert(m_ThreadStaticsBuckets[j] != null && m_ThreadStaticsBuckets[j].Length == STATICS_BUCKET_SIZE, "m_ThreadStaticsBuckets must already be initialized");
  901.                 }
  902.             }
  903.             #endif //DEBUG
  904.            
  905.             int slot = 0;
  906.             // 0 is not a valid slot number
  907.             int bits = 0;
  908.             int i;
  909.             bool bFound = false;
  910.            
  911.             if (m_ThreadStaticsBits.Length != 0 && m_ThreadStaticsBits.Length != m_ThreadStaticsBuckets.Length * STATICS_BUCKET_SIZE / 32)
  912.                 return 0;
  913.            
  914.             for (i = 0; i < m_ThreadStaticsBits.Length; i++) {
  915.                 bits = m_ThreadStaticsBits[i];
  916.                 if (bits != 0) {
  917.                     if ((bits & 65535) != 0) {
  918.                         bits = bits & 65535;
  919.                     }
  920.                     else {
  921.                         bits = (bits >> 16) & 65535;
  922.                         slot += 16;
  923.                     }
  924.                     if ((bits & 255) != 0) {
  925.                         bits = bits & 255;
  926.                     }
  927.                     else {
  928.                         slot += 8;
  929.                         bits = (bits >> 8) & 255;
  930.                     }
  931.                     int j;
  932.                     for (j = 0; j < 8; j++) {
  933.                         if ((bits & (1 << j)) != 0) {
  934.                             bFound = true;
  935.                             break;
  936.                         }
  937.                     }
  938.                     BCLDebug.Assert(j < 8, "Bad bits?");
  939.                     slot += j;
  940.                     m_ThreadStaticsBits[i] &= ~(1 << slot);
  941.                     break;
  942.                 }
  943.             }
  944.             if (bFound) {
  945.                 slot = slot + 32 * i;
  946.             }
  947.             BCLDebug.Assert(bFound || slot == 0, "Bad bits");
  948.             return slot;
  949.         }
  950. /*=============================================================*/       
  951.        
  952. /*======================================================================
  953.         **  Current thread context is stored in a slot in the thread local store
  954.         **  CurrentContext gets the Context from the slot.
  955.         ======================================================================*/       
  956.        
  957.         public static Context CurrentContext {
  958.             [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
  959.             get { return CurrentThread.GetCurrentContextInternal(); }
  960.         }
  961.        
  962.         internal Context GetCurrentContextInternal()
  963.         {
  964.             if (m_Context == null) {
  965.                 m_Context = Context.DefaultContext;
  966.             }
  967.             return m_Context;
  968.         }
  969.        
  970.         [HostProtection(SharedState = true, ExternalThreading = true)]
  971.         internal LogicalCallContext GetLogicalCallContext()
  972.         {
  973.             return ExecutionContext.LogicalCallContext;
  974.         }
  975.        
  976.         [HostProtection(SharedState = true, ExternalThreading = true)]
  977.         internal LogicalCallContext SetLogicalCallContext(LogicalCallContext callCtx)
  978.         {
  979.             LogicalCallContext oldCtx = ExecutionContext.LogicalCallContext;
  980.             ExecutionContext.LogicalCallContext = callCtx;
  981.             return oldCtx;
  982.         }
  983.        
  984.         internal IllogicalCallContext GetIllogicalCallContext()
  985.         {
  986.             return ExecutionContext.IllogicalCallContext;
  987.         }
  988.        
  989.         // Get and set thread's current principal (for role based security).
  990.         public static IPrincipal CurrentPrincipal {
  991.             get {
  992.                 lock (CurrentThread) {
  993.                     IPrincipal principal = (IPrincipal)CallContext.Principal;
  994.                     if (principal == null) {
  995.                         principal = GetDomain().GetThreadPrincipal();
  996.                         CallContext.Principal = principal;
  997.                     }
  998.                     return principal;
  999.                 }
  1000.             }
  1001.            
  1002.             [SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.ControlPrincipal)]
  1003.             set { CallContext.Principal = value; }
  1004.         }
  1005.        
  1006.         // Private routine called from unmanaged code to set an initial
  1007.         // principal for a newly created thread.
  1008.         private void SetPrincipalInternal(IPrincipal principal)
  1009.         {
  1010.             GetLogicalCallContext().SecurityData.Principal = principal;
  1011.         }
  1012.        
  1013.         // This returns the exposed context for a given context ID.
  1014.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1015.         static internal extern Context GetContextInternal(IntPtr id);
  1016.        
  1017.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1018.         internal extern object InternalCrossContextCallback(Context ctx, IntPtr ctxID, Int32 appDomainID, InternalCrossContextDelegate ftnToCall, object[] args);
  1019.        
  1020.         internal object InternalCrossContextCallback(Context ctx, InternalCrossContextDelegate ftnToCall, object[] args)
  1021.         {
  1022.             return InternalCrossContextCallback(ctx, ctx.InternalContextID, 0, ftnToCall, args);
  1023.         }
  1024.        
  1025.         // CompleteCrossContextCallback is called by the EE after transitioning to the requested context
  1026.         private static object CompleteCrossContextCallback(InternalCrossContextDelegate ftnToCall, object[] args)
  1027.         {
  1028.             return ftnToCall(args);
  1029.         }
  1030.        
  1031. /*======================================================================
  1032.         ** Returns the current domain in which current thread is running.
  1033.         ======================================================================*/       
  1034.        
  1035.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1036.         private static extern AppDomain GetDomainInternal();
  1037.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1038.         private static extern AppDomain GetFastDomainInternal();
  1039.        
  1040.         public static AppDomain GetDomain()
  1041.         {
  1042.             if (CurrentThread.m_Context == null) {
  1043.                 AppDomain ad;
  1044.                 ad = GetFastDomainInternal();
  1045.                 if (ad == null)
  1046.                     ad = GetDomainInternal();
  1047.                 return ad;
  1048.             }
  1049.             else {
  1050.                 BCLDebug.Assert(GetDomainInternal() == CurrentThread.m_Context.AppDomain, "AppDomains on the managed & unmanaged threads should match");
  1051.                 return CurrentThread.m_Context.AppDomain;
  1052.             }
  1053.         }
  1054.        
  1055.        
  1056. /*
  1057.         *  This returns a unique id to identify an appdomain.
  1058.         */       
  1059.         public static int GetDomainID()
  1060.         {
  1061.             return GetDomain().GetId();
  1062.         }
  1063.        
  1064.        
  1065.         // Retrieves the name of the thread.
  1066.         //
  1067.         public string Name {
  1068.                
  1069.             get { return m_Name; }
  1070.             [HostProtection(ExternalThreading = true)]
  1071.             set {
  1072.                 lock (this) {
  1073.                     if (m_Name != null)
  1074.                         throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WriteOnce"));
  1075.                     m_Name = value;
  1076.                    
  1077.                     InformThreadNameChangeEx(this, m_Name);
  1078.                 }
  1079.             }
  1080.         }
  1081.        
  1082.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1083.         static internal extern void InformThreadNameChangeEx(Thread t, string name);
  1084.        
  1085.         internal object AbortReason {
  1086.             get {
  1087.                 object result = null;
  1088.                 try {
  1089.                     result = GetAbortReason();
  1090.                 }
  1091.                 catch (Exception e) {
  1092.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ExceptionStateCrossAppDomain"), e);
  1093.                 }
  1094.                 return result;
  1095.             }
  1096.             set { SetAbortReason(value); }
  1097.         }
  1098.        
  1099. /*
  1100.         *  This marks the beginning of a critical code region.
  1101.         */       
  1102.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  1103.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1104.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  1105.         public static extern void BeginCriticalRegion();
  1106.        
  1107. /*
  1108.         *  This marks the end of a critical code region.
  1109.         */       
  1110.         [HostProtection(Synchronization = true, ExternalThreading = true)]
  1111.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1112.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  1113.         public static extern void EndCriticalRegion();
  1114.        
  1115. /*
  1116.         *  This marks the beginning of a code region that requires thread affinity.
  1117.         */       
  1118.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, ControlThread = true)]
  1119.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1120.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  1121.         public static extern void BeginThreadAffinity();
  1122.        
  1123. /*
  1124.         *  This marks the end of a code region that requires thread affinity.
  1125.         */       
  1126.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, ControlThread = true)]
  1127.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1128.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  1129.         public static extern void EndThreadAffinity();
  1130.        
  1131. /*=========================================================================
  1132.         ** Volatile Read & Write and MemoryBarrier methods.
  1133.         ** Provides the ability to read and write values ensuring that the values
  1134.         ** are read/written each time they are accessed.
  1135.         =========================================================================*/       
  1136.        
  1137.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1138.         // disable optimizations
  1139.         public static byte VolatileRead(ref byte address)
  1140.         {
  1141.             byte ret = address;
  1142.             MemoryBarrier();
  1143.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1144.             return ret;
  1145.         }
  1146.        
  1147.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1148.         // disable optimizations
  1149.         public static short VolatileRead(ref short address)
  1150.         {
  1151.             short ret = address;
  1152.             MemoryBarrier();
  1153.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1154.             return ret;
  1155.         }
  1156.        
  1157.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1158.         // disable optimizations
  1159.         public static int VolatileRead(ref int address)
  1160.         {
  1161.             int ret = address;
  1162.             MemoryBarrier();
  1163.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1164.             return ret;
  1165.         }
  1166.        
  1167.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1168.         // disable optimizations
  1169.         public static long VolatileRead(ref long address)
  1170.         {
  1171.             long ret = address;
  1172.             MemoryBarrier();
  1173.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1174.             return ret;
  1175.         }
  1176.        
  1177.         [CLSCompliant(false)]
  1178.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1179.         // disable optimizations
  1180.         public static sbyte VolatileRead(ref sbyte address)
  1181.         {
  1182.             sbyte ret = address;
  1183.             MemoryBarrier();
  1184.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1185.             return ret;
  1186.         }
  1187.        
  1188.         [CLSCompliant(false)]
  1189.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1190.         // disable optimizations
  1191.         public static ushort VolatileRead(ref ushort address)
  1192.         {
  1193.             ushort ret = address;
  1194.             MemoryBarrier();
  1195.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1196.             return ret;
  1197.         }
  1198.        
  1199.         [CLSCompliant(false)]
  1200.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1201.         // disable optimizations
  1202.         public static uint VolatileRead(ref uint address)
  1203.         {
  1204.             uint ret = address;
  1205.             MemoryBarrier();
  1206.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1207.             return ret;
  1208.         }
  1209.        
  1210.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1211.         // disable optimizations
  1212.         public static IntPtr VolatileRead(ref IntPtr address)
  1213.         {
  1214.             IntPtr ret = address;
  1215.             MemoryBarrier();
  1216.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1217.             return ret;
  1218.         }
  1219.        
  1220.         [CLSCompliant(false)]
  1221.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1222.         // disable optimizations
  1223.         public static UIntPtr VolatileRead(ref UIntPtr address)
  1224.         {
  1225.             UIntPtr ret = address;
  1226.             MemoryBarrier();
  1227.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1228.             return ret;
  1229.         }
  1230.        
  1231.         [CLSCompliant(false)]
  1232.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1233.         // disable optimizations
  1234.         public static ulong VolatileRead(ref ulong address)
  1235.         {
  1236.             ulong ret = address;
  1237.             MemoryBarrier();
  1238.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1239.             return ret;
  1240.         }
  1241.        
  1242.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1243.         // disable optimizations
  1244.         public static float VolatileRead(ref float address)
  1245.         {
  1246.             float ret = address;
  1247.             MemoryBarrier();
  1248.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1249.             return ret;
  1250.         }
  1251.        
  1252.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1253.         // disable optimizations
  1254.         public static double VolatileRead(ref double address)
  1255.         {
  1256.             double ret = address;
  1257.             MemoryBarrier();
  1258.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1259.             return ret;
  1260.         }
  1261.        
  1262.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1263.         // disable optimizations
  1264.         public static object VolatileRead(ref object address)
  1265.         {
  1266.             object ret = address;
  1267.             MemoryBarrier();
  1268.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1269.             return ret;
  1270.         }
  1271.        
  1272.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1273.         // disable optimizations
  1274.         public static void VolatileWrite(ref byte address, byte value)
  1275.         {
  1276.             MemoryBarrier();
  1277.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1278.             address = value;
  1279.         }
  1280.        
  1281.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1282.         // disable optimizations
  1283.         public static void VolatileWrite(ref short address, short value)
  1284.         {
  1285.             MemoryBarrier();
  1286.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1287.             address = value;
  1288.         }
  1289.        
  1290.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1291.         // disable optimizations
  1292.         public static void VolatileWrite(ref int address, int value)
  1293.         {
  1294.             MemoryBarrier();
  1295.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1296.             address = value;
  1297.         }
  1298.        
  1299.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1300.         // disable optimizations
  1301.         public static void VolatileWrite(ref long address, long value)
  1302.         {
  1303.             MemoryBarrier();
  1304.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1305.             address = value;
  1306.         }
  1307.        
  1308.         [CLSCompliant(false)]
  1309.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1310.         // disable optimizations
  1311.         public static void VolatileWrite(ref sbyte address, sbyte value)
  1312.         {
  1313.             MemoryBarrier();
  1314.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1315.             address = value;
  1316.         }
  1317.        
  1318.         [CLSCompliant(false)]
  1319.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1320.         // disable optimizations
  1321.         public static void VolatileWrite(ref ushort address, ushort value)
  1322.         {
  1323.             MemoryBarrier();
  1324.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1325.             address = value;
  1326.         }
  1327.        
  1328.         [CLSCompliant(false)]
  1329.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1330.         // disable optimizations
  1331.         public static void VolatileWrite(ref uint address, uint value)
  1332.         {
  1333.             MemoryBarrier();
  1334.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1335.             address = value;
  1336.         }
  1337.        
  1338.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1339.         // disable optimizations
  1340.         public static void VolatileWrite(ref IntPtr address, IntPtr value)
  1341.         {
  1342.             MemoryBarrier();
  1343.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1344.             address = value;
  1345.         }
  1346.        
  1347.         [CLSCompliant(false)]
  1348.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1349.         // disable optimizations
  1350.         public static void VolatileWrite(ref UIntPtr address, UIntPtr value)
  1351.         {
  1352.             MemoryBarrier();
  1353.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1354.             address = value;
  1355.         }
  1356.        
  1357.         [CLSCompliant(false)]
  1358.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1359.         // disable optimizations
  1360.         public static void VolatileWrite(ref ulong address, ulong value)
  1361.         {
  1362.             MemoryBarrier();
  1363.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1364.             address = value;
  1365.         }
  1366.        
  1367.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1368.         // disable optimizations
  1369.         public static void VolatileWrite(ref float address, float value)
  1370.         {
  1371.             MemoryBarrier();
  1372.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1373.             address = value;
  1374.         }
  1375.        
  1376.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1377.         // disable optimizations
  1378.         public static void VolatileWrite(ref double address, double value)
  1379.         {
  1380.             MemoryBarrier();
  1381.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1382.             address = value;
  1383.         }
  1384.        
  1385.         [MethodImplAttribute(MethodImplOptions.NoInlining)]
  1386.         // disable optimizations
  1387.         public static void VolatileWrite(ref object address, object value)
  1388.         {
  1389.             MemoryBarrier();
  1390.             // Call MemoryBarrier to ensure the proper semantic in a portable way.
  1391.             address = value;
  1392.         }
  1393.        
  1394.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1395.         public static extern void MemoryBarrier();
  1396.        
  1397.         //We need to mark thread statics array for AppDomain leak checking purpose
  1398.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1399.         private static extern void SetIsThreadStaticsArray(object o);
  1400.        
  1401.         private static LocalDataStoreMgr LocalDataStoreManager {
  1402.             get {
  1403.                 if (s_LocalDataStoreMgr == null) {
  1404.                     lock (s_SyncObject) {
  1405.                         if (s_LocalDataStoreMgr == null)
  1406.                             s_LocalDataStoreMgr = new LocalDataStoreMgr();
  1407.                     }
  1408.                 }
  1409.                
  1410.                 return s_LocalDataStoreMgr;
  1411.             }
  1412.         }
  1413.        
  1414.         void _Thread.GetTypeInfoCount(out uint pcTInfo)
  1415.         {
  1416.             throw new NotImplementedException();
  1417.         }
  1418.        
  1419.         void _Thread.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  1420.         {
  1421.             throw new NotImplementedException();
  1422.         }
  1423.        
  1424.         void _Thread.GetIDsOfNames(        [In()]
  1425. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  1426.         {
  1427.             throw new NotImplementedException();
  1428.         }
  1429.        
  1430.         void _Thread.Invoke(uint dispIdMember,         [In()]
  1431. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  1432.         {
  1433.             throw new NotImplementedException();
  1434.         }
  1435.        
  1436.         // Helper function to set the AbortReason for a thread abort.
  1437.         // Checks that they're not alredy set, and then atomically updates
  1438.         // the reason info (object + ADID).
  1439.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1440.         internal extern void SetAbortReason(object o);
  1441.        
  1442.         // Helper function to retrieve the AbortReason from a thread
  1443.         // abort. Will perform cross-AppDomain marshalling if the object
  1444.         // lives in a different AppDomain from the requester.
  1445.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1446.         internal extern object GetAbortReason();
  1447.        
  1448.         // Helper function to clear the AbortReason. Takes care of
  1449.         // AppDomain related cleanup if required.
  1450.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1451.         internal extern void ClearAbortReason();
  1452.        
  1453.     }
  1454.     // End of class Thread
  1455.     // declaring a local var of this enum type and passing it by ref into a function that needs to do a
  1456.     // stack crawl will both prevent inlining of the calle and pass an ESP point to stack crawl to
  1457.     // Declaring these in EH clauses is illegal; they must declared in the main method body
  1458.     [Serializable()]
  1459.     internal enum StackCrawlMark
  1460.     {
  1461.         LookForMe = 0,
  1462.         LookForMyCaller = 1,
  1463.         LookForMyCallersCaller = 2,
  1464.         LookForThread = 3
  1465.     }
  1466.    
  1467. }

Developer Fusion