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.

1 files changed, 9 insertions, 41 deletions

diff --git a/rts/Schedule.h b/rts/Schedule.h
index 0e18168755..378bd68c66 100644
--- a/rts/Schedule.h
+++ b/rts/Schedule.h
@@ -10,9 +10,9 @@
 #ifndef SCHEDULE_H
 #define SCHEDULE_H
 
-#include "OSThreads.h"
+#include "rts/OSThreads.h"
 #include "Capability.h"
-#include "EventLog.h"
+#include "eventlog/EventLog.h"
 
 /* initScheduler(), exitScheduler()
  * Called from STG :  no
@@ -30,28 +30,13 @@ void scheduleThread (Capability *cap, StgTSO *tso);
 // the desired Capability).
 void scheduleThreadOn(Capability *cap, StgWord cpu, StgTSO *tso);
 
-/* awakenBlockedQueue()
- *
- * Takes a pointer to the beginning of a blocked TSO queue, and
- * wakes up the entire queue.
- * Called from STG :  yes
- * Locks assumed   :  none
- */
-void awakenBlockedQueue (Capability *cap, StgTSO *tso);
-
 /* wakeUpRts()
  * 
  * Causes an OS thread to wake up and run the scheduler, if necessary.
  */
+#if defined(THREADED_RTS)
 void wakeUpRts(void);
-
-/* unblockOne()
- *
- * Put the specified thread on the run queue of the given Capability.
- * Called from STG :  yes
- * Locks assumed   :  we own the Capability.
- */
-StgTSO * unblockOne (Capability *cap, StgTSO *tso);
+#endif
 
 /* raiseExceptionHelper */
 StgWord raiseExceptionHelper (StgRegTable *reg, StgTSO *tso, StgClosure *exception);
@@ -69,11 +54,6 @@ StgWord findRetryFrameHelper (StgTSO *tso);
 void OSThreadProcAttr workerStart(Task *task);
 #endif
 
-char   *info_type(StgClosure *closure);    // dummy
-char   *info_type_by_ip(StgInfoTable *ip); // dummy
-void    awaken_blocked_queue(StgTSO *q);
-void    initThread(StgTSO *tso, nat stack_size);
-
 /* The state of the scheduler.  This is used to control the sequence
  * of events during shutdown, and when the runtime is interrupted
  * using ^C.
@@ -82,7 +62,7 @@ void    initThread(StgTSO *tso, nat stack_size);
 #define SCHED_INTERRUPTING  1  /* ^C detected, before threads are deleted */
 #define SCHED_SHUTTING_DOWN 2  /* final shutdown */
 
-extern volatile StgWord RTS_VAR(sched_state);
+extern volatile StgWord sched_state;
 
 /* 
  * flag that tracks whether we have done any execution in this time slice.
@@ -105,10 +85,10 @@ extern volatile StgWord recent_activity;
  *
  * In GranSim we have one run/blocked_queue per PE.
  */
-extern  StgTSO *RTS_VAR(blackhole_queue);
+extern  StgTSO *blackhole_queue;
 #if !defined(THREADED_RTS)
-extern  StgTSO *RTS_VAR(blocked_queue_hd), *RTS_VAR(blocked_queue_tl);
-extern  StgTSO *RTS_VAR(sleeping_queue);
+extern  StgTSO *blocked_queue_hd, *blocked_queue_tl;
+extern  StgTSO *sleeping_queue;
 #endif
 
 /* Set to rtsTrue if there are threads on the blackhole_queue, and
@@ -123,27 +103,15 @@ extern rtsBool blackholes_need_checking;
 extern rtsBool heap_overflow;
 
 #if defined(THREADED_RTS)
-extern Mutex RTS_VAR(sched_mutex);
+extern Mutex sched_mutex;
 #endif
 
-SchedulerStatus rts_mainLazyIO(HaskellObj p, /*out*/HaskellObj *ret);
-
 /* Called by shutdown_handler(). */
 void interruptStgRts (void);
 
-nat  run_queue_len (void);
-
 void resurrectThreads (StgTSO *);
 void performPendingThrowTos (StgTSO *);
 
-void printAllThreads(void);
-
-/* debugging only 
- */
-#ifdef DEBUG
-void print_bq (StgClosure *node);
-#endif
-
 /* -----------------------------------------------------------------------------
  * Some convenient macros/inline functions...
  */