[stdlib] Move ManagedBuffer prototype into stdlib

...in preparation to use it in _[Contiguous]ArrayBuffer

Swift SVN r22440

Author: Dave Abrahams

stdlib/core/CMakeLists.txt

@@ -56,6 +56,7 @@ set(SWIFTLIB_ESSENTIAL
   LazyCollection.swift.gyb
   LazySequence.swift
   LifetimeManager.swift
+  ManagedBuffer.swift
   Map.swift.gyb
   Mirrors.swift.gyb
   Misc.swift

test/Prototypes/HeapStorage.swift stdlib/core/ManagedBuffer.swift

@@ -1,4 +1,4 @@
-//===--- HeapStorage.swift - Replacement for HeapBuffer -------------------===//
+//===--- ManagedBuffer.swift - variable-sized buffer of aligned memory ---===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -9,39 +9,12 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-//
-//  
-//
-//===----------------------------------------------------------------------===//
-// RUN: %target-build-swift -parse-stdlib -Xfrontend -disable-access-control %s -o %t.out
-// RUN: %target-run %t.out
 
-import Swift
-import Darwin
 import SwiftShims
-import StdlibUnittest
-
-typealias _HeapObject = SwiftShims.HeapObject
-
-// This is already in the standard library
-func _roundUpToAlignment(offset: Int, alignment: Int) -> Int {
-  _sanityCheck(offset >= 0)
-  _sanityCheck(alignment > 0)
-  // Note, given that offset is >= 0, and alignment > 0, we don't
-  // need to underflow check the -1, as it can never underflow.
-  let x = (offset + alignment &- 1)
-  // Note, as alignment is a power of 2, we'll use masking to efficiently
-  // get the aligned value
-  return x & ~(alignment &- 1)
-}
 
-@asmname("swift_bufferAllocate")
-func _swift_bufferAllocate(
-  bufferType: AnyClass, size: Int, alignMask: Int) -> AnyObject
-
-/// A class containing a property of type `Value` and
-/// raw storage for an array of `Element` whose size is
-/// determined at create time.
+/// A class whose instances contain a property of type `Value` and raw
+/// storage for an array of `Element`, whose size is determined at
+/// instance creation.
 ///
 /// Note that the `Element` array is suitably-aligned **raw memory**.
 /// You are expected to construct and---if necessary---destroy objects
@@ -50,23 +23,23 @@ func _swift_bufferAllocate(
 /// any live elements in the `deinit` of a subclass.  Note: subclasses
 /// must not have any stored properties; any storage needed should be
 /// included in `Value`.
-public class HeapStorage<Value, Element> {
+public class ManagedBuffer<Value, Element> {
 
   /// Create a new instance of the most-derived class, calling
   /// `initialize` on the partially-constructed object to generate an
   /// initial `Value`.  Note, in particular, accessing `value` inside
   /// the `initialize` function is undefined.
   public final class func create(
-    minimumCapacity: Int, initialize: (HeapStorage)->Value
-  ) -> HeapStorage {
+    minimumCapacity: Int, initialize: (ManagedBuffer)->Value
+  ) -> ManagedBuffer {
     _precondition(
       minimumCapacity >= 0,
-      "HeapStorage must have non-negative capacity")
+      "ManagedBuffer must have non-negative capacity")
 
-    let totalSize = HeapStorage._elementOffset
+    let totalSize = ManagedBuffer._elementOffset
       +  minimumCapacity * strideof(Element.self)
 
-    let alignMask = HeapStorage._alignmentMask
+    let alignMask = ManagedBuffer._alignmentMask
 
     let result = self._allocate(totalSize, alignMask: alignMask)
 
@@ -79,7 +52,7 @@ public class HeapStorage<Value, Element> {
   // helper function for create, above
   internal final class func _allocate(
     totalSize: Int, alignMask: Int
-  ) -> HeapStorage {
+  ) -> ManagedBuffer {
     return unsafeDowncast(
         _swift_bufferAllocate(self, totalSize, alignMask)
       )
@@ -119,9 +92,9 @@ public class HeapStorage<Value, Element> {
   /// The actual number of elements allocated for this object.  May be
   /// nontrivial to compute; it may be a good idea to store this
   /// information in the value area upon creation.
-  internal final var _allocatedElementCount : Int {
+  public final var allocatedElementCount : Int {
     return (
-      _allocatedByteCount &- HeapStorage._elementOffset &+ sizeof(Element) &- 1
+      _allocatedByteCount &- ManagedBuffer._elementOffset &+ sizeof(Element) &- 1
     ) &/ sizeof(Element)
   }
 
@@ -159,8 +132,8 @@ public class HeapStorage<Value, Element> {
     body: (_: UnsafeMutablePointer<Value>, _: UnsafeMutablePointer<Element>)->R
   ) -> R {
     let result = body(
-      UnsafeMutablePointer(_address + HeapStorage._valueOffset),
-      UnsafeMutablePointer(_address + HeapStorage._elementOffset)
+      UnsafeMutablePointer(_address + ManagedBuffer._valueOffset),
+      UnsafeMutablePointer(_address + ManagedBuffer._elementOffset)
     )
     _fixLifetime(self)
     return result
@@ -186,97 +159,6 @@ public class HeapStorage<Value, Element> {
   /// allocated size.  Probably completely unused per
   /// <rdar://problem/18156440>
   internal final func __getInstanceSizeAndAlignMask() -> (Int,Int) {
-    return (_allocatedByteCount, HeapStorage._alignmentMask)
+    return (_allocatedByteCount, ManagedBuffer._alignmentMask)
   }
 }
-
-//===----------------------------------------------------------------------===//
-//===--- Testing code -----------------------------------------------------===//
-//===----------------------------------------------------------------------===//
-
-struct CountAndCapacity {
-  var count: LifetimeTracked
-  let capacity: Int = 0
-}
-
-// An example of HeapStorage, very similar to what Array will use.
-// However, only half of the element storage is actually used to store
-// elements, as a simple way of catching potential bugs.
-final class TestHeapStorage<T> : HeapStorage<CountAndCapacity,T> {
-  class func create(capacity: Int) -> TestHeapStorage {
-    let r = self.create(capacity) {
-      CountAndCapacity(
-        count: LifetimeTracked(0), capacity: $0._allocatedElementCount)
-    }
-    return r as TestHeapStorage
-  }
-
-  var count: Int {
-    get {
-      return value.count.value
-    }
-    set {
-      value.count = LifetimeTracked(newValue)
-    }
-  }
-  
-  var capacity: Int {
-    return value.capacity
-  }
-  
-  deinit {
-    teardown()
-  }
-
-  // This doesn't seem to compile properly when embedded directly in
-  // deinit.
-  func teardown() {
-    let count = self.count
-    
-    withUnsafeMutablePointerToElements {
-      (x: UnsafeMutablePointer<T>)->() in
-      for i in stride(from: 0, to: count, by: 2) {
-        (x + i).destroy()
-      }
-    }
-  }
-  
-  func append(x: T) {
-    let count = self.count
-    precondition(count + 2 <= capacity)
-    
-    withUnsafeMutablePointerToElements {
-      (p: UnsafeMutablePointer<T>)->() in
-      (p + count).initialize(x)
-    }
-    self.count = count + 2
-  }
-}
-
-var tests = TestSuite("HeapStorage")
-
-tests.test("basic") {
-  expectEqual(0, LifetimeTracked.instances)
-  if true {
-    let s = TestHeapStorage<LifetimeTracked>.create(0)
-    expectEqual(1, LifetimeTracked.instances)
-  }
-  
-  expectEqual(0, LifetimeTracked.instances)
-  if true {
-    let s = TestHeapStorage<LifetimeTracked>.create(10)
-    expectEqual(0, s.count)
-    expectLE(10, s.capacity)
-    expectGE(12, s.capacity)  // allow some over-allocation but not too much
-    
-    expectEqual(1, LifetimeTracked.instances)
-    for i in 1..<6 {
-      s.append(LifetimeTracked(i))
-      expectEqual(i + 1, LifetimeTracked.instances)
-      expectEqual(i * 2, s.count)
-    }
-  }
-  expectEqual(0, LifetimeTracked.instances)
-}
-
-runAllTests()

test/stdlib/ManagedBuffer.swift

@@ -0,0 +1,102 @@
+//===--- ManagedBuffer.swift ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+// RUN: %target-run-simple-swift
+
+import StdlibUnittest
+
+struct CountAndCapacity {
+  var count: LifetimeTracked
+  let capacity: Int = 0
+}
+
+// An example of ManagedBuffer, very similar to what Array will use.
+// However, only half of the element storage is actually used to store
+// elements, interleaved with garbage, as a simple way of catching
+// potential bugs.
+final class TestManagedBuffer<T> : ManagedBuffer<CountAndCapacity,T> {
+  class func create(capacity: Int) -> TestManagedBuffer {
+    let r = super.create(capacity) {
+      CountAndCapacity(
+        count: LifetimeTracked(0), capacity: $0.allocatedElementCount)
+    }
+    return r as TestManagedBuffer
+  }
+
+  var count: Int {
+    get {
+      return value.count.value
+    }
+    set {
+      value.count = LifetimeTracked(newValue)
+    }
+  }
+  
+  var capacity: Int {
+    return value.capacity
+  }
+  
+  deinit {
+    teardown()
+  }
+
+  // This doesn't seem to compile properly when embedded directly in
+  // deinit.
+  func teardown() {
+    let count = self.count
+    
+    withUnsafeMutablePointerToElements {
+      (x: UnsafeMutablePointer<T>)->() in
+      for i in stride(from: 0, to: count, by: 2) {
+        (x + i).destroy()
+      }
+    }
+  }
+  
+  func append(x: T) {
+    let count = self.count
+    precondition(count + 2 <= capacity)
+    
+    withUnsafeMutablePointerToElements {
+      (p: UnsafeMutablePointer<T>)->() in
+      (p + count).initialize(x)
+    }
+    self.count = count + 2
+  }
+}
+
+var tests = TestSuite("ManagedBuffer")
+
+tests.test("basic") {
+  expectEqual(0, LifetimeTracked.instances)
+  if true {
+    let s = TestManagedBuffer<LifetimeTracked>.create(0)
+    expectEqual(1, LifetimeTracked.instances)
+  }
+  
+  expectEqual(0, LifetimeTracked.instances)
+  if true {
+    let s = TestManagedBuffer<LifetimeTracked>.create(10)
+    expectEqual(0, s.count)
+    expectLE(10, s.capacity)
+    expectGE(12, s.capacity)  // allow some over-allocation but not too much
+    
+    expectEqual(1, LifetimeTracked.instances)
+    for i in 1..<6 {
+      s.append(LifetimeTracked(i))
+      expectEqual(i + 1, LifetimeTracked.instances)
+      expectEqual(i * 2, s.count)
+    }
+  }
+  expectEqual(0, LifetimeTracked.instances)
+}
+
+runAllTests()