*
* ---------------------------------------------------------------------------*/
-#ifndef GCTHREAD_H
-#define GCTHREAD_H
+#ifndef SM_GCTHREAD_H
+#define SM_GCTHREAD_H
-#include "OSThreads.h"
#include "WSDeque.h"
+#include "GetTime.h" // for Ticks
+
+#include "BeginPrivate.h"
/* -----------------------------------------------------------------------------
General scheme
thread-local data. We'll keep a pointer to this in a thread-local
variable, or possibly in a register.
- In the gc_thread structure is a step_workspace for each step. The
- primary purpose of the step_workspace is to hold evacuated objects;
+ In the gc_thread structure is a gen_workspace for each generation. The
+ primary purpose of the gen_workspace is to hold evacuated objects;
when an object is evacuated, it is copied to the "todo" block in
- the thread's workspace for the appropriate step. When the todo
- block is full, it is pushed to the global step->todos list, which
+ the thread's workspace for the appropriate generation. When the todo
+ block is full, it is pushed to the global gen->todos list, which
is protected by a lock. (in fact we intervene a one-place buffer
here to reduce contention).
A thread repeatedly grabs a block of work from one of the
- step->todos lists, scavenges it, and keeps the scavenged block on
+ gen->todos lists, scavenges it, and keeps the scavenged block on
its own ws->scavd_list (this is to avoid unnecessary contention
- returning the completed buffers back to the step: we can just
+ returning the completed buffers back to the generation: we can just
collect them all later).
When there is no global work to do, we start scavenging the todo
scan_bd may still be the same as todo_bd, or it might be different:
if enough objects were copied into this block that it filled up,
then we will have allocated a new todo block, but *not* pushed the
- old one to the step, because it is partially scanned.
+ old one to the generation, because it is partially scanned.
The reason to leave scanning the todo blocks until last is that we
want to deal with full blocks as far as possible.
/* -----------------------------------------------------------------------------
- Step Workspace
+ Generation Workspace
- A step workspace exists for each step for each GC thread. The GC
- thread takes a block from the todos list of the step into the
- scanbd and then scans it. Objects referred to by those in the scan
- block are copied into the todo or scavd blocks of the relevant step.
+ A generation workspace exists for each generation for each GC
+ thread. The GC thread takes a block from the todos list of the
+ generation into the scanbd and then scans it. Objects referred to
+ by those in the scan block are copied into the todo or scavd blocks
+ of the relevant generation.
------------------------------------------------------------------------- */
-typedef struct step_workspace_ {
- step * step; // the step for this workspace
+typedef struct gen_workspace_ {
+ generation * gen; // the gen for this workspace
struct gc_thread_ * my_gct; // the gc_thread that contains this workspace
// where objects to be scavenged go
StgWord pad[3];
-} step_workspace ATTRIBUTE_ALIGNED(64);
-// align so that computing gct->steps[n] is a shift, not a multiply
+} gen_workspace ATTRIBUTE_ALIGNED(64);
+// align so that computing gct->gens[n] is a shift, not a multiply
// fails if the size is <64, which is why we need the pad above
/* ----------------------------------------------------------------------------
GC thread object
- Every GC thread has one of these. It contains all the step specific
- workspaces and other GC thread local information. At some later
- point it maybe useful to move this other into the TLS store of the
- GC threads
+ Every GC thread has one of these. It contains all the generation
+ specific workspaces and other GC thread local information. At some
+ later point it maybe useful to move this other into the TLS store
+ of the GC threads
------------------------------------------------------------------------- */
typedef struct gc_thread_ {
+ Capability *cap;
+
#ifdef THREADED_RTS
OSThreadId id; // The OS thread that this struct belongs to
SpinLock gc_spin;
// --------------------
// evacuate flags
- step *evac_step; // Youngest generation that objects
+ nat evac_gen_no; // Youngest generation that objects
// should be evacuated to in
// evacuate(). (Logically an
// argument to evacuate, but it's
// instead of the to-space
// corresponding to the object
- lnat thunk_selector_depth; // ummm.... not used as of now
+ lnat thunk_selector_depth; // used to avoid unbounded recursion in
+ // evacuate() for THUNK_SELECTOR
#ifdef USE_PAPI
int papi_events;
lnat no_work;
lnat scav_find_work;
+ Ticks gc_start_cpu; // process CPU time
+ Ticks gc_start_elapsed; // process elapsed time
+ Ticks gc_start_thread_cpu; // thread CPU time
+ lnat gc_start_faults;
+
// -------------------
// workspaces
- // array of workspaces, indexed by stp->abs_no. This is placed
+ // array of workspaces, indexed by gen->abs_no. This is placed
// directly at the end of the gc_thread structure so that we can get from
// the gc_thread pointer to a workspace using only pointer
// arithmetic, no memory access. This happens in the inner loop
// of the GC, see Evac.c:alloc_for_copy().
- step_workspace steps[];
+ gen_workspace gens[];
} gc_thread;
extern nat n_gc_threads;
-/* -----------------------------------------------------------------------------
- The gct variable is thread-local and points to the current thread's
- gc_thread structure. It is heavily accessed, so we try to put gct
- into a global register variable if possible; if we don't have a
- register then use gcc's __thread extension to create a thread-local
- variable.
-
- Even on x86 where registers are scarce, it is worthwhile using a
- register variable here: I measured about a 2-5% slowdown with the
- __thread version.
- -------------------------------------------------------------------------- */
-
extern gc_thread **gc_threads;
-#if defined(THREADED_RTS)
-
-#define GLOBAL_REG_DECL(type,name,reg) register type name REG(reg);
-
-#define SET_GCT(to) gct = (to)
-
-#if defined(sparc_HOST_ARCH)
-// Don't use REG_base or R1 for gct on SPARC because they're getting clobbered
-// by something else. Not sure what yet. -- BL 2009/01/03
-
-extern __thread gc_thread* gct;
-#define DECLARE_GCT __thread gc_thread* gct;
-
-#elif defined(REG_Base) && !defined(i386_HOST_ARCH)
-// on i386, REG_Base is %ebx which is also used for PIC, so we don't
-// want to steal it
-
-GLOBAL_REG_DECL(gc_thread*, gct, REG_Base)
-#define DECLARE_GCT /* nothing */
-
-#elif defined(REG_R1)
-
-GLOBAL_REG_DECL(gc_thread*, gct, REG_R1)
-#define DECLARE_GCT /* nothing */
-
-#elif defined(__GNUC__)
-
-extern __thread gc_thread* gct;
-#define DECLARE_GCT __thread gc_thread* gct;
-
-#else
-
-#error Cannot find a way to declare the thread-local gct
-
-#endif
-
-#else // not the threaded RTS
-
-extern StgWord8 the_gc_thread[];
-
-#define gct ((gc_thread*)&the_gc_thread)
-#define SET_GCT(to) /*nothing*/
-#define DECLARE_GCT /*nothing*/
-
-#endif
+#include "EndPrivate.h"
-#endif // GCTHREAD_H
+#endif // SM_GCTHREAD_H
projects / ghc-hetmet.git / blobdiff