1. 13 Aug, 2006 1 commit
  2. 07 Apr, 2006 1 commit
    • Simon Marlow's avatar
      Reorganisation of the source tree · 0065d5ab
      Simon Marlow authored
      Most of the other users of the fptools build system have migrated to
      Cabal, and with the move to darcs we can now flatten the source tree
      without losing history, so here goes.
      
      The main change is that the ghc/ subdir is gone, and most of what it
      contained is now at the top level.  The build system now makes no
      pretense at being multi-project, it is just the GHC build system.
      
      No doubt this will break many things, and there will be a period of
      instability while we fix the dependencies.  A straightforward build
      should work, but I haven't yet fixed binary/source distributions.
      Changes to the Building Guide will follow, too.
      0065d5ab
  3. 16 Mar, 2006 1 commit
  4. 26 Oct, 2005 2 commits
  5. 24 Oct, 2005 1 commit
    • simonmar's avatar
      [project @ 2005-10-24 09:37:08 by simonmar] · 024b9229
      simonmar authored
      Fix the build; none of this is actually used in THREADED_RTS or SMP,
      but I haven't got around to fixing things so we can omit it from the
      build completely yet.
      024b9229
  6. 29 Jul, 2005 1 commit
    • sof's avatar
      [project @ 2005-07-29 20:21:50 by sof] · b3de318b
      sof authored
      win32/AsyncIO.c:onIOComplete(), awaitRequests():
        Avoid completion table overflow through the use of
        a semaphore. Worker threads (the producers) wait for a free
        event slot to appear, the RTS thread (consumer) signal slot
        availability once the completion event has been de-queued and
        processed.
      
        This bug only manifests itself in 'massively concurrent' code
        (>200 threads), where the threads simultaneously engage in IO
        through the async IO layer. conc023 and conc036 in the regression
        test suite are examples of such.
      
      Merge to STABLE.
      b3de318b
  7. 19 May, 2005 1 commit
  8. 22 Apr, 2005 1 commit
    • sof's avatar
      [project @ 2005-04-22 17:00:48 by sof] · ecb1a539
      sof authored
      [mingw only]
      Better handling of I/O request abortions upon throwing an exception
      to a Haskell thread. As was, a thread blocked on an I/O request was
      simply unblocked, but its corresponding worker thread wasn't notified
      that the request had been abandoned.
      
      This manifested itself in GHCi upon Ctrl-C being hit at the prompt -- the
      worker thread blocked waiting for input on stdin prior to Ctrl-C would
      stick around even though its corresponding Haskell thread had been
      thrown an Interrupted exception. The upshot was that the worker would
      consume the next character typed in after Ctrl-C, but then just dropping
      it. Dealing with this turned out to be even more interesting due to
      Win32 aborting any console reads when Ctrl-C/Break events are delivered.
      
      The story could be improved upon (at the cost of portability) by making
      the Scheduler able to abort worker thread system calls; as is, requests
      are cooperatively abandoned. Maybe later.
      
      Also included are other minor tidyups to Ctrl-C handling under mingw.
      
      Merge to STABLE.
      ecb1a539
  9. 14 Apr, 2005 1 commit
  10. 18 Dec, 2003 1 commit
    • simonmar's avatar
      [project @ 2003-12-18 13:27:27 by simonmar] · 50ebfb02
      simonmar authored
      Fix some threaded RTS bugs:
      
       - in awaitRequests(), it was possible to return immediately even
         though wait was set to rtsTrue.  This lead to a busy wait loop,
         so I've disabled that case (see code for details).
      
       - using PulseEvent in abandonRequestWait() wasn't the right thing,
         because it exposed a race condition.  Again, see the comment in
         the code for details.
      50ebfb02
  11. 12 Sep, 2003 1 commit
  12. 11 Sep, 2003 1 commit
  13. 16 Jul, 2003 1 commit
    • sof's avatar
      [project @ 2003-07-16 17:40:38 by sof] · 788897b6
      sof authored
      - change prototype of async proc calls to
      
            typedef int (*DoProcProc)(void *param);
      
        i.e., have the proc return a result. Turned out that almost all
        uses of the primop ended up encoding a result via their 'param'.
      
      - when adding new I/O requests, shorten the time the IOManager
        lock is held. Helps to keep down the size of the thread pool.
      788897b6
  14. 12 Jul, 2003 1 commit
  15. 03 Jul, 2003 1 commit
    • sof's avatar
      [project @ 2003-07-03 15:14:56 by sof] · 18340925
      sof authored
      New primop (mingw only),
      
        asyncDoProc# :: Addr# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #)
      
      which lets a Haskell thread hand off a pointer to external code (1st arg) for
      asynchronous execution by the RTS worker thread pool. Second arg is data passed
      in to the asynchronous routine. The routine is _not_ permitted to re-enter
      the RTS as part of its execution.
      18340925
  16. 22 Feb, 2003 1 commit
    • sof's avatar
      [project @ 2003-02-22 04:51:50 by sof] · 557947d3
      sof authored
      Clean up code&interfaces that deals with timers and asynchrony:
      
      - Timer.{c,h} now defines the platform-independent interface
        to the timing services needed by the RTS. Itimer.{c,h} +
        win32/Ticker.{c,h} defines the OS-specific services that
        creates/destroys a timer.
      - For win32 plats, drop the long-standing use of the 'multimedia'
        API timers and implement the ticking service ourselves. Simpler
        and more flexible.
      - Select.c is now solely for platforms that use select() to handle
        non-blocking I/O & thread delays. win32/AwaitEvent.c provides
        the same API on the Win32 side.
      - support threadDelay on win32 platforms via worker threads.
      
      Not yet compiled up on non-win32 platforms; will do once checked in.
      557947d3
  17. 21 Feb, 2003 1 commit
    • sof's avatar
      [project @ 2003-02-21 05:34:12 by sof] · 5b4f5a6a
      sof authored
      Asynchronous / non-blocking I/O for Win32 platforms.
      
      This commit introduces a Concurrent Haskell friendly view of I/O on
      Win32 platforms. Through the use of a pool of worker Win32 threads, CH
      threads may issue asynchronous I/O requests without blocking the
      progress of other CH threads. The issuing CH thread is blocked until
      the request has been serviced though.
      
      GHC.Conc exports the primops that take care of issuing the
      asynchronous I/O requests, which the IO implementation now takes
      advantage of. By default, all Handles are non-blocking/asynchronous,
      but should performance become an issue, having a per-Handle flag for
      turning off non-blocking could easily be imagined&introduced.
      
      [Incidentally, this thread pool-based implementation could easily be
      extended to also allow Haskell code to delegate the execution of
      arbitrary pieces of (potentially blocking) external code to another OS
      thread. Given how relatively gnarly the locking story has turned out
      to be with the 'threaded' RTS, that may not be such a bad idea.]
      5b4f5a6a