Unsafe operations for array uninitialization and raw arrays

[MatthewFluet]

Highlights:

• Rename Array_uninit primitive to Array_alloc (612eede)
• Add Array_uninit: 'a array * SeqInt.int -> unit primitive (946385f)
• Add Array_uninitIsNop: 'a array -> bool primitive (426baa1)
• Add Array_allocRaw: SeqIndex.int -> 'a array and Array_toArray: 'a array -> 'a array primitives (580da00)

All new primitives are implemented in toRssa.

The Array_uninit primitive sets all objptrs in the element at the given index to a bogus non-objptr value (0wx1). One motivation for this primitive is to support space-efficient polymorphic resizeable arrays. When shrinking a resizeable array, we would like to "NULL" out the elements that are no longer part of the logical array, in order to avoid a (logical) space leak.

The Array_uninitIsNop primitive answers if the Array_uninit primitive applied to the same array would be a nop (i.e., if the array has no objptrs in the elements). This can be used to skip a bulk-Array_uninit loop when it is known that the Array_uninit operations would be nops.

It would be possible to introduce (pre-toRssa) optimizations that simplified Array_uninitIsNop and Array_uninit when it is clear that the array will never have objptrs in the elements.

The Array_allocRaw primitive allocates an array, but with a header that indicates that the array has no objptrs. A related Array_toArray primitive updates the header of an Array_allocRaw primitive to reveal the objptrs. Between the allocation and the cast, all elements of the array must be uninitialized (setting all objptrs in elements to a bogus non-objptr value (0wx1)).

One motiviation for this primitive is that, in a parallel setting, the uninitialization of an array can be a sequential bottleneck. The Array_allocRaw is a constant time operation and the subsequent Array_uninit operations can be performed in parallel.

Note that it is not safe to write non-bogus objptrs into a raw array. Because the raw array's header indicates that the array has no objptrs, non-bogus objptrs written to the array will not be traced or updated during a garbage collection.

In the future, we may consider eliminating Array_alloc (the non-raw array allocation) and moving the uninitialization loop from the runtime to SML. To do so, though, we should ensure that arrays that do not need uninitialization are optimized early in the optimization pipeline.

The extended structure Unsafe.Array has the following signature:

    structure Unsafe.Array:
       sig
          (* omit Size check;
           * objptr(s) at elements set to bogus non-objptr value;
           * non-objptr(s) at elements have indeterminate value
           *)
          val alloc: int -> 'a array
          (* omit Size check;
           * elements set to initial value
           *)
          val create: int * 'a -> 'a array
          (* omit Subscript check *)
          val sub: 'a array * int -> 'a
          val uninitIsNop: 'a array -> bool
          (* omit Subscript check;
           * objptr(s) at element set to bogus non-objptr value
           *)
          val uninit: 'a array * int -> unit
          (* omit Subscript check *)
          val update: 'a array * int * 'a -> unit

          structure Raw:
             sig
                type 'a rawarr

                (* omit Size check;
                 * objptr(s) at elements have indeterminate value;
                 * non-objptr(s) at elements have indeterminate value
                 *)
                val alloc: int -> 'a rawarr
                (* prereq: all objptr(s) at elements set to bogus
                 * non-objptr value (via uninit)
                 *)
                val toArray: 'a rawarr -> 'a array
                val uninitIsNop: 'a rawarr -> bool
                (* omit Subscript check;
                 * objptr(s) at element set to bogus non-objptr value
                 *)
                val uninit: 'a rawarr * int -> unit
             end
       end

@mikerainey