work in progress on task names

Author: ktoso

include/swift/ABI/MetadataValues.h

@@ -2719,6 +2719,7 @@ class JobFlags : public FlagSet<uint32_t> {
     // 27 is currently unused
     Task_IsAsyncLetTask                   = 28,
     Task_HasInitialTaskExecutorPreference = 29,
+    Task_HasInitialTaskName               = 30,
   };
   // clang-format on
 
@@ -2755,6 +2756,9 @@ class JobFlags : public FlagSet<uint32_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_HasInitialTaskExecutorPreference,
                                 task_hasInitialTaskExecutorPreference,
                                 task_setHasInitialTaskExecutorPreference)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_HasInitialTaskName,
+                                task_hasInitialTaskName,
+                                task_setHasInitialTaskName)
 };
 
 /// Kinds of task status record.
@@ -2784,6 +2788,9 @@ enum class TaskStatusRecordKind : uint8_t {
   /// enqueued on.
   TaskExecutorPreference = 5,
 
+  /// A human-readable task name.
+  TaskName = 6,
+
   // Kinds >= 192 are private to the implementation.
   First_Reserved = 192,
   Private_RecordLock = 192
@@ -2807,6 +2814,8 @@ enum class TaskOptionRecordKind : uint8_t {
   /// Set the initial task executor preference of the task.
   InitialTaskExecutorUnowned = 5,
   InitialTaskExecutorOwned = 6,
+  // Set a human-readable task name.
+  InitialTaskName = 7,
   /// Request a child task for swift_task_run_inline.
   RunInline = UINT8_MAX,
 };

include/swift/ABI/Task.h

@@ -421,6 +421,26 @@ class AsyncTask : public Job {
   /// Checking this is, of course, inherently race-prone on its own.
   bool isCancelled() const;
 
+  // ==== INITIAL TASK RECORDS =================================================
+  // A task may have a number of "initial" records set, they MUST be set in the
+  // following order to make the task-local allocation/deallocation's stack
+  // discipline easy to work out at the tasks destruction:
+  //
+  // - Initial TaskName
+  // - Initial ExecutorPreference
+
+  // ==== Task Naming ----------------------------------------------------------
+
+  /// At task creation a task may be assigned a name.
+  void pushInitialTaskName(const char* taskName);
+  void dropInitialTaskNameRecord();
+
+  const char* getTaskName();
+
+  bool hasInitialTaskName() const {
+    return Flags.task_hasInitialTaskName();
+  }
+
   // ==== Task Executor Preference ---------------------------------------------
 
   /// Get the preferred task executor reference if there is one set for this

include/swift/ABI/TaskOptions.h

@@ -131,6 +131,26 @@ class InitialTaskExecutorOwnedPreferenceTaskOptionRecord
   }
 };
 
+class InitialTaskNameTaskOptionRecord
+    : public TaskOptionRecord {
+
+  const char* TaskName;
+
+public:
+  InitialTaskNameTaskOptionRecord(
+      const char* taskName)
+      : TaskOptionRecord(TaskOptionRecordKind::InitialTaskName),
+        TaskName(taskName) {}
+
+  const char* getTaskName() const {
+    return TaskName;
+  }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::InitialTaskName;
+  }
+};
+
 /// Task option to specify the initial serial executor for the task.
 class InitialSerialExecutorTaskOptionRecord : public TaskOptionRecord {
   const SerialExecutorRef Executor;

include/swift/ABI/TaskStatus.h

@@ -320,6 +320,22 @@ class TaskExecutorPreferenceStatusRecord : public TaskStatusRecord {
   }
 };
 
+class TaskNameStatusRecord : public TaskStatusRecord {
+private:
+  const char *Name;
+
+public:
+  TaskNameStatusRecord(const char *name)
+      : TaskStatusRecord(TaskStatusRecordKind::TaskName),
+        Name(name) {}
+
+  const char *getName() { return Name; }
+
+  static bool classof(const TaskStatusRecord *record) {
+    return record->getKind() == TaskStatusRecordKind::TaskName;
+  }
+};
+
 // This record is allocated for a task to record what it is dependent on before
 // the task can make progress again.
 class TaskDependencyStatusRecord : public TaskStatusRecord {

include/swift/AST/ASTSynthesis.h

@@ -57,6 +57,7 @@ enum SingletonTypeSynthesizer {
   _taskExecutor,   // the '_Concurrency.TaskExecutor' protocol
   _actor,          // the '_Concurrency.Actor' protocol
   _distributedActor,  // the 'Distributed.DistributedActor' protocol
+  _unsafeRawBufferPointer // UnsafeRawBufferPointer
 };
 inline Type synthesizeType(SynthesisContext &SC,
                            SingletonTypeSynthesizer kind) {
@@ -89,6 +90,8 @@ inline Type synthesizeType(SynthesisContext &SC,
   case _distributedActor:
     return SC.Context.getProtocol(KnownProtocolKind::DistributedActor)
       ->getDeclaredInterfaceType();
+  case _unsafeRawBufferPointer:
+    return SC.Context.getUnsafeRawBufferPointerType();
   case _copyable:
     return SC.Context.getProtocol(KnownProtocolKind::Copyable)
         ->getDeclaredInterfaceType();

include/swift/AST/Builtins.def

@@ -952,7 +952,9 @@ BUILTIN_MISC_OPERATION(UnprotectedAddressOfBorrowOpaque, "unprotectedAddressOfBo
 /// createTask<T>(flags: Int,
 ///               initialSerialExecutor: (Builtin.Executor)? = nil,
 ///               taskGroup: Builtin.RawPointer? = nil,
-///               initialTaskExecutor: (Builtin.Executor)? = nil,
+///               initialTaskExecutorDeprecated: (Builtin.Executor)? = nil,
+///               initialTaskExecutorOwned: (any TaskExecutor)? = nil,
+///               taskName: UnsafeRawBufferPointer? = nil,
 ///               operation: sending @escaping () async throws -> T)
 ///  -> Builtin.NativeObject, Builtin.RawPointer)
 ///

include/swift/Basic/Features.def

@@ -151,6 +151,7 @@ BASELINE_LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins")
 BASELINE_LANGUAGE_FEATURE(BuiltinBuildComplexEqualityExecutor, 0, "Executor-building for 'complexEquality executor' builtins")
 BASELINE_LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin")
 BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncTaskOwnedTaskExecutor, 0, "Task create with owned TaskExecutor")
+BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncTaskName, 0, "Task create with a name")
 BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "Task create in task group builtin with extra flags")
 BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroupWithExecutor, 0, "Task create in task group builtin with extra flags")
 BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncDiscardingTaskInGroup, 0, "Task create in discarding task group builtin, accounting for the Void return type")

include/swift/Runtime/Concurrency.h

@@ -1010,6 +1010,9 @@ void swift_task_reportUnexpectedExecutor(
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 JobPriority swift_task_getCurrentThreadPriority(void);
 
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+const char *swift_task_getCurrentTaskName(void);
+
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_startOnMainActor(AsyncTask* job);
 

lib/AST/Builtins.cpp

@@ -219,6 +219,19 @@ _generics(ParamS... params) {
   return {{params...}};
 }
 
+///// A conditional synthesizer which generates a generic parameter list.
+///// If the 'condition' is false, no generic parameters are created.
+//template <class... ParamS>
+//struct ConditionalGenericParamListSynthesizer {
+//  bool condition;
+//  VariadicSynthesizerStorage<ParamS...> Params;
+//};
+//template <class... ParamS>
+//constexpr ConditionalGenericParamListSynthesizer<ParamS...>
+//_ifGenerics(bool condition, ParamS... params) {
+//  return {condition, {params...}};
+//}
+
 struct CountGenericParameters {
   unsigned &Count;
 
@@ -292,6 +305,21 @@ static GenericParamList *synthesizeGenericParamList(SynthesisContext &SC,
   return paramList;
 }
 
+//template <class... ParamsS>
+//static GenericParamList *synthesizeGenericParamList(
+//    SynthesisContext &SC,
+//    const ConditionalGenericParamListSynthesizer<ParamsS...> &params) {
+//  if (params.condition) {
+//    unsigned count = 0;
+//    params.Params.visit(CountGenericParameters{count});
+//    auto paramList = getGenericParams(SC.Context, count);
+//    SC.GenericParams = paramList;
+//    return paramList;
+//  } else {
+//    return GenericParamList::create(SC.Context, SourceLoc(), {}, SourceLoc());
+//  }
+//}
+
 namespace {
 struct CollectGenericParams {
   SynthesisContext &SC;
@@ -341,6 +369,24 @@ synthesizeGenericSignature(SynthesisContext &SC,
                                /*allowInverses=*/false);
 }
 
+//template <class... ParamsS>
+//static GenericSignature
+//synthesizeGenericSignature(SynthesisContext &SC,
+//                     const ConditionalGenericParamListSynthesizer<ParamsS...> &list) {
+//  CollectGenericParams collector(SC);
+//  if (list.condition) {
+//    list.Params.visit(collector);
+//
+//    return buildGenericSignature(SC.Context,
+//                                 GenericSignature(),
+//                                 std::move(collector.GenericParamTypes),
+//                                 std::move(collector.AddedRequirements),
+//                                 /*allowInverses=*/false);
+//  } else {
+//    return GenericSignature();
+//  }
+//}
+
 /// Build a builtin function declaration.
 ///
 /// This is a "legacy" interface; you should probably use one of
@@ -1553,7 +1599,35 @@ Type swift::getAsyncTaskAndContextType(ASTContext &ctx) {
   return TupleType::get(resultTupleElements, ctx);
 }
 
+//static ValueDecl *getCreateTask(ASTContext &ctx, Identifier id, bool isDiscarding) {
+//  auto taskExecutorIsAvailable =
+//      ctx.getProtocol(swift::KnownProtocolKind::TaskExecutor) != nullptr;
+//
+//  return getBuiltinFunction(
+//      ctx, id, _thin, _ifGenerics(/*if=*/isDiscarding,
+//                                  _unrestricted, _conformsToDefaults(0)),
+//      _parameters(
+//          _label("flags", _swiftInt),
+//          _label("initialSerialExecutor",
+//                 _defaulted(_optional(_executor), _nil)),
+//          _label("taskGroup", _defaulted(_optional(_rawPointer), _nil)),
+//          _label("initialTaskExecutor", _defaulted(_optional(_executor), _nil)),
+//          _label("initialTaskExecutorConsuming",
+//                 _defaulted(_consuming(_optional(_bincompatType(
+//                                /*if=*/taskExecutorIsAvailable,
+//                                _existential(_taskExecutor),
+//                                /*else=*/_executor))),
+//                            _nil)),
+//          _label("taskName", _defaulted(_optional(_unsafeRawBufferPointer), _nil)),
+//          _label("operation",
+//                 _sending(_function(_async(_throws(_thick)), _typeparam(0),
+//                                    _parameters())))),
+//      _tuple(_nativeObject, _rawPointer));
+//}
+
 static ValueDecl *getCreateTask(ASTContext &ctx, Identifier id) {
+  // return getCreateTask(ctx, id, /*isDiscarding=*/false);
+
   auto taskExecutorIsAvailable =
       ctx.getProtocol(swift::KnownProtocolKind::TaskExecutor) != nullptr;
 
@@ -1571,6 +1645,7 @@ static ValueDecl *getCreateTask(ASTContext &ctx, Identifier id) {
                                 _existential(_taskExecutor),
                                 /*else*/ _executor))),
                             _nil)),
+          _label("taskName", _defaulted(_optional(_unsafeRawBufferPointer), _nil)),
           _label("operation",
                  _sending(_function(_async(_throws(_thick)), _typeparam(0),
                                     _parameters())))),
@@ -1595,6 +1670,7 @@ static ValueDecl *getCreateDiscardingTask(ASTContext &ctx, Identifier id) {
                                 _existential(_taskExecutor),
                                 /*else*/ _executor))),
                             _nil)),
+          _label("taskName", _defaulted(_optional(_unsafeRawBufferPointer), _nil)),
           _label("operation", _sending(_function(_async(_throws(_thick)), _void,
                                                  _parameters())))),
       _tuple(_nativeObject, _rawPointer));

lib/IRGen/GenConcurrency.cpp

@@ -686,9 +686,10 @@ struct TaskGroupRecordTraits {
 
   void initialize(IRGenFunction &IGF, Address recordAddr,
                   Explosion &taskGroup) const {
+    auto record = IGF.Builder.CreateStructGEP(recordAddr, 1, 2 * IGF.IGM.getPointerSize());
     IGF.Builder.CreateStore(
         taskGroup.claimNext(),
-        IGF.Builder.CreateStructGEP(recordAddr, 1, 2 * IGF.IGM.getPointerSize()));
+        record);
   }
 };
 
@@ -747,6 +748,55 @@ struct InitialTaskExecutorOwnedRecordTraits {
   }
 };
 
+struct InitialTaskNameRecordTraits {
+  static StringRef getLabel() {
+    return "task_name";
+  }
+  static llvm::StructType *getRecordType(IRGenModule &IGM) {
+    return IGM.SwiftInitialTaskNameTaskOptionRecordTy;
+  }
+  static TaskOptionRecordFlags getRecordFlags() {
+    return TaskOptionRecordFlags(TaskOptionRecordKind::InitialTaskName);
+  }
+  static CanType getValueType(ASTContext &ctx) {
+    // FIXME: maybe raw pointer type?
+    return OptionalType::get(ctx.getUnsafeRawBufferPointerType())
+        ->getCanonicalType();
+  }
+
+  // Create 'InitialTaskNameTaskOptionRecord'
+  void initialize(IRGenFunction &IGF, Address recordAddr,
+                  Explosion &taskName) const {
+
+    fprintf(stderr, "[%s:%d](%s) initialize InitialTaskNameTaskOptionRecord\n", __FILE_NAME__, __LINE__, __FUNCTION__);
+    taskName.dump();
+
+    fprintf(stderr, "[%s:%d](%s) taskName.size() = %d\n", __FILE_NAME__, __LINE__, __FUNCTION__,
+            taskName.size());
+
+    // FIXME: why is this wrong?
+    // [GenConcurrency.cpp:725](initialize) initialize InitialTaskNameTaskOptionRecord
+    //  %16 = extractvalue { i64, i64 } %15, 0
+    //  %17 = extractvalue { i64, i64 } %15, 1
+    // [GenConcurrency.cpp:728](initialize) taskName.size() = 2
+    //  Assertion failed: (isa<llvm::StructType>(address.getElementType()) || isa<llvm::ArrayType>(address.getElementType())), function CreateStructGEP, file IRBuilder.h, line 193. Process 27213 stopped
+
+//    auto record =
+//        IGF.Builder.CreateStructGEP(recordAddr, 1, 2 * IGF.IGM.getPointerSize());
+//    IGF.Builder.CreateStore(taskName.claimNext(),
+//                            IGF.Builder.CreateStructGEP(record, 0, Size()));
+//    IGF.Builder.CreateStore(taskName.claimNext(),
+//                            IGF.Builder.CreateStructGEP(record, 1, Size()));
+
+    auto record = IGF.Builder.CreateStructGEP(recordAddr, 1, 2 * IGF.IGM.getPointerSize());
+    fprintf(stderr, "[%s:%d](%s) record = \n", __FILE_NAME__, __LINE__, __FUNCTION__);
+    record->dump();
+    IGF.Builder.CreateStore(
+        taskName.claimNext(),
+        record);
+  }
+};
+
 } // end anonymous namespace
 
 static llvm::Value *
@@ -783,12 +833,20 @@ maybeAddInitialTaskExecutorOwnedOptionRecord(IRGenFunction &IGF,
                               taskExecutorExistential);
 }
 
+static llvm::Value *
+maybeAddTaskNameOptionRecord(IRGenFunction &IGF, llvm::Value *prevOptions,
+                             OptionalExplosion &taskName) {
+  return maybeAddOptionRecord(IGF, prevOptions, InitialTaskNameRecordTraits(),
+                              taskName);
+}
+
 std::pair<llvm::Value *, llvm::Value *>
 irgen::emitTaskCreate(IRGenFunction &IGF, llvm::Value *flags,
                       OptionalExplosion &serialExecutor,
                       OptionalExplosion &taskGroup,
                       OptionalExplosion &taskExecutorUnowned,
                       OptionalExplosion &taskExecutorExistential,
+                      OptionalExplosion &taskName,
                       Explosion &taskFunction,
                       SubstitutionMap subs) {
   llvm::Value *taskOptions =
@@ -825,6 +883,16 @@ irgen::emitTaskCreate(IRGenFunction &IGF, llvm::Value *flags,
         IGF, taskOptions, taskExecutorExistential);
   }
 
+  // Add an option record for the initial task name, if present.
+  //
+  //    (lldb) e taskName.value.Values[0]
+  //        (llvm::Value *) $11 = 0x000060000220d1a0
+  //    (lldb) e taskName.value.Values[0]->dump()
+  //        %16 = extractvalue { i64, i64 } %15, 0
+  //    (lldb) e taskName.value.Values[1]->dump()
+  //       %17 = extractvalue { i64, i64 } %15, 1
+  taskOptions = maybeAddTaskNameOptionRecord(IGF, taskOptions, taskName);
+
   // In embedded Swift, create and pass result type info.
   taskOptions = maybeAddEmbeddedSwiftResultTypeInfo(IGF, taskOptions, resultType);
 

lib/IRGen/GenConcurrency.h

@@ -106,6 +106,7 @@ emitTaskCreate(IRGenFunction &IGF, llvm::Value *flags,
                OptionalExplosion &taskGroup,
                OptionalExplosion &taskExecutorUnowned,
                OptionalExplosion &taskExecutorExistential,
+               OptionalExplosion &taskName,
                Explosion &taskFunction,
                SubstitutionMap subs);