mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
c7a216058f
This PR implements first set of changes required to support autodiff for coroutines. It mostly targeted to `_modify` accessors in standard library (and beyond), but overall implementation is quite generic. There are some specifics of implementation and known limitations: - Only `@yield_once` coroutines are naturally supported - VJP is a coroutine itself: it yields the results *and* returns a pullback closure as a normal return. This allows us to capture values produced in resume part of a coroutine (this is required for defers and other cleanups / commits) - Pullback is a coroutine, we assume that coroutine cannot abort and therefore we execute the original coroutine in reverse from return via yield and then back to the entry - It seems there is no semantically sane way to support `_read` coroutines (as we will need to "accept" adjoints via yields), therefore only coroutines with inout yields are supported (`_modify` accessors). Pullbacks of such coroutines take adjoint buffer as input argument, yield this buffer (to accumulate adjoint values in the caller) and finally return the adjoints indirectly. - Coroutines (as opposed to normal functions) are not first-class values: there is no AST type for them, one cannot e.g. store them into tuples, etc. So, everywhere where AST type is required, we have to hack around. - As there is no AST type for coroutines, there is no way one could register custom derivative for coroutines. So far only compiler-produced derivatives are supported - There are lots of common things wrt normal function apply's, but still there are subtle but important differences. I tried to organize the code to enable code reuse, still it was not always possible, so some code duplication could be seen - The order of how pullback closures are produced in VJP is a bit different: for normal apply's VJP produces both value and pullback closure via a single nested VJP apply. This is not so anymore with coroutine VJP's: yielded values are produced at `begin_apply` site and pullback closure is available only from `end_apply`, so we need to track the order in which pullbacks are produced (and arrange consumption of the values accordingly – effectively delay them) - On the way some complementary changes were required in e.g. mangler / demangler This patch covers the generation of derivatives up to SIL level, however, it is not enough as codegen of `partial_apply` of a coroutine is completely broken. The fix for this will be submitted separately as it is not directly autodiff-related. --------- Co-authored-by: Andrew Savonichev <andrew.savonichev@gmail.com> Co-authored-by: Richard Wei <rxwei@apple.com>
102 lines
4.2 KiB
C++
102 lines
4.2 KiB
C++
//===--- Thunk.h - Automatic differentiation thunks -----------*- C++ -*---===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2019 - 2020 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Automatic differentiation thunk generation utilities.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_SILOPTIMIZER_UTILS_DIFFERENTIATION_THUNK_H
|
|
#define SWIFT_SILOPTIMIZER_UTILS_DIFFERENTIATION_THUNK_H
|
|
|
|
#include "swift/AST/AutoDiff.h"
|
|
#include "swift/Basic/LLVM.h"
|
|
#include "swift/SIL/SILBuilder.h"
|
|
|
|
namespace swift {
|
|
|
|
class SILOptFunctionBuilder;
|
|
class SILModule;
|
|
class SILLocation;
|
|
class SILValue;
|
|
class OpenedArchetypeType;
|
|
class GenericEnvironment;
|
|
class SubstitutionMap;
|
|
class ArchetypeType;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Helpers
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace autodiff {
|
|
|
|
class ADContext;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Thunk helpers
|
|
//===----------------------------------------------------------------------===//
|
|
// These helpers are copied/adapted from SILGen. They should be refactored and
|
|
// moved to a shared location.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
/// Get or create a reabstraction thunk from `fromType` to `toType`, to be
|
|
/// called in `caller`.
|
|
SILFunction *getOrCreateReabstractionThunk(SILOptFunctionBuilder &fb,
|
|
SILModule &module, SILLocation loc,
|
|
SILFunction *caller,
|
|
CanSILFunctionType fromType,
|
|
CanSILFunctionType toType);
|
|
|
|
SILValue reabstractCoroutine(
|
|
SILBuilder &builder, SILOptFunctionBuilder &fb, SILLocation loc,
|
|
SILValue fn, CanSILFunctionType toType,
|
|
std::function<SubstitutionMap(SubstitutionMap)> remapSubstitutions);
|
|
|
|
/// Reabstracts the given function-typed value `fn` to the target type `toType`.
|
|
/// Remaps substitutions using `remapSubstitutions`.
|
|
SILValue reabstractFunction(
|
|
SILBuilder &builder, SILOptFunctionBuilder &fb, SILLocation loc,
|
|
SILValue fn, CanSILFunctionType toType,
|
|
std::function<SubstitutionMap(SubstitutionMap)> remapSubstitutions);
|
|
|
|
/// Get or create a derivative function parameter index subset thunk from
|
|
/// `actualIndices` to `desiredIndices` for the given associated function
|
|
/// value and original function operand. Returns a pair of the parameter
|
|
/// index subset thunk and its interface substitution map (used to partially
|
|
/// apply the thunk).
|
|
/// Calls `getOrCreateSubsetParametersThunkForLinearMap` to thunk the linear
|
|
/// map returned by the derivative function.
|
|
std::pair<SILFunction *, SubstitutionMap>
|
|
getOrCreateSubsetParametersThunkForDerivativeFunction(
|
|
SILOptFunctionBuilder &fb, SILValue origFnOperand, SILValue derivativeFn,
|
|
AutoDiffDerivativeFunctionKind kind, const AutoDiffConfig &desiredConfig,
|
|
const AutoDiffConfig &actualConfig, ADContext &adContext);
|
|
|
|
/// Get or create a derivative function parameter index subset thunk from
|
|
/// `actualIndices` to `desiredIndices` for the given associated function
|
|
/// value and original function operand. Returns a pair of the parameter
|
|
/// index subset thunk and its interface substitution map (used to partially
|
|
/// apply the thunk).
|
|
std::pair<SILFunction *, SubstitutionMap>
|
|
getOrCreateSubsetParametersThunkForLinearMap(
|
|
SILOptFunctionBuilder &fb, SILFunction *assocFn,
|
|
CanSILFunctionType origFnType, CanSILFunctionType linearMapType,
|
|
CanSILFunctionType targetType, AutoDiffDerivativeFunctionKind kind,
|
|
const AutoDiffConfig &desiredConfig, const AutoDiffConfig &actualConfig,
|
|
ADContext &adContext);
|
|
|
|
} // end namespace autodiff
|
|
|
|
} // end namespace swift
|
|
|
|
#endif // SWIFT_SILOPTIMIZER_MANDATORY_DIFFERENTIATION_THUNK_H
|