webentwicklung-frage-antwort-db.com.de

Warum ist die Kompilierungszeit von Swift so langsam?

Ich benutze Xcode 6 Beta 6.

Dies ist etwas, das mich schon seit einiger Zeit nervt, aber es erreicht einen Punkt, an dem es jetzt kaum noch verwendbar ist.

Mein Projekt fängt an, eine anständige Größe von 65 Swift-Dateien und einigen überbrückten Objective-C-Dateien (die wirklich nicht die Ursache des Problems sind) zu haben.

Es scheint, als würden durch geringfügige Änderungen an einer Swift-Datei (wie das Hinzufügen eines einfachen Leerzeichens in einer Klasse, die in der App kaum verwendet wird) die gesamten Swift-Dateien für das angegebene Ziel neu kompiliert.

Nach eingehenderer Untersuchung habe ich festgestellt, dass die Compiler-Zeit zu 100% in der CompileSwift-Phase liegt, in der Xcode den Befehl swiftc für alle Swift-Dateien Ihres Ziels ausführt.

Ich führte einige weitere Untersuchungen durch und wenn ich den App-Delegaten nur mit einem Standard-Controller belasse, ist die Kompilierung sehr schnell, aber als ich immer mehr meiner Projektdateien hinzufügte, begann die Kompilierungszeit sehr langsam zu werden.

Bei nur 65 Quelldateien dauert die Kompilierung jedes Mal etwa 8 bis 10 Sekunden. Nicht sehr Swift überhaupt.

Ich habe keinen Beitrag über dieses Problem gesehen, außer diesem , aber es war eine alte Version von Xcode 6. Ich frage mich, ob ich in diesem Fall der einzige bin.

UPDATE

Ich habe ein paar Swift-Projekte auf GitHub like Alamofire , Euler und CryptoSwift überprüft, aber keines von ihnen hatte genug Swift-Dateien, um sie tatsächlich zu vergleichen. Das einzige Projekt, bei dem ich festgestellt habe, dass es ein anständiges Größe hat, war SwiftHN , und obwohl es nur ein Dutzend Quelldateien hatte, war ich immer noch in der Lage, dasselbe zu überprüfen, ein einfaches Leerzeichen und das Das gesamte Projekt musste neu kompiliert werden, was etwas Zeit in Anspruch nahm (2/3 Sekunden).

Im Vergleich zu Objective-C-Code, bei dem sowohl Analyzer als auch Compilation rasant schnell sind, wird Swift wahrscheinlich nie in der Lage sein, große Projekte zu bearbeiten, aber bitte sagen Sie mir, dass ich mich irre.

UPDATE mit Xcode 6 Beta 7

Immer noch keine Besserung. Das wird langsam lächerlich. Angesichts des Fehlens von #import in Swift sehe ich wirklich nicht, wie Apple dies jemals optimieren kann.

UPDATE mit Xcode 6.3 und Swift 1.2

Apple hat inkrementelle Builds hinzugefügt (und viele andere Compiler-Optimierungen). Sie müssen Ihren Code auf Swift 1.2 migrieren, um diese Vorteile zu nutzen. Apple hat jedoch in Xcode 6.3 ein Tool hinzugefügt, das Sie dabei unterstützt:

Enter image description here

JEDOCH

Freue dich nicht zu schnell wie ich. Der Graphenlöser, mit dem der Build inkrementell gemacht wird, ist noch nicht sehr gut optimiert.

Zunächst werden Änderungen der Funktionssignatur nicht berücksichtigt. Wenn Sie also ein Leerzeichen in den Block einer Methode einfügen, werden alle Dateien in Abhängigkeit von dieser Klasse neu kompiliert.

Zweitens scheint es, den Baum basierend auf den Dateien zu erstellen, die neu kompiliert wurden, auch wenn sich eine Änderung nicht auf sie auswirkt. Zum Beispiel, wenn Sie diese drei Klassen in verschiedene Dateien verschieben

class FileA: NSObject {
    var foo:String?
}
class FileB: NSObject {
    var bar:FileA?
}
class FileC: NSObject {
    var baz:FileB?
}

Wenn Sie nun FileA ändern, markiert der Compiler FileA offensichtlich als neu zu kompilierend. Es wird auch FileB neu kompiliert (das wäre OK, basierend auf den Änderungen an FileA), aber auch FileC, weil FileB neu kompiliert wird, und das ist ziemlich schlimm, weil FileC hier FileA nie verwendet.

Deshalb hoffe ich, dass sie diesen Abhängigkeitsbaumlöser verbessern ... Ich habe ein Radar mit diesem Beispielcode geöffnet.

UPDATE mit Xcode 7 Beta 5 und Swift 2.0

Gestern hat Apple die Beta 5 veröffentlicht und in den Versionshinweisen konnten wir sehen:

Swift Language & Compiler • Inkrementelle Builds: Das Ändern des Hauptteils einer Funktion sollte nicht länger dazu führen, dass abhängige Dateien neu erstellt werden. (15352929)

Ich habe es ausprobiert und ich muss sagen, dass es jetzt wirklich (wirklich!) Gut funktioniert. Sie haben die inkrementellen Builds in Swift stark optimiert.

Ich empfehle Ihnen dringend, eine Swift2.0-Verzweigung zu erstellen und Ihren Code mit XCode 7 Beta 5 auf dem neuesten Stand zu halten. Sie werden von den Verbesserungen des Compilers begeistert sein (ich würde jedoch sagen, dass der globale Status von XCode 7 immer noch langsam und fehlerhaft ist).

UPDATE mit Xcode 8.2

Es ist schon eine Weile her seit meinem letzten Update zu diesem Thema, also hier ist es.

Unsere App besteht jetzt aus ungefähr 20.000 Zeilen fast ausschließlich aus Swift-Code, was anständig, aber nicht herausragend ist. Es wurde eine Migration von Swift 2 und Swift 3 durchgeführt. Die Kompilierung auf einem Macbook Pro von Mitte 2014 (2,5 GHz Intel Core i7) dauert ungefähr 5/6 Minuten.

Der inkrementelle Build ist jedoch immer noch ein Witz, obwohl Apple behauptet, dass:

Xcode erstellt kein gesamtes Ziel neu, wenn nur kleine Änderungen vorgenommen wurden. (28892475)

Offensichtlich denke ich, dass viele von uns nur gelacht haben, nachdem sie diesen Unsinn überprüft haben (das Hinzufügen einer privaten (privaten!) Eigenschaft zu einer Datei meines Projekts wird das Ganze neu kompilieren ...)

Ich möchte euch auf diesen Thread in Apple-Entwicklerforen verweisen, in denen es mehr Informationen zu diesem Thema gibt (und hin und wieder die Apple-Entwickler-Kommunikation zu diesem Thema zu schätzen wissen).

Grundsätzlich haben sich die Leute ein paar Dinge ausgedacht, um den inkrementellen Build zu verbessern:

  1. Fügen Sie eine HEADER_MAP_USES_VFS-Projekteinstellung hinzu, die auf true festgelegt ist.
  2. Deaktivieren Sie Find implicit dependencies in Ihrem Schema
  3. Erstellen Sie ein neues Projekt und verschieben Sie Ihre Dateihierarchie in das neue.

Ich werde Lösung 3 ausprobieren, aber Lösung 1/2 hat bei uns nicht funktioniert.

Das Ironische an dieser ganzen Situation ist, dass wir beim ersten Beitrag zu diesem Thema Xcode 6 mit Swift-1- oder Swift-1.1-Code verwendet haben, als wir die ersten Compilations träge erreichten, und jetzt, ungefähr zwei Jahre später, trotz tatsächlicher Verbesserungen von Apple Die Situation ist genauso schlimm wie bei Xcode 6. Wie ironisch.

Tatsächlich wirklich bedaure ich es, Swift anstelle von Obj/C für unser Projekt ausgewählt zu haben, weil es täglich Frustrationen mit sich bringt. (Ich wechsele sogar zu AppCode, aber das ist eine andere Geschichte)

Wie auch immer, ich sehe diesen SO Beitrag mit über 32.000 Views und 143 Ups zum Zeitpunkt dieses Schreibens, also denke ich, dass ich nicht der einzige bin. Bleib dran, Leute, obwohl du in dieser Situation pessimistisch bist, könnte am Ende des Tunnels etwas Licht sein.

Wenn Sie die Zeit (und den Mut!) Haben, würde Apple diesbezüglich Radar begrüßen.

Bis zum nächsten Mal! Prost

UPDATE mit Xcode 9

Stolpern über das heute. Xcode führte leise ein neues Build-System ein, um die derzeitige schreckliche Leistung zu verbessern. Sie müssen es über die Arbeitsbereichseinstellungen aktivieren.

 enter image description here 

Habe es schon ausprobiert, werde diesen Beitrag aber aktualisieren, nachdem er fertig ist. Sieht aber vielversprechend aus.

201
apouche

Nun, es stellte sich heraus, dass Rob Napier recht hatte. Es war eine einzige Datei (eigentlich eine Methode), die dazu führte, dass der Compiler berzek wurde.

Versteh mich jetzt nicht falsch. Swift kompiliert alle Ihre Dateien jedes Mal neu. Das Tolle daran ist jedoch, dass Apple in den kompilierten Dateien Echtzeit-Feedback zur Kompilierung hinzugefügt hat. Xcode 6 GM zeigt jetzt an, welche Swift-Dateien kompiliert werden und welchen Status sie haben Zusammenstellung in Echtzeit, wie Sie in diesem Screenshot sehen können:

Enter image description here

Daher ist es sehr praktisch zu wissen, welche Ihrer Dateien so lange dauert. In meinem Fall war es dieser Code:

var dic = super.json().mutableCopy() as NSMutableDictionary
dic.addEntriesFromDictionary([
        "url" : self.url?.absoluteString ?? "",
        "title" : self.title ?? ""
        ])

return dic.copy() as NSDictionary

weil die Eigenschaft title vom Typ var title:String? und nicht NSString war. Der Compiler wurde verrückt, als er der NSMutableDictionary hinzugefügt wurde.

Ändern Sie es in:

var dic = super.json().mutableCopy() as NSMutableDictionary
dic.addEntriesFromDictionary([
        "url" : self.url?.absoluteString ?? "",
        "title" : NSString(string: self.title ?? "")
        ])

return dic.copy() as NSDictionary

die Compilation ging von 10/15 Sekunden (vielleicht sogar noch mehr) auf eine Sekunde ... erstaunlich.

65
apouche

Wir haben einige Maßnahmen ergriffen, um dem entgegenzuwirken, da wir etwa 100 Zeilen Swift-Code und 300 KB Zeilen ObjC haben. 

Unser erster Schritt war die Optimierung aller Funktionen entsprechend der Ausgabe der Funktionskompilierzeiten (z. B. wie hier beschrieben https://thatthinginswift.com/debug-long-compile-times-Swift/ ).

Als Nächstes haben wir ein Skript geschrieben, um alle Swift-Dateien in einer Datei zusammenzufassen. Dadurch werden die Zugriffsebenen abgebrochen, aber unsere Kompilierzeit wurde von 5-6 Minuten auf ~ 1 Minute verkürzt.

Dies ist jetzt nicht mehr möglich, da wir Apple dazu befragt haben, und es wurde empfohlen, Folgendes zu tun:

  1. Aktivieren Sie "Gesamtmoduloptimierung" in der Build-Einstellung "Swift Compiler - Code Generation". 'Fast, Whole Module Optimization' auswählen

 enter image description here

  1. Fügen Sie in Swift Compiler - Custom Flags für Ihre Entwicklungs-Builds '-Onone' hinzu.

 enter image description here  enter image description here

Wenn diese Flags gesetzt sind, kompiliert der Compiler alle Swift-Dateien in einem Schritt. Mit unserem Merge-Skript haben wir festgestellt, dass dies wesentlich schneller ist als das individuelle Kompilieren von Dateien. Ohne das Überschreiben von '-Onone'' wird jedoch auch das gesamte Modul optimiert, das langsamer ist. Wenn wir das '-Onone'-Flag in den anderen Swift-Flags setzen, wird die Optimierung angehalten, aber es wird nicht angehalten, alle Swift-Dateien in einem Schritt zu kompilieren.

Weitere Informationen zur gesamten Moduloptimierung finden Sie hier im Blog-Beitrag von Apple - https://Swift.org/blog/whole-module-optimizations/

Wir haben herausgefunden, dass diese Einstellungen unseren Swift-Code in 30 Sekunden kompilieren lassen :-) Ich habe keine Hinweise darauf, wie er bei anderen Projekten funktionieren würde, aber ich empfehle, es zu versuchen, wenn Swift-Kompilierzeiten immer noch ein Problem für Sie sind.

Hinweis für Ihre App Store-Builds sollten Sie das Flag '-Onone' auslassen, da die Optimierung für Produktions-Builds empfohlen wird.

39
Sam Stow

Wenn Sie versuchen, bestimmte Dateien zu identifizieren, die die Kompilierzeit verlangsamen, können Sie es über xctool von Ihrer Befehlszeile aus kompilieren.

Die Sache ist zu beachten, dass standardmäßig zwei Dateien gleichzeitig für jeden CPU-Kern erstellt werden und nicht die abgelaufene "Netto" -Zeit, sondern die absolute "Benutzer" -Zeit angegeben wird. Auf diese Weise gleichen sich alle Timings zwischen parallelisierten Dateien aus und sehen sehr ähnlich aus.

Um dies zu vermeiden, setzen Sie das Flag -jobs auf 1, damit die Erstellung von Dateien nicht parallelisiert wird. Es wird länger dauern, aber am Ende haben Sie "net" -Kompilierungszeiten, die Sie Datei für Datei vergleichen können.

Dies ist ein Beispielbefehl, der den Trick ausführen sollte:

xctool -workspace <your_workspace> -scheme <your_scheme> -jobs 1 build

Die Ausgabe der Phase "Kompiliere Swift-Dateien" würde etwa so aussehen:

...
   ✓ Compile EntityObserver.Swift (1623 ms)
   ✓ Compile Session.Swift (1526 ms)
   ✓ Compile SearchComposer.Swift (1556 ms)
...

Anhand dieser Ausgabe können Sie schnell feststellen, welche Dateien länger als andere Dateien kompilieren. Außerdem können Sie mit hoher Genauigkeit feststellen, ob Ihre Refactorings (explizite Besetzungen, Typhinweise usw.) die Kompilierzeiten für bestimmte Dateien verkürzen oder nicht.

HINWEIS: Technisch könnten Sie dies auch mit xcodebuild tun, aber die Ausgabe ist unglaublich wortreich und schwer zu konsumieren. 

33
Andrea Sprega

Es hat wahrscheinlich wenig mit der Größe Ihres Projekts zu tun. Es handelt sich wahrscheinlich um ein bestimmtes Stück Code, möglicherweise sogar nur eine Zeile. Sie können dies testen, indem Sie versuchen, eine Datei statt des gesamten Projekts zu kompilieren. Oder schauen Sie sich die Build-Protokolle an, um zu sehen, welche Datei so lange dauert.

Als Beispiel für die Art von Code, die Probleme verursachen kann, dauert diese 38-Zeilen-Gist in Beta7 mehr als eine Minute, um zu kompilieren. Alles wird durch diesen einen Block verursacht:

let pipeResult =
seq |> filter~~ { $0 % 2 == 0 }
  |> sorted~~ { $1 < $0 }
  |> map~~ { $0.description }
  |> joinedWithCommas

Vereinfachen Sie das durch ein oder zwei Zeilen und es wird fast sofort kompiliert. Das Problem ist, dass dies zu einem exponentiellen Wachstum (möglicherweise faktorielles Wachstum) im Compiler führt. Das ist natürlich nicht ideal, und wenn Sie solche Situationen isolieren können, sollten Sie Radargeräte öffnen, um diese Probleme zu beseitigen.

30
Rob Napier

In meinem Fall machte Xcode 7 überhaupt keinen Unterschied. Ich hatte mehrere Funktionen, die einige Sekunden zum Kompilieren benötigten.

Beispiel

// Build time: 5238.3ms
return CGSize(width: size.width + (rightView?.bounds.width ?? 0) + (leftView?.bounds.width ?? 0) + 22, height: bounds.height)

Nach dem Entpacken der Optionals fiel die Erstellungszeit um 99,4%.

// Build time: 32.4ms
var padding: CGFloat = 22
if let rightView = rightView {
    padding += rightView.bounds.width
}

if let leftView = leftView {
    padding += leftView.bounds.width
}
return CGSizeMake(size.width + padding, bounds.height)

Weitere Beispiele finden Sie in diesem Beitrag und diesem Beitrag

Build Time Analyzer für Xcode

Ich habe ein Xcode-Plug-in entwickelt , das für alle hilfreich sein kann, die unter diesen Problemen leiden.

 image

In Swift 3 scheint es Verbesserungen zu geben. Hoffentlich werden wir dann den Swift-Code schneller kompilieren.

25

Die Lösung ist Gießen.

Ich hatte eine riesige Auswahl an Wörterbüchern wie diese:

["title" : "someTitle", "textFile" : "someTextFile"],
["title" : "someTitle", "textFile" : "someTextFile"],
["title" : "someTitle", "textFile" : "someTextFile"],
["title" : "someTitle", "textFile" : "someTextFile"],
.....

Das Kompilieren dauerte ungefähr 40 Minuten. Bis ich die Wörterbücher so gegossen habe:

["title" : "someTitle", "textFile" : "someTextFile"] as [String : String],
["title" : "someTitle", "textFile" : "someTextFile"] as [String : String],
["title" : "someTitle", "textFile" : "someTextFile"] as [String : String],
....

Dies funktionierte bei fast allen anderen Problemen, bei denen ich in Bezug auf Datentypen auftrat, die ich in meiner Anwendung fest programmiert hatte.

16
YichenBman

Zu beachten ist, dass die Swift-Inferenz-Engine bei verschachtelten Typen sehr langsam sein kann. Sie können sich einen Überblick über die Ursachen der Langsamkeit verschaffen, indem Sie das Buildprotokoll für einzelne, sehr lange Kompilierungseinheiten betrachten und dann den vollständigen Xcode-erzeugten Befehl in ein Terminal-Fenster kopieren und einfügen und dann STRG-\drücken, um zu erhalten einige diagnostiken. Ein ausführliches Beispiel finden Sie unter http://blog.impathic.com/post/99647568844/debugging-slow-Swift-compile-times .

15
marcprux

Wir können den Swift-Compiler wahrscheinlich nicht reparieren, aber etwas, das wir beheben können, ist unser Code!

Im Swift-Compiler gibt es eine versteckte Option, die die genauen Zeitintervalle ausgibt, die der Compiler zum Kompilieren jeder einzelnen Funktion benötigt: -Xfrontend -debug-time-function-bodies. Dadurch können wir Engpässe in unserem Code finden und die Kompilierzeit erheblich verbessern.

Führen Sie einfach folgendes im Terminal aus und analysieren Sie die Ergebnisse:

xcodebuild -workspace App.xcworkspace -scheme App clean build OTHER_Swift_FLAGS="-Xfrontend -debug-time-function-bodies" | grep [1-9].[0-9]ms | sort -nr > culprits.txt

Awesome Brian Irace hat einen brillanten Artikel darüber geschrieben Profilieren Sie Ihre Swift-Kompilierungszeiten .

15

Stellen Sie außerdem sicher, dass Sie beim Kompilieren für Debugging (entweder Swift oder Objective-C) die Option Nur aktive Architektur erstellen festgelegt haben:

enter image description here

9
Rivera

Da all das Zeug in der Beta-Version ist und der Swift-Compiler (zumindest ab heute) nicht offen ist, gibt es vermutlich keine wirkliche Antwort auf Ihre Frage.

Zunächst einmal ist der Vergleich von Objective-C mit dem Swift-Compiler irgendwie grausam. Swift befindet sich noch in der Beta-Phase, und ich bin sicher, dass Apple daran arbeitet, Funktionalität bereitzustellen und Fehler zu beheben. Ich denke, Apple wird den Compiler rechtzeitig optimieren.

Wenn aus irgendeinem Grund alle Quelldateien vollständig kompiliert werden müssen, besteht die Möglichkeit, getrennte Module/Bibliotheken zu erstellen. Diese Option ist jedoch noch nicht möglich, da Swift Bibliotheken erst zulassen kann, wenn die Sprache stabil ist.

Ich vermute, dass sie den Compiler optimieren werden. Aus dem gleichen Grund, dass wir keine vorkompilierten Module erstellen können, könnte es sein, dass der Compiler alles von Grund auf neu kompilieren muss. Sobald die Sprache eine stabile Version erreicht hat und sich das Format der Binärdateien nicht mehr ändert, können wir unsere Bibliotheken erstellen, und vielleicht (?) Kann der Compiler auch seine Arbeit optimieren.

Nur raten, denn nur Apple weiß ...

6
George

Wechseln Sie für Xcode 8 zu den Projekteinstellungen, dann zu Editor> Build-Einstellung hinzufügen> Benutzerdefinierte Einstellung hinzufügen, und fügen Sie Folgendes hinzu:

Swift_WHOLE_MODULE_OPTIMIZATION = YES

Durch das Hinzufügen dieses Kennzeichens fielen unsere sauberen Kompilierzeiten für ein 40KLOC Swift-Projekt auf wundersame Weise von 7 Minuten auf 65 Sekunden. Außerdem kann bestätigt werden, dass 2 Freunde ähnliche Verbesserungen bei Unternehmensprojekten gesehen haben.

Ich kann nur annehmen, dass dies eine Art Fehler in Xcode 8.0 ist

BEARBEITEN: Für manche Leute scheint es in Xcode 8.3 nicht mehr zu funktionieren.

5
Chris

Verwenden Sie zum Debuggen und Testen die folgenden Einstellungen, um die Kompilierzeit von ca. 20 Minuten auf weniger als 2 Minuten zu verkürzen.

  1. Suchen Sie in den Projekterstellungseinstellungen nach "Optimierung" Schalten Sie Debug auf "Schnellste [-O3]" oder höher. 
  2. Set Build for Active Architecture: JA
  3. Debug-Informationsformat: DWARF 
  4. Gesamtmodul-Optimierung: NEIN

Ich habe unzählige Stunden damit verbracht, auf das Projekt zu warten, nur um zu realisieren, dass ich diese kleine Änderung vornehmen musste und weitere 30 Minuten warten musste, um es zu testen. Diese Einstellungen haben für mich funktioniert. (Ich experimentiere immer noch mit den Einstellungen)

Stellen Sie jedoch sicher, dass Sie mindestens "DWARF with dSYM" (wenn Sie Ihre Anwendung überwachen möchten) und "Aktive Architektur erstellen" für "Release/Archiving" für Push to iTunes Connect auf "NO" gesetzt haben (ich erinnere mich, dass ich auch hier einige Stunden verschwendet habe). 

4
Mahesh

Der Aufbau von schnellen Arrays und Wörterbüchern scheint ein ziemlich beliebter Grund zu sein (besonders für Sie, die aus einem Ruby - Hintergrund stammen), dh

var a = ["a": "b",
         "c": "d",
         "e": "f",
         "g": "h",
         "i": "j",
         "k": "l",
         "m": "n",
         "o": "p",
         "q": "r",
         "s": "t",
         "u": "v",
         "x": "z"]

wird wohl die Ursache sein, wo dies behoben werden sollte:

var a = NSMutableDictionary()
a["a"] = "b"
a["c"] = "d"
... and so on
4
Marcelo Ribeiro

Leider ist der Swift-Compiler immer noch nicht für die schnelle und inkrementelle Kompilierung (ab Xcode 6.3 beta) optimiert. In der Zwischenzeit können Sie einige der folgenden Techniken verwenden, um die Kompilierzeit von Swift zu verbessern:

  • Teilen Sie die App in Frameworks, um die Auswirkungen der Neukompilierung zu reduzieren. Beachten Sie jedoch, dass Sie zyklische Abhängigkeiten in Ihrer App vermeiden müssen. Weitere Informationen zu diesem Thema finden Sie in diesem Beitrag: http://bits.citrusbyte.com/improving-Swift-compile-time/

  • Verwenden Sie Swift für Teile Ihres Projekts, die ziemlich stabil sind und sich nicht oft ändern. In anderen Bereichen, in denen häufig gewechselt werden muss oder in denen viele Iterationen zum Kompilieren/Ausführen erforderlich sind (fast alle UI-bezogenen Elemente), sollten Sie Objective-C besser mit einem Mix-and-Match-Ansatz verwenden.

  • Testen Sie die Laufzeitcode-Injektion mit 'Injection for Xcode'.

  • Verwenden Sie die roopc-Methode: http://roopc.net/posts/2014/speeding-up-Swift-builds/

  • Entlasten Sie die Swift-Inferenz-Engine, indem Sie einige Hinweise mit expliziten Besetzungen geben.

4
vorterixe

Der Compiler verbringt viel Zeit damit, die Typen zu ermitteln und zu überprüfen. Das Hinzufügen von Typanmerkungen hilft dem Compiler also sehr. 

Wenn Sie viele verkettete Funktionsaufrufe haben wie

let sum = [1,2,3].map({String($0)}).flatMap({Float($0)}).reduce(0, combine: +)

Der Compiler braucht dann eine Weile, um herauszufinden, welcher Typ von sum sein sollte. Das Hinzufügen des Typs hilft. Was auch hilft, ist, die intermittierenden Schritte in separate Variablen zu ziehen. 

let numbers: [Int] = [1,2,3]
let strings: [String] = sum.map({String($0)})
let floats: [Float] = strings.flatMap({Float($0)})
let sum: Float = floats.reduce(0, combine: +)

Insbesondere für numerische Typen CGFloat, Int kann es sehr hilfreich sein. Eine Literalzahl wie 2 kann viele verschiedene numerische Typen darstellen. Der Compiler muss also aus dem Kontext herausfinden, um welchen es sich handelt.

Funktionen, die wie + lange nachschlagen, sollten ebenfalls vermieden werden. Die Verwendung mehrerer + zum Verketten mehrerer Arrays ist langsam, da der Compiler herausfinden muss, welche Implementierung von + für jeden + aufgerufen werden muss. Verwenden Sie daher möglichst einen var a: [Foo] mit append().

Sie können eine Warnung hinzufügen, um zu ermitteln, welche Funktionen in Xcode langsam zu übersetzen sind. 

In Build-Einstellungen für Ihr Ziel nach Other Swift Flags suchen und hinzufügen 

-Xfrontend -warn-long-function-bodies=100 

für jede Funktion zu warnen, deren Kompilierung länger als 100 ms dauert.

3
orkoden

Der Neustart meines Mac hat für dieses Problem Wunder bewirkt. Ich bin von 15 Minuten Builds zu 30 Sekunden Builds geworden, nur durch einen Neustart.

3
Sigma4Life

Für die Projekte, die Objective-C- und Swift-Code kombinieren, können Sie -enable-bridging-pch in Other Swift Flags einstellen. Damit wird der Bridging-Header nur einmal analysiert und das Ergebnis (eine temporäre "vorkompilierte Header-" oder "PCH" -Datei) wird zwischengespeichert und in allen Swift-Dateien im Ziel verwendet. Apple behauptete, dass die Bauzeit um 30% sinkt. Referenzlink:

HINWEIS: Dies funktioniert nur für Swift 3.1 und höher.

2
iHS

Schnelle Kompilierzeit wurde im neuen Xcode 6.3 verbessert

Compiler-Verbesserungen

Der Swift 1.2-Compiler wurde so entwickelt, dass er stabiler ist und verbessert Leistung in jeder Hinsicht. Diese Änderungen bieten auch eine bessere Erfahrung mit Swift in Xcode. Einige der sichtbarsten Verbesserungen umfassen:

Inkrementelle Builds

Quelldateien, die nicht geändert wurden, werden von .__ nicht mehr neu kompiliert. default, wodurch sich die Build-Zeiten für die meisten verbreiteten Fälle. Größere strukturelle Änderungen an Ihrem Code erfordern möglicherweise noch mehrere Dateien müssen neu erstellt werden.

Schnellere ausführbare Dateien

Debug-Builds erzeugen Binärdateien, die erheblich schneller laufen, und neue Optimierungen liefern noch bessere Release-Build-Leistung.

Bessere Compiler-Diagnose

Klarere Fehler- und Warnmeldungen machen es zusammen mit den neuen Fix-its einfacher, richtigen Swift 1.2-Code zu schreiben.

Stabilitätsverbesserungen

Die häufigsten Compiler-Abstürze wurden behoben. Sie sollten auch .__ sehen. weniger SourceKit-Warnungen im Xcode-Editor.

1
Vojtech Vrbka

Hier ist ein weiterer Fall, der bei Typinferenz massive Verlangsamungen verursachen kann. Koaleszenzoperatoren .

Zeilenwechsel wie:

abs(some_optional_variable ?? 0)

zu

abs((some_optional_variable ?? 0) as VARIABLE_TYPE)

habe dazu beigetragen, meine Kompilierzeit von 70 auf 13s zu bringen

0
Harry Mexican

In Xcode 6.3.1 funktionierte nichts für mich - als ich rund 100 Swift-Dateien hinzufügte, hing Xcode zufällig an Build und/oder Indexierung. Ich habe eine modulare Option ohne Erfolg ausprobiert.

Installieren und Verwenden von Xcode 6.4 Beta hat bei mir tatsächlich funktioniert.

0
hris.to

Das hat für mich magisch funktioniert - Speed ​​Up Swift Compilation . Die Compilierzeit wurde von 10 Minuten auf 3 Minuten reduziert.

Es besagt, dass Sie Whole Module Optimization einschalten sollen, während Sie -Onone in Other Swift Flags hinzufügen.

Ich verwende Swift 3 F&UUML;R Xcode 8.3/Xcode 8.2.

0
Forge