[Concurrency] Refactor _swift_taskGroup_cancelAllChildren -> _cancel

This way we do the right thing always when cancelling the group;
and we MAY visit the child tasks if we have to.

Author: ktoso

stdlib/public/Concurrency/TaskGroup.cpp

@@ -2120,8 +2120,8 @@ bool TaskGroupBase::cancelAll(AsyncTask *owningTask) {
 
   // Cancel all the child tasks.  TaskGroup is not a Sendable type,
   // so cancelAll() can only be called from the owning task.  This
-  // satisfies the precondition on cancelAllChildren_unlocked().
-  _swift_taskGroup_cancelAllChildren_unlocked(asAbstract(this), owningTask);
+  // satisfies the precondition on cancel_unlocked().
+  _swift_taskGroup_cancel_unlocked(asAbstract(this), owningTask);
 
   return true;
 }
@@ -2130,8 +2130,8 @@ SWIFT_CC(swift)
 static void swift_task_cancel_group_child_tasksImpl(TaskGroup *group) {
   // TaskGroup is not a Sendable type, and so this operation (which is not
   // currently exposed in the API) can only be called from the owning
-  // task.  This satisfies the precondition on cancelAllChildren_unlocked().
-  _swift_taskGroup_cancelAllChildren_unlocked(group, swift_task_getCurrent());
+  // task.  This satisfies the precondition on cancel_unlocked().
+  _swift_taskGroup_cancel_unlocked(group, swift_task_getCurrent());
 }
 
 // =============================================================================

stdlib/public/Concurrency/TaskPrivate.h

@@ -93,12 +93,12 @@ AsyncTask *_swift_task_setCurrent(AsyncTask *newTask);
 ///
 /// The caller must guarantee that this is called while holding the owning
 /// task's status record lock.
-void _swift_taskGroup_cancelAllChildren(TaskGroup *group);
+void _swift_taskGroup_cancel(TaskGroup *group);
 
 /// Cancel all the child tasks that belong to `group`.
 ///
 /// The caller must guarantee that this is called from the owning task.
-void _swift_taskGroup_cancelAllChildren_unlocked(TaskGroup *group,
+void _swift_taskGroup_cancel_unlocked(TaskGroup *group,
                                                  AsyncTask *owningTask);
 
 /// Remove the given task from the given task group.

stdlib/public/Concurrency/TaskStatus.cpp

@@ -780,8 +780,15 @@ void swift::_swift_taskGroup_detachChild(TaskGroup *group,
 ///
 /// The caller must guarantee that this is called while holding the owning
 /// task's status record lock.
-void swift::_swift_taskGroup_cancelAllChildren(TaskGroup *group) {
-  assert(group->isCancelled() && "Expected task group to be cancelled when cancelling all child tasks.");
+void swift::_swift_taskGroup_cancel(TaskGroup *group) {
+  // If the task group was already cancelled, we don't need to traverse children
+  // again; they already were all cancelled, or if new ones will be added, they
+  // will be added with the cancelled status set immediately.
+  bool alreadyCancelled = group->statusCancel();
+  if (alreadyCancelled) {
+    return;
+  }
+
   // Because only the owning task of the task group can modify the
   // child list of a task group status record, and it can only do so
   // while holding the owning task's status record lock, we do not need
@@ -793,7 +800,7 @@ void swift::_swift_taskGroup_cancelAllChildren(TaskGroup *group) {
 /// Cancel all the child tasks that belong to `group`.
 ///
 /// The caller must guarantee that this is called from the owning task.
-void swift::_swift_taskGroup_cancelAllChildren_unlocked(TaskGroup *group,
+void swift::_swift_taskGroup_cancel_unlocked(TaskGroup *group,
                                                         AsyncTask *owningTask) {
   // Early out. If there are no children, there's nothing to do. We can safely
   // check this without locking, since this can only be concurrently mutated
@@ -802,7 +809,7 @@ void swift::_swift_taskGroup_cancelAllChildren_unlocked(TaskGroup *group,
     return;
 
   withStatusRecordLock(owningTask, [&group](ActiveTaskStatus status) {
-    _swift_taskGroup_cancelAllChildren(group);
+    _swift_taskGroup_cancel(group);
   });
 }
 
@@ -826,12 +833,7 @@ static void performCancellationAction(TaskStatusRecord *record) {
   // under the synchronous control of the task that owns the group.
   case TaskStatusRecordKind::TaskGroup: {
     auto groupRecord = cast<TaskGroupTaskStatusRecord>(record);
-    auto group = groupRecord->getGroup();
-    auto wasAlreadyCancelled = group->statusCancel();
-    if (wasAlreadyCancelled) {
-      return;
-    }
-    _swift_taskGroup_cancelAllChildren(group);
+    _swift_taskGroup_cancel(groupRecord->getGroup());
     return;
   }