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

333: ...(751 bytes skipped)....subscribe(onTween);this._onComplete.subscribe(onComplete);}};YAHOO.util.AnimMgr=new function(){var thread=null;var queue=[];var tweenCount=0;this.fps=1000;this.delay=1;this.registerElement=function(tween){...(197 bytes skipped)...

83: ...(5 bytes skipped)...n id;};return Y.Dom.batch(el,f,Y.Dom,true)||f.apply(Y.Dom,arguments);},isAncestor:function(haystack,needle){haystack=Y.Dom.get(haystack);if(!haystack||!needle){return false;}

86: return false;};return Y.Dom.batch(needle,f,Y.Dom,true);},inDocument:function(el){var f=function(el){if(isSafari){while(el=el.parentNode){if(...(44 bytes skipped)...

335: return true;};this.start=function(){if(thread===null){thread=setInterval(this.run,this.delay);}};this.stop=function(tween){if(!tween){clearInterval(thread);for(var i=0,len=queue.length;i<len;++i){if(queue[0].isAnimated()){this.unRegister(queue[0],0);}}

336: queue=[];thread=null;tweenCount=0;}

87: typedef struct thread {

47: #define THREAD_STATS 1

48: #define THREAD_STACK_HIGHWATER 1

51: enum thread_state {

52:     THREAD_SUSPENDED = 0,

53:     THREAD_READY,

54:     THREAD_RUNNING,

55:     THREAD_BLOCKED,

56:     THREAD_SLEEPING,

57:     THREAD_DEATH,

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

63: enum thread_tls_list {

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

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

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

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

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

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

82: #define THREAD_FLAG_EXIT_ON_PANIC             (1U<<6)

83: #define THREAD_FLAG_FREE_SHADOW_STACK         (1U<<7)

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

98:     struct list_node thread_list_node;

133: } thread_t;

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

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

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

140: #define thread_curr_cpu(t) (0)

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

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

206: static inline void thread_sleep(lk_time_t delay_ms) {

232: static inline uint thread_lock_owner_get(void) {

236: static inline void thread_lock_complete(void) {

242: static inline void thread_unlock_prepare(void) {

249: #define THREAD_LOCK(state) \

254: #define THREAD_UNLOCK(state) \

258: static inline void thread_lock_ints_disabled(void) {

264: static inline void thread_unlock_ints_disabled(void) {

269: static inline bool thread_lock_held(void)

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

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

305: static inline void thread_set_flag(thread_t *t, uint flag, bool enable)

316: static inline bool thread_get_flag(thread_t *t, uint flag)

335: static inline void thread_set_flag_exit_on_panic(thread_t *t, bool enable)

340: static inline bool thread_get_flag_exit_on_panic(thread_t *t)

347: struct thread_stats {

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

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

24: #define __KERNEL_THREAD_H

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

23: #ifndef __KERNEL_THREAD_H

32: #include <arch/thread.h>

62: /* thread local storage */

103:     enum thread_state state;

119:     struct arch_thread arch;

122:     thread_start_routine entry;

129:     /* thread local storage */

145: /* thread priority */

172: void thread_init_early(void);

173: void thread_init(void);

174: void thread_become_idle(void) __NO_RETURN;

175: void thread_secondary_cpu_init_early(void);

176: void thread_secondary_cpu_entry(void) __NO_RETURN;

177: void thread_set_name(const char *name);

180:  * thread_set_priority() - set priority of current thread

181:  * @priority:      Priority for the current thread,

186:  *                 holding the thread lock.

188: void thread_set_priority(int priority);

191:  * thread_set_pinned_cpu() - Pin thread to a given CPU.

192:  * @t:             Thread to pin

193:  * @cpu:           cpu id on which to pin the thread

196:  *                 holding the thread lock.

198: void thread_set_pinned_cpu(thread_t* t, int cpu);

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

201: 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, size_t shadow_stack_s...(5 bytes skipped)...

202: status_t thread_resume(thread_t *);

203: void thread_exit(int retcode) __NO_RETURN;

204: void thread_sleep_ns(lk_time_ns_t delay_ns);

205: void thread_sleep_until_ns(lk_time_ns_t target_time_ns);

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

209: status_t thread_detach(thread_t *t);

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

211: status_t thread_detach_and_resume(thread_t *t);

212: status_t thread_set_real_time(thread_t *t);

214: void dump_thread(thread_t *t);

215: void arch_dump_thread(thread_t *t);

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

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

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

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

224: /* the current thread */

225: thread_t *get_current_thread(void);

226: void set_current_thread(thread_t *);

229: extern spin_lock_t thread_lock;

230: extern atomic_uint thread_lock_owner;

233:     return atomic_load_explicit(&thread_lock_owner, memory_order_relaxed);

237:     DEBUG_ASSERT(thread_lock_owner_get() == SMP_MAX_CPUS);

238:     atomic_store_explicit(&thread_lock_owner, arch_curr_cpu_num(),

244:     DEBUG_ASSERT(thread_lock_owner_get() == arch_curr_cpu_num());

245:     atomic_store_explicit(&thread_lock_owner, (uint)SMP_MAX_CPUS,

251:     spin_lock_irqsave(&thread_lock, state); \

252:     thread_lock_complete()

255:     thread_unlock_prepare(); \

256:     spin_unlock_irqrestore(&thread_lock, state)

260:     spin_lock(&thread_lock);

261:     thread_lock_complete();

265:     thread_unlock_prepare();

266:     spin_unlock(&thread_lock);

274:     ret = thread_lock_owner_get() == arch_curr_cpu_num();

279: /* thread local storage */

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

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

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

307:     THREAD_LOCK(state);

313:     THREAD_UNLOCK(state);

319:     THREAD_LOCK(state);

321:     THREAD_UNLOCK(state);

326:  * thread_set_flag_exit_on_panic - Set flag to ignore panic in specific thread

327:  * @t:       Thread to set flag on

328:  * @enable:  If %true, exit thread instead of halting system if panic is called

337:     thread_set_flag(t, THREAD_FLAG_EXIT_ON_PANIC, enable);

342:     return thread_get_flag(t, THREAD_FLAG_EXIT_ON_PANIC);

345: /* thread level statistics */

346: #if THREAD_STATS

363: extern struct thread_stats thread_stats[SMP_MAX_CPUS];

216: void dump_all_threads(void);

332:  * Should only be used for kernel test threads as it is generally not safe to

153:             Pointer<Thread> thread;

957:         bool prestartCoreThread() {

1353: ThreadPoolExecutor::ThreadPoolExecutor(int corePoolSize, int maxPoolSize,

1382: ThreadPoolExecutor::ThreadPoolExecutor(int corePoolSize, int maxPoolSize,

1414: ThreadPoolExecutor::ThreadPoolExecutor(int corePoolSize, int maxPoolSize,

1446: ThreadPoolExecutor::ThreadPoolExecutor(int corePoolSize, int maxPoolSize,

1690: bool ThreadPoolExecutor::prestartCoreThread() {

1478: ThreadPoolExecutor::~ThreadPoolExecutor() {

315:         bool coreThreadsCanTimeout;

961:         int prestartAllCoreThreads() {

969:         void allowCoreThreadTimeOut(bool value) {

1614: void ThreadPoolExecutor::setThreadFactory(ThreadFactory* factory) {

1627: ThreadFactory* ThreadPoolExecutor::getThreadFactory() const {

1670: void ThreadPoolExecutor::allowCoreThreadTimeout(bool value) {

1685: bool ThreadPoolExecutor::allowsCoreThreadTimeout() const {

1695: int ThreadPoolExecutor::prestartAllCoreThreads() {

61:      * task deletion logic can remain unchanged and thread safe.

102:      * for example when a ThreadFactory fails to create a thread when

114:      *             the thread transitioning to state TIDYING

168:                 AbstractQueuedSynchronizer(), Runnable(), thread(), firstTask(task), kernel(kernel), completedTasks(0) {

175:                 this->thread.reset(kernel->factory->newThread(this));

210:                     setExclusiveOwnerThread(Thread::currentThread());

226:          * to the Timer's thread.

307:          * up on a separate thread because the Worker generally adds itself to the deadWorkers

422:                     worker->thread->join();

593:                     iter->next()->thread->interrupt();

611:          *      currently waiting.  Interrupting any arbitrary thread ensures that

624:                     Pointer<Thread> thread = worker->thread;

625:                     if (!thread->isInterrupted() && worker->tryLock()) {

627:                             thread->interrupt();

656:          * Ensures that unless the pool is stopping, the current thread does not have

661:             if (this->runStateLessThan(ctl.get(), STOP) && Thread::interrupted() &&

664:                 Thread::currentThread()->interrupt();

690:          * usually leads processWorkerExit to replace this thread.

695:          * stopping, this thread does not have its interrupt set.

698:          * might throw an exception, in which case we cause thread to die

708:          * thread's UncaughtExceptionHandler).  Any thrown exception also

709:          * conservatively causes thread to die.

712:          * also throw an exception, which will also cause thread to

717:          * and the thread's UncaughtExceptionHandler have as accurate

732:                         this->parent->beforeExecute(w->thread.get(), task);

796:              * start a new thread with the given command as its first

802:              * to double-check whether we should have added a thread

806:              * stopped, or start a new thread if there are none.

809:              * thread.  If it fails, we know we are shut down or saturated

1106:          * if the thread factory fails to create a thread when asked, which requires

1111:          *      The task the new thread should run first (or null if none).

1153:             Pointer<Thread> t = w->thread;

1187:             // It is possible (but unlikely) for a thread to have been added to

1189:             // could result in a rare missed interrupt, because Thread::interrupt

1190:             // is not guaranteed to have any effect on a non-yet-started Thread

1191:             // (see Thread#interrupt).

1203:          * thread from worker set, and possibly terminates the pool or replaces the

1329:          * abrupt termination of a thread (see processWorkerExit). Other

1710: void ThreadPoolExecutor::beforeExecute(Thread* thread DECAF_UNUSED, Runnable* task DECAF_UNUSED) {

18: #include "ThreadPoolExecutor.h"

89:      *   workerCount, indicating the effective number of threads

93:      * (2^29)-1 (about 500 million) threads rather than (2^31)-1 (2

101:      * transiently different from the actual number of live threads,

103:      * asked, and when exiting threads are still performing

133:      * Threads waiting in awaitTermination() will return when the

172:                         "ThreadPoolExecutor Worker requires non-NULL pointer to parent ExecutorKernel");

217:                 this->setExclusiveOwnerThread(NULL);

291:         ThreadPoolExecutor* parent;

294:          * List containing all worker threads in pool. Accessed only when holding mainLock.

318:          * The queue used for holding tasks and handing off to worker threads.

333:          * Otherwise exiting threads would concurrently interrupt those that have not

349:         Pointer<ThreadFactory> factory;

354:         ExecutorKernel(ThreadPoolExecutor* parent,

357:                        ThreadFactory* threadFactory, RejectedExecutionHandler* handler) :

381:            if(workQueue == NULL || threadFactory == NULL || handler == NULL) {

389:            this->factory.reset(threadFactory);

417:                 // Ensure dead Worker Threads are destroyed, the Timer might not have

586:          * Force an interrupt of all threads even if they are currently active.

603:          * Interrupts threads that might be waiting for tasks (as indicated by not

610:          *      interrupted to propagate shutdown signals in case all threads are

795:              * 1. If fewer than corePoolSize threads are running, try to

799:              * threads when it shouldn't, by returning false.

932:                 // We don't really know how many new threads are "needed".

972:                     "Core threads must have nonzero keep alive times");

990:                     "Core threads must have nonzero keep alive times");

1113:          *      to bypass queuing when there are fewer than corePoolSize threads

1115:          *      (in which case we must bypass queue). Initially idle threads are

1116:          *      usually created via prestartCoreThread or to replace other dying workers.

1157:                 // Recheck while holding lock. Back out on ThreadFactory failure or if

1201:          * worker threads. Unless completedAbruptly is set, assumes that workerCount

1365:         Pointer<RejectedExecutionHandler> handler(new ThreadPoolExecutor::AbortPolicy());

1366:         Pointer<ThreadFactory> threadFactory(Executors::getDefaultThreadFactory());

1370:             threadFactory.get(), handler.get());

1373:         threadFactory.release();

1399:         Pointer<ThreadFactory> threadFactory(Executors::getDefaultThreadFactory());

1403:             threadFactory.get(), handler);

1405:         threadFactory.release();

1417:                                        ThreadFactory* threadFactory) :

1427:         if(threadFactory == NULL) {

1428:             throw NullPointerException(__FILE__, __LINE__, "The ThreadFactory pointer cannot be NULL.");

1431:         Pointer<RejectedExecutionHandler> handler(new ThreadPoolExecutor::AbortPolicy());

1435:             threadFactory, handler.get());

1449:                                        ThreadFactory* threadFactory, RejectedExecutionHandler* handler) :

1463:         if(threadFactory == NULL) {

1464:             throw NullPointerException(__FILE__, __LINE__, "The ThreadFactory pointer cannot be NULL.");

1469:             threadFactory, handler);

1488: void ThreadPoolExecutor::execute(Runnable* task) {

1495:                 "ThreadPoolExecutor::execute - Supplied Runnable pointer was NULL.");

1507: void ThreadPoolExecutor::execute(Runnable* task, bool takeOwnership) {

1514:                 "ThreadPoolExecutor::execute - Supplied Runnable pointer was NULL.");

1526: void ThreadPoolExecutor::shutdown() {

1536: ArrayList<Runnable*> ThreadPoolExecutor::shutdownNow() {

1549: bool ThreadPoolExecutor::awaitTermination(long long timeout, const TimeUnit& unit) {

1559: int ThreadPoolExecutor::getPoolSize() const {

1564: int ThreadPoolExecutor::getCorePoolSize() const {

1569: void ThreadPoolExecutor::setCorePoolSize(int poolSize) {

1579: int ThreadPoolExecutor::getMaximumPoolSize() const {

1584: void ThreadPoolExecutor::setMaximumPoolSize(int maxSize) {

1594: long long ThreadPoolExecutor::getTaskCount() const {

1599: int ThreadPoolExecutor::getActiveCount() const {

1604: long long ThreadPoolExecutor::getCompletedTaskCount() const {

1609: int ThreadPoolExecutor::getLargestPoolSize() const {

1617:         throw NullPointerException(__FILE__, __LINE__, "Cannot assign a NULL ThreadFactory.");

1621:         Pointer<ThreadFactory> temp(factory);

1632: RejectedExecutionHandler* ThreadPoolExecutor::getRejectedExecutionHandler() const {

1637: void ThreadPoolExecutor::setRejectedExecutionHandler(RejectedExecutionHandler* handler) {

1650: BlockingQueue<Runnable*>* ThreadPoolExecutor::getQueue() {

1655: bool ThreadPoolExecutor::isShutdown() const {

1660: bool ThreadPoolExecutor::isTerminated() const {

1665: bool ThreadPoolExecutor::isTerminating() const {

1675: long long ThreadPoolExecutor::getKeepAliveTime(const TimeUnit& unit) const {

1680: void ThreadPoolExecutor::setKeepAliveTime(long long timeout, const TimeUnit& unit) {

1691:     return this->kernel->prestartCoreThread();

1700: bool ThreadPoolExecutor::remove(decaf::lang::Runnable* task) {

1705: void ThreadPoolExecutor::purge() {

1714: void ThreadPoolExecutor::afterExecute(Runnable* task DECAF_UNUSED, decaf::lang::Throwable* error DECAF_UNUSED) ...(1 bytes skipped)...

1718: void ThreadPoolExecutor::terminated() {

1722: void ThreadPoolExecutor::onShutdown() {

366:            coreThreadsCanTimeout(false),

540:          * allow access from ScheduledThreadPoolExecutor.

669:          * State check needed by ScheduledThreadPoolExecutor to enable running

975:             if (value != this->coreThreadsCanTimeout) {

976:                 this->coreThreadsCanTimeout = value;

988:             if (time == 0 && this->coreThreadsCanTimeout) {

1232:                     int min = this->coreThreadsCanTimeout ? 0 : corePoolSize;

1254:          *     {@code allowCoreThreadTimeOut || workerCount > corePoolSize})

1277:                     timed = this->coreThreadsCanTimeout || wc > this->corePoolSize;

1671:     this->kernel->allowCoreThreadTimeOut(value);

1686:     return this->kernel->coreThreadsCanTimeout;

1696:     return this->kernel->prestartAllCoreThreads();

173:     String needle;

179:       needle = randomString(length, asciiOnly);

199:     FuzzerCallbacks.traceStrstr(state.haystack, state.needle, state.pc);

204:     FuzzerCallbacksOptimizedNonCritical.traceStrstr(state.haystack, state.needle, state.pc);

211:     FuzzerCallbacksOptimizedCritical.traceStrstrJava(state.haystack, state.needle, state.pc);

217:     FuzzerCallbacksOptimizedNonCritical.traceStrstrJava(state.haystack, state.needle, state.pc);

20: import java.util.concurrent.ThreadLocalRandom;

83:       Random random = ThreadLocalRandom.current();

142:       Random random = ThreadLocalRandom.current();

184:           ThreadLocalRandom.current()

50:         private Thread thread;

28: public class ThreadPool {

111: 	private final ThreadGroup threadGroup;

123: 	public ThreadPool(int pMaxSize, String pName) {

113: 	private final List waitingThreads = new ArrayList();

114: 	private final List runningThreads = new ArrayList();

226: 	public int getMaxThreads() { return maxSize; }

231:     public synchronized int getNumThreads() { return num; }

25: /** Simple thread pool. A task is executed by obtaining a thread from

29: 	/** The thread pool contains instances of {@link ThreadPool.Task}.

33: 		 * @throws Throwable The task failed, and the worker thread won't be used again.

52:             thread = new Thread(pGroup, pGroup.getName() + "-" + pNum){

80:             thread.start();

93:             synchronized (thread) {

94:                 thread.notify();

105:             synchronized (thread) {

106:                 thread.notify();

121: 	 * @param pName Thread group name.

51:         Poolable(ThreadGroup pGroup, int pNum) {

120: 	 * @param pMaxSize Maximum number of concurrent threads.

125: 		threadGroup = new ThreadGroup(pName);

167: 	 * might consider to use the {@link #addTask(ThreadPool.Task)} method instead.

189:             poolable = new Poolable(threadGroup, num++);

223: 	/** Returns the maximum number of concurrent threads.

224: 	 * @return Maximum number of threads.

228: 	/** Returns the number of threads, which have actually been created,

229:      * as opposed to the number of currently running threads.

129:         runningThreads.remove(pPoolable);

130:         waitingThreads.remove(pPoolable);

138: 	        if (runningThreads.remove(pPoolable)) {

139: 	            if (maxSize != 0  &&  runningThreads.size() + waitingThreads.size() >= maxSize) {

142: 	                waitingThreads.add(pPoolable);

179:         if (maxSize != 0  &&  runningThreads.size() >= maxSize) {

186:         if (waitingThreads.size() > 0) {

187:             poolable = (Poolable) waitingThreads.remove(waitingThreads.size()-1);

191:         runningThreads.add(poolable);

213:         while (!waitingThreads.isEmpty()) {

214:             Poolable poolable = (Poolable) waitingThreads.remove(waitingThreads.size()-1);

217:         while (!runningThreads.isEmpty()) {

218:             Poolable poolable = (Poolable) runningThreads.remove(runningThreads.size()-1);

65:   const gchar                     *needle;

408:   lookup.needle = query;

550:   g_task_run_in_thread (task, dzl_fuzzy_index_cursor_worker);

1046:         public Thread thread;

93:     private static ReferenceQueueThread REFERENCE_QUEUE_THREAD;

917:         public synchronized void notifyWaitingThread(HostConfiguration configuration) {

928:         public synchronized void notifyWaitingThread(HostConnectionPool hostPool) {

1044:     private static class WaitingThread {

1061:     private static class ReferenceQueueThread extends Thread {

1068:         public ReferenceQueueThread() {

65: public class MultiThreadedHttpConnectionManager implements HttpConnectionManager {

256:     public MultiThreadedHttpConnectionManager() {

706:         private LinkedList waitingThreads = new LinkedList();

1034:         public LinkedList waitingThreads = new LinkedList();

91:      * The thread responsible for handling lost connections.

134:             if (REFERENCE_QUEUE_THREAD != null) {

135:                 REFERENCE_QUEUE_THREAD.shutdown();

136:                 REFERENCE_QUEUE_THREAD = null;

171:             // start the reference queue thread if needed

172:             if (REFERENCE_QUEUE_THREAD == null) {

173:                 REFERENCE_QUEUE_THREAD = new ReferenceQueueThread();

174:                 REFERENCE_QUEUE_THREAD.start();

507:                             waitingThread.thread = Thread.currentThread();

531:                             // interrupted by an external thread.  Regardless we need to 

624:      * If another thread is blocked in getConnection() that could use this

741:                 waiter.thread.interrupt();

912:          * Notifies a waiting thread that a connection for the given configuration is 

922:          * Notifies a waiting thread that a connection for the given configuration is 

923:          * available.  This will wake a thread waiting in this host pool or if there is not

924:          * one a thread in the connection pool will be notified.

930:             // find the thread we are going to notify, we want to ensure that each

931:             // waiting thread is only interrupted once so we will remove it from 

937:                     LOG.debug("Notifying thread waiting on host pool, hostConfig=" 

944:                     LOG.debug("No-one waiting on host pool, notifying next waiting thread.");

954:                 waitingThread.thread.interrupt();

1041:      * A simple struct-like class to combine the waiting thread and the connection 

1045:         /** The thread that is waiting for a connection */

1048:         /** The connection pool the thread is waiting for */

1051:         /** Flag to indicate if the thread was interrupted by the ConnectionPool. Set

1053:          * before the thread is interrupted. */

1058:      * A thread for listening for HttpConnections reclaimed by the garbage

1066:          * Create an instance and make this a daemon thread.

105:      * MultiThreadedHttpConnectionManager. All static resources are released, all threads are 

453:             WaitingThread waitingThread = null;

492:                     // threads, so they avoid being sacrificed before necessary

504:                         if (waitingThread == null) {

505:                             waitingThread = new WaitingThread();

506:                             waitingThread.hostConnectionPool = hostPool;

509:                             waitingThread.interruptedByConnectionPool = false;

516:                         hostPool.waitingThreads.addLast(waitingThread);

517:                         connectionPool.waitingThreads.addLast(waitingThread);

520:                         if (!waitingThread.interruptedByConnectionPool) {

529:                         if (!waitingThread.interruptedByConnectionPool) {

533:                             hostPool.waitingThreads.remove(waitingThread);

534:                             connectionPool.waitingThreads.remove(waitingThread);

735:             // interrupt all waiting threads

738:                 WaitingThread waiter = (WaitingThread) iter.next();

777:          * connection counts and notifies waiting threads, if appropriate.

787:             notifyWaitingThread(config);

915:          * @see #notifyWaitingThread(HostConnectionPool)

918:             notifyWaitingThread(getHostPool(configuration));

933:             WaitingThread waitingThread = null;

940:                 waitingThread = (WaitingThread) hostPool.waitingThreads.removeFirst();

941:                 waitingThreads.remove(waitingThread);

946:                 waitingThread = (WaitingThread) waitingThreads.removeFirst();

947:                 waitingThread.hostConnectionPool.waitingThreads.remove(waitingThread);

949:                 LOG.debug("Notifying no-one, there are no waiting threads");

952:             if (waitingThread != null) {

953:                 waitingThread.interruptedByConnectionPool = true;

1004:                 notifyWaitingThread(hostPool);

1052:          * to true inside {@link ConnectionPool#notifyWaitingThread(HostConnectionPool)} 

1115:                     LOG.debug("ReferenceQueueThread interrupted", e);

2: ...(43 bytes skipped)...ommons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/java/org/apache/commons/httpclient/MultiThreadedHttpConnectionManager.java,v 1.47 2004/12/21 11:27:55 olegk Exp $

70:     private static final Log LOG = LogFactory.getLog(MultiThreadedHttpConnectionManager.class);

107:      * MultiThreadedHttpConnectionManager.

118:                 MultiThreadedHttpConnectionManager[]

119:                     connManagers = (MultiThreadedHttpConnectionManager[])

121:                         new MultiThreadedHttpConnectionManager

522:                             throw new IllegalThreadStateException(

523:                                 "Interrupted while waiting in MultiThreadedHttpConnectionManager");

705:         /** The list of WaitingThreads waiting for a connection */

736:             iter = waitingThreads.iterator();

764:             connection.getParams().setDefaults(MultiThreadedHttpConnectionManager.this.params);

765:             connection.setHttpConnectionManager(MultiThreadedHttpConnectionManager.this);

935:             if (hostPool.waitingThreads.size() > 0) {

942:             } else if (waitingThreads.size() > 0) {

1033:         /** The list of WaitingThreads for this host */

1070:             setName("MultiThreadedHttpConnectionManager cleanup");

756:   SCM thread;

842:   SCM thread;

131: thread_mark (SCM obj)

143: thread_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED)

178: thread_free (SCM obj)

403: static scm_i_pthread_mutex_t thread_admin_mutex = SCM_I_PTHREAD_MUTEX_INITIALIZER;

405: static int thread_count;

784: launch_thread (void *d)

873: spawn_thread (void *d)

882: scm_spawn_thread (scm_t_catch_body body, void *body_data,

1712: scm_t_bits scm_tc16_thread;

1610: static int threads_initialized_p = 0;

355: scm_i_pthread_key_t scm_i_thread_key;

508: do_thread_exit (void *v)

525: on_thread_exit (void *v)

552: static scm_i_pthread_once_t init_thread_key_once = SCM_I_PTHREAD_ONCE_INIT;

555: init_thread_key (void)

573: scm_i_init_thread_for_guile (SCM_STACKITEM *base, SCM parent)

638: #define HAVE_GET_THREAD_STACK_BASE

641: get_thread_stack_base ()

674: #define HAVE_GET_THREAD_STACK_BASE

676: get_thread_stack_base ()

686: #define HAVE_GET_THREAD_STACK_BASE

688: get_thread_stack_base ()

697: #define HAVE_GET_THREAD_STACK_BASE

700: get_thread_stack_base ()

1609: int scm_i_thread_go_to_sleep;

1613: scm_i_thread_put_to_sleep ()

1632: scm_i_thread_invalidate_freelists ()

1643: scm_i_thread_wake_up ()

1658: scm_i_thread_sleep_for_gc ()

1751: scm_init_thread_procs ()

404: static scm_i_thread *all_threads = NULL;

1396: scm_threads_mark_stacks (void)

1479: scm_pthread_mutex_lock (scm_i_pthread_mutex_t *mutex)

1494: scm_dynwind_pthread_mutex_lock (scm_i_pthread_mutex_t *mutex)

1501: scm_pthread_cond_wait (scm_i_pthread_cond_t *cond, scm_i_pthread_mutex_t *mutex)

1510: scm_pthread_cond_timedwait (scm_i_pthread_cond_t *cond,

1690: pthread_mutexattr_t scm_i_pthread_mutexattr_recursive[1];

1694: scm_threads_prehistory (SCM_STACKITEM *base)

1717: scm_init_threads ()

1744: scm_init_threads_default_dynamic_state ()

128: /*** Thread smob routines */

133:   scm_i_thread *t = SCM_I_THREAD_DATA (obj);

156:   scm_i_thread *t = SCM_I_THREAD_DATA (exp);

169:   scm_puts ("#<thread ", port);

180:   scm_i_thread *t = SCM_I_THREAD_DATA (obj);

182:   scm_gc_free (t, sizeof (*t), "thread");

192: /* Put the current thread on QUEUE and go to sleep, waiting for it to

194:    interrupted.  Upon return of this function, the current thread is

218:   scm_i_thread *t = SCM_I_CURRENT_THREAD;

246: /* Wake up the first thread on QUEUE, if any.  The caller must hold

247:    the mutex that protects QUEUE.  The awoken thread is returned, or

253:   SCM thread = dequeue (queue);

254:   if (scm_is_true (thread))

255:     scm_i_pthread_cond_signal (&SCM_I_THREAD_DATA(thread)->sleep_cond);

256:   return thread;

304:    run, triggered by another thread.

306:    The thread calling foo is out of Guile mode at the time, so the

358: resume (scm_i_thread *t)

374:   scm_i_thread *t = (scm_i_thread *)ticket;

382: static scm_i_thread *

385:   scm_i_thread *t = SCM_I_CURRENT_THREAD;

398:   scm_i_thread *t = suspend ();

409: /* Perform first stage of thread initialisation, in non-guile mode.

414:   scm_i_thread *t = malloc (sizeof (scm_i_thread));

429:   /* Calculate and store off the base of this thread's register

432:      main thread.  For other threads, therefore, find out the current

467:   scm_i_pthread_setspecific (scm_i_thread_key, t);

469:   /* As soon as this thread adds itself to the global thread list, the

472:      before the thread can lock its heap_mutex for the first time. */

474:   scm_i_pthread_mutex_lock (&thread_admin_mutex);

475:   t->next_thread = all_threads;

477:   thread_count++;

478:   scm_i_pthread_mutex_unlock (&thread_admin_mutex);

484: /* Perform second stage of thread initialisation, in guile mode.

489:   scm_i_thread *t = SCM_I_CURRENT_THREAD;

491:   SCM_NEWSMOB (t->handle, scm_tc16_thread, t);

492:   scm_gc_register_collectable_memory (t, sizeof (scm_i_thread), "thread");

505: /* Perform thread tear-down, in guile mode.

510:   scm_i_thread *t = (scm_i_thread *)v;

512:   scm_i_scm_pthread_mutex_lock (&thread_admin_mutex);

520:   scm_i_pthread_mutex_unlock (&thread_admin_mutex);

528:   scm_i_thread *t = (scm_i_thread *)v, **tp;

530:   scm_i_pthread_setspecific (scm_i_thread_key, v);

534:   scm_with_guile (do_thread_exit, v);

539:   scm_i_pthread_mutex_lock (&thread_admin_mutex);

540:   for (tp = &all_threads; *tp; tp = &(*tp)->next_thread)

543: 	*tp = t->next_thread;

546:   thread_count--;

547:   scm_i_pthread_mutex_unlock (&thread_admin_mutex);

549:   scm_i_pthread_setspecific (scm_i_thread_key, NULL);

557:   scm_i_pthread_key_create (&scm_i_thread_key, on_thread_exit);

560: /* Perform any initializations necessary to bring the current thread

568:    Return zero when the thread was in guile mode already; otherwise

575:   scm_i_thread *t;

577:   scm_i_pthread_once (&init_thread_key_once, init_thread_key);

579:   if ((t = SCM_I_CURRENT_THREAD) == NULL)

581:       /* This thread has not been guilified yet.

587: 	  /* First thread ever to enter Guile.  Run the full

595: 	  /* Guile is already initialized, but this thread enters it for

596: 	     the first time.  Only initialize this thread.

606:       /* This thread is already guilified but not in guile mode, just

611:          stack than when it was when this thread was first guilified.  Thus,

626:       /* Thread is already in guile mode.  Nothing to do.

652:      for the main thread, but we can use scm_get_stack_base in that

683:    in any thread.  We don't like hard-coding the name of a system, but there

693: #endif /* pthread methods of get_thread_stack_base */

707: #ifdef HAVE_GET_THREAD_STACK_BASE

712:   scm_i_init_thread_for_guile (get_thread_stack_base (),

732:   really_entered = scm_i_init_thread_for_guile (&base_item, parent);

750: /*** Thread creation */

766:   scm_i_thread *t;

768:   t = SCM_I_CURRENT_THREAD;

771:   data->thread = scm_current_thread ();

792: SCM_DEFINE (scm_call_with_new_thread, "call-with-new-thread", 1, 1, 0,

794: 	    "Call @code{thunk} in a new thread and with a new dynamic state,\n"

795: 	    "returning a new thread object representing the thread.  The procedure\n"

803: 	    "the @emph{exit value} of the thread and the thread is terminated.")

804: #define FUNC_NAME s_scm_call_with_new_thread

817:   data.thread = SCM_BOOL_F;

822:   err = scm_i_pthread_create (&id, NULL, launch_thread, &data);

832:   return data.thread;

855:   scm_i_thread *t = SCM_I_CURRENT_THREAD;

858:   data->thread = scm_current_thread ();

894:   data.thread = SCM_BOOL_F;

899:   err = scm_i_pthread_create (&id, NULL, spawn_thread, &data);

909:   return data.thread;

914: "Move the calling thread to the end of the scheduling queue.")

921: SCM_DEFINE (scm_join_thread, "join-thread", 1, 0, 0,

922: 	    (SCM thread),

923: "Suspend execution of the calling thread until the target @var{thread} "

924: "terminates, unless the target @var{thread} has already terminated. ")

925: #define FUNC_NAME s_scm_join_thread

927:   scm_i_thread *t;

930:   SCM_VALIDATE_THREAD (1, thread);

931:   if (scm_is_eq (scm_current_thread (), thread))

932:     SCM_MISC_ERROR ("can not join the current thread", SCM_EOL);

934:   scm_i_scm_pthread_mutex_lock (&thread_admin_mutex);

936:   t = SCM_I_THREAD_DATA (thread);

939:       block_self (t->join_queue, thread, &thread_admin_mutex, NULL);

942:       scm_i_pthread_mutex_unlock (&thread_admin_mutex);

944:       scm_i_scm_pthread_mutex_lock (&thread_admin_mutex);

948:   scm_i_pthread_mutex_unlock (&thread_admin_mutex);

1037:   SCM thread = scm_current_thread ();

1042:     m->owner = thread;

1043:   else if (scm_is_eq (m->owner, thread))

1048: 	msg = "mutex already locked by current thread";

1054: 	  if (scm_is_eq (m->owner, thread))

1068: "Lock @var{mutex}. If the mutex is already locked, the calling thread "

1070: "the calling thread owns the lock on @var{mutex}.  Locking a mutex that "

1071: "a thread already owns will succeed right away and will not block the "

1072: "thread.  That is, Guile's mutexes are @emph{recursive}. ")

1098:   SCM thread = scm_current_thread ();

1103:     m->owner = thread;

1104:   else if (scm_is_eq (m->owner, thread))

1109: 	msg = "mutex already locked by current thread";

1141:   if (!scm_is_eq (m->owner, scm_current_thread ()))

1146: 	msg = "mutex not locked by current thread";

1159: "Unlocks @var{mutex} if the calling thread owns the lock on "

1161: "thread results in undefined behaviour. Once a mutex has been unlocked, "

1162: "one thread blocked on @var{mutex} is awakened and grabs the mutex "

1163: "lock.  Every call to @code{lock-mutex} by this thread must be matched "

1182: 	    "Return the thread owning @var{mx}, or @code{#f}.")

1260:   scm_i_thread *t = SCM_I_CURRENT_THREAD;

1346: 	    "Wake up one thread that is waiting for @var{cv}")

1388:     bot = (SCM_STACKITEM *) SCM_I_CURRENT_THREAD->register_backing_store_base;  \

1398:   scm_i_thread *t;

1399:   for (t = all_threads; t; t = t->next_thread)

1401:       /* Check that thread has indeed been suspended.

1431:   scm_i_thread *t = SCM_I_CURRENT_THREAD;

1544: SCM_DEFINE (scm_current_thread, "current-thread", 0, 0, 0,

1546: 	    "Return the thread that called this function.")

1547: #define FUNC_NAME s_scm_current_thread

1549:   return SCM_I_CURRENT_THREAD->handle;

1567:   /* We can not allocate while holding the thread_admin_mutex because

1570:   int n = thread_count;

1571:   scm_i_thread *t;

1574:   scm_i_pthread_mutex_lock (&thread_admin_mutex);

1576:   for (t = all_threads; t && n > 0; t = t->next_thread)

1583:   scm_i_pthread_mutex_unlock (&thread_admin_mutex);

1588: SCM_DEFINE (scm_thread_exited_p, "thread-exited?", 1, 0, 0,

1589: 	    (SCM thread),

1590: 	    "Return @code{#t} iff @var{thread} has exited.\n")

1591: #define FUNC_NAME s_scm_thread_exited_p

1593:   return scm_from_bool (scm_c_thread_exited_p (thread));

1598: scm_c_thread_exited_p (SCM thread)

1599: #define FUNC_NAME  s_scm_thread_exited_p

1601:   scm_i_thread *t;

1602:   SCM_VALIDATE_THREAD (1, thread);

1603:   t = SCM_I_THREAD_DATA (thread);

1617:       scm_i_thread *t;

1620:       scm_i_pthread_mutex_lock (&thread_admin_mutex);

1624:       scm_i_thread_go_to_sleep = 1;

1625:       for (t = all_threads; t; t = t->next_thread)

1627:       scm_i_thread_go_to_sleep = 0;

1634:   /* thread_admin_mutex is already locked. */

1636:   scm_i_thread *t;

1637:   for (t = all_threads; t; t = t->next_thread)

1638:     if (t != SCM_I_CURRENT_THREAD)

1647:       scm_i_thread *t;

1650:       for (t = all_threads; t; t = t->next_thread)

1652:       scm_i_pthread_mutex_unlock (&thread_admin_mutex);

1653:       scm_enter_guile ((scm_t_guile_ticket) SCM_I_CURRENT_THREAD);

1660:   scm_i_thread *t = suspend ();

1719:   scm_tc16_thread = scm_make_smob_type ("thread", sizeof (scm_i_thread));

1720:   scm_set_smob_mark (scm_tc16_thread, thread_mark);

1721:   scm_set_smob_print (scm_tc16_thread, thread_print);

1722:   scm_set_smob_free (scm_tc16_thread, thread_free);

45: #include "libguile/threads.h"

145:   /* On a Gnu system pthread_t is an unsigned long, but on mingw it's a

146:      struct.  A cast like "(unsigned long) t->pthread" is a syntax error in

148:      size of pthread_t.  */

150:     scm_i_pthread_t p;

157:   scm_i_pthread_t p = t->pthread;

199:    unlocked while sleeping, just as with scm_i_pthread_cond_wait.

215: block_self (SCM queue, SCM sleep_object, scm_i_pthread_mutex_t *mutex,

229: 	err = scm_i_scm_pthread_cond_wait (&t->sleep_cond, mutex);

231: 	err = scm_i_scm_pthread_cond_timedwait (&t->sleep_cond, mutex, waittime);

346:    kind of like pthread_cleanup_push/pop calls that have to be paired up

347:    in a function.  (In fact, the pthread ones have to be paired up

352:    pthread_cancel.)

377:       scm_i_pthread_mutex_lock (&t->heap_mutex);

399:   scm_i_pthread_mutex_unlock (&t->heap_mutex);

416:   t->pthread = scm_i_pthread_self ();

446:   scm_i_pthread_cond_init (&t->sleep_cond, NULL);

457:   scm_i_pthread_mutex_init (&t->heap_mutex, NULL);

476:   all_threads = t;

532:   /* Unblocking the joining threads needs to happen in guile mode

536:   /* Removing ourself from the list of all threads needs to happen in

584:       scm_i_pthread_mutex_lock (&scm_i_init_mutex);

591: 	  scm_i_pthread_mutex_unlock (&scm_i_init_mutex);

598: 	  scm_i_pthread_mutex_unlock (&scm_i_init_mutex);

632: #if SCM_USE_PTHREAD_THREADS

634: #if HAVE_PTHREAD_ATTR_GETSTACK && HAVE_PTHREAD_GETATTR_NP

636:    It's not for MacOS X or Solaris 10, since pthread_getattr_np is not

643:   pthread_attr_t attr;

647:   pthread_getattr_np (pthread_self (), &attr);

648:   pthread_attr_getstack (&attr, &start, &size);

651:   /* XXX - pthread_getattr_np from LinuxThreads does not seem to work

656: #ifndef PTHREAD_ATTR_GETSTACK_WORKS

670: #elif HAVE_PTHREAD_GET_STACKADDR_NP

672:    It'd be nice if there was some documentation on pthread_get_stackaddr_np,

678:   return pthread_get_stackaddr_np (pthread_self ());

695: #else /* !SCM_USE_PTHREAD_THREADS */

705: #endif /* !SCM_USE_PTHREAD_THREADS */

757:   scm_i_pthread_mutex_t mutex;

758:   scm_i_pthread_cond_t cond;

770:   scm_i_scm_pthread_mutex_lock (&data->mutex);

772:   scm_i_pthread_cond_signal (&data->cond);

773:   scm_i_pthread_mutex_unlock (&data->mutex);

787:   scm_i_pthread_detach (scm_i_pthread_self ());

807:   scm_i_pthread_t id;

818:   scm_i_pthread_mutex_init (&data.mutex, NULL);

819:   scm_i_pthread_cond_init (&data.cond, NULL);

821:   scm_i_scm_pthread_mutex_lock (&data.mutex);

825:       scm_i_pthread_mutex_unlock (&data.mutex);

829:   scm_i_scm_pthread_cond_wait (&data.cond, &data.mutex);

830:   scm_i_pthread_mutex_unlock (&data.mutex);

843:   scm_i_pthread_mutex_t mutex;

844:   scm_i_pthread_cond_t cond;

857:   scm_i_scm_pthread_mutex_lock (&data->mutex);

859:   scm_i_pthread_cond_signal (&data->cond);

860:   scm_i_pthread_mutex_unlock (&data->mutex);