5051:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],

5086:   'thread': ['intro-finale/items-thread', 'intro-finale/items-thread'],

5084:   'thread-thimble': ['intro-finale/items-thread-thimble',

5085:                      'intro-finale/items-thread-thimble'],

5102:     'needle', 'halo', 'noodles', 'neutron', 'nose'

5105:     'thread', 'pinstripe', 'neutron', 'noodles', 'clove'

5125:     'thread', 'thimble', 'earmuffs', 'neutron', 'nose'

5131:     'thread', 'thimble', 'noodles', 'neutron', 'nose', 'gnocchi', 'rivet',

13797:     'intro-finale/items-needle-thread',

13798:     'intro-finale/items-needle',

13839:     'intro-finale/items-thread-thimble',

13840:     'intro-finale/items-thread',

15100:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },

15101:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },

15142:   'intro-finale/items-thread-thimble': { left: 2, top: 11, bottom: 14, right: 11, width: 52, height: 40, x: 690, y: 96 },

15143:   'intro-finale/items-thread': { left: 4, top: 16, bottom: 15, right: 13, width: 48, height: 34, x: 744, y: 96 },

5024:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],

5059:   'thread': ['intro-finale/items-thread', 'intro-finale/items-thread'],

5057:   'thread-thimble': ['intro-finale/items-thread-thimble',

5058:                      'intro-finale/items-thread-thimble'],

5075:     'needle', 'halo', 'noodles', 'neutron', 'nose'

5078:     'thread', 'pinstripe', 'neutron', 'noodles', 'clove'

5098:     'thread', 'thimble', 'earmuffs', 'neutron', 'nose'

5104:     'thread', 'thimble', 'noodles', 'neutron', 'nose', 'gnocchi', 'rivet',

13827:               // First run: Thread + thimble

13828:               nItems = ['thread', 'thimble'];

13831:               // Second run: Thread/thimble + random item that’s neither

13832:               nItems[0] = 'thread-thimble';

13836:               } while ((nItems[1] == 'thread-thimble') ||

13837:                        (nItems[1] == 'thread') || (nItems[1] == 'thimble'));

13843:             nItems = ['needle', 'noodles'];

13849:               nItems = ['thread', 'thimble'];

13852:               nItems = ['thread-thimble', 'forget-me-not'];

13859:               nItems = ['thread', 'thimble'];

13862:               nItems = ['thread-thimble', 'scissors'];

13868:             nItems = ['thread', 'pinstripe'];

13884:               nItems = ['thread', 'thimble'];

13887:               nItems = ['thread-thimble', 'neutron'];

13894:               nItems = ['thread', 'thimble'];

13897:               nItems = ['thread-thimble', 'basket'];

15362:     'intro-finale/items-needle-thread',

15363:     'intro-finale/items-needle',

15404:     'intro-finale/items-thread-thimble',

15405:     'intro-finale/items-thread',

16665:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },

16666:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },

16707:   'intro-finale/items-thread-thimble': { left: 2, top: 11, bottom: 14, right: 11, width: 52, height: 40, x: 690, y: 96 },

16708:   'intro-finale/items-thread': { left: 4, top: 16, bottom: 15, right: 13, width: 48, height: 34, x: 744, y: 96 },

185:   DWORD thread;			/* Win32 thread ID */

502:   ptw32_thread_t * thread;

158:   HANDLE threadH;		/* Win32 thread handle - POSIX thread is invalid if threadH == 0 */

162:   ptw32_mcs_lock_t threadLock;	/* Used for serialised access to public thread state */

246:   pthread_t ownerThread;

346:   void *threads;

350: typedef struct ThreadParms ThreadParms;

352: struct ThreadParms

401: typedef struct ThreadKeyAssoc ThreadKeyAssoc;

403: struct ThreadKeyAssoc

505:   ThreadKeyAssoc *nextThread;

507:   ThreadKeyAssoc *prevThread;

152: typedef struct ptw32_thread_t_       ptw32_thread_t;

155: struct ptw32_thread_t_

575: #define PTW32_THREAD_REUSE_EMPTY ((ptw32_thread_t *)(size_t) 1)

198: struct pthread_attr_t_

234: struct pthread_mutex_t_

273: struct pthread_mutexattr_t_

302: struct pthread_spinlock_t_

326: struct pthread_barrier_t_

336: struct pthread_barrierattr_t_

341: struct pthread_key_t_

360: struct pthread_cond_t_

378: struct pthread_condattr_t_

385: struct pthread_rwlock_t_

396: struct pthread_rwlockattr_t_

133:   PThreadStateInitial = 0,	/* Thread not running                   */

134:   PThreadStateRunning,		/* Thread alive & kicking               */

135:   PThreadStateSuspended,	/* Thread alive but suspended           */

136:   PThreadStateCancelPending,	/* Thread alive but                     */

138:   PThreadStateCanceling,	/* Thread alive but is                  */

141:   PThreadStateExiting,		/* Thread alive but exiting             */

143:   PThreadStateLast,             /* All handlers have been run and now   */

145:   PThreadStateReuse             /* In reuse pool.                       */

147: PThreadState;

944: #define _beginthreadex(security, \

957: #define _endthreadex ExitThread

129:    * This enumeration represents the state of the thread;

130:    * The thread is still "alive" if the numeric value of the

157:   unsigned __int64 seqNumber;	/* Process-unique thread sequence number */

159:   pthread_t ptHandle;		/* This thread's permanent pthread_t handle */

160:   ptw32_thread_t * prevReuse;	/* Links threads on reuse stack */

242:   int recursive_count;		/* Number of unlocks a thread needs to perform

263:  * Node used to manage per-thread lists of currently-held robust mutexes.

407:    *      This structure creates an association between a thread and a key.

409:    *      destroy routine for thread specific data registered by a user upon

410:    *      exiting a thread.

416:    *         T - Thread that has called pthread_setspecific(Kn)

417:    *            (head of chain is thread->keys)

436:    *      general lock (guarding the row) and the thread's general

440:    *      until both the key is deleted and the thread has called the

442:    *      to be freed as soon as either thread or key is concluded.

445:    *      key and thread locks are acquired consistently in the order

446:    *      "key lock then thread lock". An exception to this exists

447:    *      when a thread calls the destructors, however, this is done

450:    *      An association is created when a thread first calls

455:    *      thread calls the key destructor function on thread exit, or

459:    *      thread

460:    *              reference to the thread that owns the

462:    *              thread struct itself. Since the association is

463:    *              destroyed before the thread exits, this can never

464:    *              point to a different logical thread to the one that

465:    *              created the assoc, i.e. after thread struct reuse.

492:    *      1)      As soon as either the key or the thread is no longer

574: /* Thread Reuse stack bottom marker. Must not be NULL or any valid pointer to memory. */

578: extern ptw32_thread_t * ptw32_threadReuseTop;

579: extern ptw32_thread_t * ptw32_threadReuseBottom;

593: extern ptw32_mcs_lock_t ptw32_thread_reuse_lock;

626:   void ptw32_robust_mutex_remove(pthread_mutex_t* mutex, ptw32_thread_t* otp);

644:   void ptw32_threadReusePush (pthread_t thread);

648:   int ptw32_setthreadpriority (pthread_t thread, int policy, int priority);

659:   void ptw32_callUserDestroyRoutines (pthread_t thread);

661:   int ptw32_tkAssocCreate (ptw32_thread_t * thread, pthread_key_t key);

6:  * Keeps all the internals out of pthread.h

10:  *      Pthreads-win32 - POSIX Threads Library for Win32

224:   pthread_mutex_t lock;

248: 				   threads. */

267:   pthread_mutex_t mx;

308:     pthread_mutex_t mutex;	/* mutex if single cpu.            */

354:   pthread_t tid;

362:   long nWaitersBlocked;		/* Number of threads blocked            */

363:   long nWaitersGone;		/* Number of threads timed out          */

364:   long nWaitersToUnblock;	/* Number of threads to unblock         */

365:   sem_t semBlockQueue;		/* Queue up threads waiting for the     */

370:   pthread_mutex_t mtxUnblockLock;	/* Mutex that guards access to          */

373:   pthread_cond_t next;		/* Doubly linked list                   */

374:   pthread_cond_t prev;

387:   pthread_mutex_t mtxExclusiveAccess;

388:   pthread_mutex_t mtxSharedAccessCompleted;

389:   pthread_cond_t cndSharedAccessCompleted;

415:    *            (head of chain is key->threads)

451:    *      pthread_setspecific() on a key that has a specified

471:    *              The pthread_t->keys attribute is the head of a

474:    *              between a pthread_t and all pthread_key_t on which

475:    *              it called pthread_setspecific.

480:    *      nextThread

481:    *              The pthread_key_t->threads attribute is the head of

484:    *              relationship between a pthread_key_t and all the 

485:    *              PThreads that have called pthread_setspecific for

486:    *              this pthread_key_t.

488:    *      prevThread

497:    *              pthread_setspecific if the user provided a

503:   pthread_key_t key;

504:   ThreadKeyAssoc *nextKey;

506:   ThreadKeyAssoc *prevKey;

571: /* Declared in pthread_cancel.c */

580: extern pthread_key_t ptw32_selfThreadKey;

581: extern pthread_key_t ptw32_cleanupKey;

582: extern pthread_cond_t ptw32_cond_list_head;

583: extern pthread_cond_t ptw32_cond_list_tail;

587: extern unsigned __int64 ptw32_threadSeqNumber;

601: extern int pthread_count;

617:   int ptw32_is_attr (const pthread_attr_t * attr);

619:   int ptw32_cond_check_need_init (pthread_cond_t * cond);

620:   int ptw32_mutex_check_need_init (pthread_mutex_t * mutex);

621:   int ptw32_rwlock_check_need_init (pthread_rwlock_t * rwlock);

622:   int ptw32_spinlock_check_need_init (pthread_spinlock_t * lock);

624:   int ptw32_robust_mutex_inherit(pthread_mutex_t * mutex);

625:   void ptw32_robust_mutex_add(pthread_mutex_t* mutex, pthread_t self);

630: 			       HANDLE threadH, DWORD callback_arg);

636:   void ptw32_threadDestroy (pthread_t tid);

640:   pthread_t ptw32_new (void);

642:   pthread_t ptw32_threadReusePop (void);

657:     ptw32_threadStart (void *vthreadParms);

663:   void ptw32_tkAssocDestroy (ThreadKeyAssoc * assoc);

714:   _CRTIMP unsigned long __cdecl _beginthread (void (__cdecl *) (void *),

716:   _CRTIMP void __cdecl _endthread (void);

937: #if defined(NEED_CREATETHREAD)

940:  * Macro uses args so we can cast start_proc to LPTHREAD_START_ROUTINE

950:         CreateThread(security, \

952:                      (LPTHREAD_START_ROUTINE) start_proc, \

959: #endif				/* NEED_CREATETHREAD */

12:  *      Copyright(C) 1999,2005 Pthreads-win32 contributors

20:  *      http://sources.redhat.com/pthreads-win32/contributors.html

131:    * state is greater or equal "PThreadStateRunning".

161:   volatile PThreadState state;

483:    *              nextThreads link. This chain provides the 1 to many

717:   _CRTIMP unsigned long __cdecl _beginthreadex (void *, unsigned,

720:   _CRTIMP void __cdecl _endthreadex (unsigned);

631: class Thread(_Verbose):

35: _start_new_thread = thread.start_new_thread

1148: current_thread = currentThread

38: ThreadError = thread.error

1071: class _MainThread(Thread):

1096: def _pickSomeNonDaemonThread():

1111: class _DummyThread(Thread):

1135: def currentThread():

1365:     class ProducerThread(Thread):

1381:     class ConsumerThread(Thread):

1: """Thread module emulating a subset of Java's threading model."""

6:     import thread

31:            'current_thread', 'enumerate', 'Event',

32:            'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',

36: _allocate_lock = thread.allocate_lock

37: _get_ident = thread.get_ident

39: del thread

67:                 # Issue #4188: calling current_thread() can incur an infinite

73:                     name = "<OS thread %d>" % ident

93:     The func will be passed to sys.setprofile() for each thread, before its

103:     The func will be passed to sys.settrace() for each thread, before its run()

117:     A reentrant lock must be released by the thread that acquired it. Once a

118:     thread has acquired a reentrant lock, the same thread may acquire it again

119:     without blocking; the thread must release it once for each time it has

126:     """A reentrant lock must be released by the thread that acquired it. Once a

127:        thread has acquired a reentrant lock, the same thread may acquire it

128:        again without blocking; the thread must release it once for each time it

150:         When invoked without arguments: if this thread already owns the lock,

152:         if another thread owns the lock, block until the lock is unlocked. Once

153:         the lock is unlocked (not owned by any thread), then grab ownership, set

154:         the recursion level to one, and return. If more than one thread is

191:         by any thread), and if any other threads are blocked waiting for the

194:         locked and owned by the calling thread.

196:         Only call this method when the calling thread owns the lock. A

246:     notified by another thread.

257:        notified by another thread.

301:         # Return True if lock is owned by current_thread.

312:         If the calling thread has not acquired the lock when this method is

317:         variable in another thread, or until the optional timeout occurs. Once

376:         If the calling thread has not acquired the lock when this method is

403:         If the calling thread has not acquired the lock when this method

445:         on entry, block, waiting until some other thread has called release() to

482:         When the counter is zero on entry and another thread is waiting for it

483:         to become larger than zero again, wake up that thread.

528:         When the counter is zero on entry and another thread is waiting for it

529:         to become larger than zero again, wake up that thread.

567:         # private!  called by Thread._reset_internal_locks by _after_fork()

601:         block until another thread calls set() to set the flag to true, or until

617: # Helper to generate new thread names

619: _counter() # Consume 0 so first non-main thread has id 1.

620: def _newname(template="Thread-%d"):

623: # Active thread administration

625: _active = {}    # maps thread id to Thread object

632:     """A class that represents a thread of control.

649:         *name* is the thread name. By default, a unique name is constructed of

650:         the form "Thread-N" where N is a small decimal number.

658:         the base class constructor (Thread.__init__()) before doing anything

659:         else to the thread.

694:         return current_thread().daemon

697:         assert self.__initialized, "Thread.__init__() was not called"

710:         """Start the thread's activity.

712:         It must be called at most once per thread object. It arranges for the

713:         object's run() method to be invoked in a separate thread of control.

716:         same thread object.

720:             raise RuntimeError("thread.__init__() not called")

724:             self._note("%s.start(): starting thread", self)

728:             _start_new_thread(self.__bootstrap, ())

736:         """Method representing the thread's activity.

748:             # Avoid a refcycle if the thread is running a function with

749:             # an argument that has a member that points to the thread.

755:         # happen when a daemon thread wakes up at an unfortunate

783:                 self._note("%s.__bootstrap(): thread started", self)

805:                     print>>_sys.stderr, ("Exception in thread %s:\n%s" %

814:                             "Exception in thread " + self.name +

860:         "Remove current thread from the dict of currently running threads."

862:         # Notes about running with dummy_thread:

864:         # Must take care to not raise an exception if dummy_thread is being

866:         # dummy_threading).  dummy_thread.get_ident() always returns -1 since

867:         # there is only one thread if dummy_thread is being used.  Thus

868:         # len(_active) is always <= 1 here, and any Thread instance created

869:         # overwrites the (if any) thread currently registered in _active.

872:         # gets overwritten the instant an instance of Thread is created; both

873:         # threads return -1 from dummy_thread.get_ident() and thus have the

876:         # it gets a KeyError if another Thread instance was created.

888:                 # could try to acquire the lock again in the same thread, (in

889:                 # current_thread()), and would block.

895:         """Wait until the thread terminates.

897:         This blocks the calling thread until the thread whose join() method is

905:         thread is still alive, the join() call timed out.

908:         block until the thread terminates.

910:         A thread can be join()ed many times.

913:         thread as that would cause a deadlock. It is also an error to join() a

914:         thread before it has been started and attempts to do so raises the same

919:             raise RuntimeError("Thread.__init__() not called")

921:             raise RuntimeError("cannot join thread before it is started")

922:         if self is current_thread():

923:             raise RuntimeError("cannot join current thread")

927:                 self._note("%s.join(): waiting until thread stops", self)

934:                     self._note("%s.join(): thread stopped", self)

946:                         self._note("%s.join(): thread stopped", self)

957:         assert self.__initialized, "Thread.__init__() not called"

961:         assert self.__initialized, "Thread.__init__() not called"

968:         """Thread identifier of this thread or None if it has not been started.

970:         This is a nonzero integer. See the thread.get_ident() function. Thread

971:         identifiers may be recycled when a thread exits and another thread is

972:         created. The identifier is available even after the thread has exited.

975:         assert self.__initialized, "Thread.__init__() not called"

979:         """Return whether the thread is alive.

986:         assert self.__initialized, "Thread.__init__() not called"

992:         """A boolean value indicating whether this thread is a daemon thread (True) or not (False).

995:         raised. Its initial value is inherited from the creating thread; the

996:         main thread is not a daemon thread and therefore all threads created in

997:         the main thread default to daemon = False.

1003:         assert self.__initialized, "Thread.__init__() not called"

1008:             raise RuntimeError("Thread.__init__() not called")

1010:             raise RuntimeError("cannot set daemon status of active thread");

1041: class _Timer(Thread):

1051:         Thread.__init__(self)

1068: # Special thread class to represent the main thread

1074:         Thread.__init__(self, name="MainThread")

1103: # Dummy thread class to represent threads not started here.

1105: # If they invoke anything in threading.py that calls current_thread(), they

1107: # Their purpose is to return *something* from current_thread().

1114:         Thread.__init__(self, name=_newname("Dummy-%d"))

1116:         # Thread.__block consumes an OS-level locking primitive, which

1130:         assert False, "cannot join a dummy thread"

1136:     """Return the current Thread object, corresponding to the caller's thread of control.

1138:     If the caller's thread of control was not created through the threading

1139:     module, a dummy thread object with limited functionality is returned.

1145:         ##print "current_thread(): no current thread for", _get_ident()

1151:     """Return the number of Thread objects currently alive.

1167:     """Return a list of all Thread objects currently alive.

1169:     The list includes daemonic threads, dummy thread objects created by

1170:     current_thread(), and the main thread. It excludes terminated threads and

1177: from thread import stack_size

1179: # Create the main thread object,

1185: # get thread-local implementation, either from the thread

1188: # NOTE: Thread local classes follow: the Grumpy version of this file copies

1196:         key = '_local__key', 'thread.local.' + str(id(self))

1204:         # We need to create the thread dict in anticipation of

1208:         current_thread().__dict__[key] = dict

1214:     d = current_thread().__dict__.get(key)

1217:         current_thread().__dict__[key] = d

1279:         for thread in threads:

1281:                 __dict__ = thread.__dict__

1283:                 # Thread is dying, rest in peace.

1290:                     pass # didn't have anything in this thread

1300:     # by another (non-forked) thread.  http://bugs.python.org/issue874900

1304:     # fork() only copied the current thread; clear references to others.

1306:     current = current_thread()

1308:         for thread in _enumerate():

1311:             if hasattr(thread, '_reset_internal_locks'):

1312:                 thread._reset_internal_locks()

1313:             if thread is current:

1314:                 # There is only one active thread. We reset the ident to

1317:                 thread.__ident = ident

1318:                 new_active[ident] = thread

1321:                 thread.__stop()

1368:             Thread.__init__(self, name="Producer")

1384:             Thread.__init__(self, name="Consumer")

19: #  This threading model was originally inspired by Java, and inherited

29: # Rename some stuff so "from threading import *" is safe

30: __all__ = ['activeCount', 'active_count', 'Condition', 'currentThread',

45:                         module='threading', message='sys.exc_clear')

68:                 # recursion if it has to create a DummyThread on the fly.

91:     """Set a profile function for all threads started from the threading module.

101:     """Set a trace function for all threads started from the threading module.

245:     A condition variable allows one or more threads to wait until they are

256:     """Condition variables allow one or more threads to wait until they are

374:         """Wake up one or more threads waiting on this condition, if any.

379:         This method wakes up at most n of the threads waiting for the condition

380:         variable; it is a no-op if no threads are waiting.

401:         """Wake up all threads waiting on this condition.

449:         which blocked threads are awakened should not be relied on. There is no

579:         All threads waiting for the flag to become true are awakened. Threads

590:         Subsequently, threads calling wait() will block until set() is called to

629: # Main class for threads

643:         *group* should be None; reserved for future extension when a ThreadGroup

683:         if hasattr(self, '__block'):  # DummyThread deletes self.__block

693:         # Overridden in _MainThread and _DummyThread

722:             raise RuntimeError("threads can only be started once")

763:         # reported.  Also, we only suppress them for daemonic threads;

835:                 # test_threading.test_no_refcycle_through_target when

871:         # An instance of _MainThread is always created by 'threading'.  This

874:         # same key in the dict.  So when the _MainThread instance created by

875:         # 'threading' tries to clean itself up when atexit calls this method

879:         # _active if dummy_threading is being used is a red herring.  But

880:         # since it isn't if dummy_threading is *not* being used then don't

891:             if 'dummy_threading' not in _sys.modules:

953:         It has no semantics. Multiple threads may be given the same name. The

983:         returns a list of all alive threads.

999:         The entire Python program exits when no alive non-daemon threads are

1085:         t = _pickSomeNonDaemonThread()

1088:                 self._note("%s: waiting for other threads", self)

1091:             t = _pickSomeNonDaemonThread()

1108: # They are marked as daemon threads so we won't wait for them

1117:         # can never be used by a _DummyThread.  Since a _DummyThread

1146:         return _DummyThread()

1171:     threads that have not yet been started.

1181: # (Py_Main) as threading._shutdown.

1183: _shutdown = _MainThread()._exitfunc

1189: # these from _threading_local.py to avoid circular dependency issues.

1272:             threads = _enumerate()

1274:             # If enumerating the current threads fails, as it seems to do

1292: # END _threading_local.py copy

1296:     # is called from PyOS_AfterFork.  Here we cleanup threading module state

1401:         t = ProducerThread(Q, NI)

1404:     C = ConsumerThread(Q, NI*NP)

850:         # DummyThreads delete self.__block, but they have no waiters to

1295:     # This function is called by Python/ceval.c:PyEval_ReInitThreads which

88: typedef struct thread {

46: #define THREAD_STATS 1

47: #define THREAD_STACK_HIGHWATER 1

48: #define THREAD_STACK_BOUNDS_CHECK 1

50: #define THREAD_STACK_PADDING_SIZE 256

54: enum thread_state {

55:     THREAD_SUSPENDED = 0,

56:     THREAD_READY,

57:     THREAD_RUNNING,

58:     THREAD_BLOCKED,

59:     THREAD_SLEEPING,

60:     THREAD_DEATH,

63: typedef int (*thread_start_routine)(void *arg);

66: enum thread_tls_list {

79: #define THREAD_FLAG_DETACHED                  (1U<<0)

80: #define THREAD_FLAG_FREE_STACK                (1U<<1)

81: #define THREAD_FLAG_FREE_STRUCT               (1U<<2)

82: #define THREAD_FLAG_REAL_TIME                 (1U<<3)

83: #define THREAD_FLAG_IDLE                      (1U<<4)

84: #define THREAD_FLAG_DEBUG_STACK_BOUNDS_CHECK  (1U<<5)

86: #define THREAD_MAGIC (0x74687264) // 'thrd'

90:     struct list_node thread_list_node;

129: } thread_t;

132: #define thread_curr_cpu(t) ((t)->curr_cpu)

133: #define thread_pinned_cpu(t) ((t)->pinned_cpu)

134: #define thread_set_curr_cpu(t,c) ((t)->curr_cpu = (c))

135: #define thread_set_pinned_cpu(t, c) ((t)->pinned_cpu = (c))

137: #define thread_curr_cpu(t) (0)

138: #define thread_pinned_cpu(t) (-1)

139: #define thread_set_curr_cpu(t,c) do {} while(0)

140: #define thread_set_pinned_cpu(t, c) do {} while(0)

173: static inline void thread_sleep(lk_time_t delay_ms) {

201: #define THREAD_LOCK(state) spin_lock_saved_state_t state; spin_lock_irqsave(&thread_lock, state)

202: #define THREAD_UNLOCK(state) spin_unlock_irqrestore(&thread_lock, state)

204: static inline bool thread_lock_held(void)

210: static inline __ALWAYS_INLINE uintptr_t thread_tls_get(thread_t *t, uint entry)

227: #define thread_tls_set(t,e,v) \

237: struct thread_stats {

255: #define THREAD_STATS_INC(name) do { thread_stats[arch_curr_cpu_num()].name++; } while(0)

259: #define THREAD_STATS_INC(name) do { } while (0)

24: #define __KERNEL_THREAD_H

220: static inline __ALWAYS_INLINE uintptr_t __thread_tls_set(thread_t *t,

23: #ifndef __KERNEL_THREAD_H

31: #include <arch/thread.h>

49: #ifndef THREAD_STACK_PADDING_SIZE

65: /* thread local storage */

95:     enum thread_state state;

111:     struct arch_thread arch;

118:     thread_start_routine entry;

125:     /* thread local storage */

143: /* thread priority */

161: void thread_init_early(void);

162: void thread_init(void);

163: void thread_become_idle(void) __NO_RETURN;

164: void thread_secondary_cpu_init_early(void);

165: void thread_secondary_cpu_entry(void) __NO_RETURN;

166: void thread_set_name(const char *name);

167: void thread_set_priority(int priority);

168: thread_t *thread_create(const char *name, thread_start_routine entry, void *arg, int priority, size_t stack_size);

169: thread_t *thread_create_etc(thread_t *t, const char *name, thread_start_routine entry, void *arg, int priority, void *stack, size_t stack_size);

170: status_t thread_resume(thread_t *);

171: void thread_exit(int retcode) __NO_RETURN;

172: void thread_sleep_ns(lk_time_ns_t delay_ns);

174:     thread_sleep_ns(delay_ms * 1000ULL * 1000);

176: status_t thread_detach(thread_t *t);

177: status_t thread_join(thread_t *t, int *retcode, lk_time_t timeout);

178: status_t thread_detach_and_resume(thread_t *t);

179: status_t thread_set_real_time(thread_t *t);

181: void dump_thread(thread_t *t);

182: void arch_dump_thread(thread_t *t);

186: void thread_yield(void); /* give up the cpu voluntarily */

187: void thread_preempt(void); /* get preempted (inserted into head of run queue) */

188: void thread_block(void); /* block on something and reschedule */

189: void thread_unblock(thread_t *t, bool resched); /* go back in the run queue */

192: enum handler_return thread_timer_tick(void);

194: /* the current thread */

195: thread_t *get_current_thread(void);

196: void set_current_thread(thread_t *);

199: extern spin_lock_t thread_lock;

206:     return spin_lock_held(&thread_lock);

209: /* thread local storage */

217:     return thread_tls_get(get_current_thread(), entry);

230:         __thread_tls_set(t, e, v); \

233: #define tls_set(e,v) thread_tls_set(get_current_thread(), e, v)

235: /* thread level statistics */

236: #if THREAD_STATS

253: extern struct thread_stats thread_stats[SMP_MAX_CPUS];

183: void dump_all_threads(void);

18: defmodule GoogleApi.Chat.V1.Model.Thread do

20:   A thread in Hangouts Chat.

38: defimpl Poison.Decoder, for: GoogleApi.Chat.V1.Model.Thread do

40:     GoogleApi.Chat.V1.Model.Thread.decode(value, options)

44: defimpl Poison.Encoder, for: GoogleApi.Chat.V1.Model.Thread do

24:   *   `name` (*type:* `String.t`, *default:* `nil`) - Resource name, in the form "spaces/*/threads/*".

26:       Example: spaces/AAAAMpdlehY/threads/UMxbHmzDlr4

29: type Thread struct {

26: // A Thread contains the state of a Skylark thread,

27: // such as its call stack and thread-local storage.

28: // The Thread is threaded throughout the evaluator.

36: 	Print func(thread *Thread, msg string)

44: 	Load func(thread *Thread, module string) (StringDict, error)

46: 	// locals holds arbitrary "thread-local" Go values belonging to the client.

51: // SetLocal sets the thread-local value associated with the specified key.

53: func (thread *Thread) SetLocal(key string, value interface{}) {

54: 	if thread.locals == nil {

55: 		thread.locals = make(map[string]interface{})

57: 	thread.locals[key] = value

60: // Local returns the thread-local value associated with the specified key.

61: func (thread *Thread) Local(key string) interface{} {

62: 	return thread.locals[key]

67: func (thread *Thread) Caller() *Frame { return thread.frame.parent }

70: func (thread *Thread) TopFrame() *Frame { return thread.frame }

117: // The Frames of a thread are structured as a spaghetti stack, not a

217: // Thread is the state associated with the Skylark thread.

231: func ExecFile(thread *Thread, filename string, src interface{}, predeclared StringDict) (StringDict, error) {

238: 	g, err := mod.Init(thread, predeclared)

280: func (prog *Program) Init(thread *Thread, predeclared StringDict) (StringDict, error) {

283: 	_, err := Call(thread, toplevel, nil, nil)

328: func Eval(thread *Thread, filename string, src interface{}, env StringDict) (Value, error) {

341: 	return Call(thread, fn, nil, nil)

724: 			needle, ok := x.(String)

728: 			return Bool(strings.Contains(string(y), string(needle))), nil

850: func Call(thread *Thread, fn Value, args Tuple, kwargs []Tuple) (Value, error) {

856: 	thread.frame = &Frame{parent: thread.frame, callable: c}

857: 	result, err := c.CallInternal(thread, args, kwargs)

858: 	thread.frame = thread.frame.parent

779: mod thread;

139: //!     bad: std::thread::Thread,

149: //! error[E0277]: the trait bound `std::thread::Thread: HeapSize` is not satisfied

152: //! 7 |     bad: std::thread::Thread,

153: //!   |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `HeapSize` is not implemented for `Thread`

266:     clippy::needless_doctest_main,

267:     clippy::needless_pass_by_value,

42:     private final Thread thread;

40: class ThreadMonitor implements Runnable {

94:     private ThreadMonitor(final Thread thread, final long timeout) {

20:  * Monitors a thread, interrupting it if it reaches the specified timeout.

23:  * interrupting the thread being monitored. If the thread being monitored

25:  * the <i>monitor</i> thread.

31:  *           Thread monitor = ThreadMonitor.start(timeoutInMillis);

46:      * Start monitoring the current thread.

50:      * @return The monitor thread or {@code null}

53:     public static Thread start(final long timeout) {

54:         return start(Thread.currentThread(), timeout);

58:      * Start monitoring the specified thread.

60:      * @param thread The thread The thread to monitor

63:      * @return The monitor thread or {@code null}

66:     public static Thread start(final Thread thread, final long timeout) {

67:         Thread monitor = null;

69:             final ThreadMonitor timout = new ThreadMonitor(thread, timeout);

70:             monitor = new Thread(timout, ThreadMonitor.class.getSimpleName());

78:      * Stop monitoring the specified thread.

80:      * @param thread The monitor thread, may be {@code null}

82:     public static void stop(final Thread thread) {

83:         if (thread != null) {

84:             thread.interrupt();

91:      * @param thread The thread to monitor

95:         this.thread = thread;

101:      * interrupt the thread being monitored.

109:             thread.interrupt();

118:      * This method exists because Thread.sleep(100) can sleep for 0, 70, 100 or 200ms or anything else

119:      * it deems appropriate. Read the docs on Thread.sleep for further interesting details.

128:             Thread.sleep(remaining);

33:  *           ThreadMonitor.stop(monitor);

464: uint32_t NfcAdaptation::Thread(__attribute__((unused)) uint32_t arg) {

825: ThreadMutex::ThreadMutex() {

875: ThreadCondVar::ThreadCondVar() {

842: ThreadMutex::~ThreadMutex() { pthread_mutex_destroy(&mMutex); }

893: ThreadCondVar::~ThreadCondVar() { pthread_cond_destroy(&mCondVar); }

932: AutoThreadMutex::AutoThreadMutex(ThreadMutex& m) : mm(m) { mm.lock(); }

943: AutoThreadMutex::~AutoThreadMutex() { mm.unlock(); }

288:   // Android already logs thread_id, proc_id, timestamp, so disable those.

369:     GKI_create_task((TASKPTR)Thread, MMI_TASK, (int8_t*)"NFCA_THREAD", nullptr, 0,

431: ** Description: signal the CondVar to release the thread that is waiting

457: ** Function:    NfcAdaptation::Thread()

465:   const char* func = "NfcAdaptation::Thread";

61: ThreadMutex NfcAdaptation::sLock;

64: ThreadCondVar NfcAdaptation::mHalOpenCompletedEvent;

65: ThreadCondVar NfcAdaptation::mHalCloseCompletedEvent;

304:     // of a byte array is ambiguous and needlessly difficult to configure.

366:                   (pthread_cond_t*)nullptr, nullptr);

370:                     (pthread_cond_t*)nullptr, nullptr);

459: ** Description: Creates work threads

469:     ThreadCondVar CondVar;

472:                     (pthread_cond_t*)CondVar, (pthread_mutex_t*)CondVar);

818: ** Function:    ThreadMutex::ThreadMutex()

826:   pthread_mutexattr_t mutexAttr;

828:   pthread_mutexattr_init(&mutexAttr);

829:   pthread_mutex_init(&mMutex, &mutexAttr);

830:   pthread_mutexattr_destroy(&mutexAttr);

835: ** Function:    ThreadMutex::~ThreadMutex()

846: ** Function:    ThreadMutex::lock()

853: void ThreadMutex::lock() { pthread_mutex_lock(&mMutex); }

857: ** Function:    ThreadMutex::unblock()

864: void ThreadMutex::unlock() { pthread_mutex_unlock(&mMutex); }

868: ** Function:    ThreadCondVar::ThreadCondVar()

876:   pthread_condattr_t CondAttr;

878:   pthread_condattr_init(&CondAttr);

879:   pthread_cond_init(&mCondVar, &CondAttr);

881:   pthread_condattr_destroy(&CondAttr);

886: ** Function:    ThreadCondVar::~ThreadCondVar()

897: ** Function:    ThreadCondVar::wait()

904: void ThreadCondVar::wait() {

905:   pthread_cond_wait(&mCondVar, *this);

906:   pthread_mutex_unlock(*this);

911: ** Function:    ThreadCondVar::signal()

918: void ThreadCondVar::signal() {

920:   pthread_cond_signal(&mCondVar);

194:   AutoThreadMutex a(sLock);

368:     AutoThreadMutex guard(mCondVar);

389:   AutoThreadMutex a(sLock);

470:     AutoThreadMutex guard(CondVar);

919:   AutoThreadMutex a(*this);

925: ** Function:    AutoThreadMutex::AutoThreadMutex()

936: ** Function:    AutoThreadMutex::~AutoThreadMutex()

8: type Thread struct {

7: // A Thread represents an operating system thread.

9: 	pid  uint64   // thread/process ID

15: func (t *Thread) Pid() uint64 {

19: // Regs returns the set of register values for the thread.

23: func (t *Thread) Regs() []uint64 {

27: func (t *Thread) PC() Address {

31: func (t *Thread) SP() Address {

334:     private final Thread thread;

1214:         private boolean threadShouldExit(long now, long curHardShutdownTimeMs) {

287:     static final String NETWORK_THREAD_PREFIX = "kafka-admin-client-thread";

285:      * Thread name prefix for admin client network thread

327:      * The runnable used in the service thread for this admin client.

332:      * The network service thread for this admin client.

338:      * and force the RPC thread to exit. If the admin client is not closing, this will be 0.

343:      * A factory which creates TimeoutProcessors for the RPC thread.

549:         String threadName = NETWORK_THREAD_PREFIX + " | " + clientId;

550:         this.thread = new KafkaThread(threadName, runnable, true);

558:         thread.start();

602:                 client.wakeup(); // Wake the thread, if it is blocked inside poll().

614:             log.debug("Waiting for the I/O thread to exit. Hard shutdown in {} ms.", deltaMs);

617:             // close() can be called by AdminClient thread when it invokes callback. That will

619:             if (Thread.currentThread() != thread) {

620:                 // Wait for the thread to be joined.

621:                 thread.join(waitTimeMs);

625:             log.debug("Interrupted while joining I/O thread", e);

626:             Thread.currentThread().interrupt();

912:          * Only accessed from this thread.

918:          * Only accessed from this thread.

924:          * Only accessed from this thread.

930:          * Only accessed from this thread.

936:          * This will be null only if the thread has shut down.

1216:                 log.trace("All work has been completed, and the I/O thread is now exiting.");

1220:                 log.info("Forcing a hard I/O thread shutdown. Requests in progress will be aborted.");

1229:             log.trace("Thread starting");

1238:                     numTimedOut += timeoutProcessor.handleTimeouts(newCalls, "The AdminClient thread has exited.");

1241:                 numTimedOut += timeoutProcessor.handleTimeouts(pendingCalls, "The AdminClient thread has exited.");

1244:                         "The AdminClient thread has exited.");

1250:                 log.debug("Exiting AdminClientRunnable thread.");

1260:                 // Check if the AdminClient thread should shut down.

1315:          * If the AdminClient thread has exited, this will fail. Otherwise, it will succeed (even

1339:                 client.wakeup(); // wake the thread if it is in poll()

1341:                 log.debug("The AdminClient thread has exited. Timing out {}.", call);

1342:                 call.fail(Long.MAX_VALUE, new TimeoutException("The AdminClient thread has exited."));

1357:                 call.fail(Long.MAX_VALUE, new TimeoutException("The AdminClient thread is not accepting new calls."));

217: import org.apache.kafka.common.utils.KafkaThread;

1262:                 if ((curHardShutdownTimeMs != INVALID_SHUTDOWN_TIME) && threadShouldExit(now, curHardShutdownTimeMs))

1127:             "needle": "^2.2.1",

1108:         "needle": {

1098:             "needle": "^2.2.1",

1079:         "needle": {

4872: - (id)thread;

4528:     PBXLSThread *_selectedThread;

4540: - (id)selectedThread;

4689: - (id)threadViewModule;

4771: - (id)selectedThread;

4875: - (BOOL)threadIsRunning;

4876: - (BOOL)threadIsRunningButNotStepping;

4877: - (BOOL)threadStepDidTimeout;

4878: - (BOOL)threadIsSteppable;

4899: - (void)continueThread;

7806: + (void)_startCrashCatchingServiceThread;

11480: - (void)threadRequestUpdateStack:(id)fp8;

11481: - (void)threadRequestStepInstruction:(id)fp8;

11482: - (void)threadRequestNextInstruction:(id)fp8;

11483: - (void)threadRequestStepInto:(id)fp8;

11484: - (void)threadRequestStepOver:(id)fp8;

11485: - (void)threadRequestStepOut:(id)fp8;

11487: - (void)threadRequestContinue:(id)fp8;

11862:     PBXLSThread *_currentThread;

11876: - (id)currentThread;

11883: - (id)threadGroups;

11884: - (id)threadGroupWithName:(id)fp8;

11887: - (id)threads;

11888: - (id)threadWithHandle:(unsigned long)fp8;

11909: - (id)parentThread;

11923: - (void)threadDidUpdate;

11939: @interface PBXLSThread : PBXLSModel

11967: - (int)threadState;

11968: - (int)threadStateStatus;

11997: - (id)threads;

14973:     NSThread *_taskThread;

4527:     NSPopUpButtonCell *_threadsPopUp;

4539: - (void)selectThread:(id)fp8;

4544: - (void)setSelectedThread:(id)fp8;

4554:     PBXDebugThreadViewModule *_threadViewModule;

4770: - (void)setSelectedThread:(id)fp8;

4858:     PBXDebugStackTableHeaderCell *_threadsTablePopUp;

11885: - (id)_threadsOfType:(int)fp8;

11941:     int _threadState;

11943:     int _threadStateStatus;

558: - (BOOL)usesThreadedAnimation;

559: - (void)setUsesThreadedAnimation:(BOOL)fp8;

3033: - (void)_finishSpeculativeCompilationInSeparateThreadWithSpecCompInfo:(id)fp8;

4535: - (id)selectedThreadViewModule;

4537: - (BOOL)allThreadsStopped;

4541: - (void)_emptyThreadsPopUp;

4546: - (void)setThreadsPopUp:(id)fp8;

4552:     PBXDebugProcessAndThreadModule *_processAndThreadModule;

4851: @interface PBXDebugThreadViewModule : PBXDebugDSModelViewModule

4867: - (id)stackTableThreadsPopUp;

7563: @interface PBXDebugProcessAndThreadModule : PBXDebugViewModule

11457: - (void)destroyThreadWithThreadHandle:(unsigned long)fp8;

11461: - (void)willUpdateThreads;

11462: - (void)didUpdateThreads;

11505: - (oneway void)requestSuspendAllThreads;

11872: - (void)debuggerWillUpdateThreads:(id)fp8;

11881: - (void)debuggerDidUpdateThreads:(id)fp8;

11886: - (id)nonRunningThreads;

11958: - (id)parentThreadGroup;

11983: @interface PBXLSThreadGroup : PBXLSModel

13118: - (BOOL)usesThreadedAnimation;

13119: - (void)setUsesThreadedAnimation:(BOOL)fp8;

13379: + (BOOL)useThreadedAnimation;

20671: - (BOOL)usesThreadedAnimation;

20672: - (void)setUsesThreadedAnimation:(BOOL)fp8;

11458: - (id)threadGroupWithName:(id)fp8 create:(BOOL)fp12;

11459: - (oneway void)setState:(int)fp8 status:(int)fp12 isCurrentThread:(BOOL)fp16 forServerThreadHandle:(unsigned long)fp20;

11486: - (void)threadRequest:(byref id)fp8 stepUntilLineNumber:(unsigned int)fp12;

11494: - (void)requestDebuggerMovePCInThread:(unsigned long)fp8 fileSpec:(id)fp12;

11640: - (void)requestPrintDescriptionInThread:(id)fp8 atStackFrame:(id)fp12;

11875: - (void)debugger:(id)fp8 setCurrentThread:(id)fp12;

11995: - (void)debugger:(id)fp8 addThread:(id)fp12;

11996: - (void)debugger:(id)fp8 removeThread:(id)fp12;

11455: - (void)createThreadWithThreadHandle:(unsigned long)fp8 name:(id)fp12 inThreadGroupNamed:(id)fp16;

11873: - (void)debugger:(id)fp8 addThreadGroup:(id)fp12;

11874: - (void)debugger:(id)fp8 removeThreadGroup:(id)fp12;

11970: - (void)debugger:(id)fp8 setThreadState:(int)fp12 status:(int)fp16;

14988: - (BOOL)detachNewThreadSelector:(SEL)fp8 cancelSelector:(SEL)fp12 toTarget:(id)fp16 withObject:(id)fp20;

1695:         volatile Thread thread;

406:     static final class ThreadPerTaskExecutor implements Executor {

2660:             public Thread newThread(Runnable r) {

2659:         static final class DaemonThreadFactory implements ThreadFactory {

62:  * <em>non-async</em> methods may be performed by the thread that

69:  * which case, a new Thread is created to run each task).

76:  * class maintains at most one daemon thread for triggering and

174:      *   invocation if already claimed by another thread.

407:         public void execute(Runnable r) { new Thread(r).start(); }

530:          * thread claims ownership.  If async, starts as task -- a

1684:      * Completion for recording and releasing a waiting thread.  This

1698:             this.thread = Thread.currentThread();

1704:             Thread w; // no need to atomically claim

1705:             if ((w = thread) != null) {

1706:                 thread = null;

1712:             if (Thread.interrupted())

1718:                     thread == null);

1729:         final boolean isLive() { return thread != null; }

1761:             q.thread = null;

1766:                     Thread.currentThread().interrupt();

1779:         if (Thread.interrupted())

1805:                 q.thread = null;

1918:      * @throws InterruptedException if the current thread was interrupted

1935:      * @throws InterruptedException if the current thread was interrupted

2421:      * parallel thread, or else an Executor using one thread per async

2423:      * an Executor that provides at least one independent thread.

2661:                 Thread t = new Thread(r);

51:  * <p>When two or more threads attempt to

195:      * linked). Multiple threads can call postComplete, which

203:      * that wake up waiting threads.  The mechanics are similar to

213:      * threads nulling out fields.  We also try to unlink fired

216:      * volatile because they are only visible to other threads upon

403:         ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

1743:                 if (ThreadLocalRandom.nextSecondarySeed() >= 0)

2668:         static final ScheduledThreadPoolExecutor delayer;

2670:             (delayer = new ScheduledThreadPoolExecutor(

2671:                 1, new DaemonThreadFactory())).

192:     volatile @Nullable Thread thread;

1188:     abstract void putThread(Waiter waiter, Thread newValue);

1258:     void putThread(Waiter waiter, Thread newValue) {

1308:     void putThread(Waiter waiter, Thread newValue) {

1341:     void putThread(Waiter waiter, Thread newValue) {

1214:     static final long WAITER_THREAD_OFFSET;

1288:     final AtomicReferenceFieldUpdater<Waiter, Thread> waiterThreadUpdater;

158:                 newUpdater(Waiter.class, Thread.class, "thread"),

203:       ATOMIC_HELPER.putThread(this, Thread.currentThread());

214:       // unpark even though the thread has already removed itself from the list. But even if we did

216:       Thread w = thread;

218:         thread = null;

230:    *   <li>This is only called when a waiting thread times out or is interrupted. Both of which

236:     node.thread = null; // mark as 'deleted'

247:         if (curr.thread != null) { // we aren't unlinking this node, update pred.

251:           if (pred.thread == null) { // We raced with another node that unlinked pred. Restart.

385:   //   have observed 12 micros on 64 bit linux systems to wake up a parked thread). So if the

402:    * current thread is interrupted during the call, even if the value is already available.

414:     if (Thread.interrupted()) {

434:               if (Thread.interrupted()) {

449:                 // Remove the waiter, one way or another we are done parking this thread.

469:       if (Thread.interrupted()) {

513:    * current thread is interrupted during the call, even if the value is already available.

520:     if (Thread.interrupted()) {

537:             if (Thread.interrupted()) {

929:         Thread.currentThread().interrupt();

1153:     // arbitrary cycles using a thread local but this should be a good enough solution (it is also

1187:     /** Non volatile write of the thread to the {@link Waiter#thread} field. */

1248:         WAITER_THREAD_OFFSET = unsafe.objectFieldOffset(Waiter.class.getDeclaredField("thread"));

1259:       UNSAFE.putObject(waiter, WAITER_THREAD_OFFSET, newValue);

1295:         AtomicReferenceFieldUpdater<Waiter, Thread> waiterThreadUpdater,

1342:       waiter.thread = newValue;

368:   /** All waiting threads. */

934:   /** Unblocks all threads and runs all listeners. */

1033:   /** Releases all threads in the {@link #waiters} list, and clears the list. */

1300:       this.waiterThreadUpdater = waiterThreadUpdater;

1309:       waiterThreadUpdater.lazySet(waiter, newValue);

1624:             "needle": "^2.2.1",

1605:         "needle": {

192:     @NullableDecl volatile Thread thread;

1190:     abstract void putThread(Waiter waiter, Thread newValue);

1260:     void putThread(Waiter waiter, Thread newValue) {

1310:     void putThread(Waiter waiter, Thread newValue) {

1343:     void putThread(Waiter waiter, Thread newValue) {

1216:     static final long WAITER_THREAD_OFFSET;

1290:     final AtomicReferenceFieldUpdater<Waiter, Thread> waiterThreadUpdater;

158:                 newUpdater(Waiter.class, Thread.class, "thread"),

203:       ATOMIC_HELPER.putThread(this, Thread.currentThread());

214:       // unpark even though the thread has already removed itself from the list. But even if we did

216:       Thread w = thread;

218:         thread = null;

230:    *   <li>This is only called when a waiting thread times out or is interrupted. Both of which

236:     node.thread = null; // mark as 'deleted'

247:         if (curr.thread != null) { // we aren't unlinking this node, update pred.

251:           if (pred.thread == null) { // We raced with another node that unlinked pred. Restart.

385:   //   have observed 12 micros on 64 bit linux systems to wake up a parked thread). So if the

402:    * current thread is interrupted during the call, even if the value is already available.

414:     if (Thread.interrupted()) {

434:               if (Thread.interrupted()) {

449:                 // Remove the waiter, one way or another we are done parking this thread.

469:       if (Thread.interrupted()) {

513:    * current thread is interrupted during the call, even if the value is already available.

520:     if (Thread.interrupted()) {

537:             if (Thread.interrupted()) {

929:         Thread.currentThread().interrupt();

1155:     // arbitrary cycles using a thread local but this should be a good enough solution (it is also

1189:     /** Non volatile write of the thread to the {@link Waiter#thread} field. */

1250:         WAITER_THREAD_OFFSET = unsafe.objectFieldOffset(Waiter.class.getDeclaredField("thread"));

1261:       UNSAFE.putObject(waiter, WAITER_THREAD_OFFSET, newValue);

1297:         AtomicReferenceFieldUpdater<Waiter, Thread> waiterThreadUpdater,

1344:       waiter.thread = newValue;

368:   /** All waiting threads. */

934:   /** Unblocks all threads and runs all listeners. */

1034:   /** Releases all threads in the {@link #waiters} list, and clears the list. */

1302:       this.waiterThreadUpdater = waiterThreadUpdater;

1311:       waiterThreadUpdater.lazySet(waiter, newValue);

347:   optional uint64 thread  = 5; // required

54:     SUSPEND_THREAD        = 9;

55:     RESUME_THREAD         = 10;

75:   repeated uint64 thread_id = 2;

185:     UNKNOWN_THREAD             = 12;

232:   repeated uint64 thread_id = 1;

306:     THREAD_CREATED   = 2;

307:     THREAD_EXITED    = 3;

318:   optional ThreadCreatedInfo   thread_created_info   = 3;

319:   optional ThreadExitedInfo    thread_exited_info    = 4;

330:   optional uint64 thread_id = 3; // required

334:   optional uint64 thread_id = 1; // required

338:   optional uint64 thread_id = 1; // required

357:   optional uint64 thread_id    = 3; // required

365:   optional uint64 thread_id = 1; // required

333: message ThreadCreatedInfo {

337: message ThreadExitedInfo {

84:   optional SuspendThreadArgs       suspend_thread_args        = 9;

85:   optional ResumeThreadArgs        resume_thread_args         = 10;

206:   optional SuspendThreadResult       suspend_thread_result        = 9;

207:   optional ResumeThreadResult        resume_thread_result         = 10;

53:     LIST_THREADS          = 8;

83:   optional ListThreadsArgs         list_threads_args          = 8;

205:   optional ListThreadsResult         list_threads_result          = 8;

118: message ListThreadsArgs {

121: message SuspendThreadArgs {

124: message ResumeThreadArgs {

231: message ListThreadsResult {

235: message SuspendThreadResult {

238: message ResumeThreadResult {

52:     // thread control

74:   //       not all commands could be executed thread-locally (like write memory)

186:     // Someone tried to resume already running thread.

72:   // execute the command only on those threads

1560:             "needle": "^2.2.1",

1541:         "needle": {

285: Thread = namedtuple ("Thread", ("id", "name", "state", "frames"))

744:                 def thread (id, state = None):

734:                 def match_thread (thread, id, state = None):

2930:         def thread_filter_source_get (self):

2933:         def thread_filter_source_set (self, thread_filter):

2940:         def thread_filter_button_toggled (self, button):

275: class ThreadState (enum.Enum):

1955:     class ThreadStore (Gtk.ListStore):

2237:     def threads_row_activated (self, tree, path, col):

2257:     def threads_selection_changed (self, tree_sel):

2433:     class ThreadFilter (Gtk.TreeView):

2557:     class ThreadPopover (Gtk.Popover):

312:             for thread in element.find ("backtrace").iterfind ("thread"):

313:                 id      = thread.get ("id")

314:                 name    = thread.get ("name")

315:                 running = thread.get ("running")

317:                 t = Thread (

325:                 for frame in thread.iterfind ("frame"):

722:             f = eval ("lambda thread, function, %s: %s" % (

737:                              id == thread.id)                 or  \

739:                              thread.name                      and \

740:                              re.fullmatch (id, thread.name))) and \

742:                             re.fullmatch (state, str (thread.state)))

745:                     return any (match_thread (thread, id, state)

746:                                 for thread in samples[i].backtrace or [])

749:                     for thread in samples[i].backtrace or []:

750:                         if match_thread (thread, id, state):

751:                             for frame in thread.frames:

757:                 if f (thread, function, **{

2024:         self.thread_store = store

2028:         self.thread_tree = tree

2205:         sel_rows = self.thread_tree.get_selection ().get_selected_rows ()[1]

2208:             tid = self.thread_store[sel_rows[0]][self.ThreadStore.ID]

2212:         self.thread_store.clear ()

2215:             thread = samples[i].backtrace[t]

2217:             iter = self.thread_store.append (

2218:                 (t, thread.id, thread.name, str (thread.state))

2221:             if thread.id == tid:

2222:                 self.thread_tree.get_selection ().select_iter (iter)

2238:         iter = self.thread_store.get_iter (path)

2240:         tid = self.thread_store[iter][self.ThreadStore.ID]

2245:             threads = filter (lambda thread:

2246:                                 thread.id    == tid and

2247:                                 thread.state == ThreadState.RUNNING,

2298:             for thread in sample.backtrace or []:

2299:                 for frame in thread.frames:

2446:                 threads = list ({thread.id

2448:                                  for thread in sample.backtrace or ()})

2532:             threads = {thread.id: thread.name

2534:                        for thread in samples[i].backtrace or ()}

2574:             thread_filter = ProfileViewer.ThreadFilter ()

2575:             self.thread_filter = thread_filter

2576:             scrolled.add (thread_filter)

2577:             thread_filter.show ()

2640:                 thread_filter_store = popover.thread_filter.store

2642:                 self.thread_filter_store = thread_filter_store

2643:                 self.thread_filter       = thread_filter_store.get_filter ()

2645:                 history.add_source (self.thread_filter_source_get,

2646:                                     self.thread_filter_source_set)

2652:                 button.connect ("toggled", self.thread_filter_button_toggled)

2762:                 for thread in samples[i].backtrace or []:

2763:                     if thread.state in self.thread_filter[thread.id]:

2764:                         thread_frames = thread.frames

2767:                             thread_frames = reversed (thread_frames)

2772:                         for frame in thread_frames:

2931:             return self.thread_filter_store.get_filter ()

2934:             self.thread_filter = thread_filter

2936:             self.thread_filter_store.set_filter (thread_filter)

2942:                 thread_filter = self.thread_filter_store.get_filter ()

2944:                 if thread_filter != self.thread_filter:

2945:                     self.thread_filter = thread_filter

281:             ThreadState.SUSPENDED: "S",

282:             ThreadState.RUNNING:   "R"

320:                     state  = ThreadState.RUNNING if running and int (running) \

321:                              else ThreadState.SUSPENDED,

2012:         header = Gtk.HeaderBar (title = "Threads", has_subtitle = False)

2023:         store = self.ThreadStore ()

2033:         tree.connect ("row-activated", self.threads_row_activated)

2036:                                        self.threads_selection_changed)

2044:         col.add_attribute (cell, "text", self.ThreadStore.ID)

2052:         col.add_attribute (cell, "text", self.ThreadStore.NAME)

2060:         col.add_attribute (cell, "text", self.ThreadStore.STATE)

2250:             if list (threads):

2438:             STATE   = {list (ThreadState)[i]: 3 + i

2439:                        for i in range (len (ThreadState))}

2449:                 threads.sort ()

2451:                 states = [state == ThreadState.RUNNING for state in self.STATE]

2453:                 for id in threads:

2539:                 if id in threads:

2541:                     row[self.store.NAME]    = threads[id]

2638:                 popover = ProfileViewer.ThreadPopover ()

2659:                 label = Gtk.Label (label = "Threads")

814:   HANDLE thread;

42: #define CURRENT_THREAD ((HANDLE)-2)

270:   PVOID UniqueThread;

286:   ThreadBasicInformation,

287:   ThreadTimes,

288:   ThreadPriority,

289:   ThreadBasePriority,

290:   ThreadAffinityMask,

291:   ThreadImpersonationToken,

292:   ThreadDescriptorTableEntry,

293:   ThreadEnableAlignmentFaultFixup,

294:   ThreadEventPair,

295:   ThreadQuerySetWin32StartAddress,

296:   ThreadZeroTlsCell,

297:   ThreadPerformanceCount,

298:   ThreadAmILastThread,

299:   ThreadIdealProcessor,

300:   ThreadPriorityBoost,

301:   ThreadSetTlsArrayAddress,

302:   ThreadIsIoPending,

303:   ThreadHideFromDebugger

285: typedef enum _NT_THREAD_INFORMATION_CLASS {

304: } NT_THREAD_INFORMATION_CLASS,

305:     *PNT_THREAD_INFORMATION_CLASS;

273: typedef NTSTATUS(WINAPI* NtOpenThreadFunction)(OUT PHANDLE ThreadHandle,

307: typedef NTSTATUS(WINAPI* NtSetInformationThreadFunction)(

377: typedef NTSTATUS(WINAPI* NtOpenThreadTokenFunction)(IN HANDLE ThreadHandle,

383: typedef NTSTATUS(WINAPI* NtOpenThreadTokenExFunction)(IN HANDLE ThreadHandle,

408: typedef NTSTATUS(WINAPI* RtlCreateUserThreadFunction)(

266: // Process and Thread

309:     IN NT_THREAD_INFORMATION_CLASS ThreadInformationClass,

417:     OUT PHANDLE Thread,

308:     IN HANDLE ThreadHandle,

310:     IN PVOID ThreadInformation,

311:     IN ULONG ThreadInformationLength);

410:     IN PSECURITY_DESCRIPTOR ThreadSecurityDescriptor,

415:     IN LPTHREAD_START_ROUTINE StartAddress,

232: struct Thread {

247:   Thread(unsigned int tid, ThreadState state)

136: enum ThreadState {

264:   typedef std::function<bool(const Thread&)> ThreadComparator;

586:   std::vector<Thread> threads;

589:   void addThread(const Thread& thread) {

158:   dbgevt_thread_created,

161:   dbgevt_thread_closed,

266:   static ThreadComparator MakeThreadIdComparator(int tid) {

593:   std::vector<Thread> getThreads() const {

135: // Identifies the state of a thread

137:   // Thread is running

140:   // Thread is suspended

157:   // A new thread was created in the target process

160:   // An existing thread was closed in the target process

230:  * Describes a thread of the target process

233:   //  The thread ID of the thread

236:   // The state of the thread

242:    * Creates a new Thread object

244:    * @param tid The thread ID of the thread

245:    * @param state The state of the thread

252:   bool operator==(const Thread& rhs) const {

256:   bool operator<(const Thread& rhs) const {

261:    * Returns a function which matches the thread with a given id

267:     return [tid](const Thread& t)->bool {return t.tid == tid; };

414:   // Thread ID of the thread where the exception happened

590:     threads.push_back(thread);

717:       std::vector<Thread> threads = registers.getThreads();

719:       for (std::vector<Thread>::iterator Iter = threads.begin();

721:         Thread t = *Iter;

237:   ThreadState state;

594:     return threads;

720:           Iter != threads.end(); ++Iter) {