cleanups

Author: ktoso

include/swift/ABI/MetadataValues.h

@@ -2387,17 +2387,18 @@ enum class TaskOptionRecordKind : uint8_t {
 class TaskGroupFlags : public FlagSet<uint32_t> {
 public:
   enum {
-    // 8 bits are un-used, in case we want to introduce a Kind here
-
+    // 8 bits are reserved for future use
+    /// Request the TaskGroup to immediately release completed tasks,
+    /// and not store their results. This also effectively disables `next()`.
     TaskGroup_DiscardResults = 8,
   };
 
   explicit TaskGroupFlags(uint32_t bits) : FlagSet(bits) {}
   constexpr TaskGroupFlags() {}
 
   FLAGSET_DEFINE_FLAG_ACCESSORS(TaskGroup_DiscardResults,
-                                task_isDiscardResults,
-                                task_setIsDiscardResults)
+                                isDiscardResults,
+                                setIsDiscardResults)
 };
 
 /// Kinds of task group option records that can be passed to creating a task group.

lib/IRGen/GenConcurrency.cpp

@@ -285,9 +285,11 @@ llvm::Value *irgen::emitCreateTaskGroup(IRGenFunction &IGF,
 
   llvm::CallInst *call;
   if (groupFlags) {
+    fprintf(stderr, "[%s:%d](%s) group flags; invoke -> getTaskGroupInitializeWithFlagsFunctionPointer\n", __FILE_NAME__, __LINE__, __FUNCTION__);
     call = IGF.Builder.CreateCall(IGF.IGM.getTaskGroupInitializeWithFlagsFunctionPointer(),
                                   {groupFlags, group, resultTypeMetadata});
   } else {
+    fprintf(stderr, "[%s:%d](%s) no group flags; invoke -> getTaskGroupInitializeFunctionPointer\n", __FILE_NAME__, __LINE__, __FUNCTION__);
     call = IGF.Builder.CreateCall(IGF.IGM.getTaskGroupInitializeFunctionPointer(),
                                   {group, resultTypeMetadata});
   }

stdlib/public/Concurrency/TaskGroup.cpp

@@ -513,12 +513,16 @@ static void swift_taskGroup_initializeImpl(TaskGroup *group, const Metadata *T)
 
 // Initializes into the preallocated _group an actual TaskGroupImpl.
 SWIFT_CC(swift)
-static void swift_taskGroup_initializeWithFlagsImpl(size_t flags, TaskGroup *group, const Metadata *T) {
+static void swift_taskGroup_initializeWithFlagsImpl(size_t rawGroupFlags, TaskGroup *group, const Metadata *T) {
   SWIFT_TASK_DEBUG_LOG("creating task group = %p", group);
 
-  fprintf(stderr, "[%s:%d](%s) INITIALIZE FLAGS: %d\n", __FILE_NAME__, __LINE__, __FUNCTION__, flags);
+  TaskGroupFlags groupFlags(rawGroupFlags);
 
-  TaskGroupImpl *impl = ::new (group) TaskGroupImpl(T, /*discardResults=*/true);
+  fprintf(stderr, "[%s:%d](%s) INITIALIZE FLAGS: raw:%d, discardResults:%d\n", __FILE_NAME__, __LINE__, __FUNCTION__, rawGroupFlags,
+          groupFlags.isDiscardResults());
+
+  TaskGroupImpl *impl = ::new(group)
+    TaskGroupImpl(T, groupFlags.isDiscardResults());
   auto record = impl->getTaskRecord();
   assert(impl == record && "the group IS the task record");
 
@@ -674,7 +678,7 @@ static void fillGroupNextVoidResult(TaskFutureWaitAsyncContext *context,
 
 // TaskGroup is locked upon entry and exit
 void TaskGroupImpl::enqueueCompletedTask(AsyncTask *completedTask, bool hadErrorResult) {
-  if (this->discardResults) {
+  if (discardResults) {
     SWIFT_TASK_DEBUG_LOG("group has no waiting tasks, eager release mode; release result task = %p",
                          completedTask);
     // DO NOT RETAIN THE TASK.
@@ -963,7 +967,7 @@ reevaluate_if_taskgroup_has_results:;
 
       // Success! We are allowed to poll.
       ReadyQueueItem item;
-      if (this->discardResults) {
+      if (discardResults) {
         SWIFT_TASK_DEBUG_LOG("poll group = %p; polled in eager-release mode; make up Void value to yield",
                              this, assumed.readyTasks(), assumed.pendingTasks());
         result.status = PollStatus::Success;

stdlib/public/Concurrency/TaskGroup.swift

@@ -10,40 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
-import Darwin
 
 // ==== TaskGroup --------------------------------------------------------------
 
-@available(SwiftStdlib 5.8, *)
-public protocol TaskGroupAdd {
-  associatedtype ChildTaskResult: Sendable
-
-  mutating func addTask(
-          priority: TaskPriority?,
-          operation: __owned @Sendable @escaping () async -> ChildTaskResult
-  )
-
-  mutating func addTask(
-          priority: TaskPriority?,
-          operation: __owned @Sendable @escaping (inout any TaskGroupAdd) async -> ChildTaskResult
-  )
-
-  // TODO: unless cancelled versions
-
-}
-
-@available(SwiftStdlib 5.8, *)
-public protocol TaskGroupConsume {
-  associatedtype ChildTaskResult: Sendable
-
-  mutating func next() async -> ChildTaskResult?
-}
-
-// TODO: throwing versions
-
 /// Starts a new scope that can contain a dynamic number of child tasks.
 ///
 /// A group waits for all of its child tasks
@@ -1166,16 +1137,16 @@ struct TaskGroupFlags {
   /// The priority given to the job.
   var discardResults: Bool? {
     get {
-      let value = (Int(bits) & 1 << 8)
+      let value = (Int(bits) & 1 << 24)
 
       return value > 0
     }
 
     set {
       if newValue == true {
-        bits = bits | 1 << 8
+        bits = bits | 1 << 24
       } else {
-        bits = (bits & ~(1 << 8))
+        bits = (bits & ~(1 << 23))
       }
     }
   }