Preliminary support for `_specialize(exported: true, ...)` #32657

aschwaighofer · 2020-07-01T17:44:54Z

Adds support for _specialize(exported: true, ...)

This attribute allows to define a pre-specialized entry point of a
generic function in a library.

The following definition provides a pre-specialized entry point for
genericFunc(_:) for the parameter type Int that clients of the
library can call.

@_specialize(exported: true, where T == Int)
public func genericFunc<T>(_ t: T) { ... }

Pre-specializations of internal @inlinable functions are allowed.

@usableFromInline
internal struct GenericThing<T> {
  @_specialize(exported: true, where T == Int)
  @inlinable
  internal func genericMethod(_ t: T) {
  }
}

There is syntax to pre-specialize a method from a different module.

import ModuleDefiningGenericFunc

@_specialize(exported: true, target: genericFunc(_:), where T == Double)
func prespecialize_genericFunc(_ t: T) { fatalError("dont call") }

Specially marked extensions allow for pre-specialization of internal
methods accross module boundries (respecting @inlinable and
@usableFromInline).

import ModuleDefiningGenericThing
public struct Something {}

@_specializeExtension
extension GenericThing {
  @_specialize(exported: true, target: genericMethod(_:), where T == Something)
  func prespecialize_genericMethod(_ t: T) { fatalError("dont call") }
}

Adds support for marking a _specialize attribute as SPI

  @_specialize(exported: true, spi: SPIGroupName, where T == Int)
  public func myFunc() { }

The specialized entry point is only visible for modules that import
using _spi(SPIGroupName) import ModuleDefiningMyFunc .

rdar://64993425

slavapestov

Cool! Can this eventually be used to generate SwiftOnoneSupport too?

slavapestov · 2020-07-02T01:39:31Z

lib/SIL/IR/SILDeclRef.cpp

@@ -221,6 +228,12 @@ bool SILDeclRef::isImplicit() const {
 }

 SILLinkage SILDeclRef::getLinkage(ForDefinition_t forDefinition) const {
+
+  // Prespecializations are public.


Only specializations of public symbols though, right?

Pre-specialization are intentionally always public.

For example, there is going to be a public entry point for the specialized version of:

@_alwaysEmitIntoClient @_specialize(exported: true, where T == Int) internal func testGeneric<T>(t: T) { print(t) }

slavapestov · 2020-07-02T01:40:16Z

include/swift/SIL/SILDeclRef.h

@@ -151,6 +153,8 @@ struct SILDeclRef {
  /// The derivative function identifier.
  AutoDiffDerivativeFunctionIdentifier *derivativeFunctionIdentifier = nullptr;

+  GenericSignature specializedSignature;


Can we stick this in a union with derivativeFunctionIdentifier to save space?

Good point.

slavapestov · 2020-07-02T01:42:12Z

lib/Parse/ParseDecl.cpp

@@ -631,9 +631,6 @@ bool Parser::parseSpecializeAttributeArguments(
      if (ParamLabel == "exported") {
        auto trueLoc = Tok.getLoc();
        bool isTrue = consumeIf(tok::kw_true);
-        if (isTrue) {
-          diagnose(trueLoc, diag::attr_specialize_export_true_no_op);


I think you can remove this diagnostic now

slavapestov · 2020-07-02T01:43:18Z

lib/SIL/Utils/GenericSpecializationMangler.cpp

+  // use the same set of generic parameters, i.e. each generic
+  // parameter should be mapped to itself.
+  for (auto GP : CalleeGenericSig->getGenericParams()) {
+    CalleeInterfaceToSpecializedInterfaceMapping[GP] = Type(GP);


Do you really need CalleeInterfaceToSpecializedInterfaceMapping at all then? The lookup() below can be replaced with just 'type' itself, no?

Yes. Likely. I have copied this code from the FunctionSignaturePartialSpecializer and have not gone back to simplify it.

slavapestov · 2020-07-02T01:43:49Z

lib/SILOptimizer/Utils/Generics.cpp

+    : TargetModule(targetModule), isWholeModule(isWholeModule),
+      isPrespecialization(isPrespecialization) {
+  Serialized =
+      this->isPrespecialization ? IsNotSerialized : Callee->isSerialized();


Why can't we serialize the pre-specialization if the original function is serialized?

This is intentional. Pre-specialization as implemented in this patch get their own symbol/mangling to make them easily identifiable for tooling. The intent of exported pre-specializations is to reduce code size. When using the pre-specializated symbol I don't want the code to be available in the client module for further optimization.

aschwaighofer · 2020-07-02T15:07:03Z

Can this eventually be used to generate SwiftOnoneSupport too?

I think so.

shahmishal · 2020-10-01T06:55:07Z

Please update the base branch to main by Oct 5th otherwise the pull request will be closed automatically.

How to change the base branch: (Link)
More detail about the branch update: (Link)

aschwaighofer · 2020-10-09T18:44:29Z

@swift-ci Please test

swift-ci · 2020-10-09T21:49:33Z

Build failed
Swift Test OS X Platform
Git Sha - 4ec70aa7568dea343dbccea00b872c3073c71e5b

This attribute allows to define a pre-specialized entry point of a generic function in a library. The following definition provides a pre-specialized entry point for `genericFunc(_:)` for the parameter type `Int` that clients of the library can call. ``` @_specialize(exported: true, where T == Int) public func genericFunc<T>(_ t: T) { ... } ``` Pre-specializations of internal `@inlinable` functions are allowed. ``` @usableFromInline internal struct GenericThing<T> { @_specialize(exported: true, where T == Int) @inlinable internal func genericMethod(_ t: T) { } } ``` There is syntax to pre-specialize a method from a different module. ``` import ModuleDefiningGenericFunc @_specialize(exported: true, target: genericFunc(_:), where T == Double) func prespecialize_genericFunc(_ t: T) { fatalError("dont call") } ``` Specially marked extensions allow for pre-specialization of internal methods accross module boundries (respecting `@inlinable` and `@usableFromInline`). ``` import ModuleDefiningGenericThing public struct Something {} @_specializeExtension extension GenericThing { @_specialize(exported: true, target: genericMethod(_:), where T == Something) func prespecialize_genericMethod(_ t: T) { fatalError("dont call") } } ``` rdar://64993425

``` @_specialize(exported: true, spi: SPIGroupName, where T == Int) public func myFunc() { } ``` The specialized entry point is only visible for modules that import using `_spi(SPIGroupName) import ModuleDefiningMyFunc `. rdar://64993425

aschwaighofer · 2020-10-12T16:28:59Z

Please test with following PR:
swiftlang/swift-syntax#241

@swift-ci Please test

aschwaighofer · 2020-10-12T20:32:56Z

@swift-ci Please test source compatibility

aschwaighofer · 2020-10-13T14:57:32Z

The compiler failure in the source compatibility run also occurs without this change in: https://ci.swift.org/job/swift-main-source-compat-suite/5513/artifact/swift-source-compat-suite/FAIL_swift-nio-ssl_5.0_BuildSwiftPackage.log

slavapestov reviewed Jul 2, 2020

View reviewed changes

aschwaighofer force-pushed the wip_prespecialize_exported branch from efb616e to 76cd65a Compare October 1, 2020 14:09

aschwaighofer changed the base branch from master to main October 1, 2020 14:10

aschwaighofer force-pushed the wip_prespecialize_exported branch 4 times, most recently from ecc4510 to 5a39f76 Compare October 6, 2020 21:42

aschwaighofer force-pushed the wip_prespecialize_exported branch 2 times, most recently from e0a4d8f to f7c31a1 Compare October 9, 2020 17:07

aschwaighofer changed the title ~~WIP: Preliminary support for _specialize(exported: true, ...)~~ Preliminary support for _specialize(exported: true, ...) Oct 9, 2020

aschwaighofer added 3 commits October 12, 2020 09:19

Merge two fields into a PointerUnion in SILDeclRef to save space

d6d79c6

aschwaighofer force-pushed the wip_prespecialize_exported branch from 4ec70aa to d6d79c6 Compare October 12, 2020 16:20

aschwaighofer mentioned this pull request Oct 12, 2020

Update gyb generated files for _specialize syntax addition swiftlang/swift-syntax#241

Merged

aschwaighofer marked this pull request as ready for review October 12, 2020 20:32

aschwaighofer merged commit fd3e3cf into swiftlang:main Oct 13, 2020

bnbarham mentioned this pull request Oct 28, 2020

[Parse] Remove unused declaration and diagnostic message #34487

Merged

Preliminary support for _specialize(exported: true, ...) #32657

Preliminary support for _specialize(exported: true, ...) #32657

Uh oh!

Conversation

aschwaighofer commented Jul 1, 2020 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

slavapestov left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

aschwaighofer commented Jul 2, 2020

Uh oh!

shahmishal commented Oct 1, 2020

Uh oh!

aschwaighofer commented Oct 9, 2020

Uh oh!

swift-ci commented Oct 9, 2020

Uh oh!

aschwaighofer commented Oct 12, 2020

Uh oh!

aschwaighofer commented Oct 12, 2020

Uh oh!

aschwaighofer commented Oct 13, 2020

Uh oh!

Uh oh!

Preliminary support for `_specialize(exported: true, ...)` #32657

Preliminary support for `_specialize(exported: true, ...)` #32657

aschwaighofer commented Jul 1, 2020 •

edited

Loading