Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

269 lines (223 sloc) 9.86 KB
/* --------------------------------------------------------------------------
Time-stamp: <Tue Mar 06 2001 00:18:30 Stardate: [-30]6285.06 hwloidl>
Variables and functions specific to GranSim.
----------------------------------------------------------------------- */
//@node Headers for GranSim objs used only in the RTS internally, , ,
//@section Headers for GranSim objs used only in the RTS internally
//* Event queue::
//* Spark handling routines::
//* Processor related stuff::
//* Local types::
//* Statistics gathering::
//* Prototypes::
//@end menu
//*/ fool highlight
//@node Event queue, Spark handling routines, Headers for GranSim objs used only in the RTS internally, Headers for GranSim objs used only in the RTS internally
//@subsection Event queue
#if defined(GRAN) || defined(PAR)
/* Granularity event types for output (see DumpGranEvent) */
typedef enum GranEventType_ {
GR_SYSTEM_START, GR_SYSTEM_END, /* only for debugging */
} GranEventType;
extern char *gran_event_names[];
#if defined(GRAN) /* whole file */
/* Event Types (internal use only) */
typedef enum rtsEventType_ {
ContinueThread = 0, /* Continue running the first thread in the queue */
StartThread, /* Start a newly created thread */
ResumeThread, /* Resume a previously running thread */
MoveSpark, /* Move a spark from one PE to another */
MoveThread, /* Move a thread from one PE to another */
FindWork, /* Search for work */
FetchNode, /* Fetch a node */
FetchReply, /* Receive a node */
GlobalBlock, /* Block a TSO on a remote node */
UnblockThread /* Make a TSO runnable */
} rtsEventType;
/* Number of last event type */
#define MAX_EVENT 9
typedef struct rtsEvent_ {
PEs proc; /* Processor id */
PEs creator; /* Processor id of PE that created the event */
rtsEventType evttype; /* rtsEvent type */
rtsTime time; /* Time at which event happened */
StgTSO *tso; /* Associated TSO, if relevant */
StgClosure *node; /* Associated node, if relevant */
rtsSpark *spark; /* Associated SPARK, if relevant */
StgInt gc_info; /* Counter of heap objects to mark (used in GC only)*/
struct rtsEvent_ *next;
} rtsEvent;
typedef rtsEvent *rtsEventQ;
extern rtsEventQ EventHd;
/* Interface for ADT of Event Queue */
rtsEvent *get_next_event(void);
rtsTime get_time_of_next_event(void);
void insert_event(rtsEvent *newentry);
void new_event(PEs proc, PEs creator, rtsTime time,
rtsEventType evttype, StgTSO *tso,
StgClosure *node, rtsSpark *spark);
void print_event(rtsEvent *event);
void print_eventq(rtsEvent *hd);
void prepend_event(rtsEvent *event);
rtsEventQ grab_event(void);
void prune_eventq(StgTSO *tso, StgClosure *node);
void traverse_eventq_for_gc(void);
void markEventQueue(void);
//@node Spark handling routines, Processor related stuff, Event queue, Headers for GranSim objs used only in the RTS internally
//@subsection Spark handling routines
/* These functions are only used in the RTS internally; see GranSim.h for rest */
void disposeSpark(rtsSpark *spark);
void disposeSparkQ(rtsSparkQ spark);
void print_spark(rtsSpark *spark);
void print_sparkq(PEs proc);
void print_sparkq_stats(void);
nat spark_queue_len(PEs proc);
rtsSpark *delete_from_sparkq (rtsSpark *spark, PEs p, rtsBool dispose_too);
void markSparkQueue(void);
//@node Processor related stuff, Local types, Spark handling routines, Headers for GranSim objs used only in the RTS internally
//@subsection Processor related stuff
typedef enum rtsProcStatus_ {
Idle = 0, /* empty threadq */
Sparking, /* non-empty sparkq; FINDWORK has been issued */
Starting, /* STARTTHREAD has been issue */
Fetching, /* waiting for remote data (only if block-on-fetch) */
Fishing, /* waiting for remote spark/thread */
Busy /* non-empty threadq, with head of queue active */
} rtsProcStatus;
#define IS_IDLE(proc) (procStatus[proc] == Idle)
#define IS_SPARKING(proc) (procStatus[proc] == Sparking)
#define IS_STARTING(proc) (procStatus[proc] == Starting)
#define IS_FETCHING(proc) (procStatus[proc] == Fetching)
#define IS_FISHING(proc) (procStatus[proc] == Fishing)
#define IS_BUSY(proc) (procStatus[proc] == Busy)
#define ANY_IDLE (any_idle())
#define MAKE_IDLE(proc) procStatus[proc] = Idle
#define MAKE_SPARKING(proc) procStatus[proc] = Sparking
#define MAKE_STARTING(proc) procStatus[proc] = Starting
#define MAKE_FETCHING(proc) procStatus[proc] = Fetching
#define MAKE_FISHING(proc) procStatus[proc] = Fishing
#define MAKE_BUSY(proc) procStatus[proc] = Busy
//@node Local types, Statistics gathering, Processor related stuff, Headers for GranSim objs used only in the RTS internally
//@subsection Local types
/* Return codes of HandleFetchRequest:
0 ... ok (FETCHREPLY event with a buffer containing addresses of the
nearby graph has been scheduled)
1 ... node is already local (fetched by somebody else; no event is
scheduled in here)
2 ... fetch request has been forwrded to the PE that now contains the
3 ... node is a black hole (BH, BQ or RBH); no event is scheduled, and
the current TSO is put into the blocking queue of that node
4 ... out of heap in PackNearbyGraph; GC should be triggered in calling
function to guarantee that the tso and node inputs are valid
(they may be moved during GC).
Return codes of blockFetch:
0 ... ok; tso is now at beginning of BQ attached to the bh closure
1 ... the bh closure is no BH any more; tso is immediately unblocked
typedef enum rtsFetchReturnCode_ {
Ok = 0,
} rtsFetchReturnCode;
//@node Statistics gathering, Prototypes, Local types, Headers for GranSim objs used only in the RTS internally
//@subsection Statistics gathering
extern unsigned int /* nat */ OutstandingFetches[], OutstandingFishes[];
extern rtsProcStatus procStatus[];
extern StgTSO *BlockedOnFetch[];
/* global structure for collecting statistics */
typedef struct GlobalGranStats_ {
/* event stats */
nat noOfEvents;
nat event_counts[MAX_EVENT];
/* communication stats */
nat fetch_misses;
nat tot_fake_fetches; // GranSim internal; faked Fetches are a kludge!!
nat tot_low_pri_sparks;
/* load distribution statistics */
nat rs_sp_count, rs_t_count, ntimes_total, fl_total,
no_of_steals, no_of_migrates;
/* spark queue stats */
nat tot_sq_len, tot_sq_probes, tot_sparks;
nat tot_add_threads, tot_tq_len, non_end_add_threads;
/* packet statistics */
nat tot_packets, tot_packet_size, tot_cuts, tot_thunks;
/* thread stats */
nat tot_threads_created, threads_created_on_PE[MAX_PROC],
/* spark stats */
nat pruned_sparks, withered_sparks;
nat tot_sparks_created, sparks_created_on_PE[MAX_PROC];
/* scheduling stats */
nat tot_yields, tot_stackover, tot_heapover;
/* blocking queue statistics */
rtsTime tot_bq_processing_time;
nat tot_bq_len, tot_bq_len_local, tot_awbq, tot_FMBQs;
} GlobalGranStats;
extern GlobalGranStats globalGranStats;
//@node Prototypes, , Statistics gathering, Headers for GranSim objs used only in the RTS internally
//@subsection Prototypes
/* Generally useful fcts */
PEs where_is(StgClosure *node);
rtsBool is_unique(StgClosure *node);
/* Prototypes of event handling functions; needed in Schedule.c:ReSchedule() */
void do_the_globalblock (rtsEvent* event);
void do_the_unblock (rtsEvent* event);
void do_the_fetchnode (rtsEvent* event);
void do_the_fetchreply (rtsEvent* event);
void do_the_movethread (rtsEvent* event);
void do_the_movespark (rtsEvent* event);
void do_the_startthread(rtsEvent *event);
void do_the_findwork(rtsEvent* event);
void gimme_spark (rtsEvent *event, rtsBool *found_res, rtsSparkQ *spark_res);
rtsBool munch_spark (rtsEvent *event, rtsSparkQ spark);
/* GranSimLight routines */
void GranSimLight_enter_system(rtsEvent *event, StgTSO **ActiveTSOp);
void GranSimLight_leave_system(rtsEvent *event, StgTSO **ActiveTSOp);
/* Communication related routines */
rtsFetchReturnCode fetchNode(StgClosure* node, PEs from, PEs to);
rtsFetchReturnCode handleFetchRequest(StgClosure* node, PEs curr_proc, PEs p, StgTSO* tso);
void handleIdlePEs(void);
long int random(void); /* used in stealSpark() and stealThread() in GranSim.c */
/* Scheduling fcts defined in GranSim.c */
void insertThread(StgTSO *tso, PEs proc);
void endThread(StgTSO *tso, PEs proc);
rtsBool GranSimLight_insertThread(StgTSO *tso, PEs proc);
nat thread_queue_len(PEs proc);
/* For debugging */
rtsBool is_on_queue (StgTSO *tso, PEs proc);
#if defined(GRAN) || defined(PAR)
Interface for dumping routines (i.e. writing to log file).
These routines are shared with GUM (and could also be used for SMP).
void DumpGranEvent(GranEventType name, StgTSO *tso);
void DumpEndEvent(PEs proc, StgTSO *tso, rtsBool mandatory_thread);
void DumpTSO(StgTSO *tso);
void DumpRawGranEvent(PEs proc, PEs p, GranEventType name,
StgTSO *tso, StgClosure *node,
StgInt sparkname, StgInt len);
void DumpVeryRawGranEvent(rtsTime time, PEs proc, PEs p, GranEventType name,
StgTSO *tso, StgClosure *node,
StgInt sparkname, StgInt len);
#endif /* GRANSIM_RTS_H */
Jump to Line
Something went wrong with that request. Please try again.