[Concurrency] TaskLocals allow configuring inheritance: never

Author: ktoso

include/swift/ABI/Task.h

@@ -241,6 +241,12 @@ class AsyncTask : public HeapObject, public Job {
       IsParent   = 0b11
     };
 
+    /// Values must match `TaskLocalInheritance` declared in `TaskLocal.swift`.
+    enum class TaskLocalInheritance : uint8_t {
+      Default = 0,
+      Never   = 1
+    };
+
     class TaskLocalItem {
     private:
       /// Mask used for the low status bits in a task local chain item.
@@ -325,7 +331,6 @@ class AsyncTask : public HeapObject, public Job {
         size_t amountToAllocate = TaskLocalItem::itemSize(valueType);
         // assert(amountToAllocate % MaximumAlignment == 0); // TODO: do we need this?
         void *allocation = malloc(amountToAllocate); // TODO: use task-local allocator
-        fprintf(stderr, "MALLOC link item: %d\n", allocation);
         TaskLocalItem *item =
             new(allocation) TaskLocalItem(keyType, valueType);
 
@@ -430,7 +435,7 @@ class AsyncTask : public HeapObject, public Job {
 
     void popValue(AsyncTask *task);
 
-    OpaqueValue* get(const Metadata *keyType);
+    OpaqueValue* get(const Metadata *keType, TaskLocalInheritance inheritance);
   };
 
   TaskLocalValuesFragment *localValuesFragment() {
@@ -444,8 +449,9 @@ class AsyncTask : public HeapObject, public Job {
     return reinterpret_cast<TaskLocalValuesFragment*>(offset);
   }
 
-  OpaqueValue* localValueGet(const Metadata *keyType) {
-    return localValuesFragment()->get(keyType);
+  OpaqueValue* localValueGet(const Metadata *keyType,
+                    TaskLocalValuesFragment::TaskLocalInheritance inheritance) {
+    return localValuesFragment()->get(keyType, inheritance);
   }
 
   // ==== TaskGroup ------------------------------------------------------------

include/swift/Runtime/Concurrency.h

@@ -18,7 +18,6 @@
 #define SWIFT_RUNTIME_CONCURRENCY_H
 
 #include "swift/ABI/TaskStatus.h"
-#include "swift/Runtime/ExistentialContainer.h"
 
 namespace swift {
 class DefaultActor;
@@ -226,17 +225,21 @@ size_t swift_task_getJobFlags(AsyncTask* task);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_task_isCancelled(AsyncTask* task);
 
+using TaskLocalValuesFragment = AsyncTask::TaskLocalValuesFragment;
+
 /// Get a task local value from the passed in task. Its Swift signature is
 ///
 /// \code
 /// func _taskLocalValueGet<Key>(
 ///   _ task: Builtin.NativeObject,
-///   keyType: Any.Type /*Key.Type*/
+///   keyType: Any.Type /*Key.Type*/,
+///   inheritance: UInt8/*TaskLocalInheritance*/
 /// ) -> UnsafeMutableRawPointer? where Key: TaskLocalKey
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 OpaqueValue* swift_task_localValueGet(AsyncTask* task,
-                                 const Metadata *keyType);
+                                      const Metadata *keyType,
+                     TaskLocalValuesFragment::TaskLocalInheritance inheritance);
 
 /// Add a task local value to the passed in task.
 ///

stdlib/public/Concurrency/Task.cpp

@@ -32,6 +32,8 @@
 using namespace swift;
 using FutureFragment = AsyncTask::FutureFragment;
 using GroupFragment = AsyncTask::GroupFragment;
+using TaskLocalValuesFragment = AsyncTask::TaskLocalValuesFragment;
+using TaskLocalInheritance = AsyncTask::TaskLocalValuesFragment::TaskLocalInheritance;
 
 void FutureFragment::destroy() {
   auto queueHead = waitQueue.load(std::memory_order_acquire);
@@ -237,8 +239,6 @@ AsyncTaskAndContext swift::swift_task_create_future_f(
   }
 
   headerSize += sizeof(AsyncTask::TaskLocalValuesFragment);
-  fprintf(stderr, "error: %s [%s:%d] adding values fragment size=%d\n", __FUNCTION__, __FILE_NAME__, __LINE__,
-      sizeof(AsyncTask::TaskLocalValuesFragment));
 
   if (flags.task_isTaskGroup()) {
     headerSize += sizeof(AsyncTask::GroupFragment);
@@ -311,13 +311,9 @@ AsyncTaskAndContext swift::swift_task_create_future_f(
   initialContext->Flags.setShouldNotDeallocateInCallee(true);
 
   // Initialize the task-local allocator.
-  // TODO: consider providing an initial pre-allocated first slab to the
-  //       allocator.
+  // TODO: consider providing an initial pre-allocated first slab to the allocator.
   _swift_task_alloc_initialize(task);
 
-  fprintf(stderr, "error: %s [%s:%d] prepared task=%d\n", __FUNCTION__, __FILE_NAME__, __LINE__,
-          task);
-
   return {task, initialContext};
 }
 
@@ -499,28 +495,21 @@ size_t swift::swift_task_getJobFlags(AsyncTask *task) {
   return task->Flags.getOpaqueValue();
 }
 
-void swift::swift_task_local_value_push(AsyncTask *task,
-                       const Metadata *keyType,
-                       /* +1 */ OpaqueValue *value, const Metadata *valueType) {
-  fprintf(stderr, "error: %s [%s:%d] PUSH keyType=%d value=%d *value=%d\n",
-          __FUNCTION__, __FILE_NAME__, __LINE__,
-          keyType, value, *reinterpret_cast<int*>(value));
+void swift::swift_task_localValuePush(AsyncTask *task,
+                                        const Metadata *keyType,
+                                        /* +1 */ OpaqueValue *value,
+                                        const Metadata *valueType) {
   task->localValuesFragment()->pushValue(task, keyType, value, valueType);
 }
 
-void swift::swift_task_local_value_pop(AsyncTask *task) {
-  fprintf(stderr, "error: %s [%s:%d] POP task=%d\n", __FUNCTION__, __FILE_NAME__, __LINE__,
-          task);
+void swift::swift_task_localValuePop(AsyncTask *task) {
   task->localValuesFragment()->popValue(task);
 }
 
-OpaqueValue* swift::swift_task_local_value_get(AsyncTask *task,
-                                             const Metadata *keyType) {
-  auto value = task->localValueGet(keyType);
-  fprintf(stderr, "error: %s [%s:%d] lookup keyType=%d value=%d\n",
-          __FUNCTION__, __FILE_NAME__, __LINE__,
-          keyType, value);
-  return value;
+OpaqueValue* swift::swift_task_localValueGet(AsyncTask *task,
+                                             const Metadata *keyType,
+                                             TaskLocalInheritance inheritance) {
+  return task->localValueGet(keyType, inheritance);
 }
 
 namespace {

stdlib/public/Concurrency/Task.swift

@@ -12,16 +12,6 @@
 
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
-#if canImport(Darwin)
-import Darwin
-#elseif canImport(Glibc)
-import Glibc
-#elseif os(Windows)
-import CRT
-#else
-#error("Unsupported platform")
-#endif
-
 
 // ==== Task -------------------------------------------------------------------
 

stdlib/public/Concurrency/TaskGroup.cpp

@@ -1,4 +1,4 @@
-//===--- TaskGroup.cpp - Task Group internal message channel ------------===//
+//===--- TaskGroup.cpp - Task Groups --------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Object management for async child tasks that are children of a task group.
+// Object management for child tasks that are children of a task group.
 //
 //===----------------------------------------------------------------------===//
 

stdlib/public/Concurrency/TaskLocal.cpp

@@ -1,4 +1,4 @@
-//===--- TaskGroup.cpp - Task Group internal message channel ------------===//
+//===--- TaskLocal.cpp - Task Local Values --------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -9,10 +9,6 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-//
-// Object management for task local values.
-//
-//===----------------------------------------------------------------------===//
 
 #include "swift/Runtime/Concurrency.h"
 #include "swift/ABI/Task.h"
@@ -33,16 +29,12 @@ void TaskLocalValuesFragment::destroy() {
       case TaskLocalValuesFragment::NextLinkType::IsNext:
         next = item->getNext();
         item->destroy();
-        fprintf(stderr, "FREE: %d\n", item);
         free(item);
         item = next;
         break;
 
       case TaskLocalValuesFragment::NextLinkType::IsParent:
       case TaskLocalValuesFragment::NextLinkType::IsTerminal:
-        fprintf(stderr, "error: %s [%s:%d] done destroying [fragment:%d] type=%d\n", __FUNCTION__, __FILE_NAME__, __LINE__,
-                this, item->getNextLinkType());
-
         // we're done here, we must not destroy values owned by the parent task.
         return;
     }
@@ -71,10 +63,6 @@ void TaskLocalValuesFragment::pushValue(AsyncTask *task,
 
   auto item = TaskLocalItem::createLink(task, keyType, valueType);
   valueType->vw_initializeWithTake(item->getStoragePtr(), value);
-
-  fprintf(stderr, "error: %s [%s:%d] PUSH bound item: task=%d item=%d -> item.next=%d keyType=%d item->getStoragePtr=%d\n", __FUNCTION__, __FILE_NAME__, __LINE__,
-          task, item, item->getNext(), keyType, item->getStoragePtr());
-
   head = item;
 }
 
@@ -84,31 +72,26 @@ void TaskLocalValuesFragment::popValue(AsyncTask *task) {
   head = head->getNext();
 }
 
-OpaqueValue *TaskLocalValuesFragment::get(const Metadata *keyType, const TaskLocalInheritance inherit) {
+OpaqueValue *TaskLocalValuesFragment::get(
+    const Metadata *keyType,
+    const TaskLocalInheritance inherit) {
   assert(keyType && "Task.Local key must not be null.");
 
   auto item = head;
-  fprintf(stderr, "error: %s [%s:%d] get @ [%d] keyType %d\n", __FUNCTION__, __FILE_NAME__, __LINE__,
-          item, keyType);
   while (item) {
-    fprintf(stderr, "error: %s [%s:%d] loop, get; keyType=%d item=%d value=%d\n", __FUNCTION__, __FILE_NAME__, __LINE__,
-            keyType, item, item->getStoragePtr());
     if (item->keyType == keyType) {
       return item->getStoragePtr();
     }
 
-    // if the hey is an `inherit = .never` type, we stop our search the first
+    // if the key is an `inherit = .never` type, we stop our search the first
     // time we would be jumping to a parent task to continue the search.
     if (item->getNextLinkType() == NextLinkType::IsParent &&
-        inherit == TaskLocalInheritance::never)
+        inherit == TaskLocalInheritance::Never)
       return nullptr;
 
     item = item->getNext();
   }
 
-  fprintf(stderr, "error: %s [%s:%d] not found, get @ [%d] keyType %d\n", __FUNCTION__, __FILE_NAME__, __LINE__,
-          item, keyType);
-
   return nullptr;
 }
 

stdlib/public/Concurrency/TaskLocal.swift

@@ -13,16 +13,6 @@
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
 
-#if canImport(Darwin)
-import Darwin
-#elseif canImport(Glibc)
-import Glibc
-#elseif os(Windows)
-import CRT
-#else
-#error("Unsupported platform")
-#endif
-
 /// Namespace for declaring `TaskLocalKey`s.
 public enum TaskLocalValues {}
 
@@ -54,12 +44,12 @@ public protocol TaskLocalKey {
 }
 
 extension TaskLocalKey {
-  static var inherit: TaskLocalInheritance { .default }
+  public static var inherit: TaskLocalInheritance { .default }
 }
 
-///
+/// Determines task local value behavior in child tasks.
 // TODO: should likely remain extensible
-public enum TaskLocalInheritance: Int {
+public enum TaskLocalInheritance: UInt8, Equatable {
   /// The default inheritance strategy.
   ///
   /// Task local values whose keys are `default` inherited are available to the
@@ -83,7 +73,8 @@ extension Task {
     async -> Key.Value where Key: TaskLocalKey {
     let task = Builtin.getCurrentAsyncTask()
 
-    guard let rawValue = _taskLocalValueGet(task, keyType: Key.self) else {
+    let value = _taskLocalValueGet(task, keyType: Key.self, inheritance: Key.inherit.rawValue)
+    guard let rawValue = value else {
       return Key.defaultValue
     }
 
@@ -108,7 +99,6 @@ extension Task {
   ) async -> BodyResult where Key: TaskLocalKey {
     let task = Builtin.getCurrentAsyncTask()
 
-//    fputs("error [Task.swift:\(#line)]: setting DONE keyType=\(Key.self), value=\(value)\n", stderr)
     _taskLocalValuePush(task, keyType: Key.self, value: value)
 
     defer {
@@ -133,7 +123,6 @@ extension Task {
   ) async throws -> BodyResult where Key: TaskLocalKey {
     let task = Builtin.getCurrentAsyncTask()
 
-//    fputs("error [Task.swift:\(#line)]: setting DONE keyType=\(Key.self), value=\(value)\n", stderr)
     _taskLocalValuePush(task, keyType: Key.self, value: value)
 
     defer {
@@ -169,20 +158,21 @@ extension AnyTaskLocalKey: Hashable {
 
 // ==== ------------------------------------------------------------------------
 
-@_silgen_name("swift_task_local_value_push")
+@_silgen_name("swift_task_localValuePush")
 public func _taskLocalValuePush<Value>(
   _ task: Builtin.NativeObject,
   keyType: Any.Type/*Key.Type*/,
   value: __owned Value
 ) // where Key: TaskLocalKey
 
-@_silgen_name("swift_task_local_value_pop")
+@_silgen_name("swift_task_localValuePop")
 public func _taskLocalValuePop(
   _ task: Builtin.NativeObject
 )
 
-@_silgen_name("swift_task_local_value_get")
+@_silgen_name("swift_task_localValueGet")
 public func _taskLocalValueGet(
   _ task: Builtin.NativeObject,
-  keyType: Any.Type/*Key.Type*/
+  keyType: Any.Type/*Key.Type*/,
+  inheritance: UInt8/*TaskLocalInheritance*/
 ) -> UnsafeMutableRawPointer? // where Key: TaskLocalKey