Expose transferable constructor to Int8List

runtime/vm/os.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OS_H_
 #define VM_OS_H_
 
 #include "vm/globals.h"
 
 // Forward declarations.
@@ skipping 22 matching lines @@
   static int GetLocalTimeZoneAdjustmentInSeconds();
 
   // Returns the current time in milliseconds measured
   // from midnight January 1, 1970 UTC.
   static int64_t GetCurrentTimeMillis();
 
   // Returns the current time in microseconds measured
   // 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();
 
   // This constant is guaranteed to be greater or equal to the
   // preferred code alignment on all platforms.
   static const int kMaxPreferredCodeAlignment = 32;
 
   // Returns the preferred code alignment or zero if
   // the platform doesn't care. Guaranteed to be a power of two.
@@ skipping 49 matching lines @@
   static void Shutdown();
 
   static void Abort();
 
   static void Exit(int code);
 };
 
 }  // namespace dart
 
 #endif  // VM_OS_H_