1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// RUN: %target-swift-frontend -emit-ir -O -g %s | %FileCheck %s
// https://github.com/apple/swift/issues/58123
// Mutating functions with control flow can cause assertion failure for
// conflicting debug variable type
// CHECK-LABEL: define internal swiftcc float @"$s4main8TestTypeV24doDifferentiableTimeStep04timeG0ySf_tFTJpSSpSrTA"
// CHECK: [[SELF:%.*]] = alloca %T4main8TestTypeV06ManualB7TangentV
// CHECK: call void @llvm.dbg.value(metadata ptr [[SELF]]
import _Differentiation
public protocol TestInterface {
mutating func doDifferentiableTimeStep(timeStep: Float)
var zeroTangentVectorInitializer: () -> TestInterfaceTangentVector { get }
mutating func move(by offset: TestInterfaceTangentVector)
}
public protocol TestInterfaceTangentVector {
static var zero: Self { get }
static func add(lhs: TestInterfaceTangentVector, rhs: TestInterfaceTangentVector) -> TestInterfaceTangentVector
static func subtract(lhs: TestInterfaceTangentVector, rhs: TestInterfaceTangentVector) -> TestInterfaceTangentVector
static func equals(lhs: TestInterfaceTangentVector, rhs: TestInterfaceTangentVector) -> Bool
}
public extension TestInterface {
var zeroTangentVector: TestInterfaceTangentVector { zeroTangentVectorInitializer() }
}
private typealias InitFunction = @convention(c) () -> UnsafeMutableRawPointer
public protocol HasZeroTangentVectorDuplicate: Differentiable {
var duplicateZeroTangentVectorInitializer: () -> TangentVector { get }
}
public extension HasZeroTangentVectorDuplicate {
var zeroTangentVector: TangentVector { duplicateZeroTangentVectorInitializer() }
}
public extension HasZeroTangentVectorDuplicate {
var duplicateZeroTangentVectorInitializer: () -> TangentVector {
{ Self.TangentVector.zero }
}
}
struct TestType: TestInterface {
struct TestState: Differentiable {
public struct TangentVector: Differentiable, AdditiveArithmetic {
public typealias TangentVector = TestState.TangentVector
public var property0: Float.TangentVector
public var time: Float.TangentVector
public var property1: Float.TangentVector
}
public mutating func move(by offset: TangentVector) {
self.property0.move(by: offset.property0)
self.time.move(by: offset.time)
self.property1.move(by: offset.property1)
}
@noDerivative
var needUpdate: Bool
@noDerivative
var initialConditionsAreStale: Bool
var property0: Float
var time: Float
var property1: Float
init() {
self.needUpdate = true
self.initialConditionsAreStale = true
self.property0 = 0.01
self.time = 0.01
self.property1 = 0.01
}
}
var state = TestState()
@differentiable(reverse)
mutating func doDifferentiableTimeStep(timeStep: Float) {
if state.needUpdate {
differentiableDoFlow()
}
if state.initialConditionsAreStale {
doInit()
}
}
@differentiable(reverse)
mutating func differentiableDoFlow() {
state.property1 = 1.2
state.property0 = 2.3
state.needUpdate = false
}
mutating func doInit() {
state.initialConditionsAreStale = false
}
}
extension TestType: Differentiable {
struct ManualTestTangent: Differentiable & AdditiveArithmetic {
var state: TestState.TangentVector
}
typealias TangentVector = ManualTestTangent
mutating func move(by offset: ManualTestTangent) {
self.state.move(by: offset.state)
}
}
extension TestType: HasZeroTangentVectorDuplicate {}
extension TestType {
mutating func move(by offset: TestInterfaceTangentVector) {
self.move(by: offset as! Self.TangentVector)
}
var zeroTangentVectorInitializer: () -> TestInterfaceTangentVector {
let initializer: () -> TangentVector = self.duplicateZeroTangentVectorInitializer
return initializer
}
}
extension TestType.TangentVector: TestInterfaceTangentVector {
static func add(lhs: TestInterfaceTangentVector, rhs: TestInterfaceTangentVector) -> TestInterfaceTangentVector {
return (lhs as! Self) + (rhs as! Self)
}
static func subtract(lhs: TestInterfaceTangentVector, rhs: TestInterfaceTangentVector) -> TestInterfaceTangentVector {
return (lhs as! Self) - (rhs as! Self)
}
static func equals(lhs: TestInterfaceTangentVector, rhs: TestInterfaceTangentVector) -> Bool {
return (lhs as! Self) == (rhs as! Self)
}
}
|
