diff options
| author | Simon Marlow <marlowsd@gmail.com> | 2009-08-02 21:32:04 +0000 |
|---|---|---|
| committer | Simon Marlow <marlowsd@gmail.com> | 2009-08-02 21:32:04 +0000 |
| commit | a2a67cd520b9841114d69a87a423dabcb3b4368e (patch) | |
| tree | 3dc6bbf53dff5421c14fbeb2d812c1424f2718c0 /includes | |
| parent | 5d379cbe65e406d5c3a848fe7fcd090cafbfeb78 (diff) | |
| download | haskell-a2a67cd520b9841114d69a87a423dabcb3b4368e.tar.gz | |
RTS tidyup sweep, first phase
The first phase of this tidyup is focussed on the header files, and in
particular making sure we are exposinng publicly exactly what we need
to, and no more.
- Rts.h now includes everything that the RTS exposes publicly,
rather than a random subset of it.
- Most of the public header files have moved into subdirectories, and
many of them have been renamed. But clients should not need to
include any of the other headers directly, just #include the main
public headers: Rts.h, HsFFI.h, RtsAPI.h.
- All the headers needed for via-C compilation have moved into the
stg subdirectory, which is self-contained. Most of the headers for
the rest of the RTS APIs have moved into the rts subdirectory.
- I left MachDeps.h where it is, because it is so widely used in
Haskell code.
- I left a deprecated stub for RtsFlags.h in place. The flag
structures are now exposed by Rts.h.
- Various internal APIs are no longer exposed by public header files.
- Various bits of dead code and declarations have been removed
- More gcc warnings are turned on, and the RTS code is more
warning-clean.
- More source files #include "PosixSource.h", and hence only use
standard POSIX (1003.1c-1995) interfaces.
There is a lot more tidying up still to do, this is just the first
pass. I also intend to standardise the names for external RTS APIs
(e.g use the rts_ prefix consistently), and declare the internal APIs
as hidden for shared libraries.
Diffstat (limited to 'includes')
| -rw-r--r-- | includes/ClosureMacros.h | 185 | ||||
| -rw-r--r-- | includes/Cmm.h | 31 | ||||
| -rw-r--r-- | includes/GranSim.h | 331 | ||||
| -rw-r--r-- | includes/HsFFI.h | 6 | ||||
| -rw-r--r-- | includes/MachDeps.h | 3 | ||||
| -rw-r--r-- | includes/Parallel.h | 360 | ||||
| -rw-r--r-- | includes/README | 9 | ||||
| -rw-r--r-- | includes/Rts.h | 130 | ||||
| -rw-r--r-- | includes/RtsAPI.h | 2 | ||||
| -rw-r--r-- | includes/RtsConfig.h | 64 | ||||
| -rw-r--r-- | includes/RtsExternal.h | 129 | ||||
| -rw-r--r-- | includes/RtsFlags.h | 241 | ||||
| -rw-r--r-- | includes/STM.h | 245 | ||||
| -rw-r--r-- | includes/Stable.h | 63 | ||||
| -rw-r--r-- | includes/Stg.h | 57 | ||||
| -rw-r--r-- | includes/Storage.h | 583 | ||||
| -rw-r--r-- | includes/config.h | 7 | ||||
| -rw-r--r-- | includes/ghc.mk | 6 | ||||
| -rw-r--r-- | includes/ieee-flpt.h | 35 | ||||
| -rw-r--r-- | includes/mkDerivedConstants.c | 4 | ||||
| -rw-r--r-- | includes/rts/Adjustor.h | 20 | ||||
| -rw-r--r-- | includes/rts/Bytecodes.h (renamed from includes/Bytecodes.h) | 0 | ||||
| -rw-r--r-- | includes/rts/Config.h | 36 | ||||
| -rw-r--r-- | includes/rts/Constants.h (renamed from includes/Constants.h) | 6 | ||||
| -rw-r--r-- | includes/rts/EventLogFormat.h (renamed from includes/EventLogFormat.h) | 6 | ||||
| -rw-r--r-- | includes/rts/FileLock.h (renamed from includes/FileLock.h) | 7 | ||||
| -rw-r--r-- | includes/rts/Flags.h | 239 | ||||
| -rw-r--r-- | includes/rts/Globals.h (renamed from includes/RtsGlobals.h) | 9 | ||||
| -rw-r--r-- | includes/rts/Hooks.h (renamed from includes/Hooks.h) | 5 | ||||
| -rw-r--r-- | includes/rts/Hpc.h | 32 | ||||
| -rw-r--r-- | includes/rts/IOManager.h | 39 | ||||
| -rw-r--r-- | includes/rts/Linker.h (renamed from includes/Linker.h) | 8 | ||||
| -rw-r--r-- | includes/rts/Messages.h (renamed from includes/RtsMessages.h) | 27 | ||||
| -rw-r--r-- | includes/rts/OSThreads.h (renamed from includes/OSThreads.h) | 16 | ||||
| -rw-r--r-- | includes/rts/Parallel.h | 14 | ||||
| -rw-r--r-- | includes/rts/Signals.h (renamed from includes/Signals.h) | 11 | ||||
| -rw-r--r-- | includes/rts/SpinLock.h (renamed from includes/SpinLock.h) | 6 | ||||
| -rw-r--r-- | includes/rts/Stable.h | 35 | ||||
| -rw-r--r-- | includes/rts/Threads.h (renamed from includes/SchedAPI.h) | 32 | ||||
| -rw-r--r-- | includes/rts/Timer.h | 15 | ||||
| -rw-r--r-- | includes/rts/Types.h (renamed from includes/RtsTypes.h) | 8 | ||||
| -rw-r--r-- | includes/rts/prof/CCS.h (renamed from includes/StgProf.h) | 6 | ||||
| -rw-r--r-- | includes/rts/prof/LDV.h (renamed from includes/StgLdvProf.h) | 5 | ||||
| -rw-r--r-- | includes/rts/storage/Block.h (renamed from includes/Block.h) | 6 | ||||
| -rw-r--r-- | includes/rts/storage/ClosureMacros.h | 395 | ||||
| -rw-r--r-- | includes/rts/storage/ClosureTypes.h (renamed from includes/ClosureTypes.h) | 6 | ||||
| -rw-r--r-- | includes/rts/storage/Closures.h (renamed from includes/Closures.h) | 20 | ||||
| -rw-r--r-- | includes/rts/storage/FunTypes.h (renamed from includes/StgFun.h) | 8 | ||||
| -rw-r--r-- | includes/rts/storage/GC.h | 204 | ||||
| -rw-r--r-- | includes/rts/storage/InfoTables.h (renamed from includes/InfoTables.h) | 23 | ||||
| -rw-r--r-- | includes/rts/storage/Liveness.h (renamed from includes/Liveness.h) | 6 | ||||
| -rw-r--r-- | includes/rts/storage/MBlock.h | 206 | ||||
| -rw-r--r-- | includes/rts/storage/SMPClosureOps.h (renamed from includes/SMPClosureOps.h) | 6 | ||||
| -rw-r--r-- | includes/rts/storage/TSO.h (renamed from includes/TSO.h) | 39 | ||||
| -rw-r--r-- | includes/stg/DLL.h (renamed from includes/StgDLL.h) | 0 | ||||
| -rw-r--r-- | includes/stg/MachRegs.h (renamed from includes/MachRegs.h) | 0 | ||||
| -rw-r--r-- | includes/stg/MiscClosures.h (renamed from includes/StgMiscClosures.h) | 4 | ||||
| -rw-r--r-- | includes/stg/Regs.h (renamed from includes/Regs.h) | 5 | ||||
| -rw-r--r-- | includes/stg/SMP.h (renamed from includes/SMP.h) | 29 | ||||
| -rw-r--r-- | includes/stg/TailCalls.h (renamed from includes/TailCalls.h) | 0 | ||||
| -rw-r--r-- | includes/stg/Ticky.h (renamed from includes/TickyCounters.h) | 4 | ||||
| -rw-r--r-- | includes/stg/Types.h (renamed from includes/StgTypes.h) | 48 |
62 files changed, 1501 insertions, 2581 deletions
diff --git a/includes/ClosureMacros.h b/includes/ClosureMacros.h deleted file mode 100644 index 1c371b25e8..0000000000 --- a/includes/ClosureMacros.h +++ /dev/null @@ -1,185 +0,0 @@ -/* ---------------------------------------------------------------------------- - * - * (c) The GHC Team, 1998-2004 - * - * Macros for building and manipulating closures - * - * -------------------------------------------------------------------------- */ - -#ifndef CLOSUREMACROS_H -#define CLOSUREMACROS_H - -/* Say whether the code comes before the heap; on mingwin this may not be the - case, not because of another random MS pathology, but because the static - program may reside in a DLL -*/ - -/* ----------------------------------------------------------------------------- - Info tables are slammed up against the entry code, and the label - for the info table is at the *end* of the table itself. This - inline function adjusts an info pointer to point to the beginning - of the table, so we can use standard C structure indexing on it. - - Note: this works for SRT info tables as long as you don't want to - access the SRT, since they are laid out the same with the SRT - pointer as the first word in the table. - - NOTES ABOUT MANGLED C VS. MINI-INTERPRETER: - - A couple of definitions: - - "info pointer" The first word of the closure. Might point - to either the end or the beginning of the - info table, depending on whether we're using - the mini interpretter or not. GET_INFO(c) - retrieves the info pointer of a closure. - - "info table" The info table structure associated with a - closure. This is always a pointer to the - beginning of the structure, so we can - use standard C structure indexing to pull out - the fields. get_itbl(c) returns a pointer to - the info table for closure c. - - An address of the form xxxx_info points to the end of the info - table or the beginning of the info table depending on whether we're - mangling or not respectively. So, - - c->header.info = xxx_info - - makes absolute sense, whether mangling or not. - - -------------------------------------------------------------------------- */ - -#define SET_INFO(c,i) ((c)->header.info = (i)) -#define GET_INFO(c) ((c)->header.info) -#define GET_ENTRY(c) (ENTRY_CODE(GET_INFO(c))) - -#define get_itbl(c) (INFO_PTR_TO_STRUCT((c)->header.info)) -#define get_ret_itbl(c) (RET_INFO_PTR_TO_STRUCT((c)->header.info)) -#define get_fun_itbl(c) (FUN_INFO_PTR_TO_STRUCT((c)->header.info)) -#define get_thunk_itbl(c) (THUNK_INFO_PTR_TO_STRUCT((c)->header.info)) -#define get_con_itbl(c) (CON_INFO_PTR_TO_STRUCT((c)->header.info)) - -#define GET_TAG(con) (get_itbl(con)->srt_bitmap) - -#ifdef TABLES_NEXT_TO_CODE -#define INFO_PTR_TO_STRUCT(info) ((StgInfoTable *)(info) - 1) -#define RET_INFO_PTR_TO_STRUCT(info) ((StgRetInfoTable *)(info) - 1) -#define FUN_INFO_PTR_TO_STRUCT(info) ((StgFunInfoTable *)(info) - 1) -#define THUNK_INFO_PTR_TO_STRUCT(info) ((StgThunkInfoTable *)(info) - 1) -#define CON_INFO_PTR_TO_STRUCT(info) ((StgConInfoTable *)(info) - 1) -#define itbl_to_fun_itbl(i) ((StgFunInfoTable *)(((StgInfoTable *)(i) + 1)) - 1) -#define itbl_to_ret_itbl(i) ((StgRetInfoTable *)(((StgInfoTable *)(i) + 1)) - 1) -#define itbl_to_thunk_itbl(i) ((StgThunkInfoTable *)(((StgInfoTable *)(i) + 1)) - 1) -#define itbl_to_con_itbl(i) ((StgConInfoTable *)(((StgInfoTable *)(i) + 1)) - 1) -#else -#define INFO_PTR_TO_STRUCT(info) ((StgInfoTable *)info) -#define RET_INFO_PTR_TO_STRUCT(info) ((StgRetInfoTable *)info) -#define FUN_INFO_PTR_TO_STRUCT(info) ((StgFunInfoTable *)info) -#define THUNK_INFO_PTR_TO_STRUCT(info) ((StgThunkInfoTable *)info) -#define CON_INFO_PTR_TO_STRUCT(info) ((StgConInfoTable *)info) -#define itbl_to_fun_itbl(i) ((StgFunInfoTable *)(i)) -#define itbl_to_ret_itbl(i) ((StgRetInfoTable *)(i)) -#define itbl_to_thunk_itbl(i) ((StgThunkInfoTable *)(i)) -#define itbl_to_con_itbl(i) ((StgConInfoTable *)(i)) -#endif - -/* ----------------------------------------------------------------------------- - Macros for building closures - -------------------------------------------------------------------------- */ - -#ifdef PROFILING -#ifdef DEBUG_RETAINER -/* - For the sake of debugging, we take the safest way for the moment. Actually, this - is useful to check the sanity of heap before beginning retainer profiling. - flip is defined in RetainerProfile.c, and declared as extern in RetainerProfile.h. - Note: change those functions building Haskell objects from C datatypes, i.e., - all rts_mk???() functions in RtsAPI.c, as well. - */ -#define SET_PROF_HDR(c,ccs_) \ - ((c)->header.prof.ccs = ccs_, (c)->header.prof.hp.rs = (retainerSet *)((StgWord)NULL | flip)) -#else -/* - For retainer profiling only: we do not have to set (c)->header.prof.hp.rs to - NULL | flip (flip is defined in RetainerProfile.c) because even when flip - is 1, rs is invalid and will be initialized to NULL | flip later when - the closure *c is visited. - */ -/* -#define SET_PROF_HDR(c,ccs_) \ - ((c)->header.prof.ccs = ccs_, (c)->header.prof.hp.rs = NULL) - */ -/* - The following macro works for both retainer profiling and LDV profiling: - for retainer profiling, ldvTime remains 0, so rs fields are initialized to 0. - See the invariants on ldvTime. - */ -#define SET_PROF_HDR(c,ccs_) \ - ((c)->header.prof.ccs = ccs_, \ - LDV_RECORD_CREATE((c))) -#endif /* DEBUG_RETAINER */ -#define SET_STATIC_PROF_HDR(ccs_) \ - prof : { ccs : (CostCentreStack *)ccs_, hp : { rs : NULL } }, -#else -#define SET_PROF_HDR(c,ccs) -#define SET_STATIC_PROF_HDR(ccs) -#endif - -#ifdef TICKY_TICKY -#define SET_TICKY_HDR(c,stuff) /* old: (c)->header.ticky.updated = stuff */ -#define SET_STATIC_TICKY_HDR(stuff) /* old: ticky : { updated : stuff } */ -#else -#define SET_TICKY_HDR(c,stuff) -#define SET_STATIC_TICKY_HDR(stuff) -#endif - -#define SET_HDR(c,_info,ccs) \ - { \ - (c)->header.info = _info; \ - SET_PROF_HDR((StgClosure *)(c),ccs); \ - SET_TICKY_HDR((StgClosure *)(c),0); \ - } - -#define SET_ARR_HDR(c,info,costCentreStack,n_words) \ - SET_HDR(c,info,costCentreStack); \ - (c)->words = n_words; - -/* ----------------------------------------------------------------------------- - How to get hold of the static link field for a static closure. - -------------------------------------------------------------------------- */ - -/* These are hard-coded. */ -#define FUN_STATIC_LINK(p) (&(p)->payload[0]) -#define THUNK_STATIC_LINK(p) (&(p)->payload[1]) -#define IND_STATIC_LINK(p) (&(p)->payload[1]) - -INLINE_HEADER StgClosure ** -STATIC_LINK(const StgInfoTable *info, StgClosure *p) -{ - switch (info->type) { - case THUNK_STATIC: - return THUNK_STATIC_LINK(p); - case FUN_STATIC: - return FUN_STATIC_LINK(p); - case IND_STATIC: - return IND_STATIC_LINK(p); - default: - return &(p)->payload[info->layout.payload.ptrs + - info->layout.payload.nptrs]; - } -} - -#define STATIC_LINK2(info,p) \ - (*(StgClosure**)(&((p)->payload[info->layout.payload.ptrs + \ - info->layout.payload.nptrs + 1]))) - -/* ----------------------------------------------------------------------------- - INTLIKE and CHARLIKE closures. - -------------------------------------------------------------------------- */ - -#define CHARLIKE_CLOSURE(n) ((P_)&stg_CHARLIKE_closure[(n)-MIN_CHARLIKE]) -#define INTLIKE_CLOSURE(n) ((P_)&stg_INTLIKE_closure[(n)-MIN_INTLIKE]) - -#endif /* CLOSUREMACROS_H */ diff --git a/includes/Cmm.h b/includes/Cmm.h index 4577672f44..aba5c2e36b 100644 --- a/includes/Cmm.h +++ b/includes/Cmm.h @@ -66,7 +66,6 @@ #define CMINUSMINUS 1 #include "ghcconfig.h" -#include "RtsConfig.h" /* ----------------------------------------------------------------------------- Types @@ -144,6 +143,18 @@ name : bits8[] str; \ } \ +#ifdef TABLES_NEXT_TO_CODE +#define RET_LBL(f) f##_info +#else +#define RET_LBL(f) f##_ret +#endif + +#ifdef TABLES_NEXT_TO_CODE +#define ENTRY_LBL(f) f##_info +#else +#define ENTRY_LBL(f) f##_entry +#endif + /* ----------------------------------------------------------------------------- Byte/word macros @@ -320,26 +331,26 @@ Constants. -------------------------------------------------------------------------- */ -#include "Constants.h" +#include "rts/Constants.h" #include "DerivedConstants.h" -#include "ClosureTypes.h" -#include "StgFun.h" -#include "OSThreads.h" -#include "SMPClosureOps.h" +#include "rts/storage/ClosureTypes.h" +#include "rts/storage/FunTypes.h" +#include "rts/storage/SMPClosureOps.h" +#include "rts/OSThreads.h" /* * Need MachRegs, because some of the RTS code is conditionally * compiled based on REG_R1, REG_R2, etc. */ #define STOLEN_X86_REGS 4 -#include "MachRegs.h" +#include "stg/MachRegs.h" -#include "Liveness.h" -#include "StgLdvProf.h" +#include "rts/storage/Liveness.h" +#include "rts/prof/LDV.h" #undef BLOCK_SIZE #undef MBLOCK_SIZE -#include "Block.h" /* For Bdescr() */ +#include "rts/storage/Block.h" /* For Bdescr() */ #define MyCapability() (BaseReg - OFFSET_Capability_r) diff --git a/includes/GranSim.h b/includes/GranSim.h deleted file mode 100644 index be5aa83a52..0000000000 --- a/includes/GranSim.h +++ /dev/null @@ -1,331 +0,0 @@ -/* - Headers for GranSim specific objects. - - Note that in GranSim we have one run-queue and blocking-queue for each - processor. Therefore, this header file redefines variables like - run_queue_hd to be relative to CurrentProc. The main arrays of runnable - and blocking queues are defined in Schedule.c. The important STG-called - GranSim macros (e.g. for fetching nodes) are at the end of this - file. Usually they are just wrappers to proper C functions in GranSim.c. -*/ - -#ifndef GRANSIM_H -#define GRANSIM_H - -#if !defined(GRAN) - -/* Dummy definitions for basic GranSim macros called from STG land */ -#define DO_GRAN_ALLOCATE(n) /* nothing */ -#define DO_GRAN_UNALLOCATE(n) /* nothing */ -#define DO_GRAN_FETCH(node) /* nothing */ -#define DO_GRAN_EXEC(arith,branch,load,store,floats) /* nothing */ -#define GRAN_FETCH_AND_RESCHEDULE(liveness_mask,reenter) /* nothing */ -#define GRAN_RESCHEDULE(liveness_mask,reenter) /* nothing */ - -#endif - -#if defined(GRAN) /* whole file */ - -extern StgTSO *CurrentTSO; - -/* - * @node Headers for GranSim specific objects, , , - * @section Headers for GranSim specific objects - * - * @menu - * * Externs and prototypes:: - * * Run and blocking queues:: - * * Spark queues:: - * * Processor related stuff:: - * * GranSim costs:: - * * STG called GranSim functions:: - * * STG-called routines:: - * @end menu - * - * @node Externs and prototypes, Run and blocking queues, Includes, Headers for GranSim specific objects - * @subsection Externs and prototypes - */ - -/* Global constants */ -extern char *gran_event_names[]; -extern char *proc_status_names[]; -extern char *event_names[]; - -/* Vars checked from within STG land */ -extern rtsBool NeedToReSchedule, IgnoreEvents, IgnoreYields; -; -extern rtsTime TimeOfNextEvent, TimeOfLastEvent, EndOfTimeSlice; - -/* costs for basic operations (copied from RTS flags) */ -extern nat gran_arith_cost, gran_branch_cost, gran_load_cost, gran_store_cost, gran_float_cost; - -extern nat SparksAvail; /* How many sparks are available */ -extern nat SurplusThreads; /* How many excess threads are there */ -extern nat sparksIgnored, sparksCreated; - -/* - * @node Run and blocking queues, Spark queues, Externs and prototypes, Headers for GranSim specific objects - * @subsection Run and blocking queues - */ - -/* declared in Schedule.c */ -extern StgTSO *run_queue_hds[], *run_queue_tls[]; -extern StgTSO *blocked_queue_hds[], *blocked_queue_tls[]; -extern StgTSO *ccalling_threadss[]; - -#define run_queue_hd run_queue_hds[CurrentProc] -#define run_queue_tl run_queue_tls[CurrentProc] -#define blocked_queue_hd blocked_queue_hds[CurrentProc] -#define blocked_queue_tl blocked_queue_tls[CurrentProc] -#define pending_sparks_hd pending_sparks_hds[CurrentProc] -#define pending_sparks_tl pending_sparks_tls[CurrentProc] -#define ccalling_threads ccalling_threadss[CurrentProc] - -/* - * @node Spark queues, Processor related stuff, Run and blocking queues, Headers for GranSim specific objects - * @subsection Spark queues - */ - -/* - In GranSim we use a double linked list to represent spark queues. - - This is more flexible, but slower, than the array of pointers - representation used in GUM. We use the flexibility to define new fields in - the rtsSpark structure, representing e.g. granularity info (see HWL's PhD - thesis), or info about the parent of a spark. -*/ - -/* Sparks and spark queues */ -typedef struct rtsSpark_ -{ - StgClosure *node; - nat name, global; - nat gran_info; /* for granularity improvement mechanisms */ - PEs creator; /* PE that created this spark (unused) */ - struct rtsSpark_ *prev, *next; -} rtsSpark; -typedef rtsSpark *rtsSparkQ; - -/* The spark queues, proper */ -/* In GranSim this is a globally visible array of spark queues */ -extern rtsSparkQ pending_sparks_hds[]; -extern rtsSparkQ pending_sparks_tls[]; - -/* Prototypes of those spark routines visible to compiler generated .hc */ -/* Routines only used inside the RTS are defined in rts/parallel GranSimRts.h */ -rtsSpark *newSpark(StgClosure *node, - nat name, nat gran_info, nat size_info, - nat par_info, nat local); -/* void add_to_spark_queue(rtsSpark *spark); */ - -/* - * @node Processor related stuff, GranSim costs, Spark queues, Headers for GranSim specific objects - * @subsection Processor related stuff - */ - -extern PEs CurrentProc; -extern rtsTime CurrentTime[]; - -/* Maximum number of PEs that can be simulated */ -#define MAX_PROC 32 /* (BITS_IN(StgWord)) */ /* ToDo: fix this!! */ -/* -#if MAX_PROC==16 -#else -#error MAX_PROC should be 32 on this architecture -#endif -*/ - -/* #define CurrentTSO CurrentTSOs[CurrentProc] */ - -/* Processor numbers to bitmasks and vice-versa */ -#define MainProc 0 /* Id of main processor */ -#define NO_PRI 0 /* dummy priority */ -#define MAX_PRI 10000 /* max possible priority */ -#define MAIN_PRI MAX_PRI /* priority of main thread */ - -/* GrAnSim uses IdleProcs as bitmask to indicate which procs are idle */ -#define PE_NUMBER(n) (1l << (long)n) -#define ThisPE PE_NUMBER(CurrentProc) -#define MainPE PE_NUMBER(MainProc) -#define Everywhere (~0l) -#define Nowhere (0l) -#define Now CurrentTime[CurrentProc] - -#define IS_LOCAL_TO(ga,proc) ((1l << (PEs) proc) & ga) - -#define GRAN_TIME_SLICE 1000 /* max time between 2 ReSchedules */ - -/* - * @node GranSim costs, STG called GranSim functions, Processor related stuff, Headers for GranSim specific objects - * @subsection GranSim costs - */ - -/* Default constants for communication (see RtsFlags on how to change them) */ - -#define LATENCY 1000 /* Latency for single packet */ -#define ADDITIONAL_LATENCY 100 /* Latency for additional packets */ -#define BASICBLOCKTIME 10 -#define FETCHTIME (LATENCY*2+MSGUNPACKTIME) -#define LOCALUNBLOCKTIME 10 -#define GLOBALUNBLOCKTIME (LATENCY+MSGUNPACKTIME) - -#define MSGPACKTIME 0 /* Cost of creating a packet */ -#define MSGUNPACKTIME 0 /* Cost of receiving a packet */ -#define MSGTIDYTIME 0 /* Cost of cleaning up after send */ - -/* How much to increase GrAnSims internal packet size if an overflow - occurs. - NB: This is a GrAnSim internal variable and is independent of the - simulated packet buffer size. -*/ - -#define GRANSIM_DEFAULT_PACK_BUFFER_SIZE 400 -#define REALLOC_SZ 200 - -/* extern W_ gran_mpacktime, gran_mtidytime, gran_munpacktime; */ - -/* Thread cost model */ -#define THREADCREATETIME (25+THREADSCHEDULETIME) -#define THREADQUEUETIME 12 /* Cost of adding a thread to the running/runnable queue */ -#define THREADDESCHEDULETIME 75 /* Cost of descheduling a thread */ -#define THREADSCHEDULETIME 75 /* Cost of scheduling a thread */ -#define THREADCONTEXTSWITCHTIME (THREADDESCHEDULETIME+THREADSCHEDULETIME) - -/* Instruction Cost model (SPARC, including cache misses) */ -#define ARITH_COST 1 -#define BRANCH_COST 2 -#define LOAD_COST 4 -#define STORE_COST 4 -#define FLOAT_COST 1 /* ? */ - -#define HEAPALLOC_COST 11 - -#define PRI_SPARK_OVERHEAD 5 -#define PRI_SCHED_OVERHEAD 5 - -/* - * @node STG called GranSim functions, STG-called routines, GranSim costs, Headers for GranSim specific objects - * @subsection STG called GranSim functions - */ - -/* STG called GranSim functions */ -void GranSimAllocate(StgInt n); -void GranSimUnallocate(StgInt n); -void GranSimExec(StgWord ariths, StgWord branches, StgWord loads, StgWord stores, StgWord floats); -StgInt GranSimFetch(StgClosure *node); -void GranSimSpark(StgInt local, StgClosure *node); -void GranSimSparkAt(rtsSpark *spark, StgClosure *where,StgInt identifier); -void GranSimSparkAtAbs(rtsSpark *spark, PEs proc, StgInt identifier); -void GranSimBlock(StgTSO *tso, PEs proc, StgClosure *node); - - -/* - * @node STG-called routines, , STG called GranSim functions, Headers for GranSim specific objects - * @subsection STG-called routines - */ - -/* Wrapped version of calls to GranSim-specific STG routines */ - -/* -#define DO_PERFORM_RESCHEDULE(liveness, always_reenter_node) PerformReschedule_wrapper(liveness, always_reenter_node) -*/ -#define DO_GRAN_ALLOCATE(n) STGCALL1(GranSimAllocate, n) -#define DO_GRAN_UNALLOCATE(n) STGCALL1(GranSimUnallocate, n) -#define DO_GRAN_FETCH(node) STGCALL1(GranSimFetch, node) -#define DO_GRAN_EXEC(arith,branch,load,store,floats) GranSimExec(arith,branch,load,store,floats) - -/* - ToDo: Clean up this mess of GRAN macros!!! -- HWL -*/ -/* DO_GRAN_FETCH((StgClosure*)R1.p); */ -#define GRAN_FETCH() /* nothing */ - -#define GRAN_FETCH_AND_RESCHEDULE(liveness,reenter) \ - DO_GRAN_FETCH((StgClosure*)R1.p); \ - DO_GRAN_YIELD(liveness,ENTRY_CODE((D_)(*R1.p))); -/* RESTORE_EVERYTHING is done implicitly before entering threaded world again */ - -/* - This is the only macro currently enabled; - It should check whether it is time for the current thread to yield - (e.g. if there is a more recent event in the queue) and it should check - whether node is local, via a call to GranSimFetch. - ToDo: split this in 2 routines: - - GRAN_YIELD (as it is below) - - GRAN_FETCH (the rest of this macro) - emit only these 2 macros based on node's liveness - node alive: emit both macros - node not alive: do only a GRAN_YIELD - - replace gran_yield_? with gran_block_? (they really block the current - thread) -*/ -#define GRAN_RESCHEDULE(liveness,ptrs) \ - if (RET_STGCALL1(StgInt, GranSimFetch, (StgClosure*)R1.p)) {\ - EXTFUN_RTS(gran_block_##ptrs); \ - JMP_(gran_block_##ptrs); \ - } else { \ - if (TimeOfLastEvent < CurrentTime[CurrentProc] && \ - HEAP_ALLOCED((StgClosure *)R1.p) && \ - LOOKS_LIKE_GHC_INFO(get_itbl((StgClosure *)R1.p))) { \ - EXTFUN_RTS(gran_yield_##ptrs); \ - JMP_(gran_yield_##ptrs); \ - } \ - /* GRAN_YIELD(ptrs) */ \ - } - - -/* YIELD(liveness,reenter) */ - -/* GRAN_YIELD(liveness_mask); */ - -/* GRAN_FETCH_AND_RESCHEDULE(liveness_mask,reenter) */ - -#define THREAD_CONTEXT_SWITCH(liveness_mask,reenter) \ - do { \ - if (context_switch /* OR_INTERVAL_EXPIRED */) { \ - GRAN_RESCHEDULE(liveness_mask,reenter); \ - } }while(0) - -#define GRAN_EXEC(arith,branch,load,store,floats) \ - { \ - W_ cost = gran_arith_cost*arith + \ - gran_branch_cost*branch + \ - gran_load_cost*load + \ - gran_store_cost*store + \ - gran_float_cost*floats; \ - CurrentTSO->gran.exectime += cost; \ - CurrentTime[CurrentProc] += cost; \ - } - -/* In GranSim we first check whether there is an event to handle; only if - this is the case (or the time slice is over in case of fair scheduling) - we do a yield, which is very similar to that in the concurrent world - ToDo: check whether gran_yield_? can be merged with other yielding codes -*/ - -#define DO_GRAN_YIELD(ptrs) if (!IgnoreYields && \ - TimeOfLastEvent < CurrentTime[CurrentProc] && \ - HEAP_ALLOCED((StgClosure *)R1.p) && \ - LOOKS_LIKE_GHC_INFO(get_itbl((StgClosure *)R1.p))) { \ - EXTFUN_RTS(gran_yield_##ptrs); \ - JMP_(gran_yield_##ptrs); \ - } - -#define GRAN_YIELD(ptrs) \ - { \ - extern int context_switch; \ - if ( (CurrentTime[CurrentProc]>=EndOfTimeSlice) || \ - ((CurrentTime[CurrentProc]>=TimeOfNextEvent) && \ - (TimeOfNextEvent!=0) && !IgnoreEvents )) { \ - /* context_switch = 1; */ \ - DO_GRAN_YIELD(ptrs); \ - } \ - } - -#define ADD_TO_SPARK_QUEUE(spark) \ - STGCALL1(add_to_spark_queue,spark) \ - -#endif /* GRAN */ - -#endif /* GRANSIM_H */ diff --git a/includes/HsFFI.h b/includes/HsFFI.h index cd9f7ede80..f489be5623 100644 --- a/includes/HsFFI.h +++ b/includes/HsFFI.h @@ -18,8 +18,7 @@ extern "C" { /* get types from GHC's runtime system */ #include "ghcconfig.h" -#include "RtsConfig.h" -#include "StgTypes.h" +#include "stg/Types.h" /* get limits for integral types */ #ifdef HAVE_STDINT_H @@ -84,10 +83,7 @@ typedef StgDouble HsDouble; typedef StgInt HsBool; typedef void* HsPtr; /* this should better match StgAddr */ typedef void (*HsFunPtr)(void); /* this should better match StgAddr */ -typedef void* HsForeignPtr; /* ... and this StgForeignPtr */ typedef void* HsStablePtr; -typedef void* HsAddr; /* DEPRECATED */ -typedef void* HsForeignObj; /* DEPRECATED */ /* this should correspond to the type of StgChar in StgTypes.h */ #define HS_CHAR_MIN 0 diff --git a/includes/MachDeps.h b/includes/MachDeps.h index 7b71f7c378..8e6db3ec0e 100644 --- a/includes/MachDeps.h +++ b/includes/MachDeps.h @@ -58,9 +58,6 @@ #define SIZEOF_HSFUNPTR SIZEOF_VOID_P #define ALIGNMENT_HSFUNPTR ALIGNMENT_VOID_P -#define SIZEOF_HSFOREIGNPTR SIZEOF_VOID_P -#define ALIGNMENT_HSFOREIGNPTR ALIGNMENT_VOID_P - #define SIZEOF_HSSTABLEPTR SIZEOF_VOID_P #define ALIGNMENT_HSSTABLEPTR ALIGNMENT_VOID_P diff --git a/includes/Parallel.h b/includes/Parallel.h deleted file mode 100644 index e18fbe9b2c..0000000000 --- a/includes/Parallel.h +++ /dev/null @@ -1,360 +0,0 @@ -/* - Definitions for GUM i.e. running on a parallel machine. - - This section contains definitions applicable only to programs compiled - to run on a parallel machine, i.e. on GUM. Some of these definitions - are also used when simulating parallel execution, i.e. on GranSim. -*/ - -#ifndef PARALLEL_H -#define PARALLEL_H - -#if defined(PAR) || defined(GRAN) /* whole file */ - -/* - * @node Parallel definitions, End of File - * @section Parallel definitions - * - * @menu - * * Basic definitions:: - * * GUM:: - * * GranSim:: - * @end menu - * - * @node Basic definitions, GUM, Parallel definitions, Parallel definitions - * @subsection Basic definitions - */ - -/* This clashes with TICKY, but currently TICKY and PAR hate each other anyway */ -#define _HS sizeofW(StgHeader) - -/* SET_PAR_HDR and SET_STATIC_PAR_HDR now live in ClosureMacros.h */ - -/* Needed for dumping routines */ -#if defined(PAR) -# define NODE_STR_LEN 20 -# define TIME_STR_LEN 120 -# define TIME rtsTime -# define CURRENT_TIME (msTime() - startTime) -# define TIME_ON_PROC(p) (msTime() - startTime) -# define CURRENT_PROC thisPE -# define BINARY_STATS RtsFlags.ParFlags.ParStats.Binary -#elif defined(GRAN) -# define NODE_STR_LEN 20 -# define TIME_STR_LEN 120 -# define TIME rtsTime -# define CURRENT_TIME CurrentTime[CurrentProc] -# define TIME_ON_PROC(p) CurrentTime[p] -# define CURRENT_PROC CurrentProc -# define BINARY_STATS RtsFlags.GranFlags.GranSimStats.Binary -#endif - -#if defined(PAR) -# define MAX_PES 256 /* Maximum number of processors */ - /* MAX_PES is enforced by SysMan, which does not - allow more than this many "processors". - This is important because PackGA [GlobAddr.lc] - **assumes** that a PE# can fit in 8+ bits. - */ - -# define SPARK_POOLS 2 /* no. of spark pools */ -# define REQUIRED_POOL 0 /* idx of pool of mandatory sparks (concurrency) */ -# define ADVISORY_POOL 1 /* idx of pool of advisory sparks (parallelism) */ -#endif - -/* - * @menu - * * GUM:: - * * GranSim:: - * @end menu - * - * @node GUM, GranSim, Basic definitions, Parallel definitions - * @subsection GUM - */ - -#if defined(PAR) -/* - Symbolic constants for the packing code. - - This constant defines how many words of data we can pack into a single - packet in the parallel (GUM) system. -*/ - -/* - * @menu - * * Types:: - * * Externs:: - * * Prototypes:: - * * Macros:: - * @end menu - * - * @node Types, Externs, GUM, GUM - * @subsubsection Types - */ - -/* Sparks and spark queues */ -typedef StgClosure *rtsSpark; -typedef rtsSpark *rtsSparkQ; - -typedef struct rtsPackBuffer_ { - StgInt /* nat */ id; - StgInt /* nat */ size; - StgInt /* nat */ unpacked_size; - StgTSO *tso; - StgWord *buffer[0]; -} rtsPackBuffer; - -#define PACK_BUFFER_HDR_SIZE 4 - -/* - * @node Externs, Prototypes, Types, GUM - * @subsubsection Externs - */ - -/* extern rtsBool do_sp_profile; */ - -extern globalAddr theGlobalFromGA, theGlobalToGA; -extern StgBlockedFetch *PendingFetches; -extern GlobalTaskId *allPEs; - -extern rtsBool IAmMainThread, GlobalStopPending; -/*extern rtsBool fishing; */ -extern rtsTime last_fish_arrived_at; -extern nat outstandingFishes; -extern GlobalTaskId SysManTask; -extern int seed; /* pseudo-random-number generator seed: */ - /* Initialised in ParInit */ -extern StgInt threadId; /* Number of Threads that have existed on a PE */ -extern GlobalTaskId mytid; - -extern GlobalTaskId *allPEs; -extern nat nPEs; -extern nat sparksIgnored, sparksCreated, threadsIgnored, threadsCreated; -extern nat advisory_thread_count; - -extern rtsBool InGlobalGC; /* Are we in the midst of performing global GC */ - -extern ullong startTime; /* start of comp; in RtsStartup.c */ - -/* the spark pools proper */ -extern rtsSpark *pending_sparks_hd[]; /* ptr to start of a spark pool */ -extern rtsSpark *pending_sparks_tl[]; /* ptr to end of a spark pool */ -extern rtsSpark *pending_sparks_lim[]; -extern rtsSpark *pending_sparks_base[]; -extern nat spark_limit[]; - -extern rtsPackBuffer *PackBuffer; /* size: can be set via option */ -extern rtsPackBuffer *buffer; -extern rtsPackBuffer *freeBuffer; -extern rtsPackBuffer *packBuffer; -extern rtsPackBuffer *gumPackBuffer; - -extern nat thisPE; - -/* From Global.c -extern GALA *freeGALAList; -extern GALA *freeIndirections; -extern GALA *liveIndirections; -extern GALA *liveRemoteGAs; -*/ - -/* - * @node Prototypes, Macros, Externs, GUM - * @subsubsection Prototypes - */ - -/* From ParInit.c */ -void initParallelSystem(void); -void SynchroniseSystem(void); -void par_exit(StgInt n); - -PEs taskIDtoPE (GlobalTaskId gtid); -void registerTask (GlobalTaskId gtid); -globalAddr *LAGAlookup (StgClosure *addr); -StgClosure *GALAlookup (globalAddr *ga); -/*static GALA *allocIndirection (StgPtr addr); */ -globalAddr *makeGlobal (StgClosure *addr, rtsBool preferred); -globalAddr *setRemoteGA (StgClosure *addr, globalAddr *ga, rtsBool preferred); -void splitWeight (globalAddr *to, globalAddr *from); -globalAddr *addWeight (globalAddr *ga); -void initGAtables (void); -void RebuildLAGAtable (void); -StgWord PackGA (StgWord pe, int slot); - -# if defined(DEBUG) -/* from Global.c */ -/* highest_slot breaks the abstraction of the slot counter for GAs; it is - only used for sanity checking and should used nowhere else */ -StgInt highest_slot (void); -# endif - -/* - * @node Macros, , Prototypes, GUM - * @subsubsection Macros - */ - -/* delay (in us) between dying fish returning and sending out a new fish */ -#define FISH_DELAY 1000 -/* max no. of outstanding spark steals */ -#define MAX_FISHES 1 - -/* ToDo: check which of these is actually needed! */ - -# define PACK_HEAP_REQUIRED ((RtsFlags.ParFlags.packBufferSize - PACK_HDR_SIZE) / (PACK_GA_SIZE + _HS) * (MIN_UPD_SIZE + 2)) - -# define MAX_GAS (RtsFlags.ParFlags.packBufferSize / PACK_GA_SIZE) - - -# define PACK_GA_SIZE 3 /* Size of a packed GA in words */ - /* Size of a packed fetch-me in words */ -# define PACK_FETCHME_SIZE (PACK_GA_SIZE + _HS) - -# define PACK_HDR_SIZE 1 /* Words of header in a packet */ - -# define PACK_PLC_SIZE 2 /* Size of a packed PLC in words */ - -/* - Definitions relating to the entire parallel-only fixed-header field. - - On GUM, the global addresses for each local closure are stored in a - separate hash table, rather then with the closure in the heap. We call - @getGA@ to look up the global address associated with a local closure (0 - is returned for local closures that have no global address), and @setGA@ - to store a new global address for a local closure which did not - previously have one. */ - -# define GA_HDR_SIZE 0 - -# define GA(closure) getGA(closure) - -# define SET_GA(closure, ga) setGA(closure,ga) -# define SET_STATIC_GA(closure) -# define SET_GRAN_HDR(closure,pe) -# define SET_STATIC_PROCS(closure) - -# define MAX_GA_WEIGHT 0 /* Treat as 2^n */ - -/* At the moment, there is no activity profiling for GUM. This may change. */ -# define SET_TASK_ACTIVITY(act) /* nothing */ - -/* - The following macros are only needed for sanity checking (see Sanity.c). -*/ - -/* NB: this is PVM specific and should be updated for MPI etc - in PVM a task id (tid) is split into 2 parts: the id for the - physical processor it is running on and an index of tasks running - on a processor; PVM_PE_MASK indicates which part of a tid holds the - id of the physical processor (the other part of the word holds the - index on that processor) - MAX_PVM_PES and MAX_PVM_TIDS are maximal values for these 2 components - in GUM we have an upper bound for the total number of PVM PEs allowed: - it's MAX_PE defined in Parallel.h - to check the slot field of a GA we call a fct highest_slot which just - returns the internal counter -*/ -#define PVM_PE_MASK 0xfffc0000 -#define MAX_PVM_PES MAX_PES -#define MAX_PVM_TIDS MAX_PES - -#if 0 -#define LOOKS_LIKE_TID(tid) (((tid & PVM_PE_MASK) != 0) && \ - (((tid & PVM_PE_MASK) + (tid & ~PVM_PE_MASK)) < MAX_PVM_TIDS)) -#define LOOKS_LIKE_SLOT(slot) (slot<=highest_slot()) - -#define LOOKS_LIKE_GA(ga) (LOOKS_LIKE_TID((ga)->payload.gc.gtid) && \ - LOOKS_LIKE_SLOT((ga)->payload.gc.slot)) -#else -rtsBool looks_like_tid(StgInt tid); -rtsBool looks_like_slot(StgInt slot); -rtsBool looks_like_ga(globalAddr *ga); -#define LOOKS_LIKE_TID(tid) looks_like_tid(tid) -#define LOOKS_LIKE_GA(ga) looks_like_ga(ga) -#endif /* 0 */ - -#endif /* PAR */ - -/* - * @node GranSim, , GUM, Parallel definitions - * @subsection GranSim - */ - -#if defined(GRAN) -/* ToDo: Check which of the PAR routines are needed in GranSim -- HWL */ - -/* - * @menu - * * Types:: - * * Prototypes:: - * * Macros:: - * @end menu - * - * @node Types, Prototypes, GranSim, GranSim - * @subsubsection Types - */ - -typedef StgWord *StgBuffer; -typedef struct rtsPackBuffer_ { - StgInt /* nat */ id; - StgInt /* nat */ size; - StgInt /* nat */ unpacked_size; - StgTSO *tso; - StgWord *buffer; -} rtsPackBuffer; - -/* - * @node Macros, , Prototypes, GranSim - * @subsubsection Macros - */ - -/* max no. of outstanding spark steals */ -#define MAX_FISHES 1 - -/* These are needed in the packing code to get the size of the packet - right. The closures itself are never built in GrAnSim. */ -# define FETCHME_VHS IND_VHS -# define FETCHME_HS IND_HS - -# define FETCHME_GA_LOCN FETCHME_HS - -# define FETCHME_CLOSURE_SIZE(closure) IND_CLOSURE_SIZE(closure) -# define FETCHME_CLOSURE_NoPTRS(closure) 0L -# define FETCHME_CLOSURE_NoNONPTRS(closure) (IND_CLOSURE_SIZE(closure)-IND_VHS) - -# define MAX_GAS (RtsFlags.GranFlags.packBufferSize / PACK_GA_SIZE) -# define PACK_GA_SIZE 3 /* Size of a packed GA in words */ - /* Size of a packed fetch-me in words */ -# define PACK_FETCHME_SIZE (PACK_GA_SIZE + _HS) -# define PACK_HDR_SIZE 4 /* Words of header in a packet */ - -# define PACK_HEAP_REQUIRED \ - (RtsFlags.GranFlags.packBufferSize * sizeofW(StgClosure*) + \ - 2 * sizeofW(StgInt) + sizeofW(StgTSO*)) - -# define PACK_FLAG_LOCN 0 -# define PACK_TSO_LOCN 1 -# define PACK_UNPACKED_SIZE_LOCN 2 -# define PACK_SIZE_LOCN 3 -# define MAGIC_PACK_FLAG 0xfabc - -# define GA_HDR_SIZE 1 - -# define PROCS_HDR_POSN PAR_HDR_POSN -# define PROCS_HDR_SIZE 1 - -/* Accessing components of the field */ -# define PROCS(closure) ((closure)->header.gran.procs) -/* SET_PROCS is now SET_GRAN_HEADER in ClosureMacros.h. */ - -#endif /* GRAN */ - -/* - * @node End of File, , Parallel definitions - * @section End of File - */ - -#endif /* defined(PAR) || defined(GRAN) whole file */ - -#endif /* Parallel_H */ - - diff --git a/includes/README b/includes/README index 90695a6e7c..dbde6579f4 100644 --- a/includes/README +++ b/includes/README @@ -83,17 +83,14 @@ Rts.h SpinLock.h TSO.h Updates.h /* macros for performing updates */ - GranSim.h Parallel.h Block.h Stable.h Hooks.h Signals.h - DNInvoke.h - Dotnet.h - RtsExternal.h /* decls for RTS things required by .hc code */ - (RtsAPI.h) - (HsFFI.h) + Adjustor.h /* foreign import "wrapper", aka adjustors */ + StgPrimFloat.h /* primitive floating-point operations */ + Hpc.h Cmm.h /* included into .cmm source only */ DerivedConstants.h /* generated by mkDerivedConstants.c from other */ diff --git a/includes/Rts.h b/includes/Rts.h index a32bf34309..7358c368c1 100644 --- a/includes/Rts.h +++ b/includes/Rts.h @@ -1,8 +1,9 @@ /* ----------------------------------------------------------------------------- * - * (c) The GHC Team, 1998-2004 + * (c) The GHC Team, 1998-2009 * - * Top-level include file for the RTS itself + * RTS external APIs. This file declares everything that the GHC RTS + * exposes externally. * * ---------------------------------------------------------------------------*/ @@ -18,8 +19,8 @@ extern "C" { #endif #include "Stg.h" -// ToDo: move RtsExternal stuff elsewhere -#include "RtsExternal.h" +#include "HsFFI.h" +#include "RtsAPI.h" // Turn off inlining when debugging - it obfuscates things #ifdef DEBUG @@ -27,7 +28,7 @@ extern "C" { # define STATIC_INLINE static #endif -#include "RtsTypes.h" +#include "rts/Types.h" #if __GNUC__ >= 3 /* Assume that a flexible array member at the end of a struct @@ -63,11 +64,6 @@ extern "C" { #define sizeofW(t) ROUNDUP_BYTES_TO_WDS(sizeof(t)) -/* - * It's nice to be able to grep for casts - */ -#define stgCast(ty,e) ((ty)(e)) - /* ----------------------------------------------------------------------------- Assertions and Debuggery @@ -75,7 +71,8 @@ extern "C" { ASSERT(p) like CHECK(p) if DEBUG is on, otherwise a no-op -------------------------------------------------------------------------- */ -extern void _assertFail (const char *, unsigned int); +void _assertFail(const char *filename, unsigned int linenum) + GNUC3_ATTRIBUTE(__noreturn__); #define CHECK(predicate) \ if (predicate) \ @@ -124,29 +121,6 @@ extern void _assertFail (const char *, unsigned int); #define FMT_Int64 "lld" #endif -/* - * Macros for untagging and retagging closure pointers - * For more information look at the comments in Cmm.h - */ - -static inline StgWord -GET_CLOSURE_TAG(StgClosure * p) -{ - return (StgWord)p & TAG_MASK; -} - -static inline StgClosure * -UNTAG_CLOSURE(StgClosure * p) -{ - return (StgClosure*)((StgWord)p & ~TAG_MASK); -} - -static inline StgClosure * -TAG_CLOSURE(StgWord tag,StgClosure * p) -{ - return (StgClosure*)((StgWord)p | tag); -} - /* ----------------------------------------------------------------------------- Include everything STG-ish -------------------------------------------------------------------------- */ @@ -158,59 +132,62 @@ TAG_CLOSURE(StgWord tag,StgClosure * p) */ #include <stdlib.h> +#include "rts/Config.h" + /* Global constaints */ -#include "Constants.h" +#include "rts/Constants.h" /* Profiling information */ -#include "StgProf.h" -#include "StgLdvProf.h" - -/* Storage format definitions */ -#include "StgFun.h" -#include "Closures.h" -#include "Liveness.h" -#include "ClosureTypes.h" -#include "InfoTables.h" -#include "TSO.h" - -/* Info tables, closures & code fragments defined in the RTS */ -#include "StgMiscClosures.h" +#include "rts/prof/CCS.h" +#include "rts/prof/LDV.h" /* Parallel information */ -#include "OSThreads.h" -#include "SMPClosureOps.h" -#include "SpinLock.h" - -/* Macros for STG/C code */ -#include "Block.h" -#include "ClosureMacros.h" - -/* Runtime-system hooks */ -#include "Hooks.h" -#include "RtsMessages.h" +#include "rts/OSThreads.h" +#include "rts/SpinLock.h" -/* for StablePtr/getStablePtr/deRefStablePtr */ -#include "Storage.h" -#include "Stable.h" +#include "rts/Messages.h" -#include "ieee-flpt.h" - -#include "Signals.h" +/* Storage format definitions */ +#include "rts/storage/FunTypes.h" +#include "rts/storage/InfoTables.h" +#include "rts/storage/Closures.h" +#include "rts/storage/Liveness.h" +#include "rts/storage/ClosureTypes.h" +#include "rts/storage/TSO.h" +#include "stg/MiscClosures.h" /* InfoTables, closures etc. defined in the RTS */ +#include "rts/storage/SMPClosureOps.h" +#include "rts/storage/Block.h" +#include "rts/storage/ClosureMacros.h" +#include "rts/storage/MBlock.h" +#include "rts/storage/GC.h" + +/* Other RTS external APIs */ +#include "rts/Parallel.h" +#include "rts/Hooks.h" +#include "rts/Signals.h" +#include "rts/Hpc.h" +#include "rts/Flags.h" +#include "rts/Adjustor.h" +#include "rts/FileLock.h" +#include "rts/Globals.h" +#include "rts/IOManager.h" +#include "rts/Linker.h" +#include "rts/Threads.h" +#include "rts/Timer.h" +#include "rts/Stable.h" /* Misc stuff without a home */ DLL_IMPORT_RTS extern char **prog_argv; /* so we can get at these from Haskell */ DLL_IMPORT_RTS extern int prog_argc; DLL_IMPORT_RTS extern char *prog_name; -extern void stackOverflow(void); - -extern void __decodeDouble_2Int (I_ *man_sign, W_ *man_high, W_ *man_low, I_ *exp, StgDouble dbl); -extern void __decodeFloat_Int (I_ *man, I_ *exp, StgFloat flt); +void stackOverflow(void); -/* Initialising the whole adjustor thunk machinery. */ -extern void initAdjustor(void); +void stg_exit(int n) GNU_ATTRIBUTE(__noreturn__); -extern void stg_exit(int n) GNU_ATTRIBUTE(__noreturn__); +#ifndef mingw32_HOST_OS +int stg_sig_install (int, int, void *); +#endif /* ----------------------------------------------------------------------------- RTS Exit codes @@ -236,11 +213,6 @@ extern void stg_exit(int n) GNU_ATTRIBUTE(__noreturn__); extern StgInt RIGHT_ARITY_##arity; \ extern StgInt TAGGED_PTR_##arity; -#define TICK_VAR_INI(arity) \ - StgInt SLOW_CALLS_##arity = 1; \ - StgInt RIGHT_ARITY_##arity = 1; \ - StgInt TAGGED_PTR_##arity = 0; - extern StgInt TOTAL_CALLS; TICK_VAR(1) @@ -253,10 +225,6 @@ TICK_VAR(2) #define IF_RTSFLAGS(c,s) if (RtsFlags.c) { s; } -/* ----------------------------------------------------------------------------- - Assertions and Debuggery - -------------------------------------------------------------------------- */ - #ifdef DEBUG #if IN_STG_CODE #define IF_DEBUG(c,s) if (RtsFlags[0].DebugFlags.c) { s; } diff --git a/includes/RtsAPI.h b/includes/RtsAPI.h index 5160046da8..2d2c35ca97 100644 --- a/includes/RtsAPI.h +++ b/includes/RtsAPI.h @@ -26,7 +26,7 @@ typedef enum { HeapExhausted /* out of memory */ } SchedulerStatus; -typedef StgClosure *HaskellObj; +typedef struct StgClosure_ *HaskellObj; /* * An abstract type representing the token returned by rts_lock() and diff --git a/includes/RtsConfig.h b/includes/RtsConfig.h deleted file mode 100644 index 3b088b7417..0000000000 --- a/includes/RtsConfig.h +++ /dev/null @@ -1,64 +0,0 @@ -/* ----------------------------------------------------------------------------- - * - * (c) The GHC Team, 1998-2004 - * - * Rts settings. - * - * NOTE: assumes #include "ghcconfig.h" - * - * NB: THIS FILE IS INCLUDED IN NON-C CODE AND DATA! #defines only please. - * ---------------------------------------------------------------------------*/ - -#ifndef RTSCONFIG_H -#define RTSCONFIG_H - -/* - * SUPPORT_LONG_LONGS controls whether we need to support long longs on a - * particular platform. On 64-bit platforms, we don't need to support - * long longs since regular machine words will do just fine. - */ -#if HAVE_LONG_LONG && SIZEOF_VOID_P < 8 -#define SUPPORT_LONG_LONGS 1 -#endif - -/* - * Whether the runtime system will use libbfd for debugging purposes. - */ -#if defined(DEBUG) && defined(HAVE_BFD_H) && defined(HAVE_LIBBFD) && !defined(_WIN32) -#define USING_LIBBFD 1 -#endif - -/* ----------------------------------------------------------------------------- - Labels - entry labels & info labels point to the same place in - TABLES_NEXT_TO_CODE, so we only generate the _info label. Jumps - must therefore be directed to foo_info rather than foo_entry when - TABLES_NEXT_TO_CODE is on. - - This isn't a good place for these macros, but they need to be - available to .cmm sources as well as C and we don't have a better - place. - -------------------------------------------------------------------------- */ - -#ifdef TABLES_NEXT_TO_CODE -#define ENTRY_LBL(f) f##_info -#else -#define ENTRY_LBL(f) f##_entry -#endif - -#ifdef TABLES_NEXT_TO_CODE -#define RET_LBL(f) f##_info -#else -#define RET_LBL(f) f##_ret -#endif - -/* ----------------------------------------------------------------------------- - Signals - supported on non-PAR versions of the runtime. See RtsSignals.h. - -------------------------------------------------------------------------- */ - -#define RTS_USER_SIGNALS 1 - -/* Profile spin locks */ - -#define PROF_SPIN - -#endif /* RTSCONFIG_H */ diff --git a/includes/RtsExternal.h b/includes/RtsExternal.h deleted file mode 100644 index 2272b2a429..0000000000 --- a/includes/RtsExternal.h +++ /dev/null @@ -1,129 +0,0 @@ -/* ----------------------------------------------------------------------------- - * - * (c) The GHC Team, 1998-2004 - * - * Things visible externally to the RTS - * - * -------------------------------------------------------------------------- */ - -#ifndef RTSEXTERNAL_H -#define RTSEXTERNAL_H - -/* The RTS public interface. */ -#include "RtsAPI.h" - -/* The standard FFI interface */ -#include "HsFFI.h" - -#ifdef HAVE_SYS_TYPES_H -#include <sys/types.h> -#endif - -/* ----------------------------------------------------------------------------- - Functions exported by the RTS for use in Stg code - -------------------------------------------------------------------------- */ - -#if IN_STG_CODE -extern void newCAF(void*); -#else -extern void newCAF(StgClosure*); -#endif - -/* ToDo: remove? */ -extern HsInt genSymZh(void); -extern HsInt resetGenSymZh(void); - -/* Alternate to raise(3) for threaded rts, for OpenBSD */ -extern int genericRaise(int sig); - -/* Concurrency/Exception PrimOps. */ -extern int cmp_thread(StgPtr tso1, StgPtr tso2); -extern int rts_getThreadId(StgPtr tso); -extern int forkOS_createThread ( HsStablePtr entry ); -extern pid_t forkProcess(HsStablePtr *entry); -extern HsBool rtsSupportsBoundThreads(void); -extern StgInt newSpark (StgRegTable *reg, StgClosure *p); -extern void stopTimer(void); -extern unsigned int n_capabilities; - -/* grimy low-level support functions defined in StgPrimFloat.c */ -extern StgDouble __encodeDouble (I_ size, StgByteArray arr, I_ e); -extern StgDouble __2Int_encodeDouble (I_ j_high, I_ j_low, I_ e); -extern StgDouble __int_encodeDouble (I_ j, I_ e); -extern StgDouble __word_encodeDouble (W_ j, I_ e); -extern StgFloat __encodeFloat (I_ size, StgByteArray arr, I_ e); -extern StgFloat __int_encodeFloat (I_ j, I_ e); -extern StgFloat __word_encodeFloat (W_ j, I_ e); -extern StgInt isDoubleNaN(StgDouble d); -extern StgInt isDoubleInfinite(StgDouble d); -extern StgInt isDoubleDenormalized(StgDouble d); -extern StgInt isDoubleNegativeZero(StgDouble d); -extern StgInt isFloatNaN(StgFloat f); -extern StgInt isFloatInfinite(StgFloat f); -extern StgInt isFloatDenormalized(StgFloat f); -extern StgInt isFloatNegativeZero(StgFloat f); - -/* Suspending/resuming threads around foreign calls */ -extern void * suspendThread ( StgRegTable * ); -extern StgRegTable * resumeThread ( void * ); - -/* scheduler stuff */ -extern void stg_scheduleThread (StgRegTable *reg, struct StgTSO_ *tso); - -/* Creating and destroying an adjustor thunk */ -extern void* createAdjustor(int cconv, StgStablePtr hptr, StgFunPtr wptr, - char *typeString); -extern void freeHaskellFunctionPtr(void* ptr); - -/* Hpc stuff */ -extern int hs_hpc_module(char *modName, StgWord32 modCount, StgWord32 modHashNo,StgWord64 *tixArr); -// Simple linked list of modules -typedef struct _HpcModuleInfo { - char *modName; // name of module - StgWord32 tickCount; // number of ticks - StgWord32 tickOffset; // offset into a single large .tix Array - StgWord32 hashNo; // Hash number for this module's mix info - StgWord64 *tixArr; // tix Array; local for this module - struct _HpcModuleInfo *next; -} HpcModuleInfo; - -extern HpcModuleInfo *hs_hpc_rootModule(void); - - -#if defined(mingw32_HOST_OS) -extern int rts_InstallConsoleEvent ( int action, StgStablePtr *handler ); -extern void rts_ConsoleHandlerDone ( int ev ); -#else -extern int stg_sig_install (int, int, void *); -#endif - -#if defined(mingw32_HOST_OS) -extern StgInt console_handler; -#else -extern StgInt *signal_handlers; -#endif - -#if defined(mingw32_HOST_OS) -void *getIOManagerEvent (void); -HsWord32 readIOManagerEvent (void); -void sendIOManagerEvent (HsWord32 event); -#else -extern void setIOManagerPipe (int fd); -#endif - -extern void* allocateExec(unsigned int len, void **exec_addr); - -// Breakpoint stuff - -/* ----------------------------------------------------------------------------- - Storage manager stuff exported - -------------------------------------------------------------------------- */ - -extern void performGC(void); -extern void performMajorGC(void); -extern HsInt64 getAllocations( void ); -extern void revertCAFs( void ); -extern void dirty_MUT_VAR(StgRegTable *reg, StgClosure *p); -extern void dirty_MVAR(StgRegTable *reg, StgClosure *p); - -#endif /* RTSEXTERNAL_H */ diff --git a/includes/RtsFlags.h b/includes/RtsFlags.h index ab6f2982cd..778fccf40a 100644 --- a/includes/RtsFlags.h +++ b/includes/RtsFlags.h @@ -1,239 +1,2 @@ -/* ----------------------------------------------------------------------------- - * - * (c) The GHC Team, 1998-1999 - * - * Datatypes that holds the command-line flag settings. - * - * ---------------------------------------------------------------------------*/ - -#ifndef RTSFLAGS_H -#define RTSFLAGS_H - -#include <stdio.h> - -/* For defaults, see the @initRtsFlagsDefaults@ routine. */ - -struct GC_FLAGS { - FILE *statsFile; - nat giveStats; -#define NO_GC_STATS 0 -#define COLLECT_GC_STATS 1 -#define ONELINE_GC_STATS 2 -#define SUMMARY_GC_STATS 3 -#define VERBOSE_GC_STATS 4 - - nat maxStkSize; /* in *words* */ - nat initialStkSize; /* in *words* */ - - nat maxHeapSize; /* in *blocks* */ - nat minAllocAreaSize; /* in *blocks* */ - nat minOldGenSize; /* in *blocks* */ - nat heapSizeSuggestion; /* in *blocks* */ - double oldGenFactor; - double pcFreeHeap; - - nat generations; - nat steps; - rtsBool squeezeUpdFrames; - - rtsBool compact; /* True <=> "compact all the time" */ - double compactThreshold; - - rtsBool sweep; /* use "mostly mark-sweep" instead of copying - * for the oldest generation */ - rtsBool ringBell; - rtsBool frontpanel; - - int idleGCDelayTime; /* in milliseconds */ - - StgWord heapBase; /* address to ask the OS for memory */ -}; - -struct DEBUG_FLAGS { - /* flags to control debugging output & extra checking in various subsystems */ - rtsBool scheduler; /* 's' */ - rtsBool interpreter; /* 'i' */ - rtsBool weak; /* 'w' */ - rtsBool gccafs; /* 'G' */ - rtsBool gc; /* 'g' */ - rtsBool block_alloc; /* 'b' */ - rtsBool sanity; /* 'S' warning: might be expensive! */ - rtsBool stable; /* 't' */ - rtsBool prof; /* 'p' */ - rtsBool eventlog; /* 'e' */ - rtsBool linker; /* 'l' the object linker */ - rtsBool apply; /* 'a' */ - rtsBool stm; /* 'm' */ - rtsBool squeeze; /* 'z' stack squeezing & lazy blackholing */ - rtsBool hpc; /* 'c' coverage */ - rtsBool timestamp; /* add timestamps to traces */ -}; - -struct COST_CENTRE_FLAGS { - unsigned int doCostCentres; -# define COST_CENTRES_SUMMARY 1 -# define COST_CENTRES_VERBOSE 2 /* incl. serial time profile */ -# define COST_CENTRES_ALL 3 -# define COST_CENTRES_XML 4 - - int profilerTicks; /* derived */ - int msecsPerTick; /* derived */ -}; - -struct PROFILING_FLAGS { - unsigned int doHeapProfile; -# define NO_HEAP_PROFILING 0 /* N.B. Used as indexes into arrays */ -# define HEAP_BY_CCS 1 -# define HEAP_BY_MOD 2 -# define HEAP_BY_DESCR 4 -# define HEAP_BY_TYPE 5 -# define HEAP_BY_RETAINER 6 -# define HEAP_BY_LDV 7 - -# define HEAP_BY_CLOSURE_TYPE 8 - - nat profileInterval; /* delta between samples (in ms) */ - nat profileIntervalTicks; /* delta between samples (in 'ticks') */ - rtsBool includeTSOs; - - - rtsBool showCCSOnException; - - nat maxRetainerSetSize; - - nat ccsLength; - - char* modSelector; - char* descrSelector; - char* typeSelector; - char* ccSelector; - char* ccsSelector; - char* retainerSelector; - char* bioSelector; - -}; - -#ifdef EVENTLOG -struct EVENTLOG_FLAGS { - rtsBool doEventLogging; -}; -#endif - -struct CONCURRENT_FLAGS { - int ctxtSwitchTime; /* in milliseconds */ - int ctxtSwitchTicks; /* derived */ -}; - -struct MISC_FLAGS { - int tickInterval; /* in milliseconds */ - rtsBool install_signal_handlers; - rtsBool machineReadable; - StgWord linkerMemBase; /* address to ask the OS for memory - * for the linker, NULL ==> off */ -}; - -#ifdef THREADED_RTS -struct PAR_FLAGS { - nat nNodes; /* number of threads to run simultaneously */ - rtsBool migrate; /* migrate threads between capabilities */ - rtsBool wakeupMigrate; /* migrate a thread on wakeup */ - unsigned int maxLocalSparks; - rtsBool parGcEnabled; /* enable parallel GC */ - rtsBool parGcGen; /* do parallel GC in this generation - * and higher only */ - rtsBool parGcLoadBalancing; /* do load-balancing in parallel GC */ - rtsBool setAffinity; /* force thread affinity with CPUs */ -}; -#endif /* THREADED_RTS */ - -struct TICKY_FLAGS { - rtsBool showTickyStats; - FILE *tickyFile; -}; - -#ifdef USE_PAPI -#define MAX_PAPI_USER_EVENTS 8 - -struct PAPI_FLAGS { - nat eventType; /* The type of events to count */ - nat numUserEvents; - char * userEvents[MAX_PAPI_USER_EVENTS]; -}; - -#define PAPI_FLAG_CACHE_L1 1 -#define PAPI_FLAG_CACHE_L2 2 -#define PAPI_FLAG_BRANCH 3 -#define PAPI_FLAG_STALLS 4 -#define PAPI_FLAG_CB_EVENTS 5 -#define PAPI_USER_EVENTS 6 - -#endif - -/* Put them together: */ - -typedef struct _RTS_FLAGS { - /* The first portion of RTS_FLAGS is invariant. */ - struct GC_FLAGS GcFlags; - struct CONCURRENT_FLAGS ConcFlags; - struct MISC_FLAGS MiscFlags; - struct DEBUG_FLAGS DebugFlags; - struct COST_CENTRE_FLAGS CcFlags; - struct PROFILING_FLAGS ProfFlags; -#ifdef EVENTLOG - struct EVENTLOG_FLAGS EventLogFlags; -#endif - struct TICKY_FLAGS TickyFlags; - -#if defined(THREADED_RTS) - struct PAR_FLAGS ParFlags; -#endif -#ifdef USE_PAPI - struct PAPI_FLAGS PapiFlags; -#endif -} RTS_FLAGS; - -#ifdef COMPILING_RTS_MAIN -extern DLLIMPORT RTS_FLAGS RtsFlags; -#elif IN_STG_CODE -/* Hack because the C code generator can't generate '&label'. */ -extern RTS_FLAGS RtsFlags[]; -#else -extern RTS_FLAGS RtsFlags; -#endif - -/* Routines that operate-on/to-do-with RTS flags: */ - -extern void initRtsFlagsDefaults(void); -extern void setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[]); -extern void setProgName(char *argv[]); - - -/* - * The printf formats are here, so we are less likely to make - * overly-long filenames (with disastrous results). No more than 128 - * chars, please! - */ - -#define STATS_FILENAME_MAXLEN 128 - -#define GR_FILENAME_FMT "%0.124s.gr" -#define GR_FILENAME_FMT_GUM "%0.120s.%03d.%s" -#define HP_FILENAME_FMT "%0.124s.hp" -#define LIFE_FILENAME_FMT "%0.122s.life" -#define PROF_FILENAME_FMT "%0.122s.prof" -#define PROF_FILENAME_FMT_GUM "%0.118s.%03d.prof" -#define QP_FILENAME_FMT "%0.124s.qp" -#define STAT_FILENAME_FMT "%0.122s.stat" -#define TICKY_FILENAME_FMT "%0.121s.ticky" -#define TIME_FILENAME_FMT "%0.122s.time" -#define TIME_FILENAME_FMT_GUM "%0.118s.%03d.time" - -/* an "int" so as to match normal "argc" */ -/* Now defined in Stg.h (lib/std/cbits need these too.) -extern int prog_argc; -extern char **prog_argv; -*/ -extern int rts_argc; /* ditto */ -extern char *rts_argv[]; - -#endif /* RTSFLAGS_H */ +#warning RtsFlags.h is DEPRECATED; please just #include "Rts.h" +#include "Rts.h" diff --git a/includes/STM.h b/includes/STM.h deleted file mode 100644 index 3bf976551d..0000000000 --- a/includes/STM.h +++ /dev/null @@ -1,245 +0,0 @@ -/*---------------------------------------------------------------------- - * - * (c) The GHC Team, 1998-2004 - * - * STM interface definition - * - *---------------------------------------------------------------------- - - STM.h defines the C-level interface to the STM. - - The design follows that of the PPoPP 2005 paper "Composable memory - transactions" extended to include fine-grained locking of TVars. - - Three different implementations can be built. In overview: - - STM_UNIPROC -- no locking at all: not safe for concurrent invocations - - STM_CG_LOCK -- coarse-grained locking : a single mutex protects all - TVars - - STM_FG_LOCKS -- per-TVar exclusion : each TVar can be owned by at - most one TRec at any time. This allows dynamically - non-conflicting transactions to commit in parallel. - The implementation treats reads optimisitcally -- - extra versioning information is retained in the - saw_update_by field of the TVars so that they do not - need to be locked for reading. - - STM.C contains more details about the locking schemes used. - -*/ - -#ifndef STM_H -#define STM_H - -#ifdef THREADED_RTS -//#define STM_CG_LOCK -#define STM_FG_LOCKS -#else -#define STM_UNIPROC -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -/*---------------------------------------------------------------------- - - GC interaction - -------------- -*/ - -extern void stmPreGCHook(void); - -/*---------------------------------------------------------------------- - - Transaction context management - ------------------------------ - -*/ - -/* Create and enter a new transaction context */ - -extern StgTRecHeader *stmStartTransaction(Capability *cap, StgTRecHeader *outer); -extern StgTRecHeader *stmStartNestedTransaction(Capability *cap, StgTRecHeader *outer -); - -/* - * Roll back the current transatcion context. NB: if this is a nested tx - * then we merge its read set into its parents. This is because a change - * to that read set could change whether or not the tx should abort. - */ - -extern void stmAbortTransaction(Capability *cap, StgTRecHeader *trec); -extern void stmFreeAbortedTRec(Capability *cap, StgTRecHeader *trec); - -/* - * Ensure that a subsequent commit / validation will fail. We use this - * in our current handling of transactions that may have become invalid - * and started looping. We strip their stack back to the ATOMICALLY_FRAME, - * and, when the thread is next scheduled, discover it to be invalid and - * re-execute it. However, we need to force the transaction to stay invalid - * in case other threads' updates make it valid in the mean time. - */ - -extern void stmCondemnTransaction(Capability *cap, StgTRecHeader *trec); - -/* - * Return the trec within which the specified trec was created (not - * valid if trec==NO_TREC). - */ - -extern StgTRecHeader *stmGetEnclosingTRec(StgTRecHeader *trec); - -/*---------------------------------------------------------------------- - - Validation - ---------- - - Test whether the specified transaction record, and all those within which - it is nested, are still valid. - - Note: the caller can assume that once stmValidateTransaction has - returned FALSE for a given trec then that transaction will never - again be valid -- we rely on this in Schedule.c when kicking invalid - threads at GC (in case they are stuck looping) -*/ - -extern StgBool stmValidateNestOfTransactions(StgTRecHeader *trec); - -/*---------------------------------------------------------------------- - - Commit/wait/rewait operations - ----------------------------- - - These four operations return boolean results which should be interpreted - as follows: - - true => The transaction record was definitely valid - - false => The transaction record may not have been valid - - Note that, for nested operations, validity here is solely in terms - of the specified trec: it does not say whether those that it may be - nested are themselves valid. Callers can check this with - stmValidateNestOfTransactions. - - The user of the STM should ensure that it is always safe to assume that a - transaction context is not valid when in fact it is (i.e. to return false in - place of true, with side-effects as defined below). This may cause - needless retries of transactions (in the case of validate and commit), or it - may cause needless spinning instead of blocking (in the case of wait and - rewait). - - In defining the behaviour of wait and rewait we distinguish between two - different aspects of a thread's runnability: - - - We say that a thread is "blocked" when it is not running or - runnable as far as the scheduler is concerned. - - - We say that a thread is "waiting" when its StgTRecHeader is linked on an - tvar's wait queue. - - Considering only STM operations, (blocked) => (waiting). The user of the STM - should ensure that they are prepared for threads to be unblocked spuriously - and for wait/reWait to return false even when the previous transaction context - is actually still valid. -*/ - -/* - * Fill in the trec's list of invariants that might be violated by the current - * transaction. - */ - -extern StgInvariantCheckQueue *stmGetInvariantsToCheck(Capability *cap, - StgTRecHeader *trec); - -extern void stmAddInvariantToCheck(Capability *cap, - StgTRecHeader *trec, - StgClosure *code); - -/* - * Test whether the current transaction context is valid and, if so, - * commit its memory accesses to the heap. stmCommitTransaction must - * unblock any threads which are waiting on tvars that updates have - * been committed to. - */ - -extern StgBool stmCommitTransaction(Capability *cap, StgTRecHeader *trec); -extern StgBool stmCommitNestedTransaction(Capability *cap, StgTRecHeader *trec); - -/* - * Test whether the current transaction context is valid and, if so, - * start the thread waiting for updates to any of the tvars it has - * ready from and mark it as blocked. It is an error to call stmWait - * if the thread is already waiting. - */ - -extern StgBool stmWait(Capability *cap, - StgTSO *tso, - StgTRecHeader *trec); - -extern void stmWaitUnlock(Capability *cap, StgTRecHeader *trec); - -/* - * Test whether the current transaction context is valid and, if so, - * leave the thread waiting and mark it as blocked again. If the - * transaction context is no longer valid then stop the thread waiting - * and leave it as unblocked. It is an error to call stmReWait if the - * thread is not waiting. - */ - -extern StgBool stmReWait(Capability *cap, StgTSO *tso); - -/*---------------------------------------------------------------------- - - TVar management operations - -------------------------- -*/ - -extern StgTVar *stmNewTVar(Capability *cap, - StgClosure *new_value); - -/*---------------------------------------------------------------------- - - Data access operations - ---------------------- -*/ - -/* - * Return the logical contents of 'tvar' within the context of the - * thread's current transaction. - */ - -extern StgClosure *stmReadTVar(Capability *cap, - StgTRecHeader *trec, - StgTVar *tvar); - -/* Update the logical contents of 'tvar' within the context of the - * thread's current transaction. - */ - -extern void stmWriteTVar(Capability *cap, - StgTRecHeader *trec, - StgTVar *tvar, - StgClosure *new_value); - -/*----------------------------------------------------------------------*/ - -/* NULLs */ - -#define END_STM_WATCH_QUEUE ((StgTVarWatchQueue *)(void *)&stg_END_STM_WATCH_QUEUE_closure) -#define END_INVARIANT_CHECK_QUEUE ((StgInvariantCheckQueue *)(void *)&stg_END_INVARIANT_CHECK_QUEUE_closure) -#define END_STM_CHUNK_LIST ((StgTRecChunk *)(void *)&stg_END_STM_CHUNK_LIST_closure) - -#define NO_TREC ((StgTRecHeader *)(void *)&stg_NO_TREC_closure) - -/*----------------------------------------------------------------------*/ - -#ifdef __cplusplus -} -#endif - -#endif /* STM_H */ - diff --git a/includes/Stable.h b/includes/Stable.h deleted file mode 100644 index 9752a534bb..0000000000 --- a/includes/Stable.h +++ /dev/null @@ -1,63 +0,0 @@ -/* ----------------------------------------------------------------------------- - * - * (c) The GHC Team, 1998-2004 - * - * Stable Pointers: A stable pointer is represented as an index into - * the stable pointer table in the low BITS_PER_WORD-8 bits with a - * weight in the upper 8 bits. - * - * SUP: StgStablePtr used to be a synonym for StgWord, but stable pointers - * are guaranteed to be void* on the C-side, so we have to do some occasional - * casting. Size is not a matter, because StgWord is always the same size as - * a void*. - * - * ---------------------------------------------------------------------------*/ - -#ifndef STABLE_H -#define STABLE_H - -/* ----------------------------------------------------------------------------- - External C Interface - -------------------------------------------------------------------------- */ - -EXTERN_INLINE StgPtr deRefStablePtr(StgStablePtr stable_ptr); -extern void freeStablePtr(StgStablePtr sp); -extern StgStablePtr splitStablePtr(StgStablePtr sp); -extern StgStablePtr getStablePtr(StgPtr p); - -/* ----------------------------------------------------------------------------- - PRIVATE from here. - -------------------------------------------------------------------------- */ - -typedef struct { - StgPtr addr; /* Haskell object, free list, or NULL */ - StgPtr old; /* old Haskell object, used during GC */ - StgWord ref; /* used for reference counting */ - StgClosure *sn_obj; /* the StableName object (or NULL) */ -} snEntry; - -extern DLL_IMPORT_RTS snEntry *stable_ptr_table; - -extern void freeStablePtr(StgStablePtr sp); - -EXTERN_INLINE -StgPtr deRefStablePtr(StgStablePtr sp) -{ - ASSERT(stable_ptr_table[(StgWord)sp].ref > 0); - return stable_ptr_table[(StgWord)sp].addr; -} - -extern void initStablePtrTable ( void ); -extern void exitStablePtrTable ( void ); -extern void enlargeStablePtrTable ( void ); -extern StgWord lookupStableName ( StgPtr p ); - -extern void markStablePtrTable ( evac_fn evac, void *user ); -extern void threadStablePtrTable ( evac_fn evac, void *user ); -extern void gcStablePtrTable ( void ); -extern void updateStablePtrTable ( rtsBool full ); - -extern void stablePtrPreGC ( void ); -extern void stablePtrPostGC ( void ); - -#endif diff --git a/includes/Stg.h b/includes/Stg.h index 06a866256e..0344b70fd2 100644 --- a/includes/Stg.h +++ b/includes/Stg.h @@ -23,11 +23,16 @@ #ifndef STG_H #define STG_H - -/* If we include "Stg.h" directly, we're in STG code, and we therefore - * get all the global register variables, macros etc. that go along - * with that. If "Stg.h" is included via "Rts.h", we're assumed to - * be in vanilla C. +/* + * If we are compiling a .hc file, then we want all the register + * variables. This is the what happens if you #include "Stg.h" first: + * we assume this is a .hc file, and set IN_STG_CODE==1, which later + * causes the register variables to be enabled in stg/Regs.h. + * + * If instead "Rts.h" is included first, then we are compiling a + * vanilla C file. Everything from Stg.h is provided, except that + * IN_STG_CODE is not defined, and the register variables will not be + * active. */ #ifndef IN_STG_CODE # define IN_STG_CODE 1 @@ -47,7 +52,6 @@ /* Configuration */ #include "ghcconfig.h" -#include "RtsConfig.h" /* The code generator calls the math functions directly in .hc code. NB. after configuration stuff above, because this sets #defines @@ -59,7 +63,7 @@ -------------------------------------------------------------------------- */ /* - * The C backend like to refer to labels by just mentioning their + * The C backend likes to refer to labels by just mentioning their * names. Howevver, when a symbol is declared as a variable in C, the * C compiler will implicitly dereference it when it occurs in source. * So we must subvert this behaviour for .hc files by declaring @@ -165,7 +169,7 @@ -------------------------------------------------------------------------- */ #include "MachDeps.h" -#include "StgTypes.h" +#include "stg/Types.h" /* ----------------------------------------------------------------------------- Shorthand forms @@ -174,24 +178,14 @@ typedef StgChar C_; typedef StgWord W_; typedef StgWord* P_; -typedef P_* PP_; typedef StgInt I_; -typedef StgAddr A_; -typedef const StgWord* D_; -typedef StgFunPtr F_; -typedef StgByteArray B_; -typedef StgClosurePtr L_; - -typedef StgInt64 LI_; -typedef StgWord64 LW_; - -#define IF_(f) static F_ GNUC3_ATTRIBUTE(used) f(void) -#define FN_(f) F_ f(void) -#define EF_(f) extern F_ f(void) - typedef StgWord StgWordArray[]; + #define EI_(X) extern StgWordArray (X) GNU_ATTRIBUTE(aligned (8)) #define II_(X) static StgWordArray (X) GNU_ATTRIBUTE(aligned (8)) +#define IF_(f) static StgFunPtr GNUC3_ATTRIBUTE(used) f(void) +#define FN_(f) StgFunPtr f(void) +#define EF_(f) extern StgFunPtr f(void) /* ----------------------------------------------------------------------------- Tail calls @@ -200,27 +194,26 @@ typedef StgWord StgWordArray[]; to be before all procedures (inline & out-of-line). -------------------------------------------------------------------------- */ -#include "TailCalls.h" +#include "stg/TailCalls.h" /* ----------------------------------------------------------------------------- Other Stg stuff... -------------------------------------------------------------------------- */ -#include "StgDLL.h" -#include "MachRegs.h" -#include "Regs.h" - -#include "TickyCounters.h" +#include "stg/DLL.h" +#include "stg/MachRegs.h" +#include "stg/Regs.h" +#include "stg/Ticky.h" #if IN_STG_CODE /* * This is included later for RTS sources, after definitions of * StgInfoTable, StgClosure and so on. */ -#include "StgMiscClosures.h" +#include "stg/MiscClosures.h" #endif -#include "SMP.h" // write_barrier() inline is required +#include "stg/SMP.h" // write_barrier() inline is required /* ----------------------------------------------------------------------------- Moving Floats and Doubles @@ -342,7 +335,7 @@ INLINE_HEADER StgDouble PK_DBL(W_ p_src[]) In both cases the memory location might not be 64-bit aligned. -------------------------------------------------------------------------- */ -#ifdef SUPPORT_LONG_LONGS +#if SIZEOF_HSWORD == 4 typedef struct { StgWord dhi; @@ -413,7 +406,7 @@ INLINE_HEADER StgInt64 PK_Int64(W_ p_src[]) return p_src[0]; } -#endif +#endif /* SIZEOF_HSWORD == 4 */ /* ----------------------------------------------------------------------------- Split markers diff --git a/includes/Storage.h b/includes/Storage.h deleted file mode 100644 index 5d3e7733cf..0000000000 --- a/includes/Storage.h +++ /dev/null @@ -1,583 +0,0 @@ -/* ----------------------------------------------------------------------------- - * - * (c) The GHC Team, 1998-2004 - * - * External Storage Manger Interface - * - * ---------------------------------------------------------------------------*/ - -#ifndef STORAGE_H -#define STORAGE_H - -#include <stddef.h> -#include "OSThreads.h" -#include "SMP.h" - -/* ----------------------------------------------------------------------------- - * Generational GC - * - * We support an arbitrary number of generations, with an arbitrary number - * of steps per generation. Notes (in no particular order): - * - * - all generations except the oldest should have two steps. This gives - * objects a decent chance to age before being promoted, and in - * particular will ensure that we don't end up with too many - * thunks being updated in older generations. - * - * - the oldest generation has one step. There's no point in aging - * objects in the oldest generation. - * - * - generation 0, step 0 (G0S0) is the allocation area. It is given - * a fixed set of blocks during initialisation, and these blocks - * are never freed. - * - * - during garbage collection, each step which is an evacuation - * destination (i.e. all steps except G0S0) is allocated a to-space. - * evacuated objects are allocated into the step's to-space until - * GC is finished, when the original step's contents may be freed - * and replaced by the to-space. - * - * - the mutable-list is per-generation (not per-step). G0 doesn't - * have one (since every garbage collection collects at least G0). - * - * - block descriptors contain pointers to both the step and the - * generation that the block belongs to, for convenience. - * - * - static objects are stored in per-generation lists. See GC.c for - * details of how we collect CAFs in the generational scheme. - * - * - large objects are per-step, and are promoted in the same way - * as small objects, except that we may allocate large objects into - * generation 1 initially. - * - * ------------------------------------------------------------------------- */ - -typedef struct step_ { - unsigned int no; // step number in this generation - unsigned int abs_no; // absolute step number - - struct generation_ * gen; // generation this step belongs to - unsigned int gen_no; // generation number (cached) - - bdescr * blocks; // blocks in this step - unsigned int n_blocks; // number of blocks - unsigned int n_words; // number of words - - struct step_ * to; // destination step for live objects - - bdescr * large_objects; // large objects (doubly linked) - unsigned int n_large_blocks; // no. of blocks used by large objs - - StgTSO * threads; // threads in this step - // linked via global_link - - // ------------------------------------ - // Fields below are used during GC only - - // During GC, if we are collecting this step, blocks and n_blocks - // are copied into the following two fields. After GC, these blocks - // are freed. - -#if defined(THREADED_RTS) - char pad[128]; // make sure the following is - // on a separate cache line. - SpinLock sync_large_objects; // lock for large_objects - // and scavenged_large_objects -#endif - - int mark; // mark (not copy)? (old gen only) - int compact; // compact (not sweep)? (old gen only) - - bdescr * old_blocks; // bdescr of first from-space block - unsigned int n_old_blocks; // number of blocks in from-space - unsigned int live_estimate; // for sweeping: estimate of live data - - bdescr * part_blocks; // partially-full scanned blocks - unsigned int n_part_blocks; // count of above - - bdescr * scavenged_large_objects; // live large objs after GC (d-link) - unsigned int n_scavenged_large_blocks; // size (not count) of above - - bdescr * bitmap; // bitmap for compacting collection - - StgTSO * old_threads; - -} step; - - -typedef struct generation_ { - unsigned int no; // generation number - step * steps; // steps - unsigned int n_steps; // number of steps - unsigned int max_blocks; // max blocks in step 0 - bdescr *mut_list; // mut objects in this gen (not G0) - - // stats information - unsigned int collections; - unsigned int par_collections; - unsigned int failed_promotions; - - // temporary use during GC: - bdescr *saved_mut_list; -} generation; - -extern generation * RTS_VAR(generations); - -extern generation * RTS_VAR(g0); -extern step * RTS_VAR(g0s0); -extern generation * RTS_VAR(oldest_gen); -extern step * RTS_VAR(all_steps); -extern nat RTS_VAR(total_steps); - -/* ----------------------------------------------------------------------------- - Initialisation / De-initialisation - -------------------------------------------------------------------------- */ - -extern void initStorage(void); -extern void exitStorage(void); -extern void freeStorage(void); - -/* ----------------------------------------------------------------------------- - Generic allocation - - StgPtr allocateInGen(generation *g, nat n) - Allocates a chunk of contiguous store - n words long in generation g, - returning a pointer to the first word. - Always succeeds. - - StgPtr allocate(nat n) Equaivalent to allocateInGen(g0) - - StgPtr allocateLocal(Capability *cap, nat n) - Allocates memory from the nursery in - the current Capability. This can be - done without taking a global lock, - unlike allocate(). - - StgPtr allocatePinned(nat n) Allocates a chunk of contiguous store - n words long, which is at a fixed - address (won't be moved by GC). - Returns a pointer to the first word. - Always succeeds. - - NOTE: the GC can't in general handle - pinned objects, so allocatePinned() - can only be used for ByteArrays at the - moment. - - Don't forget to TICK_ALLOC_XXX(...) - after calling allocate or - allocatePinned, for the - benefit of the ticky-ticky profiler. - - rtsBool doYouWantToGC(void) Returns True if the storage manager is - ready to perform a GC, False otherwise. - - lnat allocatedBytes(void) Returns the number of bytes allocated - via allocate() since the last GC. - Used in the reporting of statistics. - - -------------------------------------------------------------------------- */ - -extern StgPtr allocate ( lnat n ); -extern StgPtr allocateInGen ( generation *g, lnat n ); -extern StgPtr allocateLocal ( Capability *cap, lnat n ); -extern StgPtr allocatePinned ( lnat n ); -extern lnat allocatedBytes ( void ); - -extern bdescr * RTS_VAR(small_alloc_list); -extern bdescr * RTS_VAR(large_alloc_list); -extern bdescr * RTS_VAR(pinned_object_block); - -extern nat RTS_VAR(alloc_blocks); -extern nat RTS_VAR(alloc_blocks_lim); - -INLINE_HEADER rtsBool -doYouWantToGC( void ) -{ - return (alloc_blocks >= alloc_blocks_lim); -} - -/* memory allocator for executable memory */ -extern void* allocateExec(unsigned int len, void **exec_addr); -extern void freeExec (void *p); - -/* for splitting blocks groups in two */ -extern bdescr * splitLargeBlock (bdescr *bd, nat blocks); - -/* ----------------------------------------------------------------------------- - Performing Garbage Collection - - GarbageCollect(get_roots) Performs a garbage collection. - 'get_roots' is called to find all the - roots that the system knows about. - - - -------------------------------------------------------------------------- */ - -extern void GarbageCollect(rtsBool force_major_gc, nat gc_type, Capability *cap); - -/* ----------------------------------------------------------------------------- - Generational garbage collection support - - recordMutable(StgPtr p) Informs the garbage collector that a - previously immutable object has - become (permanently) mutable. Used - by thawArray and similar. - - updateWithIndirection(p1,p2) Updates the object at p1 with an - indirection pointing to p2. This is - normally called for objects in an old - generation (>0) when they are updated. - - updateWithPermIndirection(p1,p2) As above but uses a permanent indir. - - -------------------------------------------------------------------------- */ - -/* - * Storage manager mutex - */ -#if defined(THREADED_RTS) -extern Mutex sm_mutex; -#endif - -#if defined(THREADED_RTS) -#define ACQUIRE_SM_LOCK ACQUIRE_LOCK(&sm_mutex); -#define RELEASE_SM_LOCK RELEASE_LOCK(&sm_mutex); -#define ASSERT_SM_LOCK() ASSERT_LOCK_HELD(&sm_mutex); -#else -#define ACQUIRE_SM_LOCK -#define RELEASE_SM_LOCK -#define ASSERT_SM_LOCK() -#endif - -#if !IN_STG_CODE - -INLINE_HEADER void -recordMutableGen(StgClosure *p, nat gen_no) -{ - bdescr *bd; - - bd = generations[gen_no].mut_list; - if (bd->free >= bd->start + BLOCK_SIZE_W) { - bdescr *new_bd; - new_bd = allocBlock(); - new_bd->link = bd; - bd = new_bd; - generations[gen_no].mut_list = bd; - } - *bd->free++ = (StgWord)p; - -} - -INLINE_HEADER void -recordMutableGenLock(StgClosure *p, nat gen_no) -{ - ACQUIRE_SM_LOCK; - recordMutableGen(p,gen_no); - RELEASE_SM_LOCK; -} - -INLINE_HEADER void -recordMutable(StgClosure *p) -{ - bdescr *bd; - ASSERT(closure_MUTABLE(p)); - bd = Bdescr((P_)p); - if (bd->gen_no > 0) recordMutableGen(p, bd->gen_no); -} - -INLINE_HEADER void -recordMutableLock(StgClosure *p) -{ - ACQUIRE_SM_LOCK; - recordMutable(p); - RELEASE_SM_LOCK; -} - -#endif // !IN_STG_CODE - -/* ----------------------------------------------------------------------------- - The CAF table - used to let us revert CAFs in GHCi - -------------------------------------------------------------------------- */ - -/* set to disable CAF garbage collection in GHCi. */ -/* (needed when dynamic libraries are used). */ -extern rtsBool keepCAFs; - -/* ----------------------------------------------------------------------------- - This is the write barrier for MUT_VARs, a.k.a. IORefs. A - MUT_VAR_CLEAN object is not on the mutable list; a MUT_VAR_DIRTY - is. When written to, a MUT_VAR_CLEAN turns into a MUT_VAR_DIRTY - and is put on the mutable list. - -------------------------------------------------------------------------- */ - -void dirty_MUT_VAR(StgRegTable *reg, StgClosure *p); - -/* ----------------------------------------------------------------------------- - DEBUGGING predicates for pointers - - LOOKS_LIKE_INFO_PTR(p) returns False if p is definitely not an info ptr - LOOKS_LIKE_CLOSURE_PTR(p) returns False if p is definitely not a closure ptr - - These macros are complete but not sound. That is, they might - return false positives. Do not rely on them to distinguish info - pointers from closure pointers, for example. - - We don't use address-space predicates these days, for portability - reasons, and the fact that code/data can be scattered about the - address space in a dynamically-linked environment. Our best option - is to look at the alleged info table and see whether it seems to - make sense... - -------------------------------------------------------------------------- */ - -INLINE_HEADER rtsBool LOOKS_LIKE_INFO_PTR (StgWord p); -INLINE_HEADER rtsBool LOOKS_LIKE_CLOSURE_PTR (void *p); // XXX StgClosure* - -/* ----------------------------------------------------------------------------- - Macros for calculating how big a closure will be (used during allocation) - -------------------------------------------------------------------------- */ - -INLINE_HEADER StgOffset PAP_sizeW ( nat n_args ) -{ return sizeofW(StgPAP) + n_args; } - -INLINE_HEADER StgOffset AP_sizeW ( nat n_args ) -{ return sizeofW(StgAP) + n_args; } - -INLINE_HEADER StgOffset AP_STACK_sizeW ( nat size ) -{ return sizeofW(StgAP_STACK) + size; } - -INLINE_HEADER StgOffset CONSTR_sizeW( nat p, nat np ) -{ return sizeofW(StgHeader) + p + np; } - -INLINE_HEADER StgOffset THUNK_SELECTOR_sizeW ( void ) -{ return sizeofW(StgSelector); } - -INLINE_HEADER StgOffset BLACKHOLE_sizeW ( void ) -{ return sizeofW(StgHeader)+MIN_PAYLOAD_SIZE; } - -/* -------------------------------------------------------------------------- - Sizes of closures - ------------------------------------------------------------------------*/ - -INLINE_HEADER StgOffset sizeW_fromITBL( const StgInfoTable* itbl ) -{ return sizeofW(StgClosure) - + sizeofW(StgPtr) * itbl->layout.payload.ptrs - + sizeofW(StgWord) * itbl->layout.payload.nptrs; } - -INLINE_HEADER StgOffset thunk_sizeW_fromITBL( const StgInfoTable* itbl ) -{ return sizeofW(StgThunk) - + sizeofW(StgPtr) * itbl->layout.payload.ptrs - + sizeofW(StgWord) * itbl->layout.payload.nptrs; } - -INLINE_HEADER StgOffset ap_stack_sizeW( StgAP_STACK* x ) -{ return AP_STACK_sizeW(x->size); } - -INLINE_HEADER StgOffset ap_sizeW( StgAP* x ) -{ return AP_sizeW(x->n_args); } - -INLINE_HEADER StgOffset pap_sizeW( StgPAP* x ) -{ return PAP_sizeW(x->n_args); } - -INLINE_HEADER StgOffset arr_words_sizeW( StgArrWords* x ) -{ return sizeofW(StgArrWords) + x->words; } - -INLINE_HEADER StgOffset mut_arr_ptrs_sizeW( StgMutArrPtrs* x ) -{ return sizeofW(StgMutArrPtrs) + x->ptrs; } - -INLINE_HEADER StgWord tso_sizeW ( StgTSO *tso ) -{ return TSO_STRUCT_SIZEW + tso->stack_size; } - -INLINE_HEADER StgWord bco_sizeW ( StgBCO *bco ) -{ return bco->size; } - -INLINE_HEADER nat -closure_sizeW_ (StgClosure *p, StgInfoTable *info) -{ - switch (info->type) { - case THUNK_0_1: - case THUNK_1_0: - return sizeofW(StgThunk) + 1; - case FUN_0_1: - case CONSTR_0_1: - case FUN_1_0: - case CONSTR_1_0: - return sizeofW(StgHeader) + 1; - case THUNK_0_2: - case THUNK_1_1: - case THUNK_2_0: - return sizeofW(StgThunk) + 2; - case FUN_0_2: - case CONSTR_0_2: - case FUN_1_1: - case CONSTR_1_1: - case FUN_2_0: - case CONSTR_2_0: - return sizeofW(StgHeader) + 2; - case THUNK: - return thunk_sizeW_fromITBL(info); - case THUNK_SELECTOR: - return THUNK_SELECTOR_sizeW(); - case AP_STACK: - return ap_stack_sizeW((StgAP_STACK *)p); - case AP: - return ap_sizeW((StgAP *)p); - case PAP: - return pap_sizeW((StgPAP *)p); - case IND: - case IND_PERM: - case IND_OLDGEN: - case IND_OLDGEN_PERM: - return sizeofW(StgInd); - case ARR_WORDS: - return arr_words_sizeW((StgArrWords *)p); - case MUT_ARR_PTRS_CLEAN: - case MUT_ARR_PTRS_DIRTY: - case MUT_ARR_PTRS_FROZEN: - case MUT_ARR_PTRS_FROZEN0: - return mut_arr_ptrs_sizeW((StgMutArrPtrs*)p); - case TSO: - return tso_sizeW((StgTSO *)p); - case BCO: - return bco_sizeW((StgBCO *)p); - case TVAR_WATCH_QUEUE: - return sizeofW(StgTVarWatchQueue); - case TVAR: - return sizeofW(StgTVar); - case TREC_CHUNK: - return sizeofW(StgTRecChunk); - case TREC_HEADER: - return sizeofW(StgTRecHeader); - case ATOMIC_INVARIANT: - return sizeofW(StgAtomicInvariant); - case INVARIANT_CHECK_QUEUE: - return sizeofW(StgInvariantCheckQueue); - default: - return sizeW_fromITBL(info); - } -} - -// The definitive way to find the size, in words, of a heap-allocated closure -INLINE_HEADER nat -closure_sizeW (StgClosure *p) -{ - return closure_sizeW_(p, get_itbl(p)); -} - -/* ----------------------------------------------------------------------------- - Sizes of stack frames - -------------------------------------------------------------------------- */ - -INLINE_HEADER StgWord stack_frame_sizeW( StgClosure *frame ) -{ - StgRetInfoTable *info; - - info = get_ret_itbl(frame); - switch (info->i.type) { - - case RET_DYN: - { - StgRetDyn *dyn = (StgRetDyn *)frame; - return sizeofW(StgRetDyn) + RET_DYN_BITMAP_SIZE + - RET_DYN_NONPTR_REGS_SIZE + - RET_DYN_PTRS(dyn->liveness) + RET_DYN_NONPTRS(dyn->liveness); - } - - case RET_FUN: - return sizeofW(StgRetFun) + ((StgRetFun *)frame)->size; - - case RET_BIG: - return 1 + GET_LARGE_BITMAP(&info->i)->size; - - case RET_BCO: - return 2 + BCO_BITMAP_SIZE((StgBCO *)((P_)frame)[1]); - - default: - return 1 + BITMAP_SIZE(info->i.layout.bitmap); - } -} - -/* ----------------------------------------------------------------------------- - Nursery manipulation - -------------------------------------------------------------------------- */ - -extern void allocNurseries ( void ); -extern void resetNurseries ( void ); -extern void resizeNurseries ( nat blocks ); -extern void resizeNurseriesFixed ( nat blocks ); -extern lnat countNurseryBlocks ( void ); - - -/* ----------------------------------------------------------------------------- - Functions from GC.c - -------------------------------------------------------------------------- */ - -typedef void (*evac_fn)(void *user, StgClosure **root); - -extern void threadPaused ( Capability *cap, StgTSO * ); -extern StgClosure * isAlive ( StgClosure *p ); -extern void markCAFs ( evac_fn evac, void *user ); -extern void GetRoots ( evac_fn evac, void *user ); - -/* ----------------------------------------------------------------------------- - Stats 'n' DEBUG stuff - -------------------------------------------------------------------------- */ - -extern ullong RTS_VAR(total_allocated); - -extern lnat calcAllocated ( void ); -extern lnat calcLiveBlocks ( void ); -extern lnat calcLiveWords ( void ); -extern lnat countOccupied ( bdescr *bd ); -extern lnat calcNeeded ( void ); - -#if defined(DEBUG) -extern void memInventory(rtsBool show); -extern void checkSanity(void); -extern nat countBlocks(bdescr *); -extern void checkNurserySanity( step *stp ); -#endif - -#if defined(DEBUG) -void printMutOnceList(generation *gen); -void printMutableList(generation *gen); -#endif - -/* ---------------------------------------------------------------------------- - Storage manager internal APIs and globals - ------------------------------------------------------------------------- */ - -#define END_OF_STATIC_LIST stgCast(StgClosure*,1) - -extern void newDynCAF(StgClosure *); - -extern void move_TSO(StgTSO *src, StgTSO *dest); -extern StgTSO *relocate_stack(StgTSO *dest, ptrdiff_t diff); - -extern StgWeak * RTS_VAR(old_weak_ptr_list); -extern StgWeak * RTS_VAR(weak_ptr_list); -extern StgClosure * RTS_VAR(caf_list); -extern StgClosure * RTS_VAR(revertible_caf_list); -extern StgTSO * RTS_VAR(resurrected_threads); - -#define IS_FORWARDING_PTR(p) ((((StgWord)p) & 1) != 0) -#define MK_FORWARDING_PTR(p) (((StgWord)p) | 1) -#define UN_FORWARDING_PTR(p) (((StgWord)p) - 1) - -INLINE_HEADER rtsBool LOOKS_LIKE_INFO_PTR_NOT_NULL (StgWord p) -{ - StgInfoTable *info = INFO_PTR_TO_STRUCT(p); - return info->type != INVALID_OBJECT && info->type < N_CLOSURE_TYPES; -} - -INLINE_HEADER rtsBool LOOKS_LIKE_INFO_PTR (StgWord p) -{ - return p && (IS_FORWARDING_PTR(p) || LOOKS_LIKE_INFO_PTR_NOT_NULL(p)); -} - -INLINE_HEADER rtsBool LOOKS_LIKE_CLOSURE_PTR (void *p) -{ - return LOOKS_LIKE_INFO_PTR((StgWord)(UNTAG_CLOSURE((StgClosure *)(p)))->header.info); -} - -#endif /* STORAGE_H */ diff --git a/includes/config.h b/includes/config.h deleted file mode 100644 index 66e2ade637..0000000000 --- a/includes/config.h +++ /dev/null @@ -1,7 +0,0 @@ -#ifndef __CONFIG_H__ -#define __CONFIG_H__ - -#warning config.h is deprecated; please use ghcconfig.h instead -#include "ghcconfig.h" - -#endif diff --git a/includes/ghc.mk b/includes/ghc.mk index a266bf4c6a..50107eda37 100644 --- a/includes/ghc.mk +++ b/includes/ghc.mk @@ -33,7 +33,7 @@ ifeq "$(GhcEnableTablesNextToCode) $(GhcUnregisterised)" "YES NO" includes_CC_OPTS += -DTABLES_NEXT_TO_CODE endif -includes_CC_OPTS += -Iincludes -Irts -Irts/parallel +includes_CC_OPTS += -Iincludes -Irts ifneq "$(GhcWithSMP)" "YES" includes_CC_OPTS += -DNOSMP @@ -129,7 +129,7 @@ includes_dist-derivedconstants_PROG = mkDerivedConstants$(exeext) $(eval $(call build-prog,includes,dist-derivedconstants,0)) -$(includes_dist-derivedconstants_depfile) : $(includes_H_CONFIG) $(includes_H_PLATFORM) +$(includes_dist-derivedconstants_depfile) : $(includes_H_CONFIG) $(includes_H_PLATFORM) $(wildcard includes/*.h) $(wildcard rts/*.h) includes/dist-derivedconstants/build/mkDerivedConstants.o : $(includes_H_CONFIG) $(includes_H_PLATFORM) ifneq "$(BINDIST)" "YES" @@ -159,7 +159,7 @@ includes_dist-ghcconstants_CC_OPTS = -DGEN_HASKELL $(eval $(call build-prog,includes,dist-ghcconstants,0)) ifneq "$(BINDIST)" "YES" -$(includes_dist-ghcconstants_depfile) : $(includes_H_CONFIG) $(includes_H_PLATFORM) +$(includes_dist-ghcconstants_depfile) : $(includes_H_CONFIG) $(includes_H_PLATFORM) $(wildcard includes/*.h) $(wildcard rts/*.h) includes/dist-ghcconstants/build/mkDerivedConstants.o : $(includes_H_CONFIG) $(includes_H_PLATFORM) diff --git a/includes/ieee-flpt.h b/includes/ieee-flpt.h deleted file mode 100644 index a1fce3a8da..0000000000 --- a/includes/ieee-flpt.h +++ /dev/null @@ -1,35 +0,0 @@ -/* this file is #included into both C (.c and .hc) and Haskell files */ - - /* IEEE format floating-point */ -#define IEEE_FLOATING_POINT 1 - - /* Radix of exponent representation */ -#ifndef FLT_RADIX -# define FLT_RADIX 2 -#endif - - /* Number of base-FLT_RADIX digits in the significand of a float */ -#ifndef FLT_MANT_DIG -# define FLT_MANT_DIG 24 -#endif - /* Minimum int x such that FLT_RADIX**(x-1) is a normalised float */ -#ifndef FLT_MIN_EXP -# define FLT_MIN_EXP (-125) -#endif - /* Maximum int x such that FLT_RADIX**(x-1) is a representable float */ -#ifndef FLT_MAX_EXP -# define FLT_MAX_EXP 128 -#endif - - /* Number of base-FLT_RADIX digits in the significand of a double */ -#ifndef DBL_MANT_DIG -# define DBL_MANT_DIG 53 -#endif - /* Minimum int x such that FLT_RADIX**(x-1) is a normalised double */ -#ifndef DBL_MIN_EXP -# define DBL_MIN_EXP (-1021) -#endif - /* Maximum int x such that FLT_RADIX**(x-1) is a representable double */ -#ifndef DBL_MAX_EXP -# define DBL_MAX_EXP 1024 -#endif diff --git a/includes/mkDerivedConstants.c b/includes/mkDerivedConstants.c index f1289f61f3..b38f3abe36 100644 --- a/includes/mkDerivedConstants.c +++ b/includes/mkDerivedConstants.c @@ -21,10 +21,8 @@ #define THREADED_RTS #include "Rts.h" -#include "RtsFlags.h" -#include "Storage.h" + #include "Stable.h" -#include "OSThreads.h" #include "Capability.h" #include <stdio.h> diff --git a/includes/rts/Adjustor.h b/includes/rts/Adjustor.h new file mode 100644 index 0000000000..71e15246c1 --- /dev/null +++ b/includes/rts/Adjustor.h @@ -0,0 +1,20 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2009 + * + * Adjustor API + * + * -------------------------------------------------------------------------- */ + +#ifndef RTS_ADJUSTOR_H +#define RTS_ADJUSTOR_H + +/* Creating and destroying an adjustor thunk */ +void* createAdjustor (int cconv, + StgStablePtr hptr, + StgFunPtr wptr, + char *typeString); + +void freeHaskellFunctionPtr (void* ptr); + +#endif /* RTS_ADJUSTOR_H */ diff --git a/includes/Bytecodes.h b/includes/rts/Bytecodes.h index 4aff907cfd..4aff907cfd 100644 --- a/includes/Bytecodes.h +++ b/includes/rts/Bytecodes.h diff --git a/includes/rts/Config.h b/includes/rts/Config.h new file mode 100644 index 0000000000..ce332fa2a2 --- /dev/null +++ b/includes/rts/Config.h @@ -0,0 +1,36 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2004 + * + * Rts settings. + * + * NOTE: assumes #include "ghcconfig.h" + * + * NB: THIS FILE IS INCLUDED IN NON-C CODE AND DATA! #defines only please. + * ---------------------------------------------------------------------------*/ + +#ifndef RTS_CONFIG_H +#define RTS_CONFIG_H + +#if defined(TICKY_TICKY) && defined(THREADED_RTS) +#error TICKY_TICKY is incompatible with THREADED_RTS +#endif + +/* + * Whether the runtime system will use libbfd for debugging purposes. + */ +#if defined(DEBUG) && defined(HAVE_BFD_H) && defined(HAVE_LIBBFD) && !defined(_WIN32) +#define USING_LIBBFD 1 +#endif + +/* ----------------------------------------------------------------------------- + Signals - supported on non-PAR versions of the runtime. See RtsSignals.h. + -------------------------------------------------------------------------- */ + +#define RTS_USER_SIGNALS 1 + +/* Profile spin locks */ + +#define PROF_SPIN + +#endif /* RTS_CONFIG_H */ diff --git a/includes/Constants.h b/includes/rts/Constants.h index 967a852496..bab45a362c 100644 --- a/includes/Constants.h +++ b/includes/rts/Constants.h @@ -14,8 +14,8 @@ * * -------------------------------------------------------------------------- */ -#ifndef CONSTANTS_H -#define CONSTANTS_H +#ifndef RTS_CONSTANTS_H +#define RTS_CONSTANTS_H /* ----------------------------------------------------------------------------- Minimum closure sizes @@ -287,4 +287,4 @@ #error RESERVED_STACK_WORDS may be wrong! #endif -#endif /* CONSTANTS_H */ +#endif /* RTS_CONSTANTS_H */ diff --git a/includes/EventLogFormat.h b/includes/rts/EventLogFormat.h index b56b0b77e4..363c1ca1cf 100644 --- a/includes/EventLogFormat.h +++ b/includes/rts/EventLogFormat.h @@ -73,8 +73,8 @@ * * -------------------------------------------------------------------------- */ -#ifndef EVENTLOGFORMAT_H -#define EVENTLOGFORMAT_H +#ifndef RTS_EVENTLOGFORMAT_H +#define RTS_EVENTLOGFORMAT_H /* * Markers for begin/end of the Header. @@ -140,4 +140,4 @@ typedef StgWord16 EventCapNo; #endif -#endif /* EVENTLOGFORMAT_H */ +#endif /* RTS_EVENTLOGFORMAT_H */ diff --git a/includes/FileLock.h b/includes/rts/FileLock.h index 3fc1a81aec..9a35ecc581 100644 --- a/includes/FileLock.h +++ b/includes/rts/FileLock.h @@ -6,7 +6,10 @@ * * ---------------------------------------------------------------------------*/ -void initFileLocking(void); -void freeFileLocking(void); +#ifndef RTS_FILELOCK_H +#define RTS_FILELOCK_H + int lockFile(int fd, dev_t dev, ino_t ino, int for_writing); int unlockFile(int fd); + +#endif /* RTS_FILELOCK_H */ diff --git a/includes/rts/Flags.h b/includes/rts/Flags.h new file mode 100644 index 0000000000..3f3a0a952f --- /dev/null +++ b/includes/rts/Flags.h @@ -0,0 +1,239 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-1999 + * + * Datatypes that holds the command-line flag settings. + * + * ---------------------------------------------------------------------------*/ + +#ifndef RTS_FLAGS_H +#define RTS_FLAGS_H + +#include <stdio.h> + +/* For defaults, see the @initRtsFlagsDefaults@ routine. */ + +struct GC_FLAGS { + FILE *statsFile; + nat giveStats; +#define NO_GC_STATS 0 +#define COLLECT_GC_STATS 1 +#define ONELINE_GC_STATS 2 +#define SUMMARY_GC_STATS 3 +#define VERBOSE_GC_STATS 4 + + nat maxStkSize; /* in *words* */ + nat initialStkSize; /* in *words* */ + + nat maxHeapSize; /* in *blocks* */ + nat minAllocAreaSize; /* in *blocks* */ + nat minOldGenSize; /* in *blocks* */ + nat heapSizeSuggestion; /* in *blocks* */ + double oldGenFactor; + double pcFreeHeap; + + nat generations; + nat steps; + rtsBool squeezeUpdFrames; + + rtsBool compact; /* True <=> "compact all the time" */ + double compactThreshold; + + rtsBool sweep; /* use "mostly mark-sweep" instead of copying + * for the oldest generation */ + rtsBool ringBell; + rtsBool frontpanel; + + int idleGCDelayTime; /* in milliseconds */ + + StgWord heapBase; /* address to ask the OS for memory */ +}; + +struct DEBUG_FLAGS { + /* flags to control debugging output & extra checking in various subsystems */ + rtsBool scheduler; /* 's' */ + rtsBool interpreter; /* 'i' */ + rtsBool weak; /* 'w' */ + rtsBool gccafs; /* 'G' */ + rtsBool gc; /* 'g' */ + rtsBool block_alloc; /* 'b' */ + rtsBool sanity; /* 'S' warning: might be expensive! */ + rtsBool stable; /* 't' */ + rtsBool prof; /* 'p' */ + rtsBool eventlog; /* 'e' */ + rtsBool linker; /* 'l' the object linker */ + rtsBool apply; /* 'a' */ + rtsBool stm; /* 'm' */ + rtsBool squeeze; /* 'z' stack squeezing & lazy blackholing */ + rtsBool hpc; /* 'c' coverage */ + rtsBool timestamp; /* add timestamps to traces */ +}; + +struct COST_CENTRE_FLAGS { + unsigned int doCostCentres; +# define COST_CENTRES_SUMMARY 1 +# define COST_CENTRES_VERBOSE 2 /* incl. serial time profile */ +# define COST_CENTRES_ALL 3 +# define COST_CENTRES_XML 4 + + int profilerTicks; /* derived */ + int msecsPerTick; /* derived */ +}; + +struct PROFILING_FLAGS { + unsigned int doHeapProfile; +# define NO_HEAP_PROFILING 0 /* N.B. Used as indexes into arrays */ +# define HEAP_BY_CCS 1 +# define HEAP_BY_MOD 2 +# define HEAP_BY_DESCR 4 +# define HEAP_BY_TYPE 5 +# define HEAP_BY_RETAINER 6 +# define HEAP_BY_LDV 7 + +# define HEAP_BY_CLOSURE_TYPE 8 + + nat profileInterval; /* delta between samples (in ms) */ + nat profileIntervalTicks; /* delta between samples (in 'ticks') */ + rtsBool includeTSOs; + + + rtsBool showCCSOnException; + + nat maxRetainerSetSize; + + nat ccsLength; + + char* modSelector; + char* descrSelector; + char* typeSelector; + char* ccSelector; + char* ccsSelector; + char* retainerSelector; + char* bioSelector; + +}; + +#ifdef EVENTLOG +struct EVENTLOG_FLAGS { + rtsBool doEventLogging; +}; +#endif + +struct CONCURRENT_FLAGS { + int ctxtSwitchTime; /* in milliseconds */ + int ctxtSwitchTicks; /* derived */ +}; + +struct MISC_FLAGS { + int tickInterval; /* in milliseconds */ + rtsBool install_signal_handlers; + rtsBool machineReadable; + StgWord linkerMemBase; /* address to ask the OS for memory + * for the linker, NULL ==> off */ +}; + +#ifdef THREADED_RTS +struct PAR_FLAGS { + nat nNodes; /* number of threads to run simultaneously */ + rtsBool migrate; /* migrate threads between capabilities */ + rtsBool wakeupMigrate; /* migrate a thread on wakeup */ + unsigned int maxLocalSparks; + rtsBool parGcEnabled; /* enable parallel GC */ + rtsBool parGcGen; /* do parallel GC in this generation + * and higher only */ + rtsBool parGcLoadBalancing; /* do load-balancing in parallel GC */ + rtsBool setAffinity; /* force thread affinity with CPUs */ +}; +#endif /* THREADED_RTS */ + +struct TICKY_FLAGS { + rtsBool showTickyStats; + FILE *tickyFile; +}; + +#ifdef USE_PAPI +#define MAX_PAPI_USER_EVENTS 8 + +struct PAPI_FLAGS { + nat eventType; /* The type of events to count */ + nat numUserEvents; + char * userEvents[MAX_PAPI_USER_EVENTS]; +}; + +#define PAPI_FLAG_CACHE_L1 1 +#define PAPI_FLAG_CACHE_L2 2 +#define PAPI_FLAG_BRANCH 3 +#define PAPI_FLAG_STALLS 4 +#define PAPI_FLAG_CB_EVENTS 5 +#define PAPI_USER_EVENTS 6 + +#endif + +/* Put them together: */ + +typedef struct _RTS_FLAGS { + /* The first portion of RTS_FLAGS is invariant. */ + struct GC_FLAGS GcFlags; + struct CONCURRENT_FLAGS ConcFlags; + struct MISC_FLAGS MiscFlags; + struct DEBUG_FLAGS DebugFlags; + struct COST_CENTRE_FLAGS CcFlags; + struct PROFILING_FLAGS ProfFlags; +#ifdef EVENTLOG + struct EVENTLOG_FLAGS EventLogFlags; +#endif + struct TICKY_FLAGS TickyFlags; + +#if defined(THREADED_RTS) + struct PAR_FLAGS ParFlags; +#endif +#ifdef USE_PAPI + struct PAPI_FLAGS PapiFlags; +#endif +} RTS_FLAGS; + +#ifdef COMPILING_RTS_MAIN +extern DLLIMPORT RTS_FLAGS RtsFlags; +#elif IN_STG_CODE +/* Hack because the C code generator can't generate '&label'. */ +extern RTS_FLAGS RtsFlags[]; +#else +extern RTS_FLAGS RtsFlags; +#endif + +/* Routines that operate-on/to-do-with RTS flags: */ + +extern void initRtsFlagsDefaults(void); +extern void setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[]); +extern void setProgName(char *argv[]); + + +/* + * The printf formats are here, so we are less likely to make + * overly-long filenames (with disastrous results). No more than 128 + * chars, please! + */ + +#define STATS_FILENAME_MAXLEN 128 + +#define GR_FILENAME_FMT "%0.124s.gr" +#define GR_FILENAME_FMT_GUM "%0.120s.%03d.%s" +#define HP_FILENAME_FMT "%0.124s.hp" +#define LIFE_FILENAME_FMT "%0.122s.life" +#define PROF_FILENAME_FMT "%0.122s.prof" +#define PROF_FILENAME_FMT_GUM "%0.118s.%03d.prof" +#define QP_FILENAME_FMT "%0.124s.qp" +#define STAT_FILENAME_FMT "%0.122s.stat" +#define TICKY_FILENAME_FMT "%0.121s.ticky" +#define TIME_FILENAME_FMT "%0.122s.time" +#define TIME_FILENAME_FMT_GUM "%0.118s.%03d.time" + +/* an "int" so as to match normal "argc" */ +/* Now defined in Stg.h (lib/std/cbits need these too.) +extern int prog_argc; +extern char **prog_argv; +*/ +extern int rts_argc; /* ditto */ +extern char *rts_argv[]; + +#endif /* RTS_FLAGS_H */ diff --git a/includes/RtsGlobals.h b/includes/rts/Globals.h index 476f112e17..71846e75a1 100644 --- a/includes/RtsGlobals.h +++ b/includes/rts/Globals.h @@ -9,13 +9,10 @@ * * ---------------------------------------------------------------------------*/ -#ifndef RTSGLOBALS_H -#define RTSGLOBALS_H - -void initGlobalStore(void); -void exitGlobalStore(void); +#ifndef RTS_GLOBALS_H +#define RTS_GLOBALS_H StgStablePtr getOrSetTypeableStore(StgStablePtr value); StgStablePtr getOrSetSignalHandlerStore(StgStablePtr value); -#endif +#endif /* RTS_GLOBALS_H */ diff --git a/includes/Hooks.h b/includes/rts/Hooks.h index e281c89ab9..4fe50b4b9f 100644 --- a/includes/Hooks.h +++ b/includes/rts/Hooks.h @@ -6,6 +6,9 @@ * * ---------------------------------------------------------------------------*/ +#ifndef RTS_HOOKS_H +#define RTS_HOOKS_H + extern char *ghc_rts_opts; extern void OnExitHook (void); @@ -14,3 +17,5 @@ extern void StackOverflowHook (unsigned long stack_size); extern void OutOfHeapHook (unsigned long request_size, unsigned long heap_size); extern void MallocFailHook (unsigned long request_size /* in bytes */, char *msg); extern void defaultsHook (void); + +#endif /* RTS_HOOKS_H */ diff --git a/includes/rts/Hpc.h b/includes/rts/Hpc.h new file mode 100644 index 0000000000..c966e32cd9 --- /dev/null +++ b/includes/rts/Hpc.h @@ -0,0 +1,32 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 2008-2009 + * + * Haskell Program Coverage + * + * -------------------------------------------------------------------------- */ + +#ifndef RTS_HPC_H +#define RTS_HPC_H + +// Simple linked list of modules +typedef struct _HpcModuleInfo { + char *modName; // name of module + StgWord32 tickCount; // number of ticks + StgWord32 tickOffset; // offset into a single large .tix Array + StgWord32 hashNo; // Hash number for this module's mix info + StgWord64 *tixArr; // tix Array; local for this module + struct _HpcModuleInfo *next; +} HpcModuleInfo; + +int hs_hpc_module (char *modName, + StgWord32 modCount, + StgWord32 modHashNo, + StgWord64 *tixArr); + +HpcModuleInfo * hs_hpc_rootModule (void); + +void startupHpc(void); +void exitHpc(void); + +#endif /* RTS_HPC_H */ diff --git a/includes/rts/IOManager.h b/includes/rts/IOManager.h new file mode 100644 index 0000000000..1c269ada6d --- /dev/null +++ b/includes/rts/IOManager.h @@ -0,0 +1,39 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2009 + * + * IO Manager functionality in the RTS + * + * -------------------------------------------------------------------------- */ + +#ifndef RTS_IOMANAGER_H +#define RTS_IOMANAGER_H + +#if defined(mingw32_HOST_OS) + +int rts_InstallConsoleEvent ( int action, StgStablePtr *handler ); +void rts_ConsoleHandlerDone ( int ev ); +extern StgInt console_handler; + +void * getIOManagerEvent (void); +HsWord32 readIOManagerEvent (void); +void sendIOManagerEvent (HsWord32 event); + +#else + +void setIOManagerPipe (int fd); + +#endif + +// +// Communicating with the IO manager thread (see GHC.Conc). +// Posix implementation in posix/Signals.c +// Win32 implementation in win32/ThrIOManager.c +// +#if defined(THREADED_RTS) +void ioManagerWakeup (void); +void ioManagerDie (void); +void ioManagerStart (void); +#endif + +#endif /* RTS_IOMANAGER_H */ diff --git a/includes/Linker.h b/includes/rts/Linker.h index 053d411153..df74e7eeb8 100644 --- a/includes/Linker.h +++ b/includes/rts/Linker.h @@ -6,8 +6,8 @@ * * ---------------------------------------------------------------------------*/ -#ifndef LINKER_H -#define LINKER_H +#ifndef RTS_LINKER_H +#define RTS_LINKER_H /* initialize the object linker */ void initLinker( void ); @@ -33,6 +33,4 @@ HsInt resolveObjs( void ); /* load a dynamic library */ const char *addDLL( char* dll_name ); -extern void markRootPtrTable(void (*)(StgClosure **)); - -#endif /* LINKER_H */ +#endif /* RTS_LINKER_H */ diff --git a/includes/RtsMessages.h b/includes/rts/Messages.h index 79c48d3b98..e01eff47cf 100644 --- a/includes/RtsMessages.h +++ b/includes/rts/Messages.h @@ -9,8 +9,8 @@ * * ---------------------------------------------------------------------------*/ -#ifndef RTSMESSAGES_H -#define RTSMESSAGES_H +#ifndef RTS_MESSAGES_H +#define RTS_MESSAGES_H #include <stdarg.h> @@ -26,14 +26,15 @@ * barf() invokes (*fatalInternalErrorFn)(). This function is not * expected to return. */ -extern void barf(const char *s, ...) +void barf(const char *s, ...) GNUC3_ATTRIBUTE(__noreturn__); -extern void vbarf(const char *s, va_list ap) +void vbarf(const char *s, va_list ap) GNUC3_ATTRIBUTE(__noreturn__); -extern void _assertFail(const char *filename, unsigned int linenum) - GNUC3_ATTRIBUTE(__noreturn__); +// declared in Rts.h: +// extern void _assertFail(const char *filename, unsigned int linenum) +// GNUC3_ATTRIBUTE(__noreturn__); /* * An error condition which is caused by and/or can be corrected by @@ -41,10 +42,10 @@ extern void _assertFail(const char *filename, unsigned int linenum) * * errorBelch() invokes (*errorMsgFn)(). */ -extern void errorBelch(const char *s, ...) +void errorBelch(const char *s, ...) GNUC3_ATTRIBUTE(format (printf, 1, 2)); -extern void verrorBelch(const char *s, va_list ap); +void verrorBelch(const char *s, va_list ap); /* * An error condition which is caused by and/or can be corrected by @@ -55,10 +56,10 @@ extern void verrorBelch(const char *s, va_list ap); * * sysErrorBelch() invokes (*sysErrorMsgFn)(). */ -extern void sysErrorBelch(const char *s, ...) +void sysErrorBelch(const char *s, ...) GNUC3_ATTRIBUTE(format (printf, 1, 2)); -extern void vsysErrorBelch(const char *s, va_list ap); +void vsysErrorBelch(const char *s, va_list ap); /* * A debugging message. Debugging messages are generated either as a @@ -67,10 +68,10 @@ extern void vsysErrorBelch(const char *s, va_list ap); * * debugBelch() invokes (*debugMsgFn)(). */ -extern void debugBelch(const char *s, ...) +void debugBelch(const char *s, ...) GNUC3_ATTRIBUTE(format (printf, 1, 2)); -extern void vdebugBelch(const char *s, va_list ap); +void vdebugBelch(const char *s, va_list ap); /* Hooks for redirecting message generation: */ @@ -88,4 +89,4 @@ extern RtsMsgFunction rtsDebugMsgFn; extern RtsMsgFunction rtsErrorMsgFn; extern RtsMsgFunction rtsSysErrorMsgFn; -#endif /* RTSMESSAGES_H */ +#endif /* RTS_MESSAGES_H */ diff --git a/includes/OSThreads.h b/includes/rts/OSThreads.h index f5c434fc28..2d32136379 100644 --- a/includes/OSThreads.h +++ b/includes/rts/OSThreads.h @@ -7,8 +7,8 @@ * * --------------------------------------------------------------------------*/ -#ifndef __OSTHREADS_H__ -#define __OSTHREADS_H__ +#ifndef RTS_OSTHREADS_H +#define RTS_OSTHREADS_H #if defined(THREADED_RTS) /* to the end */ @@ -152,7 +152,7 @@ typedef HANDLE Mutex; // General thread operations // extern OSThreadId osThreadId ( void ); -extern void shutdownThread ( void ); +extern void shutdownThread ( void ) GNUC3_ATTRIBUTE(__noreturn__); extern void yieldThread ( void ); typedef void OSThreadProcAttr OSThreadProc(void *); @@ -198,4 +198,12 @@ void setThreadAffinity (nat n, nat m); #endif /* defined(THREADED_RTS) */ -#endif /* __OSTHREADS_H__ */ +// +// Support for forkOS (defined regardless of THREADED_RTS, but does +// nothing when !THREADED_RTS). +// +#ifndef CMINUSMINUS +int forkOS_createThread ( HsStablePtr entry ); +#endif + +#endif /* RTS_OSTHREADS_H */ diff --git a/includes/rts/Parallel.h b/includes/rts/Parallel.h new file mode 100644 index 0000000000..b6759819b1 --- /dev/null +++ b/includes/rts/Parallel.h @@ -0,0 +1,14 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2009 + * + * Parallelism-related functionality + * + * -------------------------------------------------------------------------- */ + +#ifndef RTS_PARALLEL_H +#define RTS_PARALLEL_H + +StgInt newSpark (StgRegTable *reg, StgClosure *p); + +#endif /* RTS_PARALLEL_H */ diff --git a/includes/Signals.h b/includes/rts/Signals.h index a5907bbee9..8d9e0fd4b7 100644 --- a/includes/Signals.h +++ b/includes/rts/Signals.h @@ -1,18 +1,21 @@ /* ----------------------------------------------------------------------------- * - * (c) The GHC Team, 1998-2005 + * (c) The GHC Team, 1998-2009 * * RTS signal handling * * ---------------------------------------------------------------------------*/ -#ifndef SIGNALS_H -#define SIGNALS_H +#ifndef RTS_SIGNALS_H +#define RTS_SIGNALS_H +/* NB. #included in Haskell code, no prototypes in here. */ + +/* arguments to stg_sig_install() */ #define STG_SIG_DFL (-1) #define STG_SIG_IGN (-2) #define STG_SIG_ERR (-3) #define STG_SIG_HAN (-4) #define STG_SIG_RST (-5) -#endif /* SIGNALS_H */ +#endif /* RTS_SIGNALS_H */ diff --git a/includes/SpinLock.h b/includes/rts/SpinLock.h index 76fcd4e00e..ea992a3457 100644 --- a/includes/SpinLock.h +++ b/includes/rts/SpinLock.h @@ -14,8 +14,8 @@ * * -------------------------------------------------------------------------- */ -#ifndef SPINLOCK_H -#define SPINLOCK_H +#ifndef RTS_SPINLOCK_H +#define RTS_SPINLOCK_H #if defined(THREADED_RTS) @@ -101,5 +101,5 @@ INLINE_HEADER void initSpinLock(void * p STG_UNUSED) #endif /* THREADED_RTS */ -#endif /* SPINLOCK_H */ +#endif /* RTS_SPINLOCK_H */ diff --git a/includes/rts/Stable.h b/includes/rts/Stable.h new file mode 100644 index 0000000000..95a3f96156 --- /dev/null +++ b/includes/rts/Stable.h @@ -0,0 +1,35 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2004 + * + * Stable Pointers + * + * ---------------------------------------------------------------------------*/ + +#ifndef RTS_STABLE_H +#define RTS_STABLE_H + +EXTERN_INLINE StgPtr deRefStablePtr (StgStablePtr stable_ptr); +StgStablePtr getStablePtr (StgPtr p); + +/* ----------------------------------------------------------------------------- + PRIVATE from here. + -------------------------------------------------------------------------- */ + +typedef struct { + StgPtr addr; /* Haskell object, free list, or NULL */ + StgPtr old; /* old Haskell object, used during GC */ + StgWord ref; /* used for reference counting */ + StgClosure *sn_obj; /* the StableName object (or NULL) */ +} snEntry; + +extern DLL_IMPORT_RTS snEntry *stable_ptr_table; + +EXTERN_INLINE +StgPtr deRefStablePtr(StgStablePtr sp) +{ + ASSERT(stable_ptr_table[(StgWord)sp].ref > 0); + return stable_ptr_table[(StgWord)sp].addr; +} + +#endif /* RTS_STABLE_H */ diff --git a/includes/SchedAPI.h b/includes/rts/Threads.h index b11437bda2..06a0ed11dc 100644 --- a/includes/SchedAPI.h +++ b/includes/rts/Threads.h @@ -1,18 +1,18 @@ /* ----------------------------------------------------------------------------- * - * (c) The GHC Team 1998-2002 + * (c) The GHC Team 1998-2009 * * External API for the scheduler. For most uses, the functions in * RtsAPI.h should be enough. * * ---------------------------------------------------------------------------*/ -#ifndef SCHEDAPI_H -#define SCHEDAPI_H +#ifndef RTS_THREADS_H +#define RTS_THREADS_H -/* - * Creating threads - */ +// +// Creating threads +// StgTSO *createThread (Capability *cap, nat stack_size); Capability *scheduleWaitThread (StgTSO *tso, /*out*/HaskellObj* ret, @@ -24,4 +24,24 @@ StgTSO *createIOThread (Capability *cap, nat stack_size, StgClosure *closure); StgTSO *createStrictIOThread (Capability *cap, nat stack_size, StgClosure *closure); + +// Suspending/resuming threads around foreign calls +void * suspendThread (StgRegTable *); +StgRegTable * resumeThread (void *); + +// +// Thread operations from Threads.c +// +int cmp_thread (StgPtr tso1, StgPtr tso2); +int rts_getThreadId (StgPtr tso); +pid_t forkProcess (HsStablePtr *entry); +HsBool rtsSupportsBoundThreads (void); + +// The number of Capabilities +extern unsigned int n_capabilities; + +#if !IN_STG_CODE +extern Capability MainCapability; #endif + +#endif /* RTS_THREADS_H */ diff --git a/includes/rts/Timer.h b/includes/rts/Timer.h new file mode 100644 index 0000000000..e3a5c2dc69 --- /dev/null +++ b/includes/rts/Timer.h @@ -0,0 +1,15 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1995-2006 + * + * Interface to the RTS timer signal (uses OS-dependent Ticker.h underneath) + * + * ---------------------------------------------------------------------------*/ + +#ifndef RTS_TIMER_H +#define RTS_TIMER_H + +void startTimer (void); +void stopTimer (void); + +#endif /* RTS_TIMER_H */ diff --git a/includes/RtsTypes.h b/includes/rts/Types.h index 79bbf1fccf..6f399e083d 100644 --- a/includes/RtsTypes.h +++ b/includes/rts/Types.h @@ -35,10 +35,8 @@ typedef enum { rtsTrue } rtsBool; -/* - Types specific to the parallel runtime system. -*/ - -typedef ullong rtsTime; +typedef struct StgClosure_ StgClosure; +typedef struct StgInfoTable_ StgInfoTable; +typedef struct StgTSO_ StgTSO; #endif /* RTS_TYPES_H */ diff --git a/includes/StgProf.h b/includes/rts/prof/CCS.h index 9b3ce69a9f..3512930b7b 100644 --- a/includes/StgProf.h +++ b/includes/rts/prof/CCS.h @@ -6,8 +6,8 @@ * * ---------------------------------------------------------------------------*/ -#ifndef STGPROF_H -#define STGPROF_H +#ifndef RTS_PROF_CCS_H +#define RTS_PROF_CCS_H /* ----------------------------------------------------------------------------- * Data Structures @@ -234,5 +234,5 @@ extern CostCentreStack * RTS_VAR(CCS_LIST); /* registered CCS list */ #endif /* PROFILING */ -#endif /* STGPROF_H */ +#endif /* RTS_PROF_CCS_H */ diff --git a/includes/StgLdvProf.h b/includes/rts/prof/LDV.h index 3c3df1c5fa..c51b10647e 100644 --- a/includes/StgLdvProf.h +++ b/includes/rts/prof/LDV.h @@ -6,8 +6,8 @@ * * ---------------------------------------------------------------------------*/ -#ifndef STGLDVPROF_H -#define STGLDVPROF_H +#ifndef RTS_PROF_LDV_H +#define RTS_PROF_LDV_H #ifdef PROFILING @@ -42,4 +42,5 @@ #define LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(c) /* nothing */ #endif /* PROFILING */ + #endif /* STGLDVPROF_H */ diff --git a/includes/Block.h b/includes/rts/storage/Block.h index ec894da02e..849f99f430 100644 --- a/includes/Block.h +++ b/includes/rts/storage/Block.h @@ -6,8 +6,8 @@ * * ---------------------------------------------------------------------------*/ -#ifndef BLOCK_H -#define BLOCK_H +#ifndef RTS_STORAGE_BLOCK_H +#define RTS_STORAGE_BLOCK_H /* The actual block and megablock-size constants are defined in * includes/Constants.h, all constants here are derived from these. @@ -268,4 +268,4 @@ round_up_to_mblocks(StgWord words) } #endif /* !CMINUSMINUS */ -#endif /* BLOCK_H */ +#endif /* RTS_STORAGE_BLOCK_H */ diff --git a/includes/rts/storage/ClosureMacros.h b/includes/rts/storage/ClosureMacros.h new file mode 100644 index 0000000000..458960f3f7 --- /dev/null +++ b/includes/rts/storage/ClosureMacros.h @@ -0,0 +1,395 @@ +/* ---------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2004 + * + * Macros for building and manipulating closures + * + * -------------------------------------------------------------------------- */ + +#ifndef RTS_STORAGE_CLOSUREMACROS_H +#define RTS_STORAGE_CLOSUREMACROS_H + +/* ----------------------------------------------------------------------------- + Info tables are slammed up against the entry code, and the label + for the info table is at the *end* of the table itself. This + inline function adjusts an info pointer to point to the beginning + of the table, so we can use standard C structure indexing on it. + + Note: this works for SRT info tables as long as you don't want to + access the SRT, since they are laid out the same with the SRT + pointer as the first word in the table. + + NOTES ABOUT MANGLED C VS. MINI-INTERPRETER: + + A couple of definitions: + + "info pointer" The first word of the closure. Might point + to either the end or the beginning of the + info table, depending on whether we're using + the mini interpretter or not. GET_INFO(c) + retrieves the info pointer of a closure. + + "info table" The info table structure associated with a + closure. This is always a pointer to the + beginning of the structure, so we can + use standard C structure indexing to pull out + the fields. get_itbl(c) returns a pointer to + the info table for closure c. + + An address of the form xxxx_info points to the end of the info + table or the beginning of the info table depending on whether we're + mangling or not respectively. So, + + c->header.info = xxx_info + + makes absolute sense, whether mangling or not. + + -------------------------------------------------------------------------- */ + +#define SET_INFO(c,i) ((c)->header.info = (i)) +#define GET_INFO(c) ((c)->header.info) +#define GET_ENTRY(c) (ENTRY_CODE(GET_INFO(c))) + +#define get_itbl(c) (INFO_PTR_TO_STRUCT((c)->header.info)) +#define get_ret_itbl(c) (RET_INFO_PTR_TO_STRUCT((c)->header.info)) +#define get_fun_itbl(c) (FUN_INFO_PTR_TO_STRUCT((c)->header.info)) +#define get_thunk_itbl(c) (THUNK_INFO_PTR_TO_STRUCT((c)->header.info)) +#define get_con_itbl(c) (CON_INFO_PTR_TO_STRUCT((c)->header.info)) + +#define GET_TAG(con) (get_itbl(con)->srt_bitmap) + +#ifdef TABLES_NEXT_TO_CODE +#define INFO_PTR_TO_STRUCT(info) ((StgInfoTable *)(info) - 1) +#define RET_INFO_PTR_TO_STRUCT(info) ((StgRetInfoTable *)(info) - 1) +#define FUN_INFO_PTR_TO_STRUCT(info) ((StgFunInfoTable *)(info) - 1) +#define THUNK_INFO_PTR_TO_STRUCT(info) ((StgThunkInfoTable *)(info) - 1) +#define CON_INFO_PTR_TO_STRUCT(info) ((StgConInfoTable *)(info) - 1) +#define itbl_to_fun_itbl(i) ((StgFunInfoTable *)(((StgInfoTable *)(i) + 1)) - 1) +#define itbl_to_ret_itbl(i) ((StgRetInfoTable *)(((StgInfoTable *)(i) + 1)) - 1) +#define itbl_to_thunk_itbl(i) ((StgThunkInfoTable *)(((StgInfoTable *)(i) + 1)) - 1) +#define itbl_to_con_itbl(i) ((StgConInfoTable *)(((StgInfoTable *)(i) + 1)) - 1) +#else +#define INFO_PTR_TO_STRUCT(info) ((StgInfoTable *)info) +#define RET_INFO_PTR_TO_STRUCT(info) ((StgRetInfoTable *)info) +#define FUN_INFO_PTR_TO_STRUCT(info) ((StgFunInfoTable *)info) +#define THUNK_INFO_PTR_TO_STRUCT(info) ((StgThunkInfoTable *)info) +#define CON_INFO_PTR_TO_STRUCT(info) ((StgConInfoTable *)info) +#define itbl_to_fun_itbl(i) ((StgFunInfoTable *)(i)) +#define itbl_to_ret_itbl(i) ((StgRetInfoTable *)(i)) +#define itbl_to_thunk_itbl(i) ((StgThunkInfoTable *)(i)) +#define itbl_to_con_itbl(i) ((StgConInfoTable *)(i)) +#endif + +/* ----------------------------------------------------------------------------- + Macros for building closures + -------------------------------------------------------------------------- */ + +#ifdef PROFILING +#ifdef DEBUG_RETAINER +/* + For the sake of debugging, we take the safest way for the moment. Actually, this + is useful to check the sanity of heap before beginning retainer profiling. + flip is defined in RetainerProfile.c, and declared as extern in RetainerProfile.h. + Note: change those functions building Haskell objects from C datatypes, i.e., + all rts_mk???() functions in RtsAPI.c, as well. + */ +#define SET_PROF_HDR(c,ccs_) \ + ((c)->header.prof.ccs = ccs_, (c)->header.prof.hp.rs = (retainerSet *)((StgWord)NULL | flip)) +#else +/* + For retainer profiling only: we do not have to set (c)->header.prof.hp.rs to + NULL | flip (flip is defined in RetainerProfile.c) because even when flip + is 1, rs is invalid and will be initialized to NULL | flip later when + the closure *c is visited. + */ +/* +#define SET_PROF_HDR(c,ccs_) \ + ((c)->header.prof.ccs = ccs_, (c)->header.prof.hp.rs = NULL) + */ +/* + The following macro works for both retainer profiling and LDV profiling: + for retainer profiling, ldvTime remains 0, so rs fields are initialized to 0. + See the invariants on ldvTime. + */ +#define SET_PROF_HDR(c,ccs_) \ + ((c)->header.prof.ccs = ccs_, \ + LDV_RECORD_CREATE((c))) +#endif /* DEBUG_RETAINER */ +#else +#define SET_PROF_HDR(c,ccs) +#endif + +#define SET_HDR(c,_info,ccs) \ + { \ + (c)->header.info = _info; \ + SET_PROF_HDR((StgClosure *)(c),ccs); \ + } + +#define SET_ARR_HDR(c,info,costCentreStack,n_words) \ + SET_HDR(c,info,costCentreStack); \ + (c)->words = n_words; + +/* ----------------------------------------------------------------------------- + How to get hold of the static link field for a static closure. + -------------------------------------------------------------------------- */ + +/* These are hard-coded. */ +#define FUN_STATIC_LINK(p) (&(p)->payload[0]) +#define THUNK_STATIC_LINK(p) (&(p)->payload[1]) +#define IND_STATIC_LINK(p) (&(p)->payload[1]) + +INLINE_HEADER StgClosure ** +STATIC_LINK(const StgInfoTable *info, StgClosure *p) +{ + switch (info->type) { + case THUNK_STATIC: + return THUNK_STATIC_LINK(p); + case FUN_STATIC: + return FUN_STATIC_LINK(p); + case IND_STATIC: + return IND_STATIC_LINK(p); + default: + return &(p)->payload[info->layout.payload.ptrs + + info->layout.payload.nptrs]; + } +} + +#define STATIC_LINK2(info,p) \ + (*(StgClosure**)(&((p)->payload[info->layout.payload.ptrs + \ + info->layout.payload.nptrs + 1]))) + +/* ----------------------------------------------------------------------------- + INTLIKE and CHARLIKE closures. + -------------------------------------------------------------------------- */ + +#define CHARLIKE_CLOSURE(n) ((P_)&stg_CHARLIKE_closure[(n)-MIN_CHARLIKE]) +#define INTLIKE_CLOSURE(n) ((P_)&stg_INTLIKE_closure[(n)-MIN_INTLIKE]) + +/* ---------------------------------------------------------------------------- + Macros for untagging and retagging closure pointers + For more information look at the comments in Cmm.h + ------------------------------------------------------------------------- */ + +static inline StgWord +GET_CLOSURE_TAG(StgClosure * p) +{ + return (StgWord)p & TAG_MASK; +} + +static inline StgClosure * +UNTAG_CLOSURE(StgClosure * p) +{ + return (StgClosure*)((StgWord)p & ~TAG_MASK); +} + +static inline StgClosure * +TAG_CLOSURE(StgWord tag,StgClosure * p) +{ + return (StgClosure*)((StgWord)p | tag); +} + +/* ----------------------------------------------------------------------------- + Forwarding pointers + -------------------------------------------------------------------------- */ + +#define IS_FORWARDING_PTR(p) ((((StgWord)p) & 1) != 0) +#define MK_FORWARDING_PTR(p) (((StgWord)p) | 1) +#define UN_FORWARDING_PTR(p) (((StgWord)p) - 1) + +/* ----------------------------------------------------------------------------- + DEBUGGING predicates for pointers + + LOOKS_LIKE_INFO_PTR(p) returns False if p is definitely not an info ptr + LOOKS_LIKE_CLOSURE_PTR(p) returns False if p is definitely not a closure ptr + + These macros are complete but not sound. That is, they might + return false positives. Do not rely on them to distinguish info + pointers from closure pointers, for example. + + We don't use address-space predicates these days, for portability + reasons, and the fact that code/data can be scattered about the + address space in a dynamically-linked environment. Our best option + is to look at the alleged info table and see whether it seems to + make sense... + -------------------------------------------------------------------------- */ + +INLINE_HEADER rtsBool LOOKS_LIKE_INFO_PTR_NOT_NULL (StgWord p) +{ + StgInfoTable *info = INFO_PTR_TO_STRUCT(p); + return info->type != INVALID_OBJECT && info->type < N_CLOSURE_TYPES; +} + +INLINE_HEADER rtsBool LOOKS_LIKE_INFO_PTR (StgWord p) +{ + return p && (IS_FORWARDING_PTR(p) || LOOKS_LIKE_INFO_PTR_NOT_NULL(p)); +} + +INLINE_HEADER rtsBool LOOKS_LIKE_CLOSURE_PTR (void *p) +{ + return LOOKS_LIKE_INFO_PTR((StgWord)(UNTAG_CLOSURE((StgClosure *)(p)))->header.info); +} + +/* ----------------------------------------------------------------------------- + Macros for calculating the size of a closure + -------------------------------------------------------------------------- */ + +INLINE_HEADER StgOffset PAP_sizeW ( nat n_args ) +{ return sizeofW(StgPAP) + n_args; } + +INLINE_HEADER StgOffset AP_sizeW ( nat n_args ) +{ return sizeofW(StgAP) + n_args; } + +INLINE_HEADER StgOffset AP_STACK_sizeW ( nat size ) +{ return sizeofW(StgAP_STACK) + size; } + +INLINE_HEADER StgOffset CONSTR_sizeW( nat p, nat np ) +{ return sizeofW(StgHeader) + p + np; } + +INLINE_HEADER StgOffset THUNK_SELECTOR_sizeW ( void ) +{ return sizeofW(StgSelector); } + +INLINE_HEADER StgOffset BLACKHOLE_sizeW ( void ) +{ return sizeofW(StgHeader)+MIN_PAYLOAD_SIZE; } + +/* -------------------------------------------------------------------------- + Sizes of closures + ------------------------------------------------------------------------*/ + +INLINE_HEADER StgOffset sizeW_fromITBL( const StgInfoTable* itbl ) +{ return sizeofW(StgClosure) + + sizeofW(StgPtr) * itbl->layout.payload.ptrs + + sizeofW(StgWord) * itbl->layout.payload.nptrs; } + +INLINE_HEADER StgOffset thunk_sizeW_fromITBL( const StgInfoTable* itbl ) +{ return sizeofW(StgThunk) + + sizeofW(StgPtr) * itbl->layout.payload.ptrs + + sizeofW(StgWord) * itbl->layout.payload.nptrs; } + +INLINE_HEADER StgOffset ap_stack_sizeW( StgAP_STACK* x ) +{ return AP_STACK_sizeW(x->size); } + +INLINE_HEADER StgOffset ap_sizeW( StgAP* x ) +{ return AP_sizeW(x->n_args); } + +INLINE_HEADER StgOffset pap_sizeW( StgPAP* x ) +{ return PAP_sizeW(x->n_args); } + +INLINE_HEADER StgOffset arr_words_sizeW( StgArrWords* x ) +{ return sizeofW(StgArrWords) + x->words; } + +INLINE_HEADER StgOffset mut_arr_ptrs_sizeW( StgMutArrPtrs* x ) +{ return sizeofW(StgMutArrPtrs) + x->ptrs; } + +INLINE_HEADER StgWord tso_sizeW ( StgTSO *tso ) +{ return TSO_STRUCT_SIZEW + tso->stack_size; } + +INLINE_HEADER StgWord bco_sizeW ( StgBCO *bco ) +{ return bco->size; } + +INLINE_HEADER nat +closure_sizeW_ (StgClosure *p, StgInfoTable *info) +{ + switch (info->type) { + case THUNK_0_1: + case THUNK_1_0: + return sizeofW(StgThunk) + 1; + case FUN_0_1: + case CONSTR_0_1: + case FUN_1_0: + case CONSTR_1_0: + return sizeofW(StgHeader) + 1; + case THUNK_0_2: + case THUNK_1_1: + case THUNK_2_0: + return sizeofW(StgThunk) + 2; + case FUN_0_2: + case CONSTR_0_2: + case FUN_1_1: + case CONSTR_1_1: + case FUN_2_0: + case CONSTR_2_0: + return sizeofW(StgHeader) + 2; + case THUNK: + return thunk_sizeW_fromITBL(info); + case THUNK_SELECTOR: + return THUNK_SELECTOR_sizeW(); + case AP_STACK: + return ap_stack_sizeW((StgAP_STACK *)p); + case AP: + return ap_sizeW((StgAP *)p); + case PAP: + return pap_sizeW((StgPAP *)p); + case IND: + case IND_PERM: + case IND_OLDGEN: + case IND_OLDGEN_PERM: + return sizeofW(StgInd); + case ARR_WORDS: + return arr_words_sizeW((StgArrWords *)p); + case MUT_ARR_PTRS_CLEAN: + case MUT_ARR_PTRS_DIRTY: + case MUT_ARR_PTRS_FROZEN: + case MUT_ARR_PTRS_FROZEN0: + return mut_arr_ptrs_sizeW((StgMutArrPtrs*)p); + case TSO: + return tso_sizeW((StgTSO *)p); + case BCO: + return bco_sizeW((StgBCO *)p); + case TVAR_WATCH_QUEUE: + return sizeofW(StgTVarWatchQueue); + case TVAR: + return sizeofW(StgTVar); + case TREC_CHUNK: + return sizeofW(StgTRecChunk); + case TREC_HEADER: + return sizeofW(StgTRecHeader); + case ATOMIC_INVARIANT: + return sizeofW(StgAtomicInvariant); + case INVARIANT_CHECK_QUEUE: + return sizeofW(StgInvariantCheckQueue); + default: + return sizeW_fromITBL(info); + } +} + +// The definitive way to find the size, in words, of a heap-allocated closure +INLINE_HEADER nat +closure_sizeW (StgClosure *p) +{ + return closure_sizeW_(p, get_itbl(p)); +} + +/* ----------------------------------------------------------------------------- + Sizes of stack frames + -------------------------------------------------------------------------- */ + +INLINE_HEADER StgWord stack_frame_sizeW( StgClosure *frame ) +{ + StgRetInfoTable *info; + + info = get_ret_itbl(frame); + switch (info->i.type) { + + case RET_DYN: + { + StgRetDyn *dyn = (StgRetDyn *)frame; + return sizeofW(StgRetDyn) + RET_DYN_BITMAP_SIZE + + RET_DYN_NONPTR_REGS_SIZE + + RET_DYN_PTRS(dyn->liveness) + RET_DYN_NONPTRS(dyn->liveness); + } + + case RET_FUN: + return sizeofW(StgRetFun) + ((StgRetFun *)frame)->size; + + case RET_BIG: + return 1 + GET_LARGE_BITMAP(&info->i)->size; + + case RET_BCO: + return 2 + BCO_BITMAP_SIZE((StgBCO *)((P_)frame)[1]); + + default: + return 1 + BITMAP_SIZE(info->i.layout.bitmap); + } +} + +#endif /* RTS_STORAGE_CLOSUREMACROS_H */ diff --git a/includes/ClosureTypes.h b/includes/rts/storage/ClosureTypes.h index 99bd3060ff..3415d423a3 100644 --- a/includes/ClosureTypes.h +++ b/includes/rts/storage/ClosureTypes.h @@ -7,8 +7,8 @@ * * -------------------------------------------------------------------------- */ -#ifndef CLOSURETYPES_H -#define CLOSURETYPES_H +#ifndef RTS_STORAGE_CLOSURETYPES_H +#define RTS_STORAGE_CLOSURETYPES_H /* * WARNING WARNING WARNING @@ -93,4 +93,4 @@ #define WHITEHOLE 69 #define N_CLOSURE_TYPES 70 -#endif /* CLOSURETYPES_H */ +#endif /* RTS_STORAGE_CLOSURETYPES_H */ diff --git a/includes/Closures.h b/includes/rts/storage/Closures.h index eb5d1ed89d..6e06e57f3c 100644 --- a/includes/Closures.h +++ b/includes/rts/storage/Closures.h @@ -6,8 +6,8 @@ * * -------------------------------------------------------------------------- */ -#ifndef CLOSURES_H -#define CLOSURES_H +#ifndef RTS_STORAGE_CLOSURES_H +#define RTS_STORAGE_CLOSURES_H /* * The Layout of a closure header depends on which kind of system we're @@ -51,14 +51,14 @@ typedef struct { -------------------------------------------------------------------------- */ typedef struct { - const struct _StgInfoTable* info; + const StgInfoTable* info; #ifdef PROFILING StgProfHeader prof; #endif } StgHeader; typedef struct { - const struct _StgInfoTable* info; + const StgInfoTable* info; #ifdef PROFILING StgProfHeader prof; #endif @@ -77,10 +77,10 @@ typedef struct { /* All closures follow the generic format */ -struct StgClosure_ { +typedef struct StgClosure_ { StgHeader header; struct StgClosure_ *payload[FLEXIBLE_ARRAY]; -}; +} *StgClosurePtr; // StgClosure defined in Rts.h typedef struct { StgThunkHeader header; @@ -124,7 +124,7 @@ typedef struct { StgHeader header; StgClosure *indirectee; StgClosure *static_link; - struct _StgInfoTable *saved_info; + StgInfoTable *saved_info; } StgIndStatic; typedef struct { @@ -273,7 +273,7 @@ typedef struct { -------------------------------------------------------------------------- */ typedef struct { - const struct _StgInfoTable* info; + const StgInfoTable* info; StgWord liveness; StgWord ret_addr; StgClosure * payload[FLEXIBLE_ARRAY]; @@ -287,7 +287,7 @@ typedef struct { * The stack frame size is also cached in the frame for convenience. */ typedef struct { - const struct _StgInfoTable* info; + const StgInfoTable* info; StgWord size; StgClosure * fun; StgClosure * payload[FLEXIBLE_ARRAY]; @@ -414,4 +414,4 @@ typedef struct { StgClosure *alt_code; } StgCatchRetryFrame; -#endif /* CLOSURES_H */ +#endif /* RTS_STORAGE_CLOSURES_H */ diff --git a/includes/StgFun.h b/includes/rts/storage/FunTypes.h index e6f9b1fe0e..402c913bcd 100644 --- a/includes/StgFun.h +++ b/includes/rts/storage/FunTypes.h @@ -1,11 +1,13 @@ /* ----------------------------------------------------------------------------- + * * (c) The GHC Team, 2002 * * Things for functions. + * * ---------------------------------------------------------------------------*/ -#ifndef STGFUN_H -#define STGFUN_H +#ifndef RTS_STORAGE_FUNTYPES_H +#define RTS_STORAGE_FUNTYPES_ /* generic - function comes with a small bitmap */ #define ARG_GEN 0 @@ -49,4 +51,4 @@ #define ARG_PPPPPPP 24 #define ARG_PPPPPPPP 25 -#endif /* STGFUN_H */ +#endif /* RTS_STORAGE_FUNTYPES_H */ diff --git a/includes/rts/storage/GC.h b/includes/rts/storage/GC.h new file mode 100644 index 0000000000..df4ba9d153 --- /dev/null +++ b/includes/rts/storage/GC.h @@ -0,0 +1,204 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2004 + * + * External Storage Manger Interface + * + * ---------------------------------------------------------------------------*/ + +#ifndef RTS_STORAGE_GC_H +#define RTS_STORAGE_GC_H + +#include <stddef.h> +#include "rts/OSThreads.h" + +/* ----------------------------------------------------------------------------- + * Generational GC + * + * We support an arbitrary number of generations, with an arbitrary number + * of steps per generation. Notes (in no particular order): + * + * - all generations except the oldest should have the same + * number of steps. Multiple steps gives objects a decent + * chance to age before being promoted, and helps ensure that + * we don't end up with too many thunks being updated in older + * generations. + * + * - the oldest generation has one step. There's no point in aging + * objects in the oldest generation. + * + * - generation 0, step 0 (G0S0) is the allocation area. It is given + * a fixed set of blocks during initialisation, and these blocks + * normally stay in G0S0. In parallel execution, each + * Capability has its own nursery. + * + * - during garbage collection, each step which is an evacuation + * destination (i.e. all steps except G0S0) is allocated a to-space. + * evacuated objects are allocated into the step's to-space until + * GC is finished, when the original step's contents may be freed + * and replaced by the to-space. + * + * - the mutable-list is per-generation (not per-step). G0 doesn't + * have one (since every garbage collection collects at least G0). + * + * - block descriptors contain pointers to both the step and the + * generation that the block belongs to, for convenience. + * + * - static objects are stored in per-generation lists. See GC.c for + * details of how we collect CAFs in the generational scheme. + * + * - large objects are per-step, and are promoted in the same way + * as small objects, except that we may allocate large objects into + * generation 1 initially. + * + * ------------------------------------------------------------------------- */ + +typedef struct step_ { + unsigned int no; // step number in this generation + unsigned int abs_no; // absolute step number + + struct generation_ * gen; // generation this step belongs to + unsigned int gen_no; // generation number (cached) + + bdescr * blocks; // blocks in this step + unsigned int n_blocks; // number of blocks + unsigned int n_words; // number of words + + struct step_ * to; // destination step for live objects + + bdescr * large_objects; // large objects (doubly linked) + unsigned int n_large_blocks; // no. of blocks used by large objs + + StgTSO * threads; // threads in this step + // linked via global_link + + // ------------------------------------ + // Fields below are used during GC only + + // During GC, if we are collecting this step, blocks and n_blocks + // are copied into the following two fields. After GC, these blocks + // are freed. + +#if defined(THREADED_RTS) + char pad[128]; // make sure the following is + // on a separate cache line. + SpinLock sync_large_objects; // lock for large_objects + // and scavenged_large_objects +#endif + + int mark; // mark (not copy)? (old gen only) + int compact; // compact (not sweep)? (old gen only) + + bdescr * old_blocks; // bdescr of first from-space block + unsigned int n_old_blocks; // number of blocks in from-space + unsigned int live_estimate; // for sweeping: estimate of live data + + bdescr * part_blocks; // partially-full scanned blocks + unsigned int n_part_blocks; // count of above + + bdescr * scavenged_large_objects; // live large objs after GC (d-link) + unsigned int n_scavenged_large_blocks; // size (not count) of above + + bdescr * bitmap; // bitmap for compacting collection + + StgTSO * old_threads; + +} step; + + +typedef struct generation_ { + unsigned int no; // generation number + step * steps; // steps + unsigned int n_steps; // number of steps + unsigned int max_blocks; // max blocks in step 0 + bdescr *mut_list; // mut objects in this gen (not G0) + + // stats information + unsigned int collections; + unsigned int par_collections; + unsigned int failed_promotions; + + // temporary use during GC: + bdescr *saved_mut_list; +} generation; + +extern generation * generations; + +extern generation * g0; +extern step * g0s0; +extern generation * oldest_gen; +extern step * all_steps; +extern nat total_steps; + +/* ----------------------------------------------------------------------------- + Generic allocation + + StgPtr allocateInGen(generation *g, nat n) + Allocates a chunk of contiguous store + n words long in generation g, + returning a pointer to the first word. + Always succeeds. + + StgPtr allocate(nat n) Equaivalent to allocateInGen(g0) + + StgPtr allocateLocal(Capability *cap, nat n) + Allocates memory from the nursery in + the current Capability. This can be + done without taking a global lock, + unlike allocate(). + + StgPtr allocatePinned(nat n) Allocates a chunk of contiguous store + n words long, which is at a fixed + address (won't be moved by GC). + Returns a pointer to the first word. + Always succeeds. + + NOTE: the GC can't in general handle + pinned objects, so allocatePinned() + can only be used for ByteArrays at the + moment. + + Don't forget to TICK_ALLOC_XXX(...) + after calling allocate or + allocatePinned, for the + benefit of the ticky-ticky profiler. + + rtsBool doYouWantToGC(void) Returns True if the storage manager is + ready to perform a GC, False otherwise. + + lnat allocatedBytes(void) Returns the number of bytes allocated + via allocate() since the last GC. + Used in the reporting of statistics. + + -------------------------------------------------------------------------- */ + +StgPtr allocate ( lnat n ); +StgPtr allocateInGen ( generation *g, lnat n ); +StgPtr allocateLocal ( Capability *cap, lnat n ); +StgPtr allocatePinned ( lnat n ); +lnat allocatedBytes ( void ); + +/* memory allocator for executable memory */ +void * allocateExec(unsigned int len, void **exec_addr); +void freeExec (void *p); + +/* ----------------------------------------------------------------------------- + Performing Garbage Collection + -------------------------------------------------------------------------- */ + +void performGC(void); +void performMajorGC(void); + +/* ----------------------------------------------------------------------------- + The CAF table - used to let us revert CAFs in GHCi + -------------------------------------------------------------------------- */ + +void newCAF (StgClosure*); +void newDynCAF (StgClosure *); +void revertCAFs (void); + +/* set to disable CAF garbage collection in GHCi. */ +/* (needed when dynamic libraries are used). */ +extern rtsBool keepCAFs; + +#endif /* RTS_STORAGE_GC_H */ diff --git a/includes/InfoTables.h b/includes/rts/storage/InfoTables.h index 0c6ab52745..4596ce2d75 100644 --- a/includes/InfoTables.h +++ b/includes/rts/storage/InfoTables.h @@ -6,8 +6,8 @@ * * -------------------------------------------------------------------------- */ -#ifndef INFOTABLES_H -#define INFOTABLES_H +#ifndef RTS_STORAGE_INFOTABLES_H +#define RTS_STORAGE_INFOTABLES_H /* ---------------------------------------------------------------------------- Relative pointers @@ -212,11 +212,7 @@ typedef union { /* * The "standard" part of an info table. Every info table has this bit. */ -typedef struct _StgInfoTable { - -#ifndef TABLES_NEXT_TO_CODE - StgFunPtr entry; /* pointer to the entry code */ -#endif +typedef struct StgInfoTable_ { #ifdef PROFILING StgProfInfo prof; @@ -236,7 +232,7 @@ typedef struct _StgInfoTable { #ifdef TABLES_NEXT_TO_CODE StgCode code[FLEXIBLE_ARRAY]; #endif -} StgInfoTable; +} *StgInfoTablePtr; /* ----------------------------------------------------------------------------- @@ -254,7 +250,7 @@ typedef struct _StgInfoTable { bitmap fields have also been omitted. -------------------------------------------------------------------------- */ -typedef struct _StgFunInfoExtraRev { +typedef struct StgFunInfoExtraRev_ { OFFSET_FIELD ( slow_apply_offset ); /* apply to args on the stack */ union { StgWord bitmap; @@ -265,7 +261,7 @@ typedef struct _StgFunInfoExtraRev { StgHalfWord arity; /* function arity */ } StgFunInfoExtraRev; -typedef struct _StgFunInfoExtraFwd { +typedef struct StgFunInfoExtraFwd_ { StgHalfWord fun_type; /* function type */ StgHalfWord arity; /* function arity */ StgSRT *srt; /* pointer to the SRT table */ @@ -313,7 +309,7 @@ typedef struct { * pointer iff srt_bitmap is zero. */ -typedef struct _StgThunkInfoTable { +typedef struct StgThunkInfoTable_ { #if !defined(TABLES_NEXT_TO_CODE) StgInfoTable i; #endif @@ -331,7 +327,7 @@ typedef struct _StgThunkInfoTable { Constructor info tables -------------------------------------------------------------------------- */ -typedef struct _StgConInfoTable { +typedef struct StgConInfoTable_ { #if !defined(TABLES_NEXT_TO_CODE) StgInfoTable i; #endif @@ -410,4 +406,5 @@ typedef struct _StgConInfoTable { #else #define GET_PROF_DESC(info) ((info)->prof.closure_desc) #endif -#endif /* INFOTABLES_H */ + +#endif /* RTS_STORAGE_INFOTABLES_H */ diff --git a/includes/Liveness.h b/includes/rts/storage/Liveness.h index cc93cae34f..66c82f3134 100644 --- a/includes/Liveness.h +++ b/includes/rts/storage/Liveness.h @@ -11,8 +11,8 @@ * * -------------------------------------------------------------------------- */ -#ifndef LIVENESS_H -#define LIVENESS_H +#ifndef RTS_STORAGE_LIVENESS_H +#define RTS_STORAGE_LIVENESS_H #define NO_PTRS 0xff #define R1_PTR (NO_PTRS ^ (1<<0)) @@ -31,4 +31,4 @@ #define RET_DYN_PTRS(l) ((l)>>24 & 0xff) #define RET_DYN_LIVENESS(l) ((l) & 0xffff) -#endif /* LIVENESS_H */ +#endif /* RTS_STORAGE_LIVENESS_H */ diff --git a/includes/rts/storage/MBlock.h b/includes/rts/storage/MBlock.h new file mode 100644 index 0000000000..03396c1fd7 --- /dev/null +++ b/includes/rts/storage/MBlock.h @@ -0,0 +1,206 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2008 + * + * MegaBlock Allocator interface. + * + * See wiki commentary at + * http://hackage.haskell.org/trac/ghc/wiki/Commentary/HeapAlloced + * + * ---------------------------------------------------------------------------*/ + +#ifndef RTS_STORAGE_MBLOCK_H +#define RTS_STORAGE_MBLOCK_H + +extern lnat mblocks_allocated; + +extern void initMBlocks(void); +extern void * getMBlock(void); +extern void * getMBlocks(nat n); +extern void freeAllMBlocks(void); + +#ifdef DEBUG +extern void *getFirstMBlock(void); +extern void *getNextMBlock(void *mblock); +#endif + +/* ----------------------------------------------------------------------------- + The HEAP_ALLOCED() test. + + HEAP_ALLOCED is called FOR EVERY SINGLE CLOSURE during GC. + It needs to be FAST. + + See wiki commentary at + http://hackage.haskell.org/trac/ghc/wiki/Commentary/HeapAlloced + + Implementation of HEAP_ALLOCED + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Since heap is allocated in chunks of megablocks (MBLOCK_SIZE), we + can just use a table to record which megablocks in the address + space belong to the heap. On a 32-bit machine, with 1Mb + megablocks, using 8 bits for each entry in the table, the table + requires 4k. Lookups during GC will be fast, because the table + will be quickly cached (indeed, performance measurements showed no + measurable difference between doing the table lookup and using a + constant comparison). + + On 64-bit machines, we cache one 12-bit block map that describes + 4096 megablocks or 4GB of memory. If HEAP_ALLOCED is called for + an address that is not in the cache, it calls slowIsHeapAlloced + (see MBlock.c) which will find the block map for the 4GB block in + question. + -------------------------------------------------------------------------- */ + +#if SIZEOF_VOID_P == 4 +extern StgWord8 mblock_map[]; + +/* On a 32-bit machine a 4KB table is always sufficient */ +# define MBLOCK_MAP_SIZE 4096 +# define MBLOCK_MAP_ENTRY(p) ((StgWord)(p) >> MBLOCK_SHIFT) +# define HEAP_ALLOCED(p) mblock_map[MBLOCK_MAP_ENTRY(p)] +# define HEAP_ALLOCED_GC(p) HEAP_ALLOCED(p) + +/* ----------------------------------------------------------------------------- + HEAP_ALLOCED for 64-bit machines. + + Here are some cache layout options: + + [1] + 16KB cache of 16-bit entries, 1MB lines (capacity 8GB) + mblock size = 20 bits + entries = 8192 13 bits + line size = 0 bits (1 bit of value) + tag size = 15 bits + = 48 bits + + [2] + 32KB cache of 16-bit entries, 4MB lines (capacity 32GB) + mblock size = 20 bits + entries = 16384 14 bits + line size = 2 bits (4 bits of value) + tag size = 12 bits + = 48 bits + + [3] + 16KB cache of 16-bit entries, 2MB lines (capacity 16GB) + mblock size = 20 bits + entries = 8192 13 bits + line size = 1 bits (2 bits of value) + tag size = 14 bits + = 48 bits + + [4] + 4KB cache of 32-bit entries, 16MB lines (capacity 16GB) + mblock size = 20 bits + entries = 1024 10 bits + line size = 4 bits (16 bits of value) + tag size = 14 bits + = 48 bits + + [5] + 4KB cache of 64-bit entries, 32MB lines (capacity 16GB) + mblock size = 20 bits + entries = 512 9 bits + line size = 5 bits (32 bits of value) + tag size = 14 bits + = 48 bits + + We actually use none of the above. After much experimentation it was + found that optimising the lookup is the most important factor, + followed by reducing the number of misses. To that end, we use a + variant of [1] in which each cache entry is ((mblock << 1) + value) + where value is 0 for non-heap and 1 for heap. The cache entries can + be 32 bits, since the mblock number is 48-20 = 28 bits, and we need + 1 bit for the value. The cache can be as big as we like, but + currently we use 8k entries, giving us 8GB capacity. + + ---------------------------------------------------------------------------- */ + +#elif SIZEOF_VOID_P == 8 + +#define MBC_LINE_BITS 0 +#define MBC_TAG_BITS 15 +typedef StgWord32 MbcCacheLine; // could use 16, but 32 was faster +typedef StgWord8 MBlockMapLine; + +#define MBLOCK_MAP_LINE(p) (((StgWord)p & 0xffffffff) >> (MBLOCK_SHIFT + MBC_LINE_BITS)) + +#define MBC_LINE_SIZE (1<<MBC_LINE_BITS) +#define MBC_SHIFT (48 - MBLOCK_SHIFT - MBC_LINE_BITS - MBC_TAG_BITS) +#define MBC_ENTRIES (1<<MBC_SHIFT) + +extern MbcCacheLine mblock_cache[]; + +#define MBC_LINE(p) ((StgWord)p >> (MBLOCK_SHIFT + MBC_LINE_BITS)) + +#define MBLOCK_MAP_ENTRIES (1 << (32 - MBLOCK_SHIFT - MBC_LINE_BITS)) + +typedef struct { + StgWord32 addrHigh32; + MBlockMapLine lines[MBLOCK_MAP_ENTRIES]; +} MBlockMap; + +extern lnat mpc_misses; + +StgBool HEAP_ALLOCED_miss(StgWord mblock, void *p); + +INLINE_HEADER +StgBool HEAP_ALLOCED(void *p) +{ + StgWord mblock; + nat entry_no; + MbcCacheLine entry, value; + + mblock = (StgWord)p >> MBLOCK_SHIFT; + entry_no = mblock & (MBC_ENTRIES-1); + entry = mblock_cache[entry_no]; + value = entry ^ (mblock << 1); + // this formulation coaxes gcc into prioritising the value==1 + // case, which we expect to be the most common. + // __builtin_expect() didn't have any useful effect (gcc-4.3.0). + if (value == 1) { + return 1; + } else if (value == 0) { + return 0; + } else { + // putting the rest out of line turned out to be a slight + // performance improvement: + return HEAP_ALLOCED_miss(mblock,p); + } +} + +// In the parallel GC, the cache itself is safe to *read*, and can be +// updated atomically, but we need to place a lock around operations +// that touch the MBlock map. +INLINE_HEADER +StgBool HEAP_ALLOCED_GC(void *p) +{ + StgWord mblock; + nat entry_no; + MbcCacheLine entry, value; + StgBool b; + + mblock = (StgWord)p >> MBLOCK_SHIFT; + entry_no = mblock & (MBC_ENTRIES-1); + entry = mblock_cache[entry_no]; + value = entry ^ (mblock << 1); + if (value == 1) { + return 1; + } else if (value == 0) { + return 0; + } else { + // putting the rest out of line turned out to be a slight + // performance improvement: + ACQUIRE_SPIN_LOCK(&gc_alloc_block_sync); + b = HEAP_ALLOCED_miss(mblock,p); + RELEASE_SPIN_LOCK(&gc_alloc_block_sync); + return b; + } +} + +#else +# error HEAP_ALLOCED not defined +#endif + +#endif /* RTS_STORAGE_MBLOCK_H */ diff --git a/includes/SMPClosureOps.h b/includes/rts/storage/SMPClosureOps.h index f46dbdefe8..d5f7c3f295 100644 --- a/includes/SMPClosureOps.h +++ b/includes/rts/storage/SMPClosureOps.h @@ -6,8 +6,8 @@ * * -------------------------------------------------------------------------- */ -#ifndef SMPCLOSUREOPS_H -#define SMPCLOSUREOPS_H +#ifndef RTS_STORAGE_SMPCLOSUREOPS_H +#define RTS_STORAGE_SMPCLOSUREOPS_H #ifdef CMINUSMINUS @@ -75,4 +75,4 @@ EXTERN_INLINE void unlockTSO(StgTSO *tso) #endif /* CMINUSMINUS */ -#endif /* SMPCLOSUREOPS_H */ +#endif /* RTS_STORAGE_SMPCLOSUREOPS_H */ diff --git a/includes/TSO.h b/includes/rts/storage/TSO.h index af624f7666..7cb245909f 100644 --- a/includes/TSO.h +++ b/includes/rts/storage/TSO.h @@ -1,36 +1,13 @@ /* ----------------------------------------------------------------------------- * - * (c) The GHC Team, 1998-1999 + * (c) The GHC Team, 1998-2009 * * The definitions for Thread State Objects. * * ---------------------------------------------------------------------------*/ -#ifndef TSO_H -#define TSO_H - -#if DEBUG -#define TSO_MAGIC 4321 -#endif - -typedef struct { - StgInt pri; - StgInt magic; - StgInt sparkname; - rtsTime startedat; - rtsBool exported; - StgInt basicblocks; - StgInt allocs; - rtsTime exectime; - rtsTime fetchtime; - rtsTime fetchcount; - rtsTime blocktime; - StgInt blockcount; - rtsTime blockedat; - StgInt globalsparks; - StgInt localsparks; - rtsTime clock; -} StgTSOStatBuf; +#ifndef RTS_STORAGE_TSO_H +#define RTS_STORAGE_TSO_H /* * PROFILING info in a TSO @@ -146,14 +123,14 @@ typedef struct StgTSO_ { StgPtr sp; StgWord stack[FLEXIBLE_ARRAY]; -} StgTSO; +} *StgTSOPtr; /* ----------------------------------------------------------------------------- functions -------------------------------------------------------------------------- */ -extern void dirty_TSO (Capability *cap, StgTSO *tso); -extern void setTSOLink (Capability *cap, StgTSO *tso, StgTSO *target); +void dirty_TSO (Capability *cap, StgTSO *tso); +void setTSOLink (Capability *cap, StgTSO *tso, StgTSO *target); /* ----------------------------------------------------------------------------- Invariants: @@ -174,7 +151,7 @@ extern void setTSOLink (Capability *cap, StgTSO *tso, StgTSO *target); ---------------------------------------------------------------------- NotBlocked NULL runnable_queue, or running - BlockedOnBlackHole the BLACKHOLE_BQ the BLACKHOLE_BQ's queue + BlockedOnBlackHole the BLACKHOLE blackhole_queue BlockedOnMVar the MVAR the MVAR's queue @@ -226,4 +203,4 @@ extern StgTSO dummy_tso; /* this is the NIL ptr for a TSO queue (e.g. runnable queue) */ #define END_TSO_QUEUE ((StgTSO *)(void*)&stg_END_TSO_QUEUE_closure) -#endif /* TSO_H */ +#endif /* RTS_STORAGE_TSO_H */ diff --git a/includes/StgDLL.h b/includes/stg/DLL.h index 5e824271bf..5e824271bf 100644 --- a/includes/StgDLL.h +++ b/includes/stg/DLL.h diff --git a/includes/MachRegs.h b/includes/stg/MachRegs.h index d6075326db..d6075326db 100644 --- a/includes/MachRegs.h +++ b/includes/stg/MachRegs.h diff --git a/includes/StgMiscClosures.h b/includes/stg/MiscClosures.h index d5a03fcdd9..1591570780 100644 --- a/includes/StgMiscClosures.h +++ b/includes/stg/MiscClosures.h @@ -253,7 +253,6 @@ RTS_INFO(stg_sel_5_upd_info); RTS_INFO(stg_sel_6_upd_info); RTS_INFO(stg_sel_7_upd_info); RTS_INFO(stg_sel_8_upd_info); -RTS_INFO(stg_sel_8_upd_info); RTS_INFO(stg_sel_9_upd_info); RTS_INFO(stg_sel_10_upd_info); RTS_INFO(stg_sel_11_upd_info); @@ -271,7 +270,6 @@ RTS_ENTRY(stg_sel_5_upd_entry); RTS_ENTRY(stg_sel_6_upd_entry); RTS_ENTRY(stg_sel_7_upd_entry); RTS_ENTRY(stg_sel_8_upd_entry); -RTS_ENTRY(stg_sel_8_upd_entry); RTS_ENTRY(stg_sel_9_upd_entry); RTS_ENTRY(stg_sel_10_upd_entry); RTS_ENTRY(stg_sel_11_upd_entry); @@ -517,7 +515,7 @@ RTS_FUN(orIntegerzh_fast); RTS_FUN(xorIntegerzh_fast); RTS_FUN(complementIntegerzh_fast); -#ifdef SUPPORT_LONG_LONGS +#if SIZEOF_HSINT == 4 RTS_FUN(int64ToIntegerzh_fast); RTS_FUN(word64ToIntegerzh_fast); diff --git a/includes/Regs.h b/includes/stg/Regs.h index beb71c9184..fb26254d5a 100644 --- a/includes/Regs.h +++ b/includes/stg/Regs.h @@ -37,14 +37,9 @@ typedef union { StgWord w; StgAddr a; StgChar c; - StgInt8 i8; StgFloat f; StgInt i; StgPtr p; - StgClosurePtr cl; - StgStackOffset offset; /* unused? */ - StgByteArray b; - StgTSOPtr t; } StgUnion; /* diff --git a/includes/SMP.h b/includes/stg/SMP.h index b7538424b9..5d9d80169b 100644 --- a/includes/SMP.h +++ b/includes/stg/SMP.h @@ -9,28 +9,17 @@ #ifndef SMP_H #define SMP_H -/* THREADED_RTS is currently not compatible with the following options: - * - * PROFILING (but only 1 CPU supported) - * TICKY_TICKY - * Unregisterised builds are ok, but only 1 CPU supported. - */ - #if defined(THREADED_RTS) -#if defined(TICKY_TICKY) -#error Build options incompatible with THREADED_RTS. -#endif - /* ---------------------------------------------------------------------------- Atomic operations ------------------------------------------------------------------------- */ -#if !IN_STG_CODE -// We only want write_barrier() declared in .hc files. Defining the -// other inline functions here causes type mismatch errors from gcc, -// because the generated C code is assuming that there are no -// prototypes in scope. +#if !IN_STG_CODE || IN_STGCRUN +// We only want the barriers, e.g. write_barrier(), declared in .hc +// files. Defining the other inline functions here causes type +// mismatch errors from gcc, because the generated C code is assuming +// that there are no prototypes in scope. /* * The atomic exchange operation: xchg(p,w) exchanges the value @@ -94,12 +83,8 @@ EXTERN_INLINE void load_load_barrier(void); Implementations ------------------------------------------------------------------------- */ -#if !IN_STG_CODE +#if !IN_STG_CODE || IN_STGCRUN -/* - * NB: the xchg instruction is implicitly locked, so we do not need - * a lock prefix here. - */ EXTERN_INLINE StgWord xchg(StgPtr p, StgWord w) { @@ -107,6 +92,8 @@ xchg(StgPtr p, StgWord w) #if i386_HOST_ARCH || x86_64_HOST_ARCH result = w; __asm__ __volatile__ ( + // NB: the xchg instruction is implicitly locked, so we do not + // need a lock prefix here. "xchg %1,%0" :"+r" (result), "+m" (*p) : /* no input-only operands */ diff --git a/includes/TailCalls.h b/includes/stg/TailCalls.h index 854c7b4b18..854c7b4b18 100644 --- a/includes/TailCalls.h +++ b/includes/stg/TailCalls.h diff --git a/includes/TickyCounters.h b/includes/stg/Ticky.h index 38e84ef2af..fd7edf85c5 100644 --- a/includes/TickyCounters.h +++ b/includes/stg/Ticky.h @@ -3,7 +3,8 @@ * (c) The GHC Team, 2007 * * Declarations for counters used by ticky-ticky profiling. - *----------------------------------------------------------------------------- */ + * + * -------------------------------------------------------------------------- */ #ifndef TICKYCOUNTERS_H @@ -25,7 +26,6 @@ #define EXTERN extern #endif - /* Here are all the counter declarations: */ EXTERN StgInt ENT_VIA_NODE_ctr INIT(0); diff --git a/includes/StgTypes.h b/includes/stg/Types.h index 7f2c08e5e2..227356c9ea 100644 --- a/includes/StgTypes.h +++ b/includes/stg/Types.h @@ -19,9 +19,8 @@ StgInt Signed version of StgWord StgAddr Generic address type - StgBool, StgVoid, StgClosurePtr, StgPtr, StgOffset, - StgTSOPtr, StgForeignPtr, StgStackOffset, StgStackPtr, - StgCode, StgArray, StgByteArray, StgStablePtr, StgFunPtr, + StgBool, StgVoid, StgPtr, StgOffset, + StgCode, StgStablePtr, StgFunPtr, StgUnion. * WARNING: Keep this file, MachDeps.h, and HsFFI.h in synch! @@ -58,23 +57,17 @@ typedef unsigned int StgWord32; #error GHC untested on this architecture: sizeof(int) != 4 #endif -#ifdef SUPPORT_LONG_LONGS -/* assume long long is 64 bits */ -# ifndef _MSC_VER -typedef signed long long int StgInt64; -typedef unsigned long long int StgWord64; -# else -typedef __int64 StgInt64; -typedef unsigned __int64 StgWord64; -# endif -#elif SIZEOF_LONG == 8 +#if SIZEOF_LONG == 8 typedef signed long StgInt64; typedef unsigned long StgWord64; #elif defined(__MSVC__) typedef __int64 StgInt64; typedef unsigned __int64 StgWord64; +#elif SIZEOF_LONG_LONG == 8 +typedef signed long long int StgInt64; +typedef unsigned long long int StgWord64; #else -#error GHC untested on this architecture: sizeof(void *) < 8 and no long longs. +#error cannot find a way to define StgInt64 #endif /* @@ -106,40 +99,21 @@ typedef StgWord16 StgHalfWord; #define W_MASK (sizeof(W_)-1) -typedef void* StgAddr; - /* * Other commonly-used STG datatypes. */ +typedef void* StgAddr; typedef StgWord32 StgChar; typedef int StgBool; - typedef float StgFloat; typedef double StgDouble; - -typedef void StgVoid; - -typedef struct StgClosure_ StgClosure; -typedef StgClosure* StgClosurePtr; -typedef StgWord* StgPtr; /* pointer into closure */ +typedef StgWord* StgPtr; /* heap or stack pointer */ typedef StgWord volatile* StgVolatilePtr; /* pointer to volatile word */ typedef StgWord StgOffset; /* byte offset within closure */ - -typedef struct StgTSO_* StgTSOPtr; - -typedef void* StgForeignPtr; - -typedef StgInt StgStackOffset; /* offset in words! */ - -typedef StgWord* StgStackPtr; - -typedef StgWord8 StgCode; /* close enough */ - -typedef StgPtr* StgArray; /* the goods of an Array# */ -typedef char* StgByteArray; /* the goods of a ByteArray# */ - +typedef StgWord8 StgCode; /* close enough */ typedef void* StgStablePtr; +typedef StgWord8* StgByteArray; /* Types for the generated C functions |