Skip to content

Commit d723fc2

Browse files
ktosoktoso
committed
we can make the thunk THE witness which will work
1 parent 96562cc commit d723fc2

7 files changed

+136
-40
lines changed

‎lib/SIL/IR/SILDeclRef.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1052,6 +1052,8 @@ bool SILDeclRef::requiresNewVTableEntry() const {
10521052
return true;
10531053
if (!hasDecl())
10541054
return false;
1055+
// if (isDistributedThunk())
1056+
// return false;
10551057
if (isBackDeploymentThunk())
10561058
return false;
10571059
auto fnDecl = dyn_cast<AbstractFunctionDecl>(getDecl());

‎lib/SILGen/SILGenPoly.cpp

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -4442,12 +4442,14 @@ void SILGenFunction::emitProtocolWitness(
44424442
// If the witness is isolated to a distributed actor, but the requirement is
44434443
// not, go through the distributed thunk.
44444444
if (witness.hasDecl() &&
4445-
getActorIsolation(witness.getDecl()).isDistributedActor() &&
4446-
requirement.hasDecl() &&
4447-
!getActorIsolation(requirement.getDecl()).isDistributedActor()) {
4448-
witness = SILDeclRef(
4449-
cast<AbstractFunctionDecl>(witness.getDecl())->getDistributedThunk())
4450-
.asDistributed();
4445+
getActorIsolation(witness.getDecl()).isDistributedActor()) {
4446+
if ((requirement.hasDecl() && !getActorIsolation(requirement.getDecl()).isDistributedActor()) ||
4447+
(requirement.hasDecl() && isa<FuncDecl>(requirement.getDecl()) && witness.getFuncDecl()->isDistributed())) {
4448+
fprintf(stderr, "[%s:%d] (%s) witness thunk\n", __FILE__, __LINE__, __FUNCTION__);
4449+
auto thunk = cast<AbstractFunctionDecl>(witness.getDecl())->getDistributedThunk();
4450+
thunk->dump();
4451+
witness = SILDeclRef(thunk) .asDistributed();
4452+
}
44514453
} else if (enterIsolation) {
44524454
// If we are supposed to enter the actor, do so now by hopping to the
44534455
// actor.

‎lib/Sema/CSApply.cpp

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7932,10 +7932,15 @@ bool ExprRewriter::requiresDistributedThunk(Expr *base, SourceLoc memberLoc,
79327932
auto *memberDecl = memberRef.getDecl();
79337933
assert(memberDecl);
79347934

7935-
auto *memberDC = memberDecl->getDeclContext();
79367935
// Protocol requirements are dispatched through a witness which is always
79377936
// a distributed thunk.
7938-
if (isa_and_nonnull<ProtocolDecl>(memberDC->getAsDecl()))
7937+
//
7938+
// // the call on the protocol needs no thunk...
7939+
// but the witness of the distributed func requirement should
7940+
// have been the thunk of the CONCRETE distributed actor....?
7941+
// This way we'd call the isRemote/isLocal stuff, but defined IN the concrete DA.
7942+
auto *memberDC = memberDecl->getDeclContext();
7943+
if (isa<ProtocolDecl>(memberDC))
79397944
return false;
79407945

79417946
if (auto *FD = dyn_cast<FuncDecl>(memberDecl)) {

‎lib/Sema/CodeSynthesisDistributedActor.cpp

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -670,8 +670,13 @@ static FuncDecl *createDistributedThunkFunction(FuncDecl *func) {
670670
auto &C = func->getASTContext();
671671
auto DC = func->getDeclContext();
672672

673-
auto systemTy = getConcreteReplacementForProtocolActorSystemType(func);
674-
assert(systemTy &&
673+
// NOTE: So we don't need a thunk in the protocol, we should call the underlying
674+
// thing instead, which MUST have a thunk, since it must be a distributed func as well...
675+
if (dyn_cast<ProtocolDecl>(DC)) {
676+
return nullptr;
677+
}
678+
679+
assert(getConcreteReplacementForProtocolActorSystemType(func) &&
675680
"Thunk synthesis must have concrete actor system type available");
676681

677682
DeclName thunkName;

‎lib/Sema/TypeCheckProtocol.cpp

Lines changed: 17 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1401,9 +1401,25 @@ bool WitnessChecker::findBestWitness(
14011401
attempt = static_cast<Attempt>(attempt + 1)) {
14021402
SmallVector<ValueDecl *, 4> witnesses;
14031403
switch (attempt) {
1404-
case Regular:
1404+
case Regular: {
14051405
witnesses = lookupValueWitnesses(requirement, ignoringNames);
1406+
1407+
// ValueDecl* thunk = nullptr;
1408+
// for (auto witness : witnesses) {
1409+
// if (auto func = dyn_cast<FuncDecl>(witness)) {
1410+
// if (func->isDistributed()) {
1411+
// thunk = func->getDistributedThunk();
1412+
// fprintf(stderr, "[%s:%d] (%s) ALSO CONSIDER THUNK!!!\n", __FILE__, __LINE__, __FUNCTION__);
1413+
// }
1414+
// }
1415+
// }
1416+
// if (thunk) {
1417+
// witnesses.clear();
1418+
// witnesses.push_back(thunk);
1419+
// }
1420+
14061421
break;
1422+
}
14071423
case OperatorsFromOverlay: {
14081424
// If we have a Clang declaration, the matching operator might be in the
14091425
// overlay for that module.

‎test/Distributed/Runtime/distributed_actor_func_calls_remoteCall_through_generic.swift

Lines changed: 25 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,8 @@ protocol DistributedWorker: DistributedActor where ActorSystem == DefaultDistrib
2525
associatedtype WorkResult: Sendable & Codable
2626

2727
distributed func submit(work: WorkItem) async throws -> WorkResult
28+
29+
func sync(work: WorkItem) -> WorkResult
2830
}
2931

3032
distributed actor TheWorker: DistributedWorker {
@@ -35,28 +37,9 @@ distributed actor TheWorker: DistributedWorker {
3537
distributed func submit(work: WorkItem) async throws -> WorkResult {
3638
"\(Self.self) echo: \(work)"
3739
}
38-
}
39-
40-
actor WorkerPool<Worker: DistributedWorker> {
41-
typealias ActorSystem = FakeRoundtripActorSystem
42-
typealias WorkItem = Worker.WorkItem
43-
typealias WorkResult = Worker.WorkResult
44-
45-
let actorSystem: ActorSystem
46-
let worker: Worker
47-
48-
init(worker: Worker, actorSystem: ActorSystem) {
49-
self.worker = worker
50-
self.actorSystem = actorSystem
51-
}
52-
53-
func submit(work: WorkItem) async throws -> WorkResult {
54-
let worker = try await self.selectWorker()
55-
return try await worker.submit(work: work)
56-
}
5740

58-
func selectWorker() async throws -> Worker {
59-
return self.worker
41+
func sync(work: WorkItem) -> WorkResult {
42+
return "SYNC: \(work)"
6043
}
6144
}
6245

@@ -66,25 +49,38 @@ func test() async throws {
6649
let w = TheWorker(actorSystem: system)
6750
let remoteW = try! TheWorker.resolve(id: w.id, using: system)
6851
print("remoteW is remote: \(__isRemoteActor(remoteW))")
52+
// CHECK: remoteW is remote: true
6953

7054
// direct calls work ok:
71-
// let reply = try await remoteW.submit(work: "Hello")
55+
let replyDirect = try await remoteW.submit(work: "Direct")
56+
print("reply direct: \(replyDirect)")
57+
// CHECK: >> remoteCall: on:main.TheWorker, target:main.TheWorker.submit(work:), invocation:FakeInvocationEncoder(genericSubs: [], arguments: ["Direct"], returnType: Optional(Swift.String), errorType: Optional(Swift.Error)), throwing:Swift.Error, returning:Swift.String
58+
// CHECK: reply direct: TheWorker echo: Direct
59+
60+
print("==== ---------------------------------------------------")
7261

73-
// Fails with:
74-
// Cannot handle types other than extensions and actor declarations in distributed function checking.
75-
// UNREACHABLE executed at /Users/ktoso/code/swift-project/swift/lib/Sema/TypeCheckDistributed.cpp:514!
7662
func callWorker<W: DistributedWorker>(w: W) async throws -> String where W.WorkItem == String, W.WorkResult == String {
7763
try await w.submit(work: "Hello")
7864
}
7965
let reply = try await callWorker(w: remoteW)
8066

81-
// let pool = WorkerPool<TheWorker>(worker: remoteW, actorSystem: system)
82-
// let reply = try await pool.submit(work: "Hello")
67+
print("reply: \(reply)")
8368
// CHECK: >> remoteCall: on:main.TheWorker, target:main.TheWorker.submit(work:), invocation:FakeInvocationEncoder(genericSubs: [], arguments: ["Hello"], returnType: Optional(Swift.String), errorType: Optional(Swift.Error)), throwing:Swift.Error, returning:Swift.String
84-
8569
// CHECK: << remoteCall return: TheWorker echo: Hello
86-
print("reply: \(reply)")
8770
// CHECK: reply: TheWorker echo: Hello
71+
72+
// ----------
73+
let replySyncRemote = await remoteW.whenLocal { __secretlyKnownToBeLocal in
74+
__secretlyKnownToBeLocal.sync(work: "test")
75+
}
76+
print("reply sync (remote): \(replySyncRemote)")
77+
// CHECK: reply sync (remote): nil
78+
79+
let replySyncLocal = await w.whenLocal { __secretlyKnownToBeLocal in
80+
__secretlyKnownToBeLocal.sync(work: "test")
81+
}
82+
print("reply sync (local): \(replySyncLocal)")
83+
// CHECK: reply sync (local): Optional("SYNC: test")
8884
}
8985

9086
@main struct Main {

‎test/Distributed/Runtime/distributed_actor_func_calls_remoteCall_through_generic_local.swift

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
// RUN: %empty-directory(%t)
2+
// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/../Inputs/FakeDistributedActorSystems.swift
3+
// RUN: %target-build-swift -module-name main -Xfrontend -disable-availability-checking -j2 -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -o %t/a.out
4+
// RUN: %target-run %t/a.out | %FileCheck %s --color --dump-input=always
5+
6+
// REQUIRES: executable_test
7+
// REQUIRES: concurrency
8+
// REQUIRES: distributed
9+
10+
// rdar://76038845
11+
// UNSUPPORTED: use_os_stdlib
12+
// UNSUPPORTED: back_deployment_runtime
13+
14+
// FIXME(distributed): Distributed actors currently have some issues on windows, isRemote always returns false. rdar://82593574
15+
// UNSUPPORTED: OS=windows-msvc
16+
17+
import Distributed
18+
import FakeDistributedActorSystems
19+
20+
21+
typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
22+
23+
protocol DistributedWorker: DistributedActor where ActorSystem == DefaultDistributedActorSystem {
24+
associatedtype WorkItem: Sendable & Codable
25+
associatedtype WorkResult: Sendable & Codable
26+
27+
distributed func submit(work: WorkItem) async throws -> WorkResult
28+
}
29+
30+
distributed actor TheWorker: DistributedWorker {
31+
typealias ActorSystem = DefaultDistributedActorSystem
32+
typealias WorkItem = String
33+
typealias WorkResult = String
34+
35+
distributed func submit(work: WorkItem) -> WorkResult {
36+
"\(Self.self) echo: \(work)"
37+
}
38+
}
39+
40+
func test() async throws {
41+
let system = DefaultDistributedActorSystem()
42+
43+
let w = TheWorker(actorSystem: system)
44+
let remoteW = try! TheWorker.resolve(id: w.id, using: system)
45+
print("remoteW is remote: \(__isRemoteActor(remoteW))")
46+
// CHECK: remoteW is remote: true
47+
48+
// direct calls work ok:
49+
let replyDirect = try await remoteW.submit(work: "Direct")
50+
print("reply direct: \(replyDirect)")
51+
// CHECK: >> remoteCall: on:main.TheWorker, target:main.TheWorker.submit(work:), invocation:FakeInvocationEncoder(genericSubs: [], arguments: ["Direct"], returnType: Optional(Swift.String), errorType: nil), throwing:Swift.Never, returning:Swift.String
52+
// CHECK: reply direct: TheWorker echo: Direct
53+
54+
print("==== ---------------------------------------------------")
55+
56+
func callWorker<W: DistributedWorker>(w: W) async throws -> String where W.WorkItem == String, W.WorkResult == String {
57+
try await w.submit(work: "Hello")
58+
}
59+
let reply = try await callWorker(w: remoteW)
60+
print("reply: \(reply)")
61+
// CHECK: >> remoteCall: on:main.TheWorker, target:main.TheWorker.submit(work:), invocation:FakeInvocationEncoder(genericSubs: [], arguments: ["Hello"], returnType: Optional(Swift.String), errorType: nil), throwing:Swift.Never, returning:Swift.String
62+
// CHECK: << remoteCall return: TheWorker echo: Hello
63+
// CHECK: reply: TheWorker echo: Hello
64+
}
65+
66+
@main struct Main {
67+
static func main() async {
68+
try! await test()
69+
}
70+
}

0 commit comments

Comments
 (0)