Expose transferable constructor to Int8List

runtime/vm/os.h

Index: runtime/vm/os.h
diff --git a/runtime/vm/os.h b/runtime/vm/os.h
index e33b274f7122fd2ec583676464fc8dcba59b8368..d7d293acafc92b66b95574712fdd53dd3e5bda75 100644
--- a/runtime/vm/os.h
+++ b/runtime/vm/os.h
@@ -40,6 +40,22 @@ class OS {
   // from midnight January 1, 1970 UTC.
   static int64_t GetCurrentTimeMicros();
 
+  // Returns an aligned array of type T with n entries.
+  // Alignment must be >= 16 and a power of two.
+  template<typename T>
+  static T* AllocateAlignedArray(intptr_t n, intptr_t alignment) {
+    T* result = reinterpret_cast<T*>(OS::AlignedAllocate(n * sizeof(*result),
+                                                         alignment));
+    return result;
+  }

[siva, 2012/11/30 22:15:53]

This function here looks pretty ugly and is not strictly
an OS api.

I would move it out from here to byte_array.cc as a static
function in that file.

[cshapiro, 2012/11/30 22:18:11]

It was my idea to stuff this in here.  I would have preferred the template
interface be the only interface to allocating.  I suppose we could make the
aligned stuff below private and have this be the interface.  (Otherwise, you
have to cast all over the place.)

[siva, 2012/11/30 22:33:21]

The only use of this currently seems to be in byte_array.cc

why not wait for more use cases before deciding which way to go.

It would be nice if the API was similar to malloc (we have code which
does cast the result of malloc based on the type).

On 2012/11/30 22:18:11, cshapiro wrote:

[Cutch, 2012/11/30 22:34:27]

This is how the code was originally structured. The ArrayAllocation method was
private to byte_array.cc
On 2012/11/30 22:33:21, siva wrote:

[cshapiro, 2012/11/30 22:35:53]

We also have code that uses new and delete which handles types in a less clumsy
fashion than malloc.  That is used in places where memory that is truly an array
is allocated.

The interface we have is close to memalign (which provides the additional
alignment parameter not present in malloc).

+
+  // Returns an aligned pointer in the C heap with room for size bytes.
+  // Alignment must be >= 16 and a power of two.
+  static void* AlignedAllocate(intptr_t size, intptr_t alignment);
+
+  // Frees a pointer returned from AlignedAllocate.
+  static void AlignedFree(void* ptr);
+
   // Returns the activation frame alignment constraint or zero if
   // the platform doesn't care. Guaranteed to be a power of two.
   static word ActivationFrameAlignment();