Skip to content
Snippets Groups Projects
  1. Jun 08, 2024
    • Reinier Maas's avatar
      Fix: `SpinLock` not defined · 690e32cc
      Reinier Maas authored
      690e32cc
    • Reinier Maas's avatar
    • Reinier Maas's avatar
      27fd4579
    • davide's avatar
      23a3496a
    • Duncan Coutts's avatar
    • Duncan Coutts's avatar
      Add Note [Byte arrays outside of the HEAP_ALLOCED space] · aeb437ae
      Duncan Coutts authored
      And refer to it from the various places involved in the scheme.
      aeb437ae
    • Duncan Coutts's avatar
      15cd45a0
    • Duncan Coutts's avatar
      Update user guide for byte arrays outside of the heap · d37adba1
      Duncan Coutts authored
      Add a sub-subsection in the chapter on GHC extensions to the FFI, under
      the existing Memory Allocation subsection.
      
      Explain that it's permitted to have {Mutable}ByteArray# outside the heap
      and the tricky associated constraints. Mention the new primop
      placeByteArray#.
      d37adba1
    • Duncan Coutts's avatar
      Add test T17747 · 72433621
      Duncan Coutts authored
      Closes issue #17747
      
      Test that we can allocate ByteArray#s outside of the HEAP_ALLOCED()
      address space without upsetting the GC. To be extra sure we attach weak
      pointers with C finalizers to the ByteArray#s. We keep them alive and
      run a major GC so that the GC has to trace the live ByteArray#s.
      
      Prior to the first patch in this series, doing this would upset the GC
      because the GC does not expect heap objects with closure type ARR_WORDS
      to exist outside the GC heap.
      
      > internal error: evacuate(static): strange closure type 42
      
      Finally we allow everything to be GC'd again, and check that the C
      finalizers did run.
      
      This feature also required a change to the isByteArrayPinned# which
      itself required a CMM implementation of the HEAP_ALLOCED system. So we
      also add a check that the CMM and C implementations of HEAP_ALLOCED
      agree with each other.
      72433621
    • Duncan Coutts's avatar
      Fix isByteArrayPinned# for the !HEAP_ALLOCATED case · 5118d563
      Duncan Coutts authored
      The isByteArrayPinned# primop works by looking up the block descriptor
      for the byte array to see if it lives in a pinned area or not. This of
      course cannot work for byte arrays that are not HEAP_ALLOCATED since
      they don't have block descriptors.
      
      The solution is to check if it is HEAP_ALLOCATED first. Since this is
      done in CMM code we make use of the new HEAP_ALLOCATED support for CMM.
      It is a bit awkward since it does not have a uniform interface.
      5118d563
    • Duncan Coutts's avatar
      Define HEAP_ALLOCED for CMM code · 9096dd40
      Duncan Coutts authored
      Allow rts/sm/HeapAlloc.h to be #included by CMM code and have it provide
      a suitable implementation of HEAP_ALLOCED.
      
      The HEAP_ALLOCED system has three implementations, the large address
      space case, two fallbakc impls, one for 32bit and one for 64bit. The
      first two are simple enough that we can provide a HEAP_ALLOCED macro
      that can be used in a CMM expression context.
      
      The 64bit fallback case is rather more tricky. We provide a different
      interface to HEAP_ALLOCED for this case, which has to be called in a
      statement/"callish" style.
      9096dd40
    • Duncan Coutts's avatar
      Add new primop placeByteArray# · 2d5d85ce
      Duncan Coutts authored
      It places a byte array heap object header at the given address, which
      must be outside the heap. It also sets the byte array size.
      2d5d85ce
    • Duncan Coutts's avatar
      Permit ARR_WORDS closures outside HEAP_ALLOCED space · 70838940
      Duncan Coutts authored
      In the GC, evacuate() is prepared to deal with some heap objects that
      are not in the HEAP_ALLOCED() memory space. These are mainly the heap
      objects that GHC puts into the data sections of object files.
      
      It is also useful however to allow ByteArray# and MutableByteArray#
      heap objects to appear outside of the HEAP_ALLOCED() memory space. These
      have the ARR_WORDS closure type and contain no pointer should be easy to
      deal with. Indeed evacuate() already deals with closure types for
      constructors containing no pointers by doing nothing.
      
      So we just tack the ARR_WORDS case into this group of closure types that
      are permitted outside the HEAP_ALLOCED area but otherwise ignored.
      70838940
  2. Jun 07, 2024
  3. Jun 06, 2024
  4. Jun 05, 2024
  5. Jun 04, 2024
Loading