Skip to content

Commit a2dcb60

Browse files
kubamracekkubamracek
committed
[embedded] Introduce a new swift_taskGroup_initializeWithOptions runtime entrypoint
1 parent f1c2334 commit a2dcb60

File tree

6 files changed

+78
-44
lines changed

6 files changed

+78
-44
lines changed

‎include/swift/ABI/MetadataValues.h‎

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2792,10 +2792,6 @@ class TaskGroupFlags : public FlagSet<uint32_t> {
27922792
/// Request the TaskGroup to immediately release completed tasks,
27932793
/// and not store their results. This also effectively disables `next()`.
27942794
TaskGroup_DiscardResults = 8,
2795-
/// The `Metadata *T` in swift_taskGroup_initialize and in
2796-
/// swift_taskGroup_initializeWithFlags pointer is actually a
2797-
/// TaskOptionRecord pointer. Used only in Embedded Swift.
2798-
TaskGroup_MetadataAsOptionRecord = 9,
27992795
};
28002796

28012797
explicit TaskGroupFlags(uint32_t bits) : FlagSet(bits) {}
@@ -2804,10 +2800,6 @@ class TaskGroupFlags : public FlagSet<uint32_t> {
28042800
FLAGSET_DEFINE_FLAG_ACCESSORS(TaskGroup_DiscardResults,
28052801
isDiscardResults,
28062802
setIsDiscardResults)
2807-
2808-
FLAGSET_DEFINE_FLAG_ACCESSORS(TaskGroup_MetadataAsOptionRecord,
2809-
isMetadataAsOptionRecord,
2810-
setIsMetadataAsOptionRecord)
28112803
};
28122804

28132805
/// Flags for cancellation records.

‎include/swift/Runtime/Concurrency.h‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -215,6 +215,17 @@ void swift_taskGroup_initialize(TaskGroup *group, const Metadata *T);
215215
SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
216216
void swift_taskGroup_initializeWithFlags(size_t flags, TaskGroup *group, const Metadata *T);
217217

218+
/// Initialize a `TaskGroup` in the passed `group` memory location.
219+
/// The caller is responsible for retaining and managing the group's lifecycle.
220+
///
221+
/// Its Swift signature is
222+
///
223+
/// \code
224+
/// func swift_taskGroup_initialize(flags: Int, group: Builtin.RawPointer)
225+
/// \endcode
226+
SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
227+
void swift_taskGroup_initializeWithOptions(size_t flags, TaskGroup *group, const Metadata *T, TaskOptionRecord *options);
228+
218229
/// Attach a child task to the parent task's task group record.
219230
///
220231
/// This function MUST be called from the AsyncTask running the task group.

‎include/swift/Runtime/RuntimeFunctions.def‎

Lines changed: 16 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2555,7 +2555,7 @@ FUNCTION(TaskRunInline,
25552555
EFFECT(NoEffect),
25562556
UNKNOWN_MEMEFFECTS)
25572557

2558-
// void swift_taskGroup_initialize(TaskGroup *group);
2558+
// void swift_taskGroup_initialize(TaskGroup *group, const Metadata *T);
25592559
FUNCTION(TaskGroupInitialize,
25602560
swift_taskGroup_initialize, SwiftCC,
25612561
ConcurrencyAvailability,
@@ -2565,7 +2565,7 @@ FUNCTION(TaskGroupInitialize,
25652565
EFFECT(Concurrency),
25662566
UNKNOWN_MEMEFFECTS)
25672567

2568-
// void swift_taskGroup_initializeWithFlags(size_t flags, TaskGroup *group);
2568+
// void swift_taskGroup_initializeWithFlags(size_t flags, TaskGroup *group, const Metadata *T);
25692569
FUNCTION(TaskGroupInitializeWithFlags,
25702570
swift_taskGroup_initializeWithFlags, SwiftCC,
25712571
ConcurrencyDiscardingTaskGroupAvailability,
@@ -2578,6 +2578,20 @@ FUNCTION(TaskGroupInitializeWithFlags,
25782578
EFFECT(Concurrency),
25792579
UNKNOWN_MEMEFFECTS)
25802580

2581+
// void swift_taskGroup_initializeWithTaskOptions(size_t flags, TaskGroup *group, const Metadata *T, TaskOptionRecord *options);
2582+
FUNCTION(TaskGroupInitializeWithOptions,
2583+
swift_taskGroup_initializeWithOptions, SwiftCC,
2584+
ConcurrencyDiscardingTaskGroupAvailability,
2585+
RETURNS(VoidTy),
2586+
ARGS(SizeTy, // flags
2587+
Int8PtrTy, // group
2588+
TypeMetadataPtrTy, // T.Type
2589+
SwiftTaskOptionRecordPtrTy // options
2590+
),
2591+
ATTRS(NoUnwind),
2592+
EFFECT(Concurrency),
2593+
UNKNOWN_MEMEFFECTS)
2594+
25812595
// void swift_taskGroup_destroy(TaskGroup *group);
25822596
FUNCTION(TaskGroupDestroy,
25832597
swift_taskGroup_destroy, SwiftCC,

‎lib/IRGen/GenConcurrency.cpp‎

Lines changed: 16 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -336,38 +336,30 @@ llvm::Value *irgen::emitCreateTaskGroup(IRGenFunction &IGF,
336336
"createTaskGroup should have a type substitution");
337337
auto resultType = subs.getReplacementTypes()[0]->getCanonicalType();
338338

339-
// In desktop Swift, we pass a Metadata pointer as the last argument. In
340-
// Embedded Swift, we pass a TaskOptionRecord list, and mark a bit in
341-
// groupFlags.
342-
llvm::Value *metadataOrTypeOptionRecord;
343339
if (IGF.IGM.Context.LangOpts.hasFeature(Feature::Embedded)) {
344-
metadataOrTypeOptionRecord =
345-
llvm::ConstantPointerNull::get(IGF.IGM.Int8PtrTy);
346-
metadataOrTypeOptionRecord = maybeAddEmbeddedSwiftResultTypeInfo(
347-
IGF, metadataOrTypeOptionRecord, resultType);
348-
llvm::IntegerType *IntPtrTy = IGF.IGM.IntPtrTy;
349-
TaskGroupFlags taskgroupFlags(0);
350-
taskgroupFlags.setIsMetadataAsOptionRecord(true);
351-
auto flagValue = llvm::ConstantInt::get(IGF.IGM.IntPtrTy,
352-
taskgroupFlags.getOpaqueValue());
353-
if (!groupFlags) {
354-
groupFlags = flagValue;
355-
} else {
356-
groupFlags = IGF.Builder.CreateOr(groupFlags, flagValue);
357-
}
358-
} else {
359-
metadataOrTypeOptionRecord = IGF.emitAbstractTypeMetadataRef(resultType);
340+
// In Embedded Swift, call swift_taskGroup_initializeWithOptions instead, to
341+
// avoid needing a Metadata argument.
342+
llvm::Value *options = llvm::ConstantPointerNull::get(IGF.IGM.Int8PtrTy);
343+
llvm::Value *resultTypeMetadata = llvm::ConstantPointerNull::get(IGF.IGM.Int8PtrTy);
344+
options = maybeAddEmbeddedSwiftResultTypeInfo(IGF, options, resultType);
345+
if (!groupFlags) groupFlags = llvm::ConstantInt::get(IGF.IGM.SizeTy, 0);
346+
llvm::CallInst *call = IGF.Builder.CreateCall(IGF.IGM.getTaskGroupInitializeWithOptionsFunctionPointer(),
347+
{groupFlags, group, resultTypeMetadata, options});
348+
call->setDoesNotThrow();
349+
call->setCallingConv(IGF.IGM.SwiftCC);
350+
return group;
360351
}
361352

353+
auto resultTypeMetadata = IGF.emitAbstractTypeMetadataRef(resultType);
354+
362355
llvm::CallInst *call;
363356
if (groupFlags) {
364-
call = IGF.Builder.CreateCall(
365-
IGF.IGM.getTaskGroupInitializeWithFlagsFunctionPointer(),
366-
{groupFlags, group, metadataOrTypeOptionRecord});
357+
call = IGF.Builder.CreateCall(IGF.IGM.getTaskGroupInitializeWithFlagsFunctionPointer(),
358+
{groupFlags, group, resultTypeMetadata});
367359
} else {
368360
call =
369361
IGF.Builder.CreateCall(IGF.IGM.getTaskGroupInitializeFunctionPointer(),
370-
{group, metadataOrTypeOptionRecord});
362+
{group, resultTypeMetadata});
371363
}
372364
call->setDoesNotThrow();
373365
call->setCallingConv(IGF.IGM.SwiftCC);

‎stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -300,6 +300,10 @@ OVERRIDE_TASK_GROUP(taskGroup_initializeWithFlags, void,
300300
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
301301
swift::, (size_t flags, TaskGroup *group, const Metadata *T), (flags, group, T))
302302

303+
OVERRIDE_TASK_GROUP(taskGroup_initializeWithOptions, void,
304+
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
305+
swift::, (size_t flags, TaskGroup *group, const Metadata *T, TaskOptionRecord *options), (flags, group, T, options))
306+
303307
OVERRIDE_TASK_STATUS(taskGroup_attachChild, void,
304308
SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
305309
swift::, (TaskGroup *group, AsyncTask *child),

‎stdlib/public/Concurrency/TaskGroup.cpp‎

Lines changed: 31 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -955,6 +955,8 @@ TaskGroup* TaskGroupTaskStatusRecord::getGroup() {
955955
// =============================================================================
956956
// ==== initialize -------------------------------------------------------------
957957

958+
static void _swift_taskGroup_initialize(ResultTypeInfo resultType, size_t rawGroupFlags, TaskGroup *group);
959+
958960
// Initializes into the preallocated _group an actual TaskGroupBase.
959961
SWIFT_CC(swift)
960962
static void swift_taskGroup_initializeImpl(TaskGroup *group, const Metadata *T) {
@@ -965,21 +967,27 @@ static void swift_taskGroup_initializeImpl(TaskGroup *group, const Metadata *T)
965967
SWIFT_CC(swift)
966968
static void swift_taskGroup_initializeWithFlagsImpl(size_t rawGroupFlags,
967969
TaskGroup *group, const Metadata *T) {
968-
TaskGroupFlags groupFlags(rawGroupFlags);
969-
SWIFT_TASK_GROUP_DEBUG_LOG_0(group, "create group, from task:%p; flags: isDiscardingResults=%d",
970-
swift_task_getCurrent(),
971-
groupFlags.isDiscardResults());
972-
973970
ResultTypeInfo resultType;
974971
#if !SWIFT_CONCURRENCY_EMBEDDED
975972
resultType.metadata = T;
976-
assert(!groupFlags.isMetadataAsOptionRecord());
977973
#else
978-
assert(groupFlags.isMetadataAsOptionRecord());
979-
TaskOptionRecord *options = (TaskOptionRecord *)T;
974+
swift_unreachable("swift_taskGroup_initializeWithFlags in embedded");
975+
#endif
976+
_swift_taskGroup_initialize(resultType, rawGroupFlags, group);
977+
}
978+
979+
// Initializes into the preallocated _group an actual instance.
980+
SWIFT_CC(swift)
981+
static void swift_taskGroup_initializeWithOptionsImpl(size_t rawGroupFlags, TaskGroup *group, const Metadata *T, TaskOptionRecord *options) {
982+
ResultTypeInfo resultType;
983+
#if !SWIFT_CONCURRENCY_EMBEDDED
984+
resultType.metadata = T;
985+
#endif
986+
980987
for (auto option = options; option; option = option->getParent()) {
981988
switch (option->getKind()) {
982989
case TaskOptionRecordKind::ResultTypeInfo: {
990+
#if SWIFT_CONCURRENCY_EMBEDDED
983991
auto *typeInfo = cast<ResultTypeInfoTaskOptionRecord>(option);
984992
resultType = {
985993
.size = typeInfo->size,
@@ -988,13 +996,26 @@ static void swift_taskGroup_initializeWithFlagsImpl(size_t rawGroupFlags,
988996
.storeEnumTagSinglePayload = typeInfo->storeEnumTagSinglePayload,
989997
.destroy = typeInfo->destroy,
990998
};
999+
#else
1000+
swift_unreachable("ResultTypeInfo in non embedded");
1001+
#endif
9911002
break;
9921003
}
9931004
default:
994-
swift_unreachable("only ResultTypeInfo expected");
1005+
break; // ignore unknown records
9951006
}
9961007
}
997-
#endif
1008+
1009+
assert(!resultType.isNull());
1010+
1011+
_swift_taskGroup_initialize(resultType, rawGroupFlags, group);
1012+
}
1013+
1014+
static void _swift_taskGroup_initialize(ResultTypeInfo resultType, size_t rawGroupFlags, TaskGroup *group) {
1015+
TaskGroupFlags groupFlags(rawGroupFlags);
1016+
SWIFT_TASK_GROUP_DEBUG_LOG_0(group, "create group, from task:%p; flags: isDiscardingResults=%d",
1017+
swift_task_getCurrent(),
1018+
groupFlags.isDiscardResults());
9981019

9991020
TaskGroupBase *impl;
10001021
if (groupFlags.isDiscardResults()) {

0 commit comments

Comments
 (0)