---

yaml
---
r: 348667
b: refs/heads/master
c: d30d333
h: refs/heads/master
i:
  348665: ad64827
  348663: a8ee905

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 170a84c5bdc2322395c8746b70c34ffeb16c021d
+refs/heads/master: d30d3334dbc87aeadbf88be929ad187fc7be76d7
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/stdlib/private/OSLog/OSLog.swift

@@ -73,15 +73,18 @@ internal func osLog(
 
   let arguments = message.interpolation.arguments
 
-  // Ideally, we could stack allocate the buffer as it is local to this
-  // function and also its size is a compile-time constant.
-  let bufferMemory =
-    UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
-  var builder = OSLogByteBufferBuilder(bufferMemory)
+  // Allocate a byte buffer to store the arguments. The buffer could be stack
+  // allocated as it is local to this function and also its size is a
+  // compile-time constant.
+  let bufferMemory = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+  // Array of references to auxiliary storage created during serialization of
+  // strings. This array can be stack allocated.
+  var stringStorageObjects: [AnyObject] = []
 
-  builder.serialize(preamble)
-  builder.serialize(argumentCount)
-  arguments.serialize(into: &builder)
+  var currentBufferPosition = bufferMemory
+  serialize(preamble, at: &currentBufferPosition)
+  serialize(argumentCount, at: &currentBufferPosition)
+  arguments.serializeAt(&currentBufferPosition, using: &stringStorageObjects)
 
   ___os_log_impl(UnsafeMutableRawPointer(mutating: #dsohandle),
                  logObject,
@@ -90,7 +93,9 @@ internal func osLog(
                  bufferMemory,
                  UInt32(bufferSize))
 
-  builder.destroy()
+  // The following operation extends the lifetime of stringStorageObjects
+  // and also of the objects stored in it till this point.
+  stringStorageObjects.removeAll()
   bufferMemory.deallocate()
 }
 
@@ -118,15 +123,19 @@ func _checkFormatStringAndBuffer(
 
   // Code that will execute at runtime.
   let bufferMemory = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
-  var builder = OSLogByteBufferBuilder(bufferMemory)
+  var stringStorageObjects: [AnyObject] = []
 
-  builder.serialize(preamble)
-  builder.serialize(argumentCount)
-  message.interpolation.arguments.serialize(into: &builder)
+  var currentBufferPosition = bufferMemory
+  serialize(preamble, at: &currentBufferPosition)
+  serialize(argumentCount, at: &currentBufferPosition)
+  message.interpolation.arguments.serializeAt(
+    &currentBufferPosition,
+    using: &stringStorageObjects)
 
   assertion(
     formatString,
     UnsafeBufferPointer(start: UnsafePointer(bufferMemory), count: bufferSize))
 
+  stringStorageObjects.removeAll()
   bufferMemory.deallocate()
 }

trunk/stdlib/private/OSLog/OSLogIntegerTypes.swift

@@ -143,7 +143,9 @@ extension OSLogArguments {
   internal mutating func append<T>(
     _ value: @escaping () -> T
   ) where T: FixedWidthInteger {
-    argumentClosures!.append({ $0.serialize(value()) })
+    argumentClosures.append({ (position, _) in
+      serialize(value(), at: &position)
+    })
   }
 }
 
@@ -159,15 +161,17 @@ internal func sizeForEncoding<T>(
   return type.bitWidth &>> logBitsPerByte
 }
 
-extension OSLogByteBufferBuilder {
-  /// Serialize an integer at the buffer location pointed to by `position`.
-  @usableFromInline
-  internal mutating func serialize<T>(
-    _ value: T
-  ) where T : FixedWidthInteger {
-    let byteCount = sizeForEncoding(T.self)
-    let dest = UnsafeMutableRawBufferPointer(start: position, count: byteCount)
-    withUnsafeBytes(of: value) { dest.copyMemory(from: $0) }
-    position += byteCount
-  }
+/// Serialize an integer at the buffer location that `position` points to and
+/// increment `position` by the byte size of `T`.
+@usableFromInline
+@_alwaysEmitIntoClient
+internal func serialize<T>(
+  _ value: T,
+  at bufferPosition: inout ByteBufferPointer
+) where T : FixedWidthInteger {
+  let byteCount = sizeForEncoding(T.self)
+  let dest =
+    UnsafeMutableRawBufferPointer(start: bufferPosition, count: byteCount)
+  withUnsafeBytes(of: value) { dest.copyMemory(from: $0) }
+  bufferPosition += byteCount
 }

trunk/stdlib/private/OSLog/OSLogMessage.swift

@@ -320,6 +320,8 @@ public struct OSLogMessage :
   }
 }
 
+public typealias ByteBufferPointer = UnsafeMutablePointer<UInt8>
+public typealias StorageObjects = [AnyObject]
 
 /// A representation of a sequence of arguments and headers (of possibly
 /// different types) that have to be serialized to a byte buffer. The arguments
@@ -330,73 +332,64 @@ public struct OSLogMessage :
 @usableFromInline
 internal struct OSLogArguments {
   /// An array of closures that captures arguments of possibly different types.
+  /// Each closure accepts a pointer into a byte buffer and serializes the
+  /// captured arguments at the pointed location. The closures also accept an
+  /// array of AnyObject to store references to auxiliary storage created during
+  /// serialization.
   @usableFromInline
-  internal var argumentClosures: [(inout OSLogByteBufferBuilder) -> ()]?
+  internal var argumentClosures: [(inout ByteBufferPointer,
+    inout StorageObjects) -> ()]
 
   /// This function must be constant evaluable.
   @inlinable
   @_semantics("constant_evaluable")
   @_optimize(none)
   internal init() {
-    argumentClosures = nil
+    argumentClosures = []
   }
 
   @usableFromInline
   internal init(capacity: Int) {
     argumentClosures = []
-    argumentClosures!.reserveCapacity(capacity)
+    argumentClosures.reserveCapacity(capacity)
   }
 
   /// Append a byte-sized header, constructed by
   /// `OSLogMessage.appendInterpolation`, to the tracked array of closures.
   @usableFromInline
   internal mutating func append(_ header: UInt8) {
-    argumentClosures!.append({ $0.serialize(header) })
+    argumentClosures.append({ (position, _) in
+      serialize(header, at: &position)
+    })
   }
 
   /// `append` for other types must be implemented by extensions.
 
+  /// Serialize the arguments tracked by self in a byte buffer.
+  /// - Parameters:
+  ///   - bufferPosition: the pointer to a location within a byte buffer where
+  ///   the argument must be serialized. This will be incremented by the number
+  ///   of bytes used up to serialize the arguments.
+  ///   - storageObjects: An array to store references to objects representing
+  ///   auxiliary storage created during serialization. This is only used while
+  ///   serializing strings.
   @usableFromInline
-  internal func serialize(into bufferBuilder: inout OSLogByteBufferBuilder) {
-    argumentClosures?.forEach { $0(&bufferBuilder) }
+  internal func serializeAt(
+    _ bufferPosition: inout ByteBufferPointer,
+    using storageObjects: inout StorageObjects
+  ) {
+    argumentClosures.forEach { $0(&bufferPosition, &storageObjects) }
   }
 }
 
-/// A struct that manages serialization of instances of specific types to a
-/// byte buffer. The byte buffer is provided as an argument to the initializer
-/// so that its lifetime can be managed by the caller.
+/// Serialize a UInt8 value at the buffer location pointed to by `bufferPosition`,
+/// and increment the `bufferPosition` with the byte size of the serialized value.
 @usableFromInline
-internal struct OSLogByteBufferBuilder {
-  internal var position: UnsafeMutablePointer<UInt8>
-
-  /// Objects denoting storage created by the serialize methods. Such storage
-  /// is created while serializing strings as os_log requires stable pointers to
-  /// Swift strings, which may require copying them to a in-memory buffer.
-  /// The lifetime of this auxiliary storage is same as the lifetime of `self`.
-  internal var auxiliaryStorage: [AnyObject]
-
-  /// Initializer that accepts a pointer to a preexisting buffer.
-  /// - Parameter bufferStart: the starting pointer to a byte buffer
-  ///   that must contain the serialized bytes.
-  @usableFromInline
-  internal init(_ bufferStart: UnsafeMutablePointer<UInt8>) {
-    position = bufferStart
-    auxiliaryStorage = []
-  }
-
-  /// Serialize a UInt8 value at the buffer location pointed to by `position`.
-  @usableFromInline
-  internal mutating func serialize(_ value: UInt8) {
-    position[0] = value
-    position += 1
-  }
-
-  /// `serialize` for other other types must be implemented by extensions.
-
-  /// This function exists so that clients can control the lifetime of a stack-
-  /// allocated instance of OSLogByteBufferBuilder.
-  @usableFromInline
-  internal mutating func destroy() {
-    auxiliaryStorage = []
-  }
+@_alwaysEmitIntoClient
+internal func serialize(
+  _ value: UInt8,
+  at bufferPosition: inout ByteBufferPointer)
+{
+  bufferPosition[0] = value
+  bufferPosition += 1
 }

trunk/stdlib/private/OSLog/OSLogStringTypes.swift

@@ -89,7 +89,7 @@ extension OSLogArguments {
   /// by this instance.
   @usableFromInline
   internal mutating func append(_ value: @escaping () -> String) {
-    argumentClosures!.append({ $0.serialize(value()) })
+    argumentClosures.append({ serialize(value(), at: &$0, using: &$1) })
   }
 }
 
@@ -107,24 +107,28 @@ internal func sizeForEncoding() -> Int {
   return Int.bitWidth &>> logBitsPerByte
 }
 
-extension OSLogByteBufferBuilder {
-  /// Serialize a string at the buffer location pointed to by `position`. 
-  /// Record any auxiliary storage created for getting a stable pointer to the
-  /// parameter string in the `self.auxiliaryStorage` property, so that the
-  /// storage is alive for the lifetime of `self`.
-  @usableFromInline
-  internal mutating func serialize(_ stringValue: String) {
-    let (optionalStorage, bytePointer): (AnyObject?, UnsafeRawPointer) =
-      _convertConstStringToUTF8PointerArgument(
-        stringValue)
-
-    if let storage = optionalStorage {
-      auxiliaryStorage.append(storage)
-    }
+/// Serialize a stable pointer to the string `stringValue` at the buffer location
+/// pointed by `bufferPosition`. When necessary, this function would copy the
+/// string contents to a storage with a stable pointer. If that happens, a reference
+/// to the storage will be added to `storageObjects`.
+@usableFromInline
+@_alwaysEmitIntoClient
+internal func serialize(
+  _ stringValue: String,
+  at bufferPosition: inout ByteBufferPointer,
+  using storageObjects: inout StorageObjects
+) {
+  let (optionalStorage, bytePointer): (AnyObject?, UnsafeRawPointer) =
+    _convertConstStringToUTF8PointerArgument(
+      stringValue)
 
-    let byteCount = sizeForEncoding()
-    let dest = UnsafeMutableRawBufferPointer(start: position, count: byteCount)
-    withUnsafeBytes(of: bytePointer) { dest.copyMemory(from: $0) }
-    position += byteCount
+  if let storage = optionalStorage {
+    storageObjects.append(storage)
   }
+
+  let byteCount = sizeForEncoding()
+  let dest =
+    UnsafeMutableRawBufferPointer(start: bufferPosition, count: byteCount)
+  withUnsafeBytes(of: bytePointer) { dest.copyMemory(from: $0) }
+  bufferPosition += byteCount
 }