// catching unsafe call-ins.
rtsBool in_haskell;
+ // true if this Capability is currently in the GC
+ rtsBool in_gc;
+
// The run queue. The Task owning this Capability has exclusive
// access to its run queue, so can wake up threads without
// taking a lock, and the common path through the scheduler is
Task *suspended_ccalling_tasks;
// One mutable list per generation, so we don't need to take any
- // locks when updating an old-generation thunk. These
- // mini-mut-lists are moved onto the respective gen->mut_list at
- // each GC.
+ // locks when updating an old-generation thunk. This also lets us
+ // keep track of which closures this CPU has been mutating, so we
+ // can traverse them using the right thread during GC and avoid
+ // unnecessarily moving the data from one cache to another.
bdescr **mut_lists;
+ bdescr **saved_mut_lists; // tmp use during GC
// Context switch flag. We used to have one global flag, now one
// per capability. Locks required : none (conflicts are harmless)
INLINE_HEADER Capability *
regTableToCapability (StgRegTable *reg)
{
- return (Capability *)((void *)((unsigned char*)reg - sizeof(StgFunTable)));
+ return (Capability *)((void *)((unsigned char*)reg - FIELD_OFFSET(Capability,r)));
}
// Initialise the available capabilities.
extern Capability *last_free_capability;
// GC indicator, in scope for the scheduler
+#define PENDING_GC_SEQ 1
+#define PENDING_GC_PAR 2
extern volatile StgWord waiting_for_gc;
// Acquires a capability at a return point. If *cap is non-NULL, then
// need to service some global event.
//
void prodOneCapability (void);
+void prodCapability (Capability *cap, Task *task);
// Similar to prodOneCapability(), but prods all of them.
//
//
rtsBool tryGrabCapability (Capability *cap, Task *task);
-// Try to steal a spark from other Capabilities
+// Try to find a spark to run
//
-StgClosure *stealWork (Capability *cap);
+StgClosure *findSpark (Capability *cap);
// True if any capabilities have sparks
//