Capability.c 19.7 KB
Newer Older
sof's avatar
sof committed
1
/* ---------------------------------------------------------------------------
2
 *
3
 * (c) The GHC Team, 2003-2006
sof's avatar
sof committed
4
5
6
 *
 * Capabilities
 *
sof's avatar
sof committed
7
8
 * A Capability represent the token required to execute STG code,
 * and all the state an OS thread/task needs to run Haskell code:
sof's avatar
sof committed
9
 * its STG registers, a pointer to its TSO, a nursery etc. During
sof's avatar
sof committed
10
 * STG execution, a pointer to the capabilitity is kept in a
11
 * register (BaseReg; actually it is a pointer to cap->r).
sof's avatar
sof committed
12
 *
13
14
15
 * Only in an THREADED_RTS build will there be multiple capabilities,
 * for non-threaded builds there is only one global capability, namely
 * MainCapability.
16
 *
sof's avatar
sof committed
17
 * --------------------------------------------------------------------------*/
18

sof's avatar
sof committed
19
20
21
#include "PosixSource.h"
#include "Rts.h"
#include "RtsUtils.h"
22
#include "RtsFlags.h"
23
#include "STM.h"
sof's avatar
sof committed
24
#include "OSThreads.h"
sof's avatar
sof committed
25
#include "Capability.h"
26
#include "Schedule.h"
27
#include "Sparks.h"
Simon Marlow's avatar
Simon Marlow committed
28
#include "Trace.h"
sof's avatar
sof committed
29

30
31
32
// one global capability, this is the Capability for non-threaded
// builds, and for +RTS -N1
Capability MainCapability;
sof's avatar
sof committed
33

34
nat n_capabilities;
35
Capability *capabilities = NULL;
sof's avatar
sof committed
36

37
38
39
40
41
// Holds the Capability which last became free.  This is used so that
// an in-call has a chance of quickly finding a free Capability.
// Maintaining a global free list of Capabilities would require global
// locking, so we don't do that.
Capability *last_free_capability;
42

43
#if defined(THREADED_RTS)
44
45
46
STATIC_INLINE rtsBool
globalWorkToDo (void)
{
47
    return blackholes_need_checking
48
	|| sched_state >= SCHED_INTERRUPTING
49
50
	;
}
51
#endif
52

53
54
55
#if defined(THREADED_RTS)
STATIC_INLINE rtsBool
anyWorkForMe( Capability *cap, Task *task )
56
{
57
58
59
60
61
62
    if (task->tso != NULL) {
	// A bound task only runs if its thread is on the run queue of
	// the capability on which it was woken up.  Otherwise, we
	// can't be sure that we have the right capability: the thread
	// might be woken up on some other capability, and task->cap
	// could change under our feet.
63
	return !emptyRunQueue(cap) && cap->run_queue_hd->bound == task;
64
    } else {
65
66
67
68
69
70
	// A vanilla worker task runs if either there is a lightweight
	// thread at the head of the run queue, or the run queue is
	// empty and (there are sparks to execute, or there is some
	// other global condition to check, such as threads blocked on
	// blackholes).
	if (emptyRunQueue(cap)) {
71
72
73
	    return !emptySparkPoolCap(cap)
		|| !emptyWakeupQueue(cap)
		|| globalWorkToDo();
74
75
	} else
	    return cap->run_queue_hd->bound == NULL;
76
77
    }
}
78
#endif
79
80
81

/* -----------------------------------------------------------------------------
 * Manage the returning_tasks lists.
82
 *
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 * These functions require cap->lock
 * -------------------------------------------------------------------------- */

#if defined(THREADED_RTS)
STATIC_INLINE void
newReturningTask (Capability *cap, Task *task)
{
    ASSERT_LOCK_HELD(&cap->lock);
    ASSERT(task->return_link == NULL);
    if (cap->returning_tasks_hd) {
	ASSERT(cap->returning_tasks_tl->return_link == NULL);
	cap->returning_tasks_tl->return_link = task;
    } else {
	cap->returning_tasks_hd = task;
    }
    cap->returning_tasks_tl = task;
99
100
}

101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
STATIC_INLINE Task *
popReturningTask (Capability *cap)
{
    ASSERT_LOCK_HELD(&cap->lock);
    Task *task;
    task = cap->returning_tasks_hd;
    ASSERT(task);
    cap->returning_tasks_hd = task->return_link;
    if (!cap->returning_tasks_hd) {
	cap->returning_tasks_tl = NULL;
    }
    task->return_link = NULL;
    return task;
}
#endif

117
/* ----------------------------------------------------------------------------
118
119
120
121
 * Initialisation
 *
 * The Capability is initially marked not free.
 * ------------------------------------------------------------------------- */
122
123

static void
124
initCapability( Capability *cap, nat i )
sof's avatar
sof committed
125
{
126
    nat g;
127

128
129
130
131
132
133
134
135
136
137
138
139
140
    cap->no = i;
    cap->in_haskell        = rtsFalse;

    cap->run_queue_hd      = END_TSO_QUEUE;
    cap->run_queue_tl      = END_TSO_QUEUE;

#if defined(THREADED_RTS)
    initMutex(&cap->lock);
    cap->running_task      = NULL; // indicates cap is free
    cap->spare_workers     = NULL;
    cap->suspended_ccalling_tasks = NULL;
    cap->returning_tasks_hd = NULL;
    cap->returning_tasks_tl = NULL;
141
142
    cap->wakeup_queue_hd    = END_TSO_QUEUE;
    cap->wakeup_queue_tl    = END_TSO_QUEUE;
143
144
#endif

sof's avatar
sof committed
145
    cap->f.stgGCEnter1     = (F_)__stg_gc_enter_1;
146
    cap->f.stgGCFun        = (F_)__stg_gc_fun;
147

148
    cap->mut_lists  = stgMallocBytes(sizeof(bdescr *) *
149
150
				     RtsFlags.GcFlags.generations,
				     "initCapability");
151
152
153

    for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
	cap->mut_lists[g] = NULL;
154
    }
155
156
157
158
159

    cap->free_tvar_wait_queues = END_STM_WAIT_QUEUE;
    cap->free_trec_chunks = END_STM_CHUNK_LIST;
    cap->free_trec_headers = NO_TREC;
    cap->transaction_tokens = 0;
sof's avatar
sof committed
160
161
}

162
/* ---------------------------------------------------------------------------
sof's avatar
sof committed
163
164
 * Function:  initCapabilities()
 *
165
 * Purpose:   set up the Capability handling. For the THREADED_RTS build,
sof's avatar
sof committed
166
 *            we keep a table of them, the size of which is
167
 *            controlled by the user via the RTS flag -N.
sof's avatar
sof committed
168
 *
169
 * ------------------------------------------------------------------------- */
sof's avatar
sof committed
170
void
171
initCapabilities( void )
sof's avatar
sof committed
172
{
173
174
#if defined(THREADED_RTS)
    nat i;
175

176
#ifndef REG_Base
Simon Marlow's avatar
Simon Marlow committed
177
178
179
180
181
182
183
    // We can't support multiple CPUs if BaseReg is not a register
    if (RtsFlags.ParFlags.nNodes > 1) {
	errorBelch("warning: multiple CPUs not supported in this build, reverting to 1");
	RtsFlags.ParFlags.nNodes = 1;
    }
#endif

184
185
186
187
188
189
190
191
192
193
194
    n_capabilities = RtsFlags.ParFlags.nNodes;

    if (n_capabilities == 1) {
	capabilities = &MainCapability;
	// THREADED_RTS must work on builds that don't have a mutable
	// BaseReg (eg. unregisterised), so in this case
	// capabilities[0] must coincide with &MainCapability.
    } else {
	capabilities = stgMallocBytes(n_capabilities * sizeof(Capability),
				      "initCapabilities");
    }
195

196
    for (i = 0; i < n_capabilities; i++) {
197
	initCapability(&capabilities[i], i);
198
    }
199

Simon Marlow's avatar
Simon Marlow committed
200
    debugTrace(DEBUG_sched, "allocated %d capabilities", n_capabilities);
201
202
203

#else /* !THREADED_RTS */

204
    n_capabilities = 1;
205
    capabilities = &MainCapability;
206
    initCapability(&MainCapability, 0);
207

208
209
#endif

210
211
212
213
    // There are no free capabilities to begin with.  We will start
    // a worker Task to each Capability, which will quickly put the
    // Capability on the free list when it finds nothing to do.
    last_free_capability = &capabilities[0];
sof's avatar
sof committed
214
215
}

216
/* ----------------------------------------------------------------------------
217
218
219
220
221
222
223
224
225
226
 * Give a Capability to a Task.  The task must currently be sleeping
 * on its condition variable.
 *
 * Requires cap->lock (modifies cap->running_task).
 *
 * When migrating a Task, the migrater must take task->lock before
 * modifying task->cap, to synchronise with the waking up Task.
 * Additionally, the migrater should own the Capability (when
 * migrating the run queue), or cap->lock (when migrating
 * returning_workers).
227
228
 *
 * ------------------------------------------------------------------------- */
229
230
231

#if defined(THREADED_RTS)
STATIC_INLINE void
232
giveCapabilityToTask (Capability *cap USED_IF_DEBUG, Task *task)
233
{
234
235
    ASSERT_LOCK_HELD(&cap->lock);
    ASSERT(task->cap == cap);
Simon Marlow's avatar
Simon Marlow committed
236
237
238
239
    trace(TRACE_sched | DEBUG_sched,
	  "passing capability %d to %s %p",
	  cap->no, task->tso ? "bound task" : "worker",
	  (void *)task->id);
240
241
242
243
244
245
246
    ACQUIRE_LOCK(&task->lock);
    task->wakeup = rtsTrue;
    // the wakeup flag is needed because signalCondition() doesn't
    // flag the condition if the thread is already runniing, but we want
    // it to be sticky.
    signalCondition(&task->cond);
    RELEASE_LOCK(&task->lock);
247
}
248
#endif
249

250
/* ----------------------------------------------------------------------------
sof's avatar
sof committed
251
252
 * Function:  releaseCapability(Capability*)
 *
sof's avatar
sof committed
253
254
255
 * Purpose:   Letting go of a capability. Causes a
 *            'returning worker' thread or a 'waiting worker'
 *            to wake up, in that order.
256
257
 * ------------------------------------------------------------------------- */

258
#if defined(THREADED_RTS)
259
void
260
releaseCapability_ (Capability* cap)
261
{
262
263
264
265
    Task *task;

    task = cap->running_task;

266
    ASSERT_PARTIAL_CAPABILITY_INVARIANTS(cap,task);
267
268

    cap->running_task = NULL;
269

270
271
    // Check to see whether a worker thread can be given
    // the go-ahead to return the result of an external call..
272
273
274
275
    if (cap->returning_tasks_hd != NULL) {
	giveCapabilityToTask(cap,cap->returning_tasks_hd);
	// The Task pops itself from the queue (see waitForReturnCapability())
	return;
276
    }
277
278
279
280
281
282
283
284
285

    // If the next thread on the run queue is a bound thread,
    // give this Capability to the appropriate Task.
    if (!emptyRunQueue(cap) && cap->run_queue_hd->bound) {
	// Make sure we're not about to try to wake ourselves up
	ASSERT(task != cap->run_queue_hd->bound);
	task = cap->run_queue_hd->bound;
	giveCapabilityToTask(cap,task);
	return;
286
    }
287

288
    if (!cap->spare_workers) {
289
290
291
292
	// Create a worker thread if we don't have one.  If the system
	// is interrupted, we only create a worker task if there
	// are threads that need to be completed.  If the system is
	// shutting down, we never create a new worker.
293
	if (sched_state < SCHED_SHUTTING_DOWN || !emptyRunQueue(cap)) {
Simon Marlow's avatar
Simon Marlow committed
294
295
	    debugTrace(DEBUG_sched,
		       "starting new worker on capability %d", cap->no);
296
297
298
	    startWorkerTask(cap, workerStart);
	    return;
	}
299
    }
300

301
302
    // If we have an unbound thread on the run queue, or if there's
    // anything else to do, give the Capability to a worker thread.
303
304
    if (!emptyRunQueue(cap) || !emptyWakeupQueue(cap)
	      || !emptySparkPoolCap(cap) || globalWorkToDo()) {
305
306
307
308
309
310
311
	if (cap->spare_workers) {
	    giveCapabilityToTask(cap,cap->spare_workers);
	    // The worker Task pops itself from the queue;
	    return;
	}
    }

312
    last_free_capability = cap;
Simon Marlow's avatar
Simon Marlow committed
313
    trace(TRACE_sched | DEBUG_sched, "freeing capability %d", cap->no);
sof's avatar
sof committed
314
315
}

316
void
317
releaseCapability (Capability* cap USED_IF_THREADS)
318
319
320
321
322
323
324
{
    ACQUIRE_LOCK(&cap->lock);
    releaseCapability_(cap);
    RELEASE_LOCK(&cap->lock);
}

static void
325
releaseCapabilityAndQueueWorker (Capability* cap USED_IF_THREADS)
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
{
    Task *task;

    ACQUIRE_LOCK(&cap->lock);

    task = cap->running_task;

    // If the current task is a worker, save it on the spare_workers
    // list of this Capability.  A worker can mark itself as stopped,
    // in which case it is not replaced on the spare_worker queue.
    // This happens when the system is shutting down (see
    // Schedule.c:workerStart()).
    // Also, be careful to check that this task hasn't just exited
    // Haskell to do a foreign call (task->suspended_tso).
    if (!isBoundTask(task) && !task->stopped && !task->suspended_tso) {
	task->next = cap->spare_workers;
	cap->spare_workers = task;
    }
    // Bound tasks just float around attached to their TSOs.

    releaseCapability_(cap);

    RELEASE_LOCK(&cap->lock);
}
#endif
sof's avatar
sof committed
351

352
/* ----------------------------------------------------------------------------
353
 * waitForReturnCapability( Task *task )
sof's avatar
sof committed
354
355
 *
 * Purpose:  when an OS thread returns from an external call,
356
357
 * it calls waitForReturnCapability() (via Schedule.resumeThread())
 * to wait for permission to enter the RTS & communicate the
sof's avatar
sof committed
358
 * result of the external call back to the Haskell thread that
sof's avatar
sof committed
359
360
 * made it.
 *
361
 * ------------------------------------------------------------------------- */
sof's avatar
sof committed
362
void
363
waitForReturnCapability (Capability **pCap, Task *task)
sof's avatar
sof committed
364
{
365
#if !defined(THREADED_RTS)
366

367
368
369
    MainCapability.running_task = task;
    task->cap = &MainCapability;
    *pCap = &MainCapability;
370

371
#else
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
    Capability *cap = *pCap;

    if (cap == NULL) {
	// Try last_free_capability first
	cap = last_free_capability;
	if (!cap->running_task) {
	    nat i;
	    // otherwise, search for a free capability
	    for (i = 0; i < n_capabilities; i++) {
		cap = &capabilities[i];
		if (!cap->running_task) {
		    break;
		}
	    }
	    // Can't find a free one, use last_free_capability.
	    cap = last_free_capability;
	}

	// record the Capability as the one this Task is now assocated with.
	task->cap = cap;

393
    } else {
394
	ASSERT(task->cap == cap);
395
396
    }

397
    ACQUIRE_LOCK(&cap->lock);
sof's avatar
sof committed
398

Simon Marlow's avatar
Simon Marlow committed
399
    debugTrace(DEBUG_sched, "returning; I want capability %d", cap->no);
sof's avatar
sof committed
400

401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
    if (!cap->running_task) {
	// It's free; just grab it
	cap->running_task = task;
	RELEASE_LOCK(&cap->lock);
    } else {
	newReturningTask(cap,task);
	RELEASE_LOCK(&cap->lock);

	for (;;) {
	    ACQUIRE_LOCK(&task->lock);
	    // task->lock held, cap->lock not held
	    if (!task->wakeup) waitCondition(&task->cond, &task->lock);
	    cap = task->cap;
	    task->wakeup = rtsFalse;
	    RELEASE_LOCK(&task->lock);

	    // now check whether we should wake up...
	    ACQUIRE_LOCK(&cap->lock);
	    if (cap->running_task == NULL) {
		if (cap->returning_tasks_hd != task) {
		    giveCapabilityToTask(cap,cap->returning_tasks_hd);
		    RELEASE_LOCK(&cap->lock);
		    continue;
		}
		cap->running_task = task;
		popReturningTask(cap);
		RELEASE_LOCK(&cap->lock);
		break;
	    }
	    RELEASE_LOCK(&cap->lock);
	}

    }

435
    ASSERT_FULL_CAPABILITY_INVARIANTS(cap,task);
436

Simon Marlow's avatar
Simon Marlow committed
437
    trace(TRACE_sched | DEBUG_sched, "resuming capability %d", cap->no);
438
439
440
441
442
443

    *pCap = cap;
#endif
}

#if defined(THREADED_RTS)
444
/* ----------------------------------------------------------------------------
445
 * yieldCapability
446
 * ------------------------------------------------------------------------- */
sof's avatar
sof committed
447

sof's avatar
sof committed
448
void
449
yieldCapability (Capability** pCap, Task *task)
sof's avatar
sof committed
450
{
451
452
    Capability *cap = *pCap;

453
    // The fast path has no locking, if we don't enter this while loop
454
455

    while ( cap->returning_tasks_hd != NULL || !anyWorkForMe(cap,task) ) {
Simon Marlow's avatar
Simon Marlow committed
456
	debugTrace(DEBUG_sched, "giving up capability %d", cap->no);
457
458

	// We must now release the capability and wait to be woken up
459
	// again.
460
	task->wakeup = rtsFalse;
461
462
463
464
465
466
467
468
469
470
	releaseCapabilityAndQueueWorker(cap);

	for (;;) {
	    ACQUIRE_LOCK(&task->lock);
	    // task->lock held, cap->lock not held
	    if (!task->wakeup) waitCondition(&task->cond, &task->lock);
	    cap = task->cap;
	    task->wakeup = rtsFalse;
	    RELEASE_LOCK(&task->lock);

Simon Marlow's avatar
Simon Marlow committed
471
472
	    debugTrace(DEBUG_sched, "woken up on capability %d", cap->no);

473
474
	    ACQUIRE_LOCK(&cap->lock);
	    if (cap->running_task != NULL) {
Simon Marlow's avatar
Simon Marlow committed
475
476
		debugTrace(DEBUG_sched, 
			   "capability %d is owned by another task", cap->no);
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
		RELEASE_LOCK(&cap->lock);
		continue;
	    }

	    if (task->tso == NULL) {
		ASSERT(cap->spare_workers != NULL);
		// if we're not at the front of the queue, release it
		// again.  This is unlikely to happen.
		if (cap->spare_workers != task) {
		    giveCapabilityToTask(cap,cap->spare_workers);
		    RELEASE_LOCK(&cap->lock);
		    continue;
		}
		cap->spare_workers = task->next;
		task->next = NULL;
	    }
	    cap->running_task = task;
	    RELEASE_LOCK(&cap->lock);
	    break;
	}

Simon Marlow's avatar
Simon Marlow committed
498
	trace(TRACE_sched | DEBUG_sched, "resuming capability %d", cap->no);
499
	ASSERT(cap->running_task == task);
500
501
    }

502
    *pCap = cap;
503

504
    ASSERT_FULL_CAPABILITY_INVARIANTS(cap,task);
505

506
    return;
sof's avatar
sof committed
507
508
}

509
510
511
512
513
514
515
516
517
518
519
520
/* ----------------------------------------------------------------------------
 * Wake up a thread on a Capability.
 *
 * This is used when the current Task is running on a Capability and
 * wishes to wake up a thread on a different Capability.
 * ------------------------------------------------------------------------- */

void
wakeupThreadOnCapability (Capability *cap, StgTSO *tso)
{
    ASSERT(tso->cap == cap);
    ASSERT(tso->bound ? tso->bound->cap == cap : 1);
521
522
523
    ASSERT_LOCK_HELD(&cap->lock);

    tso->cap = cap;
524
525
526
527
528
529
530
531

    if (cap->running_task == NULL) {
	// nobody is running this Capability, we can add our thread
	// directly onto the run queue and start up a Task to run it.
	appendToRunQueue(cap,tso);

	// start it up
	cap->running_task = myTask(); // precond for releaseCapability_()
Simon Marlow's avatar
Simon Marlow committed
532
	trace(TRACE_sched, "resuming capability %d", cap->no);
533
534
535
536
537
538
539
	releaseCapability_(cap);
    } else {
	appendToWakeupQueue(cap,tso);
	// someone is running on this Capability, so it cannot be
	// freed without first checking the wakeup queue (see
	// releaseCapability_).
    }
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
}

void
wakeupThreadOnCapability_lock (Capability *cap, StgTSO *tso)
{
    ACQUIRE_LOCK(&cap->lock);
    migrateThreadToCapability (cap, tso);
    RELEASE_LOCK(&cap->lock);
}

void
migrateThreadToCapability (Capability *cap, StgTSO *tso)
{
    // ASSUMES: cap->lock is held (asserted in wakeupThreadOnCapability)
    if (tso->bound) {
	ASSERT(tso->bound->cap == tso->cap);
    	tso->bound->cap = cap;
    }
    tso->cap = cap;
    wakeupThreadOnCapability(cap,tso);
}

void
migrateThreadToCapability_lock (Capability *cap, StgTSO *tso)
{
    ACQUIRE_LOCK(&cap->lock);
    migrateThreadToCapability (cap, tso);
567
568
569
    RELEASE_LOCK(&cap->lock);
}

570
/* ----------------------------------------------------------------------------
571
 * prodCapabilities
sof's avatar
sof committed
572
 *
573
574
575
 * Used to indicate that the interrupted flag is now set, or some
 * other global condition that might require waking up a Task on each
 * Capability.
576
577
 * ------------------------------------------------------------------------- */

578
579
580
581
582
583
static void
prodCapabilities(rtsBool all)
{
    nat i;
    Capability *cap;
    Task *task;
584

585
586
587
588
589
    for (i=0; i < n_capabilities; i++) {
	cap = &capabilities[i];
	ACQUIRE_LOCK(&cap->lock);
	if (!cap->running_task) {
	    if (cap->spare_workers) {
Simon Marlow's avatar
Simon Marlow committed
590
		trace(TRACE_sched, "resuming capability %d", cap->no);
591
592
593
594
595
596
597
598
		task = cap->spare_workers;
		ASSERT(!task->stopped);
		giveCapabilityToTask(cap,task);
		if (!all) {
		    RELEASE_LOCK(&cap->lock);
		    return;
		}
	    }
599
	}
600
	RELEASE_LOCK(&cap->lock);
601
    }
602
    return;
sof's avatar
sof committed
603
}
604

605
606
607
608
609
void
prodAllCapabilities (void)
{
    prodCapabilities(rtsTrue);
}
sof's avatar
sof committed
610

611
/* ----------------------------------------------------------------------------
612
613
614
615
616
617
 * prodOneCapability
 *
 * Like prodAllCapabilities, but we only require a single Task to wake
 * up in order to service some global event, such as checking for
 * deadlock after some idle time has passed.
 * ------------------------------------------------------------------------- */
618

619
620
621
622
void
prodOneCapability (void)
{
    prodCapabilities(rtsFalse);
623
}
624
625
626
627
628
629
630
631
632
633
634
635
636

/* ----------------------------------------------------------------------------
 * shutdownCapability
 *
 * At shutdown time, we want to let everything exit as cleanly as
 * possible.  For each capability, we let its run queue drain, and
 * allow the workers to stop.
 *
 * This function should be called when interrupted and
 * shutting_down_scheduler = rtsTrue, thus any worker that wakes up
 * will exit the scheduler and call taskStop(), and any bound thread
 * that wakes up will return to its caller.  Runnable threads are
 * killed.
637
 *
638
 * ------------------------------------------------------------------------- */
639
640

void
641
shutdownCapability (Capability *cap, Task *task)
642
{
643
644
    nat i;

645
    ASSERT(sched_state == SCHED_SHUTTING_DOWN);
646
647
648
649

    task->cap = cap;

    for (i = 0; i < 50; i++) {
Simon Marlow's avatar
Simon Marlow committed
650
651
	debugTrace(DEBUG_sched, 
		   "shutting down capability %d, attempt %d", cap->no, i);
652
653
654
	ACQUIRE_LOCK(&cap->lock);
	if (cap->running_task) {
	    RELEASE_LOCK(&cap->lock);
Simon Marlow's avatar
Simon Marlow committed
655
	    debugTrace(DEBUG_sched, "not owner, yielding");
656
657
	    yieldThread();
	    continue;
658
	}
659
660
	cap->running_task = task;
	if (!emptyRunQueue(cap) || cap->spare_workers) {
Simon Marlow's avatar
Simon Marlow committed
661
662
	    debugTrace(DEBUG_sched, 
		       "runnable threads or workers still alive, yielding");
663
664
665
666
	    releaseCapability_(cap); // this will wake up a worker
	    RELEASE_LOCK(&cap->lock);
	    yieldThread();
	    continue;
667
	}
Simon Marlow's avatar
Simon Marlow committed
668
	debugTrace(DEBUG_sched, "capability %d is stopped.", cap->no);
669
670
	RELEASE_LOCK(&cap->lock);
	break;
671
    }
672
673
    // we now have the Capability, its run queue and spare workers
    // list are both empty.
674
675
676

    // We end up here only in THREADED_RTS
    closeMutex(&cap->lock);
677
}
678

679
680
681
682
/* ----------------------------------------------------------------------------
 * tryGrabCapability
 *
 * Attempt to gain control of a Capability if it is free.
683
 *
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
 * ------------------------------------------------------------------------- */

rtsBool
tryGrabCapability (Capability *cap, Task *task)
{
    if (cap->running_task != NULL) return rtsFalse;
    ACQUIRE_LOCK(&cap->lock);
    if (cap->running_task != NULL) {
	RELEASE_LOCK(&cap->lock);
	return rtsFalse;
    }
    task->cap = cap;
    cap->running_task = task;
    RELEASE_LOCK(&cap->lock);
    return rtsTrue;
}


702
#endif /* THREADED_RTS */
703
704