Tailles binaires (non compressées) :

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

On dirait que la taille non minifiée est 30% plus grande que Fable 1.3.x, mais cela disparaît après la minification.
Bon travail @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

On dirait que le javascript FCS n'évolue pas linéairement avec la taille.
Mise à jour : voir le bas du fil pour les statistiques à jour.

Ce génial @ncave ! Merci beaucoup pour ces données, il sera beaucoup plus facile de vérifier si les futurs développements vont dans la bonne direction :+1: Les résultats sont vraiment très intéressants et prometteurs. C'est vraiment encourageant de voir que la partie Fable est aussi rapide que .NET (même si c'est peut-être parce que nous sautons la phase d'optimisation) et je suis sûr que nous pouvons aussi rendre la partie FCS plus rapide.

On s'attendait à ce que le bundle non minifié soit un peu plus gros (à cause de la modification du nom) mais aussi que le résultat fonctionnerait mieux avec les minificateurs JS :) Je me demande si l'amélioration lors de la création du vérificateur interactif est également due aux bits WebAssembly dans Long.js , car le type int64 est beaucoup utilisé lors de la lecture des assemblys.

@alfonsogarciacaro Bonne nouvelle à tous ! Après avoir basculé le lexer FCS de char à uint16, les temps de banc se sont améliorés de 20x à 2x (vs dotnet core) sur les gros fichiers.
Mise à jour : voir le bas du fil pour les statistiques à jour.

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

Sur les fichiers de taille moyenne, de 7x à 3x (vs dotnet core) :
Mise à jour : voir le bas du fil pour les statistiques à jour.

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

C'est super @ncave , super boulot !!! :Clap clap clap:

Super travail @ncave :)

Merci pour ce que vous faites 👏

Je suis très heureux que nous ayons enfin un bon exemple de l'amélioration des performances de l'utilisation de tableaux typés grâce à vous @ncave :) Je me demande également si nous devrions envisager de compiler char en JS number ( et char[] comme UInt16Array ). IIRC, la principale raison d'utiliser JS string était l'énumération de chaînes. Mais nous devons maintenant faire une conversion spéciale de string en char seq de toute façon pour corriger #1279. Nous pourrions donc profiter de l'occasion pour changer la représentation des caractères. Qu'en pensez-vous @ncave ?

@alfonsogarciacaro Bien sûr, essayons, car nous pouvons mesurer les performances maintenant.

@ncave J'ai commencé à travailler pour compiler des caractères sous forme de nombres dans cette branche . J'ai réussi à faire les tests passent, mais je suis concerné il peut y avoir des situations où string casted à typées IEnumerable ou un générique seq<'T> et les choses peuvent se casser parce que nous ne pouvons pas détecter les conversions et lors de l'énumération, nous obtiendrons des chaînes au lieu de nombres. Qu'est-ce que tu penses?

@alfonsogarciacaro Avez-vous un exemple ?

@alfonsogarciacaro Je veux dire, est-ce différent de lancer char (ou int ou float) sur un objet et de le faire circuler, où vous perdez le type?

Un peu artificiel, mais quelque chose comme ça :

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'|]]

La deuxième assertion échouera dans Fable dev2.0-chars (elle passe dans .NET F#). Bien que maintenant que j'y pense, ce n'est peut-être pas quelque chose de très important car nous comptons déjà sur la connaissance des génériques au moment de la compilation pour de nombreuses méthodes de collecte, donc le transtypage en IEnumerable non typé est susceptible de poser des problèmes dans de nombreux situations. Peut-on vivre avec ça ? La compilation de caractères sous forme de nombres est-elle une amélioration ?

Un autre problème que je viens de remarquer est l'impression des caractères (comme dans printfn "%A" 'a' ).

@alfonsogarciacaro Je ne sais pas si la compilation de caractères sous forme de nombres sera une amélioration, en essayant de tester le dev2.0-chars mais cela échoue avec ceci:
Fable/src/dotnet/Fable.Core/Fable.Core.fs(1,1): error FABLE: Classes without a primary constructor cannot be inherited: System.Attribute
y a-t-il eu un changement récent de constructeurs dans cette branche ?

Hmm, j'ai supprimé du code défensif pour simplifier les choses, mais c'est étrange que cette erreur ne se soit pas produite avant. Pour l'instant, je viens d'ajouter un type d'attribut factice afin qu'il soit possible d'en hériter, puis de rebaser la branche dev2.0-chars.

@alfonsogarciacaro Je ne vois aucune différence dans les performances au banc de dev2.0 et dev2.0-chars , donc c'est à vous de décider dans quelle direction vous voulez aller, selon ce qui fonctionne le mieux. L'interopérabilité JS doit peut-être être prise en compte, mais je ne suis pas un expert là-bas, donc je n'ai pas d'opinion. Si vous décidez de remplacer les caractères par des ints, le problème printfn "%A" peut peut-être être résolu en examinant les types d'arguments et en convertissant les caractères avant d'appeler le javascript d'impression, mais je n'ai vraiment aucune préférence dans les deux cas.

Parfait, merci beaucoup d'avoir vérifié @ncave. Ok, je vais juste soumettre un PR WIP pour le moment, et nous pourrons le revoir plus tard. BTW, je veux recommencer à construire le REPL dans Appveyor (j'ai toujours des problèmes lors de la construction du REPL localement sur macOS). Utilisez-vous simplement la cible REPL Fake pour cela ou faites-vous autre chose?

@alfonsogarciacaro Je construisais juste le banc pour l'instant ( cd src/dotnet/Fable.JS/bench && yarn build ).
Juste pour info, il y a toujours un problème en suspens avec le javascript FCS généré par Fable 2.0 avec lequel je me bats, il n'émet aucun membre d'objet à part le constructeur dans le F# AST. Cela pourrait en fait fausser les statistiques ci-dessus, car il y a moins de travail à traiter par la suite. Mais il ne devrait pas y avoir de problème pour le construire en CI.

@ncave J'ai apporté quelques modifications à l'application de banc, j'espère que vous les fable-repl AppVeyor dans le répertoire Fable.JS/out (vous pouvez également l'obtenir en exécutant yarn build dans le répertoire Fable.JS), puis exécuter sh local_test.sh dans le répertoire bench (notez que j'ai également mis à jour les fichiers de métadonnées dans le référentiel):

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

BTW, j'ai supprimé les #if FABLE_COMPILER conditionnels dans FableTransforms.fs et la compilation JS fonctionne toujours ! (Comme prévu, la partie Fable fait un peu plus de travail maintenant.) Mon ordinateur est plus lent que le vôtre mais les résultats comparatifs semblent être similaires :)

Nous pouvons probablement annoncer la bêta maintenant et préparer une version en ligne de REPL 2 :tada:

@alfonsogarciacaro C'est bien, même si ma préférence serait de garder le banc en tant que projet unique. Son objectif est d'exécuter exactement le même code sur différentes plates-formes et de comparer les résultats, ce qui sera un peu plus difficile à maintenir si ce code se trouve dans deux projets différents.

Vous avez raison, mais c'était un peu difficile de garder un seul projet après avoir séparé le REPL (la version JS n'a pas de référence directe à Fable.JS). Cependant, le fichier principal est toujours le même pour les deux projets ( Fable.JS/bench/app.fs ) donc j'espère que cela évitera que le code diverge. Peut-être pouvons-nous essayer de les garder comme ça pour le moment et revenir à un seul projet si nous voyons que cela ne fonctionne pas ?

1487 corrige le problème de saut de certaines liaisons REPL. Comme suspect, les nombres réels ne sont plus aussi spectaculaires qu'avant puisque le compilateur doit en faire plus, voici les derniers nombres plus réalistes :

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

Pourtant, seulement 4x-5x plus lent (par rapport au .NET Core hautement optimisé) n'est pas trop mal pour commencer.
Je ne pense pas que nous ayons encore exploré toutes les opportunités d'optimisation.

@ncave Latest Fable 2 en ligne REPL place le compilateur FCS/Fable dans un worker afin qu'il ne gèle pas l'interface utilisateur. J'ai également ajouté une option pour activer l'optimisation FCS, la journalisation de certaines statistiques de performances (visibles dans la console du navigateur, similaires à celles que vous avez créées pour le banc) ainsi que les échantillons de sudoku et de trace de rayon. Espérons que cela facilite le jeu avec le REPL pour trouver plus d'opportunités d'optimisation :)

BTW, Fable 1.37 était environ 10 fois plus lent que .NET, non ? Nous avons donc encore une amélioration des performances même si les temps ne sont pas aussi proches que nous l'espérions du .NET.

@alfonsogarciacaro Oui, Fable 2.0 semble environ deux fois plus rapide que Fable 1.3.x.

@ncave Je mélange ici les statistiques de Fable 1 du premier commentaire avec les données de Fable 2

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 Plus ou moins, oui. Vous n'êtes pas sûr de ce que vous essayez de faire, des mesures à jour ou de la publication à partir du haut du fil ? Les performances REPL n'ont pas beaucoup changé après le retour des caractères impl, ce qui est bien. Nous pouvons remesurer une fois que la branche des propriétés s'est installée.

Merci @ncave. Je voulais juste avoir la bonne comparaison entre Fable 1 et 2 à montrer dans les messages et les discussions :)

@alfonsogarciacaro Pour être juste, une partie de l'amélioration de Fable2 sur la charge de travail REPL provient du passage du lexer FCS-Fable de char à uint16, ce qui aurait également profité à Fable1, donc je ne sais pas à quel point ces chiffres sont utiles pour la comparaison. Pourtant, le REPL2 est plus rapide, c'est un fait.

Ouais, mais personne ne le sait :wink: Je plaisante, ce serait bien d'essayer d'exécuter le benchmark avec les tableaux uint16 dans Fable 1, mais de toute façon je mentionnerai que le benchmark contient quelques ajustements de performances dans Fable 2.

Pourriez-vous s'il vous plaît spécifier quelle version de FCS/Fable avait besoin pour construire ce projet ? Existe-t-il un didacticiel disponible (car il faudra probablement une astuce pour le construire).

En ce moment, il échoue avec :

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

@zpodlovics Si vous souhaitez simplement exécuter le benchmark REPL localement :

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

Si, par hasard, vous effectuez une analyse des performances, merci de partager, merci d'avance.

@ncave Merci ! Presque là. D'abord, il a raté une sorte de fichier de ressources FSComp. Je l'ai généré en exécutant dotnet restore dans FSharp.Compiler.Service_fable/fcs/fcs-fable/codegen

Cependant, lorsque j'essaie de construire le projet de banc après de nombreuses compilations, il échoue avec :

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)

Une idée? Quels fichiers dois-je avoir dans FSharp.Compiler.Service_fable/fcs/fcs-fable/codegen ?

@zpodlovics Je m'excuse, voici l'étape de codegen manquante :

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

J'ai également mis à jour les étapes ci-dessus.

@ncave Merci pour votre aide ! J'ai pu construire le repl. J'ai également pu faire du profilage. Le profilage fait avec l'option perf + nodejs --perf-basic-prof .

1) Visualisation Speedscope (vous devez installer speedscope depuis https://github.com/jlfwong/speedscope)

fable2-repl-2018-08_31_1-speedscope.zip Le nœud a exécuté plusieurs threads, le premier thread n'est pas vraiment intéressant, vous pouvez passer d'un thread à l'autre en cliquant sur les icônes haut ( ^ ) / bas ( v ) en haut au milieu de l'écran de visualisation ( ^ perf tid v ). Le fil le plus intéressant est le 6.

2) Visualisation SVG, zoomable (en cliquant sur l'un des éléments) (Attention : le rendu d'un SVG d'environ 50 Mo prendra vraiment beaucoup de temps) :

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

Statistiques à jour basées sur la branche principale FCS-Fable PR, montrant l'impact sur les performances du passage du type LexBuffer à 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

Pour récapituler, l'utilisation de LexBuffer<uint16> dans FCS-Fable (Node.js) est environ 3 à LexBuffer<char> fois plus rapide que
(sur .NET Core, il n'y a pas de différence entre les deux).