Binäre Größen (unkomprimiert):

Fable 2.0.0 alpha, FCS 24.0.1
------------------------------------------------

------------------------------------------------
REPL benchmark - DotNet Core 2.1.300 (Release)
------------------------------------------------
bench.dll     :     14,848 bytes
Fable.JS.dll  :  1,613,824 bytes
fcs-fable.dll : 11,409,920 bytes 
------------- : ----------------
Total 3 Files : 13,038,592 bytes

------------------------------------------------
REPL benchmark - Fable 1.3.7, JavaScript
------------------------------------------------
CommonJS   :  10,784,296 bytes
ES2015     :   9,916,968 bytes
rollup     :   9,311,190 bytes
webpack -p :   4,776,623 bytes

------------------------------------------------
REPL benchmark - Fable 2.0.0 alpha, JavaScript
------------------------------------------------
CommonJS   :  14,197,490 bytes
ES2015     :  13,402,026 bytes
rollup     :  11,118,337 bytes
webpack -p :   3,679,020 bytes

Sieht so aus, als ob die nicht verkleinerte Größe 30% größer ist als die von Fable 1.3.x, aber das geht nach der Verkleinerung weg.
Gute Arbeit @alfonsogarciacaro!

Large test file (50 kB):

------------------------------------------------
REPL benchmark - DotNet Core 2.1.300
------------------------------------------------
InteractiveChecker created in 1374 ms
iteration 1, FCS time: 2837 ms, Fable time: 864 ms
iteration 2, FCS time: 417 ms, Fable time: 263 ms
iteration 3, FCS time: 373 ms, Fable time: 303 ms
iteration 4, FCS time: 495 ms, Fable time: 236 ms
iteration 5, FCS time: 363 ms, Fable time: 229 ms
iteration 6, FCS time: 462 ms, Fable time: 233 ms
iteration 7, FCS time: 433 ms, Fable time: 222 ms
iteration 8, FCS time: 369 ms, Fable time: 297 ms
iteration 9, FCS time: 378 ms, Fable time: 228 ms
iteration 10, FCS time: 461 ms, Fable time: 226 ms

------------------------------------------------
REPL benchmark - Fable 2.0.0 alpha, Node.js 10.5.0
------------------------------------------------
InteractiveChecker created in 2914 ms
iteration 1, FCS time: 7527 ms, Fable time: 531 ms
iteration 2, FCS time: 8852 ms, Fable time: 275 ms
iteration 3, FCS time: 8392 ms, Fable time: 257 ms
iteration 4, FCS time: 8266 ms, Fable time: 241 ms
iteration 5, FCS time: 8308 ms, Fable time: 212 ms
iteration 6, FCS time: 8123 ms, Fable time: 349 ms
iteration 7, FCS time: 8336 ms, Fable time: 209 ms
iteration 8, FCS time: 8305 ms, Fable time: 207 ms
iteration 9, FCS time: 8214 ms, Fable time: 202 ms
iteration 10, FCS time: 8207 ms, Fable time: 201 ms

Sieht so aus, als ob das FCS-Javascript nicht linear mit der Größe skaliert.
Update: Aktuelle Statistiken finden Sie am Ende des Threads.

Dieses tolle @ncave! Vielen Dank für diese Daten, es wird viel einfacher zu überprüfen, ob zukünftige Entwicklungen in die richtige Richtung gehen :+1: Die Ergebnisse sind sehr interessant und vielversprechend. Es ist wirklich ermutigend zu sehen, dass der Fable-Teil so schnell ist wie .NET (obwohl es vielleicht daran liegt, dass wir die Optimierungsphase überspringen) und ich bin sicher, dass wir den FCS-Teil auch schneller machen können.

Es wurde erwartet, dass das unminifizierte Bundle etwas größer ist (wegen Namensmängeln), aber auch, dass das Ergebnis mit JS-Minifiern besser funktionieren würde :) Ich frage mich, ob die Verbesserung beim Erstellen des Interactive Checkers auch auf die WebAssembly-Bits in Long.js zurückzuführen ist. da der int64-Typ beim Lesen der Assemblys häufig verwendet wird.

@alfonsogarciacaro Gute Nachrichten an alle! Nach der Umstellung des FCS-Lexers von char auf uint16 verbesserten sich die Bench-Times von 20x auf 2x (im Vergleich zu dotnet core) bei großen Dateien.
Update: Aktuelle Statistiken finden Sie am Ende des Threads.

Large test file (50 kB):

------------------------------------------------
REPL benchmark - DotNet Core 2.1.300
------------------------------------------------
InteractiveChecker created in 1244 ms
iteration 1, FCS time: 2672 ms, Fable time: 786 ms
iteration 2, FCS time: 438 ms, Fable time: 213 ms
iteration 3, FCS time: 343 ms, Fable time: 212 ms
iteration 4, FCS time: 349 ms, Fable time: 211 ms
iteration 5, FCS time: 360 ms, Fable time: 213 ms
iteration 6, FCS time: 435 ms, Fable time: 217 ms
iteration 7, FCS time: 436 ms, Fable time: 211 ms
iteration 8, FCS time: 352 ms, Fable time: 214 ms
iteration 9, FCS time: 354 ms, Fable time: 217 ms
iteration 10, FCS time: 348 ms, Fable time: 222 ms

------------------------------------------------
REPL benchmark - Fable 2.0.0 alpha, Node.js 10.5.0
------------------------------------------------
InteractiveChecker created in 2885 ms
iteration 1, FCS time: 2209 ms, Fable time: 531 ms
iteration 2, FCS time: 1259 ms, Fable time: 287 ms
iteration 3, FCS time: 923 ms, Fable time: 263 ms
iteration 4, FCS time: 838 ms, Fable time: 229 ms
iteration 5, FCS time: 898 ms, Fable time: 249 ms
iteration 6, FCS time: 787 ms, Fable time: 234 ms
iteration 7, FCS time: 734 ms, Fable time: 223 ms
iteration 8, FCS time: 701 ms, Fable time: 214 ms
iteration 9, FCS time: 688 ms, Fable time: 204 ms
iteration 10, FCS time: 712 ms, Fable time: 200 ms

Bei mittelgroßen Dateien von 7x auf 3x (im Vergleich zu Dotnet-Kern):
Update: Aktuelle Statistiken finden Sie am Ende des Threads.

Medium test file (10 kB):

------------------------------------------------
REPL benchmark - DotNet Core 2.1.300
------------------------------------------------
InteractiveChecker created in 1251 ms
iteration 1, FCS time: 2401 ms, Fable time: 614 ms
iteration 2, FCS time: 73 ms, Fable time: 41 ms
iteration 3, FCS time: 67 ms, Fable time: 41 ms
iteration 4, FCS time: 94 ms, Fable time: 40 ms
iteration 5, FCS time: 87 ms, Fable time: 41 ms
iteration 6, FCS time: 87 ms, Fable time: 42 ms
iteration 7, FCS time: 69 ms, Fable time: 41 ms
iteration 8, FCS time: 66 ms, Fable time: 42 ms
iteration 9, FCS time: 66 ms, Fable time: 41 ms
iteration 10, FCS time: 70 ms, Fable time: 41 ms

------------------------------------------------
REPL benchmark - Fable 2.0.0 alpha, Node.js 10.5.0
------------------------------------------------
InteractiveChecker created in 2868 ms
iteration 1, FCS time: 896 ms, Fable time: 239 ms
iteration 2, FCS time: 365 ms, Fable time: 128 ms
iteration 3, FCS time: 346 ms, Fable time: 74 ms
iteration 4, FCS time: 242 ms, Fable time: 63 ms
iteration 5, FCS time: 215 ms, Fable time: 70 ms
iteration 6, FCS time: 199 ms, Fable time: 58 ms
iteration 7, FCS time: 212 ms, Fable time: 55 ms
iteration 8, FCS time: 213 ms, Fable time: 58 ms
iteration 9, FCS time: 200 ms, Fable time: 56 ms
iteration 10, FCS time: 183 ms, Fable time: 52 ms

Das ist großartig @ncave , tolle Arbeit!!! :Klatsch Klatsch klatsch:

Tolle Arbeit

Danke für das was du tust 👏 👏

Ich bin sehr froh , dass wir endlich ein gutes Beispiel für die Leistungssteigerung haben typisierten Arrays dank Ihnen @ncave :) Ich frage mich auch , wenn wir die Erstellung berücksichtigen sollten , char als JS number ( und char[] als UInt16Array ). IIRC war der Hauptgrund für die Verwendung von JS string Aufzählung von Zeichenfolgen. Aber wir müssen jetzt sowieso eine spezielle Konvertierung von string in char seq vornehmen , um #1279 zu beheben. Wir könnten also die Gelegenheit nutzen, die Zeichendarstellung zu ändern. Was denkst du @ncave?

@alfonsogarciacaro Klar, versuchen wir es, da wir jetzt die Leistung messen können.

@ncave Ich habe mit der Kompilierung von Zeichen als Zahlen in diesem Zweig begonnen . Ich habe es geschafft, die Tests zu bestehen, aber ich mache mir Sorgen, dass es Situationen geben kann, in denen string in ein nicht typisiertes IEnumerable oder ein allgemeines seq<'T> und die Dinge kaputt gehen können, weil wir es nicht können erkennen die Konvertierungen und beim Aufzählen erhalten wir Zeichenfolgen anstelle von Zahlen. Was denken Sie?

@alfonsogarciacaro Hast du ein Beispiel?

@alfonsogarciacaro Ich meine, ist es anders, als char (oder int oder float) auf ein Objekt zu herumzugeben , wo Sie Typ verlieren?

Etwas erfunden, aber ungefähr so:

open System.Collections

let chunkTyped size (xs: 'T seq) =
    Seq.chunkBySize size xs

let chunkUntyped size (xs: IEnumerable) =
    xs |> Seq.cast<obj> |> Seq.chunkBySize size

testCase "Casting string to IEnumerable" <| fun () ->
    let xs1 = "fffff" |> chunkTyped 3
    let xs2 = "fffff" |> chunkUntyped 3
    Seq.toList xs1 |> equal [[|'f';'f';'f'|]; [|'f';'f'|]]
    Seq.toList xs2 |> equal [[|'f';'f';'f'|]; [|'f';'f'|]]

Der zweite Assert schlägt in Fable dev2.0-chars fehl (er wird in .NET F# übergeben). Obwohl jetzt, wo ich darüber nachdenke, ist es vielleicht nicht etwas sehr wichtig sein , weil wir bereits wissen , die Generika bei der Kompilierung für viele Erhebungsmethoden angewiesen, so zu untypisierten Gießen IEnumerable in viele zu verursachen Probleme gebunden ist Situationen. Können wir damit leben? Ist das Kompilieren von Zeichen als Zahlen eine Verbesserung?

Ein anderes Problem, das mir gerade aufgefallen ist, ist das Drucken von Zeichen (wie in printfn "%A" 'a' ).

@alfonsogarciacaro Ich weiß nicht, ob das Kompilieren von Zeichen als Zahlen eine Verbesserung darstellt, wenn ich versuche, die dev2.0-chars zu testen, aber es schlägt fehl :
Fable/src/dotnet/Fable.Core/Fable.Core.fs(1,1): error FABLE: Classes without a primary constructor cannot be inherited: System.Attribute
Gab es in letzter Zeit einen Wechsel bei den Konstrukteuren in dieser Branche?

Hmm, ich habe etwas defensiven Code entfernt , um die Dinge zu vereinfachen, aber es ist seltsam, dass der Fehler vorher nicht aufgetreten ist. Im Moment habe ich nur einen Dummy-Attributtyp hinzugefügt, damit es möglich ist, davon zu erben und dann den dev2.0-chars-Zweig umzubasieren.

@alfonsogarciacaro Ich sehe keinen Unterschied in der dev2.0 und dev2.0-chars , also liegt es an dir, welchen Weg du gehen willst, was am besten funktioniert. Möglicherweise muss JS-Interop berücksichtigt werden, aber ich bin kein Experte, also habe ich keine Meinung. Wenn Sie sich entscheiden, die Zeichen durch Ints zu ersetzen, kann das printfn-Problem "%A" vielleicht behoben werden, indem Sie die Argumenttypen untersuchen und die Zeichen konvertieren, bevor Sie das print-Javascript aufrufen, aber ich habe wirklich keine Präferenz.

Perfekt, vielen Dank für das Überprüfen von @ncave. Ok, ich werde vorerst nur eine WIP-PR einreichen, und wir können sie später erneut überprüfen. Übrigens, ich möchte die REPL erneut in Appveyor erstellen (ich habe immer wieder Probleme beim lokalen Erstellen der REPL auf macOS). Verwenden Sie dafür nur das REPL-Fake-Target oder tun Sie etwas anderes?

@alfonsogarciacaro Ich habe gerade die Bank gebaut ( cd src/dotnet/Fable.JS/bench && yarn build ).
Nur zur Info, es gibt immer noch ein offenes Problem mit dem von Fable 2.0 generierten FCS-Javascript, mit dem ich zu kämpfen habe. Es gibt keine Objektmember außer dem Konstruktor in den F# AST aus. Dies könnte die obigen Statistiken tatsächlich verzerren, da danach weniger Arbeit zu verarbeiten ist. Aber es sollte kein Problem sein, es nach CI zu erstellen.

@ncave Ich habe einige Änderungen an der Bank-App vorgenommen, ich hoffe, Sie sind damit fable-repl Verzeichnis Fable.JS/out entpackt habe (Sie können es auch erhalten, indem Sie yarn build in Fable.JS-Verzeichnis ausführen) und dann Ausführen von sh local_test.sh im Verzeichnis bench (beachten Sie, dass ich auch die Metadatendateien im Repository aktualisiert habe):

REPL benchmark - DotNet Core 2.1.200 (Release)
------------------------------------------------
iteration 1, FCS time: 11090 ms, Fable time: 5615 ms
iteration 2, FCS time: 1358 ms, Fable time: 747 ms
iteration 3, FCS time: 1693 ms, Fable time: 592 ms
iteration 4, FCS time: 1148 ms, Fable time: 487 ms
iteration 5, FCS time: 803 ms, Fable time: 739 ms
iteration 6, FCS time: 1378 ms, Fable time: 669 ms
iteration 7, FCS time: 785 ms, Fable time: 492 ms
iteration 8, FCS time: 937 ms, Fable time: 522 ms
iteration 9, FCS time: 946 ms, Fable time: 487 ms
iteration 10, FCS time: 783 ms, Fable time: 579 ms

------------------------------------------------
REPL benchmark - Fable 2.0.0 alpha, Node.js 8.9.4
------------------------------------------------
InteractiveChecker created in 3893 ms
iteration 1, FCS time: 3866 ms, Fable time: 1270 ms
iteration 2, FCS time: 2955 ms, Fable time: 768 ms
iteration 3, FCS time: 2277 ms, Fable time: 781 ms
iteration 4, FCS time: 2327 ms, Fable time: 719 ms
iteration 5, FCS time: 2017 ms, Fable time: 616 ms
iteration 6, FCS time: 2048 ms, Fable time: 624 ms
iteration 7, FCS time: 2134 ms, Fable time: 584 ms
iteration 8, FCS time: 1945 ms, Fable time: 616 ms
iteration 9, FCS time: 2038 ms, Fable time: 1009 ms
iteration 10, FCS time: 1996 ms, Fable time: 692 ms

Übrigens, ich habe die #if FABLE_COMPILER Bedingungen in FableTransforms.fs entfernt und die JS-Kompilierung funktioniert immer noch! (Wie erwartet arbeitet der Fable-Teil jetzt etwas mehr.) Mein Computer ist langsamer als Ihrer, aber die Vergleichsergebnisse scheinen ähnlich zu sein :)

Wir können wahrscheinlich jetzt die Beta ankündigen und eine Online-Version von REPL 2 vorbereiten :tada:

@alfonsogarciacaro Das ist in Ordnung, obwohl ich es

Sie haben Recht, aber es war etwas schwierig, ein einzelnes Projekt nach dem Trennen der REPL zu behalten (die JS-Version hat keinen direkten Bezug zu Fable.JS). Die Hauptdatei ist jedoch für beide Projekte immer noch dieselbe ( Fable.JS/bench/app.fs ), sodass hoffentlich verhindert wird, dass der Code divergiert. Vielleicht können wir versuchen, sie vorerst so zu belassen und zu einem einzelnen Projekt zurückzukehren, wenn wir feststellen, dass es nicht funktioniert?

1487 behebt das Problem, dass REPL einige Bindungen überspringt. Wie vermutet, sind die reellen Zahlen nicht mehr so ​​spektakulär wie zuvor, da der Compiler mehr tun muss, hier die neuesten realistischeren Zahlen:

Large test file (50 kB):
------------------------------------------------

------------------------------------------------
REPL benchmark - DotNet Core 2.1.301
------------------------------------------------
InteractiveChecker created in 1273 ms
iteration 1, FCS time: 2876 ms, Fable time: 814 ms
iteration 2, FCS time: 436 ms, Fable time: 213 ms
iteration 3, FCS time: 372 ms, Fable time: 211 ms
iteration 4, FCS time: 369 ms, Fable time: 216 ms
iteration 5, FCS time: 374 ms, Fable time: 214 ms
iteration 6, FCS time: 370 ms, Fable time: 215 ms
iteration 7, FCS time: 374 ms, Fable time: 214 ms
iteration 8, FCS time: 441 ms, Fable time: 212 ms
iteration 9, FCS time: 429 ms, Fable time: 220 ms
iteration 10, FCS time: 373 ms, Fable time: 214 ms

------------------------------------------------
REPL benchmark - Fable 2.0.0 alpha, Node.js 10.6.0
------------------------------------------------
InteractiveChecker created in 1830 ms
iteration 1, FCS time: 3434 ms, Fable time: 1490 ms
iteration 2, FCS time: 2131 ms, Fable time: 956 ms
iteration 3, FCS time: 1724 ms, Fable time: 948 ms
iteration 4, FCS time: 1521 ms, Fable time: 893 ms
iteration 5, FCS time: 1464 ms, Fable time: 831 ms
iteration 6, FCS time: 1561 ms, Fable time: 908 ms
iteration 7, FCS time: 1402 ms, Fable time: 841 ms
iteration 8, FCS time: 1341 ms, Fable time: 830 ms
iteration 9, FCS time: 1468 ms, Fable time: 894 ms
iteration 10, FCS time: 1370 ms, Fable time: 847 ms


------------------------------------------------
Medium test file (10 kB):
------------------------------------------------

------------------------------------------------
REPL benchmark - DotNet Core 2.1.301
------------------------------------------------
InteractiveChecker created in 1286 ms
iteration 1, FCS time: 2571 ms, Fable time: 654 ms
iteration 2, FCS time: 74 ms, Fable time: 43 ms
iteration 3, FCS time: 75 ms, Fable time: 43 ms
iteration 4, FCS time: 78 ms, Fable time: 46 ms
iteration 5, FCS time: 74 ms, Fable time: 43 ms
iteration 6, FCS time: 73 ms, Fable time: 42 ms
iteration 7, FCS time: 75 ms, Fable time: 42 ms
iteration 8, FCS time: 78 ms, Fable time: 42 ms
iteration 9, FCS time: 73 ms, Fable time: 42 ms
iteration 10, FCS time: 74 ms, Fable time: 49 ms

------------------------------------------------
REPL benchmark - Fable 2.0.0 alpha, Node.js 10.6.0
------------------------------------------------
InteractiveChecker created in 1849 ms
iteration 1, FCS time: 1283 ms, Fable time: 597 ms
iteration 2, FCS time: 704 ms, Fable time: 269 ms
iteration 3, FCS time: 518 ms, Fable time: 242 ms
iteration 4, FCS time: 473 ms, Fable time: 217 ms
iteration 5, FCS time: 435 ms, Fable time: 232 ms
iteration 6, FCS time: 390 ms, Fable time: 210 ms
iteration 7, FCS time: 364 ms, Fable time: 197 ms
iteration 8, FCS time: 385 ms, Fable time: 200 ms
iteration 9, FCS time: 369 ms, Fable time: 190 ms
iteration 10, FCS time: 355 ms, Fable time: 180 ms

Dennoch ist nur etwa 4x-5x langsamer (im Vergleich zum hochoptimierten .NET Core) für den Anfang nicht schlecht.
Ich glaube, wir haben noch nicht alle Optimierungsmöglichkeiten ausgelotet.

@ncave Latest Fable 2 Online REPL fügt den FCS/Fable-Compiler in einen Worker ein, damit die Benutzeroberfläche nicht einfriert. Ich habe auch eine Option hinzugefügt, um die FCS-Optimierung, die Protokollierung einiger Leistungsstatistiken (sichtbar in der Browserkonsole, ähnlich denen, die Sie für die Bank erstellt haben) sowie die Sudoku- und Raytrace-Beispiele zu aktivieren. Hoffentlich erleichtert dies das Spielen mit der REPL, um mehr Optimierungsmöglichkeiten zu finden :)

Übrigens, Fable 1.37 war etwa 10x langsamer als .NET, oder? Wir haben also immer noch eine Leistungssteigerung, auch wenn die Zeiten nicht so nah wie erhofft an .NET sind.

@alfonsogarciacaro Ja, Fable 2.0 scheint ungefähr doppelt so schnell zu sein wie Fable 1.3.x.

@ncave Ich mische hier die Fable 1-Statistiken aus dem ersten Kommentar mit Fable 2-Daten aus diesem . Sieht das richtig aus?

Medium test file (10 kB):

------------------------------------------------
REPL benchmark - DotNet Core 2.1.300
------------------------------------------------
InteractiveChecker created in 1315 ms
iteration 1, FCS time: 2418 ms, Fable time: 598 ms
iteration 2, FCS time: 78 ms, Fable time: 42 ms
iteration 3, FCS time: 67 ms, Fable time: 41 ms
iteration 4, FCS time: 74 ms, Fable time: 41 ms
iteration 5, FCS time: 67 ms, Fable time: 44 ms
iteration 6, FCS time: 66 ms, Fable time: 62 ms
iteration 7, FCS time: 71 ms, Fable time: 104 ms
iteration 8, FCS time: 74 ms, Fable time: 52 ms
iteration 9, FCS time: 67 ms, Fable time: 43 ms
iteration 10, FCS time: 88 ms, Fable time: 41 ms

------------------------------------------------
REPL benchmark - Fable 1.3.7, Node.js 10.5.0
------------------------------------------------
InteractiveChecker created in 5232 ms
iteration 1, FCS time: 1866 ms, Fable time: 736 ms
iteration 2, FCS time: 1077 ms, Fable time: 402 ms
iteration 3, FCS time: 969 ms, Fable time: 348 ms
iteration 4, FCS time: 846 ms, Fable time: 328 ms
iteration 5, FCS time: 834 ms, Fable time: 322 ms
iteration 6, FCS time: 764 ms, Fable time: 304 ms
iteration 7, FCS time: 745 ms, Fable time: 293 ms
iteration 8, FCS time: 744 ms, Fable time: 286 ms
iteration 9, FCS time: 729 ms, Fable time: 289 ms
iteration 10, FCS time: 728 ms, Fable time: 287 ms

------------------------------------------------
REPL benchmark - Fable 2.0.0 alpha, Node.js 10.6.0
------------------------------------------------
InteractiveChecker created in 1849 ms
iteration 1, FCS time: 1283 ms, Fable time: 597 ms
iteration 2, FCS time: 704 ms, Fable time: 269 ms
iteration 3, FCS time: 518 ms, Fable time: 242 ms
iteration 4, FCS time: 473 ms, Fable time: 217 ms
iteration 5, FCS time: 435 ms, Fable time: 232 ms
iteration 6, FCS time: 390 ms, Fable time: 210 ms
iteration 7, FCS time: 364 ms, Fable time: 197 ms
iteration 8, FCS time: 385 ms, Fable time: 200 ms
iteration 9, FCS time: 369 ms, Fable time: 190 ms
iteration 10, FCS time: 355 ms, Fable time: 180 ms

@alfonsogarciacaro Mehr oder weniger ja. Sie sind sich nicht sicher, was Sie tun möchten, aktuelle Messungen oder ein erneutes Posten vom Anfang des Threads? Die REPL-Leistung hat sich nach dem Zurückschalten der Zeichen-Impl nicht viel geändert, was gut ist. Wir können nachmessen, nachdem sich die Immobilienbranche eingestellt hat.

Danke @ncave. Ich wollte nur den richtigen Vergleich zwischen Fable 1 und 2 haben, um ihn in Schlagposts und Talks zu zeigen :)

@alfonsogarciacaro Um fair zu sein, kommt ein Teil der Fable2-Verbesserung der REPL-Arbeitslast aus der Umstellung des FCS-Fable-Lexers von char auf uint16, was auch Fable1 zugute gekommen wäre, daher bin ich mir nicht sicher, wie nützlich diese Zahlen für den Vergleich sind. Trotzdem ist der REPL2 schneller, das ist eine Tatsache.

Ja, aber niemand weiß , dass: wink: Ich mache nur Spaß, es wäre schön , zu versuchen , die Benchmark mit den laufen uint16 Arrays in Fable 1, aber irgendwie werde ich die Benchmark erwähnen einige Performance - Verbesserungen in Fable enthält 2.

Könnten Sie bitte angeben, welche Version von FCS/Fable zum Erstellen dieses Projekts benötigt wird? Ist ein Tutorial verfügbar (da es wahrscheinlich einen Trick erfordert, um es zu erstellen).

Im Moment scheitert es mit:

Skipping project "/tmp/FSharp.Compiler.Service_fable/fcs/fcs-fable/fcs-fable.fsproj" because it was not found.

@zpodlovics Wenn Sie den REPL-Benchmark nur lokal

git clone -b fable2 https://github.com/ncave/FSharp.Compiler.Service.git FSharp.Compiler.Service_fable
cd FSharp.Compiler.Service_fable
fcs\build CodeGen.Fable

cd ../Fable
build
yarn build-bench
yarn start-bench

Wenn Sie zufällig eine Perf-Analyse durchführen, teilen Sie diese bitte mit, danke im Voraus.

@ncave Danke! Fast dort. Zuerst fehlte eine Art Ressourcendatei FSComp. Ich habe es mit dotnet restore in FSharp.Compiler.Service_fable/fcs/fcs-fable/codegen generated generiert

Wenn ich jedoch versuche, das Bench-Projekt nach viel Kompilierung zu erstellen, schlägt es fehl mit:

fable: Compiled ../../../../../FSharp.Compiler.Service_fable/src/fsharp/ErrorResolutionHints.fs
fable: Compiled ../../../../../FSharp.Compiler.Service_fable/src/utils/EditDistance.fs
ERROR: File /tmp/FSharp.Compiler.Service_fable/fcs/fcs-fable/codegen/pars.fs doesn't belong to parsed project (/tmp/FSharp.Compiler.Service_fable/fcs/fcs-fable/codegen/pars.fs)

Irgendeine Idee? Welche Dateien sollte ich in FSharp.Compiler.Service_fable/fcs/fcs-fable/codegen ?

@zpodlovics Ich entschuldige mich, hier ist der fehlende Codegen-Schritt:

cd FSharp.Compiler.Service_fable
fcs\build CodeGen.Fable

Ich habe die Schritte oben auch aktualisiert.

@ncave Danke für deine Hilfe! Ich konnte die Repl. Auch ein Profiling konnte ich machen. Die Profilerstellung erfolgt mit perf + nodejs --perf-basic-prof Option.

1) Speedscope-Visualisierung (Sie müssen Speedscope von https://github.com/jlfwong/speedscope installieren)

fable2-repl-2018-08_31_1-speedscope.zip Node hat mehrere Threads ausgeführt, der erste Thread ist nicht wirklich interessant, Sie können zwischen den Threads wechseln, indem Sie auf die Symbole nach oben ( ^ ) / unten ( v ) oben in der Mitte klicken den Visualisierungsbildschirm ( ^ perf tid v ). Der interessanteste Thread ist der 6.

2) SVG-Visualisierung, zoombar (durch Klicken auf eines der Elemente) (Achtung: das Rendern einer ~50 MB SVG dauert wirklich sehr lange):

fable2-repl-2018-08_31_1-svg.zip

Aktuelle Statistiken basierend auf dem Hauptzweig FCS-Fable PR, die die Leistungseinbußen durch die Umstellung des Typs LexBuffer auf uint16 :

REPL benchmark
Fable v2.0.0-beta-005, FCS v25.0.1,
.NET Core v2.1.402, Node.js v10.11.0
(best times out of several runs)
------------------------------------------------

Medium test file (10 kB), LexBuffer<char> (Node.js):
------------------------------------------------
InteractiveChecker created in 1780 ms
iteration 1, FCS time: 1398 ms, Fable time: 551 ms
iteration 2, FCS time: 965 ms, Fable time: 299 ms
iteration 3, FCS time: 866 ms, Fable time: 214 ms
iteration 4, FCS time: 803 ms, Fable time: 212 ms
iteration 5, FCS time: 721 ms, Fable time: 187 ms
iteration 6, FCS time: 693 ms, Fable time: 173 ms
iteration 7, FCS time: 655 ms, Fable time: 176 ms
iteration 8, FCS time: 665 ms, Fable time: 158 ms
iteration 9, FCS time: 630 ms, Fable time: 159 ms
iteration 10, FCS time: 613 ms, Fable time: 154 ms
Done in 13.36s.

------------------------------------------------
Medium test file (10 kB), LexBuffer<uint16> (Node.js):
------------------------------------------------
InteractiveChecker created in 1830 ms
iteration 1, FCS time: 1166 ms, Fable time: 561 ms
iteration 2, FCS time: 692 ms, Fable time: 295 ms
iteration 3, FCS time: 515 ms, Fable time: 275 ms
iteration 4, FCS time: 483 ms, Fable time: 189 ms
iteration 5, FCS time: 404 ms, Fable time: 185 ms
iteration 6, FCS time: 406 ms, Fable time: 179 ms
iteration 7, FCS time: 347 ms, Fable time: 187 ms
iteration 8, FCS time: 366 ms, Fable time: 159 ms
iteration 9, FCS time: 347 ms, Fable time: 162 ms
iteration 10, FCS time: 335 ms, Fable time: 154 ms
Done in 10.49s.

------------------------------------------------
Medium test file (10 kB), LexBuffer<uint16> (.NET Core):
------------------------------------------------
InteractiveChecker created in 1321 ms
iteration 1, FCS time: 2269 ms, Fable time: 615 ms
iteration 2, FCS time: 77 ms, Fable time: 41 ms
iteration 3, FCS time: 75 ms, Fable time: 42 ms
iteration 4, FCS time: 89 ms, Fable time: 44 ms
iteration 5, FCS time: 71 ms, Fable time: 45 ms
iteration 6, FCS time: 87 ms, Fable time: 44 ms
iteration 7, FCS time: 77 ms, Fable time: 49 ms
iteration 8, FCS time: 74 ms, Fable time: 44 ms
iteration 9, FCS time: 83 ms, Fable time: 44 ms
iteration 10, FCS time: 75 ms, Fable time: 42 ms



md5-4bf3b05172fab5ad8da37cd002881e84



------------------------------------------------
Large test file (50 kB), LexBuffer<char> (Node.js):
------------------------------------------------
InteractiveChecker created in 1822 ms
iteration 1, FCS time: 9243 ms, Fable time: 1462 ms
iteration 2, FCS time: 9145 ms, Fable time: 828 ms
iteration 3, FCS time: 8803 ms, Fable time: 754 ms
iteration 4, FCS time: 8983 ms, Fable time: 785 ms
iteration 5, FCS time: 8634 ms, Fable time: 734 ms
iteration 6, FCS time: 8622 ms, Fable time: 688 ms
iteration 7, FCS time: 8679 ms, Fable time: 754 ms
iteration 8, FCS time: 8473 ms, Fable time: 700 ms
iteration 9, FCS time: 8714 ms, Fable time: 689 ms
iteration 10, FCS time: 8798 ms, Fable time: 746 ms
Done in 99.37s.

------------------------------------------------
Large test file (50 kB), LexBuffer<uint16> (Node.js):
------------------------------------------------
InteractiveChecker created in 1826 ms
iteration 1, FCS time: 3456 ms, Fable time: 1415 ms
iteration 2, FCS time: 2082 ms, Fable time: 845 ms
iteration 3, FCS time: 1512 ms, Fable time: 761 ms
iteration 4, FCS time: 1536 ms, Fable time: 793 ms
iteration 5, FCS time: 1356 ms, Fable time: 712 ms
iteration 6, FCS time: 1295 ms, Fable time: 697 ms
iteration 7, FCS time: 1407 ms, Fable time: 769 ms
iteration 8, FCS time: 1245 ms, Fable time: 699 ms
iteration 9, FCS time: 1220 ms, Fable time: 673 ms
iteration 10, FCS time: 1366 ms, Fable time: 752 ms
Done in 27.70s.

------------------------------------------------
Large test file (50 kB), LexBuffer<uint16> (.NET Core):
------------------------------------------------
InteractiveChecker created in 1391 ms
iteration 1, FCS time: 2596 ms, Fable time: 794 ms
iteration 2, FCS time: 446 ms, Fable time: 228 ms
iteration 3, FCS time: 356 ms, Fable time: 232 ms
iteration 4, FCS time: 426 ms, Fable time: 218 ms
iteration 5, FCS time: 364 ms, Fable time: 218 ms
iteration 6, FCS time: 359 ms, Fable time: 226 ms
iteration 7, FCS time: 356 ms, Fable time: 227 ms
iteration 8, FCS time: 454 ms, Fable time: 220 ms
iteration 9, FCS time: 354 ms, Fable time: 224 ms
iteration 10, FCS time: 357 ms, Fable time: 222 ms

Um es noch einmal zusammenzufassen, die Verwendung von LexBuffer<uint16> in FCS-Fable (Node.js) ist LexBuffer<char> großen Dateien (50k) ungefähr 3-4x schneller als
(Unter .NET Core gibt es keinen Unterschied zwischen den beiden).