[Distributed] IRGen: Provide argument/result types to the accessor

Author: xedin

lib/IRGen/GenDistributed.cpp

@@ -33,6 +33,7 @@
 #include "ScalarPairTypeInfo.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/AST/ExtInfo.h"
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/IRGen/Linking.h"
 #include "swift/SIL/SILFunction.h"
@@ -92,7 +93,9 @@ class DistributedAccessor {
   void emit();
 
 private:
-  void computeArguments(llvm::Value *argumentBuffer, Explosion &arguments);
+  void computeArguments(llvm::Value *argumentBuffer,
+                        llvm::Value *argumentTypes,
+                        Explosion &arguments);
 
   FunctionPointer getPointerToTarget() const;
 
@@ -132,7 +135,9 @@ static CanSILFunctionType getAccessorType(IRGenModule &IGM,
       /*genericSignature=*/nullptr, extInfo, SILCoroutineKind::None,
       ParameterConvention::Direct_Guaranteed,
       {/*argumentBuffer=*/getRawPointerParameter(),
+       /*argumentTypes=*/getRawPointerParameter(),
        /*resultBuffer=*/getRawPointerParameter(),
+       /*resultType=*/getRawPointerParameter(),
        /*actor=*/targetTy->getParameters().back()},
       /*Yields=*/{},
       /*Results=*/{},
@@ -181,6 +186,7 @@ DistributedAccessor::DistributedAccessor(IRGenFunction &IGF,
               FunctionPointer::BasicKind::AsyncFunctionPointer))) {}
 
 void DistributedAccessor::computeArguments(llvm::Value *argumentBuffer,
+                                           llvm::Value *argumentTypes,
                                            Explosion &arguments) {
   auto fnType = Target->getLoweredFunctionType();
 
@@ -301,8 +307,12 @@ void DistributedAccessor::emit() {
 
   // UnsafeRawPointer that holds all of the argument values.
   auto *argBuffer = params.claimNext();
+  // `swift.type**` that holds the argument types that correspond to values.
+  auto *argTypes = params.claimNext();
   // UnsafeRawPointer that is used to store the result.
   auto *resultBuffer = params.claimNext();
+  // `swift.type*` that holds the type fo the result.
+  auto *resultType = params.claimNext();
   // Reference to a `self` of the actor to be called.
   auto *actorSelf = params.claimNext();
 
@@ -333,7 +343,7 @@ void DistributedAccessor::emit() {
 
   // Step one is to load all of the data from argument buffer,
   // so it could be forwarded to the distributed method.
-  computeArguments(argBuffer, arguments);
+  computeArguments(argBuffer, argTypes, arguments);
 
   // Step two, let's form and emit a call to the distributed method
   // using computed argument explosion.

stdlib/public/Concurrency/Actor.cpp

@@ -1727,7 +1727,9 @@ using TargetExecutorSignature =
     AsyncSignature<void(/*on=*/DefaultActor *,
                         /*targetName=*/const char *, /*targetNameSize=*/size_t,
                         /*argumentBuffer=*/void *,
+                        /*argumentTypes=*/const Metadata *const *,
                         /*resultBuffer=*/void *,
+                        /*resultType=*/const Metadata *,
                         /*resumeFunc=*/TaskContinuationFunction *,
                         /*callContext=*/AsyncContext *),
                    /*throws=*/true>;
@@ -1742,7 +1744,11 @@ TargetExecutorSignature::FunctionType swift_distributed_execute_target;
 ///   - a result buffer as a raw pointer
 ///   - a reference to an actor to execute method on.
 using DistributedAccessorSignature =
-    AsyncSignature<void(void *, void *, HeapObject *),
+    AsyncSignature<void(/*argumentBuffer=*/void *,
+                        /*argumentTypes=*/const Metadata *const *,
+                        /*resultBuffer=*/void *,
+                        /*resultType=*/const Metadata *,
+                        /*actor=*/HeapObject *),
                    /*throws=*/true>;
 
 SWIFT_CC(swiftasync)
@@ -1769,7 +1775,9 @@ void ::swift_distributed_execute_target(
     DefaultActor *actor,
     const char *targetNameStart, size_t targetNameLength,
     void *argumentBuffer,
+    const Metadata *const *argumentTypes,
     void *resultBuffer,
+    const Metadata *resultType,
     TaskContinuationFunction *resumeFunc,
     AsyncContext *callContext) {
   auto *accessor = findDistributedAccessor(targetNameStart, targetNameLength);
@@ -1803,5 +1811,8 @@ void ::swift_distributed_execute_target(
   calleeContext->ResumeParent = reinterpret_cast<TaskContinuationFunction *>(
       swift_distributed_execute_target_resume);
 
-  accessorEntry(calleeContext, argumentBuffer, resultBuffer, actor);
+  accessorEntry(calleeContext,
+                argumentBuffer, argumentTypes,
+                resultBuffer, resultType,
+                actor);
 }

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -207,11 +207,9 @@ extension DistributedActorSystem {
     }
 
     // Prepare buffer for the parameter types to be decoded into:
-    let paramTypesBuffer = UnsafeMutableRawBufferPointer
-      .allocate(byteCount: MemoryLayout<Any.Type>.size * Int(paramCount),
-        alignment: MemoryLayout<Any.Type>.alignment)
+    let argumentTypesBuffer = UnsafeMutableBufferPointer<Any.Type>.allocate(capacity: Int(paramCount))
     defer {
-      paramTypesBuffer.deallocate()
+      argumentTypesBuffer.deallocate()
     }
 
     // Demangle and write all parameter types into the prepared buffer
@@ -220,7 +218,7 @@ extension DistributedActorSystem {
         nameUTF8.baseAddress!, UInt(nameUTF8.endIndex),
         genericEnv,
         substitutionsBuffer,
-        paramTypesBuffer.baseAddress!._rawValue, Int(paramCount))
+        argumentTypesBuffer.baseAddress!._rawValue, Int(paramCount))
     }
 
     // Fail if the decoded parameter types count seems off and fishy
@@ -234,11 +232,11 @@ extension DistributedActorSystem {
     }
 
     // Copy the types from the buffer into a Swift Array
-    var paramTypes: [Any.Type] = []
+    var argumentTypes: [Any.Type] = []
     do {
-      paramTypes.reserveCapacity(Int(decodedNum))
-      for paramType in paramTypesBuffer.bindMemory(to: Any.Type.self) {
-        paramTypes.append(paramType)
+      argumentTypes.reserveCapacity(Int(decodedNum))
+      for argumentType in argumentTypesBuffer {
+        argumentTypes.append(argumentType)
       }
     }
 
@@ -268,7 +266,7 @@ extension DistributedActorSystem {
     }
 
     // Prepare the buffer to decode the argument values into
-    let hargs = HeterogeneousBuffer.allocate(forTypes: paramTypes)
+    let hargs = HeterogeneousBuffer.allocate(forTypes: argumentTypes)
     defer {
       hargs.deinitialize()
       hargs.deallocate()
@@ -279,14 +277,14 @@ extension DistributedActorSystem {
       // TODO(distributed): decode the generics info
       // TODO(distributed): move this into the IRGen synthesized funcs, so we don't need hargs at all and can specialize the decodeNextArgument calls
       do {
-        var paramIdx = 0
+        var argumentIdx = 0
         for unsafeRawArgPointer in hargs {
-          guard paramIdx < paramCount else {
+          guard argumentIdx < paramCount else {
             throw ExecuteDistributedTargetError(
-              message: "Unexpected attempt to decode more parameters than expected: \(paramIdx + 1)")
+              message: "Unexpected attempt to decode more parameters than expected: \(argumentIdx + 1)")
           }
-          let paramType = paramTypes[paramIdx]
-          paramIdx += 1
+          let argumentType = argumentTypes[argumentIdx]
+          argumentIdx += 1
 
           // FIXME(distributed): func doDecode<Arg: SerializationRequirement>(_: Arg.Type) throws {
           // FIXME:     but how would we call this...?
@@ -296,7 +294,7 @@ extension DistributedActorSystem {
               .bindMemory(to: Arg.self, capacity: 1)
             try invocationDecoder.decodeNextArgument(Arg.self, into: unsafeArgPointer)
           }
-          try _openExistential(paramType, do: doDecodeArgument)
+          try _openExistential(argumentType, do: doDecodeArgument)
         }
       }
 
@@ -308,7 +306,9 @@ extension DistributedActorSystem {
         on: actor,
         mangledTargetName, UInt(mangledTargetName.count),
         argumentBuffer: hargs.buffer._rawValue, // TODO(distributed): pass the invocationDecoder instead, so we can decode inside IRGen directly into the argument explosion
-        resultBuffer: resultBuffer._rawValue
+        argumentTypes: argumentTypesBuffer.baseAddress!._rawValue,
+        resultBuffer: resultBuffer._rawValue,
+        resultType: returnTypeFromTypeInfo
       )
 
       func onReturn<R>(_ resultTy: R.Type) async throws {
@@ -327,7 +327,9 @@ func _executeDistributedTarget(
   on actor: AnyObject, // DistributedActor
   _ targetName: UnsafePointer<UInt8>, _ targetNameLength: UInt,
   argumentBuffer: Builtin.RawPointer, // HeterogeneousBuffer of arguments
-  resultBuffer: Builtin.RawPointer
+  argumentTypes: Builtin.RawPointer,
+  resultBuffer: Builtin.RawPointer,
+  resultType: Any.Type
 ) async throws
 
 // ==== ----------------------------------------------------------------------------------------------------------------

test/Distributed/distributed_actor_accessor_thunks_64bit.swift

@@ -90,7 +90,7 @@ public distributed actor MyOtherActor {
 
 // CHECK: define hidden swifttailcc void @"$s27distributed_actor_accessors7MyActorC7simple1yySiFTE"
 
-// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors7MyActorC7simple1yySiFTETF"(%swift.context* swiftasync %0, i8* %1, i8* %2, %T27distributed_actor_accessors7MyActorC* %3)
+// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors7MyActorC7simple1yySiFTETF"(%swift.context* swiftasync %0, i8* %1, i8* %2, i8* %3, i8* %4, %T27distributed_actor_accessors7MyActorC* %5)
 
 /// Read the current offset and cast an element to `Int`
 
@@ -113,7 +113,7 @@ public distributed actor MyOtherActor {
 // CHECK-SAME: i8* bitcast (void (%swift.context*, i64, %T27distributed_actor_accessors7MyActorC*)* @"$s27distributed_actor_accessors7MyActorC7simple1yySiFTE" to i8*),
 // CHECK-SAME: %swift.context* [[THUNK_CONTEXT_PTR]],
 // CHECK-SAME: i64 [[ARG_VAL]],
-// CHECK-SAME: %T27distributed_actor_accessors7MyActorC* %3)
+// CHECK-SAME: %T27distributed_actor_accessors7MyActorC* %5)
 
 // CHECK-NEXT: [[TASK_REF:%.*]] = extractvalue { i8*, %swift.error* } [[THUNK_RESULT]], 0
 // CHECK-NEXT: {{.*}} = call i8* @__swift_async_resume_project_context(i8* [[TASK_REF]])
@@ -141,7 +141,7 @@ public distributed actor MyOtherActor {
 // CHECK-SAME: i8* bitcast (void (%swift.context*, i64, %T27distributed_actor_accessors7MyActorC*)* @"$s27distributed_actor_accessors7MyActorC7simple2ySSSiFTE" to i8*),
 // CHECK-SAME: %swift.context* [[THUNK_CONTEXT_PTR]],
 // CHECK-SAME: i64 [[NATIVE_ARG_VAL]],
-// CHECK-SAME: %T27distributed_actor_accessors7MyActorC* %3)
+// CHECK-SAME: %T27distributed_actor_accessors7MyActorC* %5)
 
 // CHECK-NEXT: [[TASK_REF:%.*]] = extractvalue { i8*, i64, %swift.bridge*, %swift.error* } [[THUNK_RESULT]], 0
 // CHECK-NEXT: {{.*}} = call i8* @__swift_async_resume_project_context(i8* [[TASK_REF]])
@@ -164,7 +164,7 @@ public distributed actor MyOtherActor {
 // CHECK: define hidden swifttailcc void @"$s27distributed_actor_accessors7MyActorC7simple3ySiSSFTE"
 
 /// !!! in `simple3` interesting bits are: argument value extraction (because string is exploded into N arguments) and call to distributed thunk
-// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors7MyActorC7simple3ySiSSFTETF"(%swift.context* swiftasync {{.*}}, i8* [[ARG_BUFF:%.*]], i8* [[RESULT_BUFF:%.*]], %T27distributed_actor_accessors7MyActorC* {{.*}})
+// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors7MyActorC7simple3ySiSSFTETF"(%swift.context* swiftasync {{.*}}, i8* [[ARG_BUFF:%.*]], i8* [[ARG_TYPES:%.*]], i8* [[RESULT_BUFF:%.*]], {{.*}}, %T27distributed_actor_accessors7MyActorC* {{.*}})
 
 // CHECK: [[TYPED_RESULT_BUFF:%.*]] = bitcast i8* [[RESULT_BUFF]] to %TSi*
 
@@ -188,7 +188,7 @@ public distributed actor MyOtherActor {
 // CHECK-SAME: %swift.context* [[THUNK_CONTEXT_PTR]],
 // CHECK-SAME: i64 [[STR_SIZE]],
 // CHECK-SAME: %swift.bridge* [[STR_VAL]],
-// CHECK-SAME: %T27distributed_actor_accessors7MyActorC* %3)
+// CHECK-SAME: %T27distributed_actor_accessors7MyActorC* %5)
 
 // CHECK-NEXT: [[TASK_REF:%.*]] = extractvalue { i8*, i64, %swift.error* } [[THUNK_RESULT]], 0
 // CHECK-NEXT: {{.*}} = call i8* @__swift_async_resume_project_context(i8* [[TASK_REF]])
@@ -201,15 +201,14 @@ public distributed actor MyOtherActor {
 
 // CHECK: define hidden swifttailcc void @"$s27distributed_actor_accessors7MyActorC16single_case_enumyAA7SimpleEOAFFTE"
 
-// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors7MyActorC16single_case_enumyAA7SimpleEOAFFTETF"(%swift.context* swiftasync %0, i8* [[BUFFER:%.*]], i8* [[RESULT_BUFF:%.*]], %T27distributed_actor_accessors7MyActorC* {{.*}})
+// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors7MyActorC16single_case_enumyAA7SimpleEOAFFTETF"(%swift.context* swiftasync %0, i8* [[BUFFER:%.*]], i8* [[ARG_TYPES:%.*]], i8* [[RESULT_BUFF:%.*]], {{.*}}, %T27distributed_actor_accessors7MyActorC* {{.*}})
 
 /// First, let's check that there were no loads from the argument buffer and no stores to "current offset".
 
 // CHECK: [[OFFSET:%.*]] = bitcast i8** %offset to i8*
 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[OFFSET]])
 // CHECK-NEXT: store i8* [[BUFFER]], i8** %offset
 // CHECK-NEXT: %elt_offset = load i8*, i8** %offset
-// CHECK-NEXT: [[ELT_PTR:.*]] = bitcast i8* %elt_offset to %T27distributed_actor_accessors7SimpleEO*
 // CHECK-NEXT: [[OFFSET:%.*]] = bitcast i8** %offset to i8*
 // CHECK-NEXT call void @llvm.lifetime.end.p0i8(i64 8, i8* [[OFFSET]])
 
@@ -226,7 +225,7 @@ public distributed actor MyOtherActor {
 
 /// First, Load both arguments from the buffer.
 
-// CHECK: [[TYPED_RESULT_BUFF:%.*]] = bitcast i8* %2 to %T27distributed_actor_accessors9IndirectEO*
+// CHECK: [[TYPED_RESULT_BUFF:%.*]] = bitcast i8* [[RESULT_BUFF]] to %T27distributed_actor_accessors9IndirectEO*
 // CHECK: store i8* %1, i8** %offset
 // CHECK-NEXT: %elt_offset = load i8*, i8** %offset
 
@@ -257,7 +256,7 @@ public distributed actor MyOtherActor {
 
 // CHECK: define hidden swifttailcc void @"$s27distributed_actor_accessors7MyActorC7complexyAA11LargeStructVSaySiG_AA3ObjCSSSgAFtFTE"
 
-// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors7MyActorC7complexyAA11LargeStructVSaySiG_AA3ObjCSSSgAFtFTETF"(%swift.context* swiftasync {{.*}}, i8* [[ARG_BUFF:%.*]], i8* [[RESULT_BUFF:%.*]], %T27distributed_actor_accessors7MyActorC* {{.*}})
+// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors7MyActorC7complexyAA11LargeStructVSaySiG_AA3ObjCSSSgAFtFTETF"(%swift.context* swiftasync {{.*}}, i8* [[ARG_BUFF:%.*]], i8* [[ARG_TYPES:%.*]], i8* [[RESULT_BUFF:%.*]], {{.*}}, %T27distributed_actor_accessors7MyActorC* {{.*}})
 
 /// First, let's check that all of the different argument types here are loaded correctly.
 
@@ -318,7 +317,7 @@ public distributed actor MyOtherActor {
 
 /// Let's check that there is no offset allocation here since parameter list is empty
 
-// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors12MyOtherActorC5emptyyyFTETF"(%swift.context* swiftasync {{.*}}, i8* [[ARG_BUFF:%.*]], i8* [[RESULT_BUFF:%.*]], %T27distributed_actor_accessors12MyOtherActorC* {{.*}})
+// CHECK: define internal swifttailcc void @"$s27distributed_actor_accessors12MyOtherActorC5emptyyyFTETF"(%swift.context* swiftasync {{.*}}, i8* [[ARG_BUFF:%.*]], i8* [[ARG_TYPES:%.*]], i8* [[RESULT_BUFF:%.*]], {{.*}}, %T27distributed_actor_accessors12MyOtherActorC* {{.*}})
 // CHECK-NEXT: entry:
 // CHECK-NEXT: {{.*}} = alloca %swift.context*
 // CHECK-NEXT: %swifterror = alloca swifterror %swift.error*