1. 29 Mar, 2008 1 commit
  2. 25 Sep, 2007 1 commit
  3. 01 Sep, 2007 1 commit
  4. 30 Aug, 2007 1 commit
  5. 14 May, 2007 1 commit
  6. 10 May, 2007 1 commit
  7. 03 May, 2007 1 commit
  8. 17 Apr, 2007 1 commit
    • Simon Marlow's avatar
      Re-working of the breakpoint support · cdce6477
      Simon Marlow authored
      This is the result of Bernie Pope's internship work at MSR Cambridge,
      with some subsequent improvements by me.  The main plan was to
       (a) Reduce the overhead for breakpoints, so we could enable 
           the feature by default without incurrent a significant penalty
       (b) Scatter more breakpoint sites throughout the code
      Currently we can set a breakpoint on almost any subexpression, and the
      overhead is around 1.5x slower than normal GHCi.  I hope to be able to
      get this down further and/or allow breakpoints to be turned off.
      This patch also fixes up :print following the recent changes to
      constructor info tables.  (most of the :print tests now pass)
      We now support single-stepping, which just enables all breakpoints.
        :step <expr>     executes <expr> with single-stepping turned on
        :step            single-steps from the current breakpoint
      The mechanism is quite different to the previous implementation.  We
      share code with the HPC (haskell program coverage) implementation now.
      The coverage pass annotates source code with "tick" locations which
      are tracked by the coverage tool.  In GHCi, each "tick" becomes a
      potential breakpoint location.
      Previously breakpoints were compiled into code that magically invoked
      a nested instance of GHCi.  Now, a breakpoint causes the current
      thread to block and control is returned to GHCi.
      See the wiki page for more details and the current ToDo list:
  9. 17 Mar, 2007 1 commit
  10. 14 Mar, 2007 2 commits
  11. 06 Mar, 2007 1 commit
    • Simon Marlow's avatar
      add noDuplicate# · 78c491b1
      Simon Marlow authored
      This primop ensures that the current computation is not being
      duplicated, by calling threadPaused().  The idea is to use it inside
      unsafePerformIO/unsafeInterleaveIO (see #986).
  12. 01 Mar, 2007 1 commit
  13. 28 Feb, 2007 1 commit
  14. 27 Feb, 2007 1 commit
  15. 09 Dec, 2006 1 commit
  16. 07 Oct, 2006 1 commit
  17. 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.
  18. 27 Mar, 2006 1 commit
    • Simon Marlow's avatar
      Add a new primitive forkOn#, for forking a thread on a specific Capability · c520a3a2
      Simon Marlow authored
      This gives some control over affinity, while we figure out the best
      way to automatically schedule threads to make best use of the
      available parallelism.
      In addition to the primitive, there is also:
        GHC.Conc.forkOnIO :: Int -> IO () -> IO ThreadId
      where 'forkOnIO i m' creates a thread on Capability (i `rem` N), where
      N is the number of available Capabilities set by +RTS -N.
      Threads forked by forkOnIO do not automatically migrate when there are
      free Capabilities, like normal threads do.  Still, if you're using
      forkOnIO exclusively, it's a good idea to do +RTS -qm to disable work
      pushing anyway (work pushing takes too much time when the run queues
      are large, this is something we need to fix).
  19. 25 Nov, 2005 1 commit
  20. 25 Jul, 2005 1 commit
    • simonmar's avatar
      [project @ 2005-07-25 14:12:48 by simonmar] · e792bb84
      simonmar authored
      Remove the ForeignObj# type, and all its PrimOps.  The new efficient
      representation of ForeignPtr doesn't use ForeignObj# underneath, and
      there seems no need to keep it.
  21. 07 Mar, 2005 2 commits
  22. 04 Mar, 2005 1 commit
    • sof's avatar
      [project @ 2005-03-04 19:19:56 by sof] · 75d52d81
      sof authored
      Since MachDeps.h doesn't include ghcconfig.h, include it specifically here
      (for the benefit of mingw). That may not be the right file to use in the
      grander scheme of things tho.
      Merge to STABLE (or something equivalent; as-is STABLE doesn't build on mingw.)
  23. 31 Jan, 2005 1 commit
    • simonpj's avatar
      [project @ 2005-01-31 13:25:33 by simonpj] · f25b9225
      simonpj authored
      	Types and evaluated-ness in
      	  CoreTidy and CorePrep
      This commmit fixes two problems.
      1.  DataToTagOp requires its argument to be evaluated, otherwise it silently
          gives the wrong answer.  This was not happening because we had
      	case (tag2Enum x) of y -> ...(dataToTag y)...
          and the tag2Enum was being inlined (it's non-speculative), giving
      	...(dataToTag (tag2Enum x))...
          Rather than relying on a somewhat-delicate global invariant, CorePrep
          now establishes the invariant that DataToTagOp's argument is evaluated.
          It does so by putting up-to-date is-evaluated information into each
          binder's UnfoldingInfo; not a full unfolding, just the (OtherCon [])
          for evaluated binders.
          Then there's a special case for DataToTag where applications are dealt with.
          Finally, we make DataToTagOp strict, which it really is.
      2.  CoreTidy now does GADT refinement as it goes. This is important to ensure that
          each variable occurrence has informative type information, which in turn is
          essential to make exprType work (otherwise it can simply crash).
          [This happened in test gadt/tdpe]
          CorePrep has the same problem, but the solution is a little different:
          when looking up in the cloning environment, use the type at the occurrence
          site if we're inside a GADT.  It might be cleaner to use the same story as
          CoreTidy, but then we'd need to keep an in-scope set for type variables.
          No big deal either way.
  24. 18 Nov, 2004 1 commit
  25. 01 Oct, 2003 1 commit
    • wolfgang's avatar
      [project @ 2003-10-01 10:57:39 by wolfgang] · d3581a6a
      wolfgang authored
      New implementation & changed type signature of forkProcess
      forkProcess now has the following type:
      forkProcess :: IO () -> IO ProcessID
      forkProcessAll has been removed as it is unimplementable in the threaded RTS.
      forkProcess using the old type (IO (Maybe ProcessID)) was impossible to
      implement correctly in the non-threaded RTS and very hard to implement
      in the threaded RTS.
      The new type signature allows a clean and simple implementation.
  26. 21 Sep, 2003 1 commit
    • wolfgang's avatar
      [project @ 2003-09-21 22:20:51 by wolfgang] · 85aa72b9
      wolfgang authored
      Bound Threads
      Introduce a way to use foreign libraries that rely on thread local state
      from multiple threads (mainly affects the threaded RTS).
      See the file threads.tex in CVS at haskell-report/ffi/threads.tex
      (not entirely finished yet) for a definition of this extension. A less formal
      description is also found in the documentation of Control.Concurrent.
      The changes mostly affect the THREADED_RTS (./configure --enable-threaded-rts),
      except for saving & restoring errno on a per-TSO basis, which is also necessary
      for the non-threaded RTS (a bugfix).
      Detailed list of changes
      - errno is saved in the TSO object and restored when necessary:
      ghc/includes/TSO.h, ghc/rts/Interpreter.c, ghc/rts/Schedule.c
      - rts_mainLazyIO is no longer needed, main is no special case anymore
      ghc/includes/RtsAPI.h, ghc/rts/RtsAPI.c, ghc/rts/Main.c, ghc/rts/Weak.c
      - passCapability: a new function that releases the capability and "passes"
        it to a specific OS thread:
      ghc/rts/Capability.h ghc/rts/Capability.c
      - waitThread(), scheduleWaitThread() and schedule() get an optional
        Capability *initialCapability passed as an argument:
      ghc/includes/SchedAPI.h, ghc/rts/Schedule.c, ghc/rts/RtsAPI.c
      - Bound Thread scheduling (that's what this is all about):
      ghc/rts/Schedule.h, ghc/rts/Schedule.c
      - new Primop isCurrentThreadBound#:
      ghc/compiler/prelude/primops.txt.pp, ghc/includes/PrimOps.h, ghc/rts/PrimOps.hc,
      ghc/rts/Schedule.h, ghc/rts/Schedule.c
      - a simple function, rtsSupportsBoundThreads, that returns true if THREADED_RTS
        is defined:
      ghc/rts/Schedule.h, ghc/rts/Schedule.c
      - a new implementation of forkProcess (the old implementation stays in place
        for the non-threaded case). Partially broken; works for the standard
        fork-and-exec case, but not for much else. A proper forkProcess is
        really next to impossible to implement:
      - Library support for bound threads:
            rtsSupportsBoundThreads, isCurrentThreadBound, forkOS,
            runInBoundThread, runInUnboundThread
      libraries/base/Control/Concurrent.hs, libraries/base/Makefile,
      libraries/base/include/HsBase.h, libraries/base/cbits/forkOS.c (new file)
  27. 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.
  28. 19 Jun, 2003 1 commit
    • simonmar's avatar
      [project @ 2003-06-19 10:42:24 by simonmar] · d89872a4
      simonmar authored
      Add raiseIO# primop.
      This is part of ensuring that exceptions are *precise* in the IO monad
      (as opposed to imprecise exceptions in the pure world).  If we allow
      the strictness analyser to see the definition of throwIO:
        throwIO e = IO $ \s -> throw e
      then it might re-order evaluation in the IO monad, with the result
      that we get _|_ instead of an exception, or one kind of exception when
      we were expecting another.  We therefore must prevent the strictness
      analyser from doing these reorderings in the IO monad.  Hiding the
      definition of throwIO by making it a primop solves part of the problem
      (there's more to come).
      See SourceForge bug #752149.
  29. 24 Mar, 2003 1 commit
    • simonmar's avatar
      [project @ 2003-03-24 14:46:53 by simonmar] · b3f53081
      simonmar authored
      Fix some bugs in compacting GC.
      Bug 1: When threading the fields of an AP or PAP, we were grabbing the
      info table of the function without unthreading it first.
      Bug 2: eval_thunk_selector() might accidentally find itself in
      to-space when going through indirections in a compacted generation.
      We must check for this case and bale out if necessary.
      Bug 3: This is somewhat more nasty.  When we have an AP or PAP that
      points to a BCO, the layout info for the AP/PAP is in the BCO's
      instruction array, which is two objects deep from the AP/PAP itself.
      The trouble is, during compacting GC, we can only safely look one
      object deep from the current object, because pointers from objects any
      deeper might have been already updated to point to their final
      The solution is to put the arity and bitmap info for a BCO into the
      BCO object itself.  This means BCOs become variable-length, which is a
      slight annoyance, but it also means that looking up the arity/bitmap
      is quicker.  There is a slight reduction in complexity in the byte
      code generator due to not having to stuff the bitmap at the front of
      the instruction stream.
  30. 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.]
  31. 04 Feb, 2003 1 commit
    • simonpj's avatar
      [project @ 2003-02-04 12:40:00 by simonpj] · 74775c6b
      simonpj authored
      Make utils/genprimopcode recognise the type ().
          It was previously written 'Unit', which is easily
          confused with the type 'Unit' (used for generic
          derived instances).
  32. 11 Dec, 2002 1 commit
    • simonmar's avatar
      [project @ 2002-12-11 15:36:20 by simonmar] · 0bffc410
      simonmar authored
      Merge the eval-apply-branch on to the HEAD
      This is a change to GHC's evaluation model in order to ultimately make
      GHC more portable and to reduce complexity in some areas.
      At some point we'll update the commentary to describe the new state of
      the RTS.  Pending that, the highlights of this change are:
        - No more Su.  The Su register is gone, update frames are one
          word smaller.
        - Slow-entry points and arg checks are gone.  Unknown function calls
          are handled by automatically-generated RTS entry points (AutoApply.hc,
          generated by the program in utils/genapply).
        - The stack layout is stricter: there are no "pending arguments" on
          the stack any more, the stack is always strictly a sequence of
          stack frames.
          This means that there's no need for LOOKS_LIKE_GHC_INFO() or
          LOOKS_LIKE_STATIC_CLOSURE() any more, and GHC doesn't need to know
          how to find the boundary between the text and data segments (BIG WIN!).
        - A couple of nasty hacks in the mangler caused by the neet to
          identify closure ptrs vs. info tables have gone away.
        - Info tables are a bit more complicated.  See InfoTables.h for the
        - As a side effect, GHCi can now deal with polymorphic seq.  Some bugs
          in GHCi which affected primitives and unboxed tuples are now
        - Binary sizes are reduced by about 7% on x86.  Performance is roughly
          similar, some programs get faster while some get slower.  I've seen
          GHCi perform worse on some examples, but haven't investigated
          further yet (GHCi performance *should* be about the same or better
          in theory).
        - Internally the code generator is rather better organised.  I've moved
          info-table generation from the NCG into the main codeGen where it is
          shared with the C back-end; info tables are now emitted as arrays
          of words in both back-ends.  The NCG is one step closer to being able
          to support profiling.
      This has all been fairly thoroughly tested, but no doubt I've messed
      up the commit in some way.
  33. 18 Oct, 2002 1 commit
  34. 26 Jun, 2002 1 commit
    • stolz's avatar
      [project @ 2002-06-26 08:18:38 by stolz] · fbbed914
      stolz authored
      - Make TSO "stable" again: The thread label was changing the size of the
         TSO if you were building a debugging-RTS, leading to binary
         incompatibility. Now we map TSOs to strings using Hash.c.
      - API change for labelThread: Label arbitrary threads.
  35. 18 Jun, 2002 1 commit
    • simonpj's avatar
      [project @ 2002-06-18 13:58:22 by simonpj] · 80e39963
      simonpj authored
      	    Rehash the handling of SeqOp
      See the comments in the commentary (Cunning Prelude Code).
      * Expunge SeqOp altogether
      * Add GHC.Base.lazy :: a -> a
        to GHC.Base
      * Add GHC.Base.lazy
        to basicTypes/MkId.  The idea is that this defn will over-ride
        the info from GHC.Base.hi, thereby hiding strictness and
      * Make stranal/WorkWrap do a "manual inlining" for GHC.Base.lazy
        This happens nicely after the strictness analyser has run.
      * Expunge the SeqOp/ParOp magic in CorePrep
      * Expunge the RULE for seq in PrelRules
      * Change the defns of pseq/par in GHC.Conc to:
      	{-# INLINE pseq  #-}
             	pseq :: a -> b -> b
             	pseq  x y = x `seq` lazy y
             	{-# INLINE par  #-}
             	par :: a -> b -> b
             	par  x y = case (par# x) of { _ -> lazy y }
  36. 01 May, 2002 1 commit
  37. 10 Apr, 2002 1 commit
    • stolz's avatar
      [project @ 2002-04-10 11:43:43 by stolz] · c1f3fad1
      stolz authored
      Two new scheduler-API primops:
      1) GHC.Conc.forkProcess/forkProcess# :: IO Int
         This is a low-level call to fork() to replace Posix.forkProcess().
         In a Concurrent Haskell setting, only the thread invoking forkProcess()
         is alive in the child process. Other threads will be GC'ed!
            This brings the RTS closer to pthreads, where a call to fork()
         doesn't clone any pthreads, either.
            The result is 0 for the child and the child's pid for the parent.
         The primop will barf() when used on mingw32, sorry.
      2) GHC.Conc.labelThread/forkProcess# :: String -> IO ()
         Useful for scheduler debugging: If the RTS is compiled with DEBUGging
         support, this primitive assigns a name to the current thread which
         will be used in debugging output (+RTS -D1). For larger applications,
         simply numbering threads is not sufficient.
           Notice: The Haskell side of this call is always available, but if
         you are not compiling with debugging support, the actual primop will
         turn into a no-op.
  38. 27 Mar, 2002 1 commit