jtremesay a écrit 362 commentaires

Dit autrement, c'est super de pouvoir acheter un thermomix, mais si on ne peut plus se loger et se soigner ?

Comme l'a dit un grand philosophe, «C'est juste insultant de demander de quoi se loger et manger après avoir cramé 1500 € dans de la futilité.»

Quand tu es pauvres, tu n'achètes pas de Thermomix, non mais oh, faut pas déconner non plus. Tu ne pourras pas nécessairement mieux te loger ou te soigner, mais au moins Zenitram ne se sentira pas insulté, et je pense que c'est ça le plus plus important (sic).

Comme le chante les Fatals Picards, mes gosses iront dans le privé, parce que merde, je vote à droite (un truc du genre).

J'y ai pensé, mais il est demandé que le livre choisi traite du Libre. Et même si il pourrait être utile pour survivre à certains débats LinuxFR, j'étais pas sûr que le lien avec le Libre soit suffisamment important pour qu'ils acceptent.

Les failles Spectres et meltdown étaient exploitable par du JS dans le navigateur (src), donc je suppose que pour celles là aussi ça doit être possible.

Ou alors par un chaînage de vulnérabilité, tel que par exemple dans la libpng où une image spécialement formée peut permettre à l'attaquant d'exécuter du code (cf)

Pour la culture, c'est l'extension standard des fichiers écrits en ColdFusion.

Pis avoir une application desktop dédié à ça alors qu'il suffit d'aller directement sur invidio.us, je ne suis pas non plus convaincu de la pertinence, et je n'y vois pas la valeur ajoutée.

À celui qui me dira que ça me permet d'avoir des abonnements sans créer de compte, je lui répondrai qu'il suffit d'utiliser les flux RSS YouTube/Invidio.us. (Ok, c'est une réponse utile que pour celui qui a déjà un agrégateur de flux RSS, mais si tu es prêt à installer un logiciel qui fait que du "YouTube", je suis sûr que tu peux aussi installer un logiciel qui fait d'autre choses que du YouTube)

Je comprends rien en design analogique et je sais qu'il suffit de 2 transistors en série pour faire un ET ^'
Est-ce que tu pourrais annoter l'image pour faire ressortir les transistors ainsi que leurs drains, sources et grilles ?

que plusieurs étapes que tu définis comme très longues semblent automatiques avec ta pile?

Pas que avec ma pile. Tous les logiciels de placement et de routage de microélectronique ont des algorithmes pour faire le travail à la place des ingénieurs.
Voici un exemple de placement/routage avec l'outil Cadence Encounter. Comme tu peux le constater, ça peut se résumer à cliquer sur les boutons place et route.
Il est à noter que l'on peut aussi piloter le logiciel avec des scripts tcl pour n'avoir aucune intervention manuelle à faire. D'une manière générale, tous les outils de µélectronique sont pilotable par des scripts tcl.

Mis a part l'échelle (de quelques cm pour l'électroniques à quelques mm pour la µélec) qu'est-ce qui, selon toi, l'explique?

J'ignore pourquoi les logiciels d'électroniques ne sont pas automatisés. Mais je peux expliquer pourquoi il est nécessaire que ceux de µélectroniques le soient.
Les netlists ont tendance à être assez grosses : l'ALU du tuto fait à peine 949 portes logiques, mais sur un design un peu plus conséquent tel que le microcontrôleur ARM Cortex M0 (le plus petit des ARM) on passe déjà à 21026 portes logiques (toi aussi tu peux faire joujou avec les ARM Cortex M0 et M3). Et je ne parle même pas des dernières cartes graphiques où le nombre de portes logiques dépasse le milliards.

=== CORTEXM0INTEGRATION ===

   Number of wires:              20875
   Number of wire bits:          21178
   Number of public wires:       20875
   Number of public wire bits:   21178
   Number of memories:               0
   Number of memory bits:            0
   Number of processes:              0
   Number of cells:              21026
     AND2X2                        522
     AOI21X1                      1477
     AOI22X1                       971
     BUFX2                         134
     DFFPOSX1                      976
     DFFSR                         358
     INVX1                        2764
     MUX2X1                         34
     NAND2X1                      2697
     NAND3X1                      1513
     NOR2X1                       2661
     NOR3X1                        351
     OAI21X1                      5379
     OAI22X1                       295
     OR2X2                         321
     XNOR2X1                       426
     XOR2X1                        147

Il est tout simplement inhumain de placer et router un tel nombre de portes logiques à la main.

L'autre bénéfice de l'automatisation des outils via des scripts est la possibilité de relancer les flots pour obtenir des résultats répétables. Parce que les flots, tu vas très souvent les relancer pour converger vers le résultat final :

*lance le flot*
- zut, la STA n'est pas validée
*modifie les contraintes de timings*
*relance le flot*
- maintenant je vois qu'on peut essayer d'améliorer la densité de circuit
*modifie les paramètres de densité*
*relance le flot*
…

typiquement, la conception d'une puce va ressembler à ça

écrire configuration initiale
exécuter flot
tant que résultat pas satisfaisant faire
    modifier paramètres
    relancer flot
fin faire
ouvrir la bouteille de champagne

Il ont bien gravé en 7nm de chez TSMC.
La seule autre référence que je trouve sur le site pour du 7nm concerne les puces Versal ("the industry’s first ACAP, built on 7nm process technology and shipping to early access customers now."). Ils n'en parlent pas sur la page du produit.

Si tu voulais juste le tuto, il suffisait d'aller sur le site officiel ;)

AMI est l'ancien nom de ON Semiconductor. Europractice IC permet de fondre chez eux. Les prix sont entre 700€ et 1000€ du mm² avec cette techno selon les options.

Ok, il existe un plugin en beta pas intégré upstream pour parser le VHDL, je m'incline :)

J'étais pas bien réveillé quand j'ai fait le câblage et le calcul :-/

Je n'ai pas dit que je ne connaissais pas d'implémentation libre de VHDL, mais qu'il m'avait l'air d'être moins bien supporté que Verilog.
Il n'est par exemple pas supporté par le logiciel de synthèse logique Yosys qui est au cœur de Qflow pour faire les implémentation physique ou de SymbiFlow pour cibler les FPGA.
Il n'est pas non plus supporté par vtr, la plateforme de développement académique autour des FPGA.
Et une rapide recherche duckduckgo ne me permet pas de trouver de synthétiseur libre pour vhdl.
Il aurait beau avoir le meilleur simulateur du monde, si je ne peux pas faire de synthèse logique avec, le language ne me sert à rien.

beaucoup de mots que pas grand monde ne doit comprendre ici ;)

Je sais, mais au moment de l'écriture du journal (minuit passé), je ne me suis pas senti motivé pour faire EDA 101…

Par contre qflow est un (très vieil) outils vraiment intéressant.

Pour avoir utiliser les outils des éditeurs Synopsys et Cadence, je trouve que ses deux seuls avantages sont d'être gratuits facile à utiliser pour des petits projets par son coté clickodrome.
Maintenant que je vais devoir faire des trucs un peu plus complexe pour garder des temps d'implémentations raisonnable, j'ai peur que ça soit la merde. Il y a un gros manque de documentation ou d'exemple au niveau de qflow lui même et des outils utilisés.

Je ne sais pas si les mots suivants ont du sens pour toi, mais il faudrait que j'arrive à mettre en place un flot hiérarchique où je fais d'abord l'implémentation de la tuile logique puis que je l'utilise sous forme de hard macro dans le cœur.
Et je pense que le jour où j'y arriverai, je ferais un petit article pour ne pas perdre la connaissance :)

Le code source est disponible. Y'a qu'à crées un cœur spécifique FPGA répondant au besoin et trouver quelques milliers d'euros pour passer en fonderie :)

Dans l'absolu, il a pas tord. C'est effectivement plus bas niveau que l'assembleur au sens où on manipule directement des portes logiques.

Freem<, pour l'exemple, là je décris un simple additionneur 32 bits en verilog :

module Adder(s, a, b);
    input [3:0] a, b;
    output [3:0] s;

    assign s = a + b;
endmodule

Ici, c'est ce que j'obtiens après un passage dans un outil de synthèse. Il m'a tout converti en portes logiques abstraites

module Adder(s, a, b);
  wire _00_;
  wire _01_;
  wire _02_;
  wire _03_;
  wire _04_;
  wire _05_;
  wire _06_;
  wire _07_;
  wire _08_;
  wire _09_;
  (* src = "rtl/Adder.v:2" *)
  input [3:0] a;
  (* src = "rtl/Adder.v:2" *)
  input [3:0] b;
  (* src = "rtl/Adder.v:3" *)
  output [3:0] s;
  assign _00_ = a[1] ^ b[1];
  assign _01_ = ~(a[0] & b[0]);
  assign s[1] = ~(_01_ ^ _00_);
  assign _02_ = a[2] ^ b[2];
  assign _03_ = ~(a[1] & b[1]);
  assign _04_ = _00_ & ~(_01_);
  assign _05_ = _03_ & ~(_04_);
  assign s[2] = ~(_05_ ^ _02_);
  assign _06_ = ~(a[3] ^ b[3]);
  assign _07_ = ~(a[2] & b[2]);
  assign _08_ = _02_ & ~(_05_);
  assign _09_ = _07_ & ~(_08_);
  assign s[3] = _09_ ^ _06_;
  assign s[0] = a[0] ^ b[0];
endmodule

À partir de là, je peux lui demander de transformer cette logique en LUT pour cibler un FPGA (ici un ICE40 de chez Lattice)

module Adder(s, a, b);
  wire _0_;
  wire _1_;
  (* src = "rtl/Adder.v:2" *)
  input [3:0] a;
  (* src = "rtl/Adder.v:2" *)
  input [3:0] b;
  (* src = "rtl/Adder.v:3" *)
  output [3:0] s;
  (* module_not_derived = 32'd1 *)
  (* src = "/home/killruana/opt/eda/yosys/usr/local/bin/../share/yosys/ice40/cells_map.v:56" *)
  SB_LUT4 #(
    .LUT_INIT(16'h9666)
  ) _2_ (
    .I0(b[1]),
    .I1(a[1]),
    .I2(b[0]),
    .I3(a[0]),
    .O(s[1])
  );
  (* module_not_derived = 32'd1 *)
  (* src = "/home/killruana/opt/eda/yosys/usr/local/bin/../share/yosys/ice40/cells_map.v:51" *)
  SB_LUT4 #(
    .LUT_INIT(16'h3cc3)
  ) _3_ (
    .I0(1'h0),
    .I1(b[2]),
    .I2(a[2]),
    .I3(_0_),
    .O(s[2])
  );
  (* module_not_derived = 32'd1 *)
  (* src = "/home/killruana/opt/eda/yosys/usr/local/bin/../share/yosys/ice40/cells_map.v:56" *)
  SB_LUT4 #(
    .LUT_INIT(16'h077f)
  ) _4_ (
    .I0(b[0]),
    .I1(a[0]),
    .I2(b[1]),
    .I3(a[1]),
    .O(_0_)
  );
  (* module_not_derived = 32'd1 *)
  (* src = "/home/killruana/opt/eda/yosys/usr/local/bin/../share/yosys/ice40/cells_map.v:56" *)
  SB_LUT4 #(
    .LUT_INIT(16'h6a56)
  ) _5_ (
    .I0(_1_),
    .I1(b[2]),
    .I2(a[2]),
    .I3(_0_),
    .O(s[3])
  );
  (* module_not_derived = 32'd1 *)
  (* src = "/home/killruana/opt/eda/yosys/usr/local/bin/../share/yosys/ice40/cells_map.v:46" *)
  SB_LUT4 #(
    .LUT_INIT(16'h0ff0)
  ) _6_ (
    .I0(1'h0),
    .I1(1'h0),
    .I2(b[3]),
    .I3(a[3]),
    .O(_1_)
  );
  (* module_not_derived = 32'd1 *)
  (* src = "/home/killruana/opt/eda/yosys/usr/local/bin/../share/yosys/ice40/cells_map.v:46" *)
  SB_LUT4 #(
    .LUT_INIT(16'h0ff0)
  ) _7_ (
    .I0(1'h0),
    .I1(1'h0),
    .I2(b[0]),
    .I3(a[0]),
    .O(s[0])
  );
endmodule

Ou alors de cibler une véritable bibliothèques de portes logiques (ici des standard cell OSU 035) pour ensuite fabriquer un circuit intégré

module Adder(s, a, b);
  wire _00_;
  wire _01_;
  wire _02_;
  wire _03_;
  wire _04_;
  wire _05_;
  wire _06_;
  wire _07_;
  wire _08_;
  wire _09_;
  wire _10_;
  (* src = "rtl/Adder.v:2" *)
  input [3:0] a;
  (* src = "rtl/Adder.v:2" *)
  input [3:0] b;
  (* src = "rtl/Adder.v:3" *)
  output [3:0] s;
  NAND2X1 _11_ (
    .A(b[0]),
    .B(a[0]),
    .Y(_00_)
  );
  NAND2X1 _12_ (
    .A(b[1]),
    .B(a[1]),
    .Y(_01_)
  );
  INVX1 _13_ (
    .A(_01_),
    .Y(_02_)
  );
  NOR2X1 _14_ (
    .A(b[1]),
    .B(a[1]),
    .Y(_03_)
  );
  NOR2X1 _15_ (
    .A(_03_),
    .B(_02_),
    .Y(_04_)
  );
  XNOR2X1 _16_ (
    .A(_04_),
    .B(_00_),
    .Y(s[1])
  );
  OAI21X1 _17_ (
    .A(_00_),
    .B(_03_),
    .C(_01_),
    .Y(_05_)
  );
  AND2X2 _18_ (
    .A(b[2]),
    .B(a[2]),
    .Y(_06_)
  );
  NOR2X1 _19_ (
    .A(b[2]),
    .B(a[2]),
    .Y(_07_)
  );
  NOR2X1 _20_ (
    .A(_07_),
    .B(_06_),
    .Y(_08_)
  );
  XOR2X1 _21_ (
    .A(_05_),
    .B(_08_),
    .Y(s[2])
  );
  AOI21X1 _22_ (
    .A(_05_),
    .B(_08_),
    .C(_06_),
    .Y(_09_)
  );
  XOR2X1 _23_ (
    .A(b[3]),
    .B(a[3]),
    .Y(_10_)
  );
  XNOR2X1 _24_ (
    .A(_09_),
    .B(_10_),
    .Y(s[3])
  );
  XOR2X1 _25_ (
    .A(b[0]),
    .B(a[0]),
    .Y(s[0])
  );
endmodule

Et c'est la que je me rends compte que mon outil de synthèse est bof. Vu que dans ma bibliothèque de porte logique j'ai une porte de type full adder, il aurait pu me générer le résultat suivant :

module Adder(s, a, b);    
    wire _00_;
    wire _01_;
    wire _02_;

    FAX1 _04_(
        .A(a[3]),
        .B(a[3]),
        .C(_02_)
        .YC(),
        .YS(s[3])
    );
    FAX1 _05_(
        .A(a[2]),
        .B(a[2]),
        .C(_01_)
        .YC(_02_),
        .YS(s[2])
    );
    FAX1 _06_(
        .A(a[1]),
        .B(a[1]),
        .C(_00_)
        .YC(_01_),
        .YS(s[1])
    );
    HAX1 _07_(
        .A(a[0]),
        .B(a[0]),
        .YC(_00_),
        .YS(s[0])
    );
endmodule

Dans l'absolu, les deux résultats précédents sont fonctionnellement équivalents. Mais il y a de bonnes chances que la solution à base de full-adder soit plus intéressante au niveau vitesse de fonctionnement et surface utilisée.

Je suis informaticien. J'ai commencé avec un magnifique effet Dunning-Kruger avant de me rendre compte que tel Jon Snow, je ne savais rien. Depuis, je suis largement tombé dans le travers inverse…

Plop, ici l'auteur du journal à l'origine de la dépêche.

J'ai écrit le journal parce que j'étais content d'avoir franchi une étape dans le cadre de mon projet. Mais en vrai pour l'instant il n'y a pas grand chose. C'est un peu comme si Mr Torvald avait annoncé sur Usenet que son proto-noyau arrivait à se faire charger correctement et qu'il affichait un hello world (en somme la première étape des tutos d'OSDev). C'est cool pour lui, mais il lui reste beaucoup de travail avant de révolutionner le monde. Pis la qualité du journal est assez bof, c'est pas très clair, bref ça a été écrit au milieu de la nuit dans l'euphorie et la fatigue.

Je comptais produire une dépêche, mais pas tout de suite. Je voulais attendre d'avoir des vrais trucs à présenter tel qu'un cœur FPGA fonctionnel avec au moins 1k éléments logique (le minimum pour être crédible dans l'industrie) et la chaîne d'outils pour le programmer.

Je critique pas, je suis juste surpris de l'ampleur des réactions. Je m'attendais à finir avec un journal à +10 et 3 commentaires de félicitations de gens qui s'y connaissent en FPGA, pas à un journal à +68, des discutions techniques intéressantes, une dépêche et martoni< qui me cite déjà en tant que vendeur de FPGA sur son blog.

Tu connais Symbiflow ?

Oui, on en a un peu parlé dans les commentaires du journal

Pour ma défense, j'ai plus cherché sur github que dans les papiers de recherche ^'

Tu t'es déjà auto-répondu, mais je vais faire un complément de réponse.

Tu n'avais pas tout à fait tord, OFP ne sert pas qu'à créer les FPGA (-> génerer le RTL). C'est la trousse à outil multi-fonction qui fera tout. Il s'occupera aussi de générer et exécuter les flots d'implémentations et surtout de la programmation (synthèse, P&R, bitstream) des FPGAs. Mais je ne comptais pas réinventer la roue et dans l'idée OFP générera les bibliothèques technos spécifiques à l'architecture cible (ce genre de fichiers quoi) et appellera en sous main les outils dédiés.

Après, j'ai pas forcément fait une recherche ultra-détaillée sur l'existant (shame on me). Je connaissais déjà yosys et j'avais entendu parler de arachne-pnr (et son successeur nextpnr) via le projet IceStorm.
Mais comme avant d'envisager la programmation des FPGA il me fallait déjà des cœurs plus ou moins fonctionnels (qui ont au moins un RTL valide :p), j'avais pas creusé le sujet plus que ça.
Maintenant que je connais son existence, je tenterai de m'intégrer dessus pour gérer la programmation :)

Concernant ton blog, je sais, je t'avais envoyé un petit mail il y a quelques mois pour apporter une petite correction sur la toolchain de mon ancien employeur et pour vaguement mentionner ce projet :)

kFPGA
Un embryons de projet «fabless» de FPGA libre. À suivre !
Le premier modèle est bientôt sortie et se nomme k1g1

Je ne suis pas sûr de la pertinence de me mentionner parmi les vendeurs tant que je n'aurais pas au moins le K1G1k (1k logic elements !!!!!), mais c'est gentil :)

Il y a plein d'instructions spécialisées comme des CRC, des hash, toutes ne peuvent pas être dans un jeu d'instruction.

Concernant le CRC, il y a une instruction prévu pour dans le jeu d'instruction Intel (voir page 334), le compilateur peut donc émettre l'opcode lançant le calcul d'un CRC. Même principe pour les instructions accélérant le support du chiffrement/déchiffrement AES et autres.

Si j'ai bien compris le principe de tensorflow de google, ils ont simplement ajouter à un jeu d'instruction vectoriel, un jeu d'instruction matriciel (le vecteur de 4 peut aussi être une matrice 2*2)

De ce que je vois, ils n'ont pas rajouté d'instructions mais ont tout simplement utilisés les instructions vectoriels de calcul pour faire des maths sur des matrices. Il y a d'ailleurs un article d'Intel là dessus. Ne pas oublier que dans ce contexte, vectoriel n'a pas la définition mathématique de "matrice dont l'une des dimensions est de cardinal 1" (ou quelque soit la bonne manière de le formuler) mais "instruction agissant sur plusieurs données à la fois".

Je n'étais pas sûr d'avoir compris le sens de ta demande et je suis parti du mauvais côté de l'interprétation :D

Non, à ma connaissance il n'y a pas de processeur intégrant des FPGA.
Xilinx propose les Zynq qui dans le même SoC embarque un FPGA et un processeur ARM, mais le processeur accède au FPGA via un un bus classique comme il accéderait à un autre type de contrôleur.

À mon avis, pour voir arriver ce genre de solution, il faudrait que les créateurs de processeurs aient accès à des cœurs de FPGA pour pouvoir les intégrer. Hors, jusque là, les designs de processeurs était courant mais pas ceux de FPGA ;) Mais depuis qu'Intel a racheté Altera et possède donc le savoir faire sur les deux domaines, on peut envisager qu'ils se penchent sur l'idée.

J'ai pas relu dans le détail mon contrat, mais je pense que malgré mon départ je reste soumis à une clause de confidentialité ou truc du genre. Donc je vais me contenter de commenter ce qui a été rendu public

• Un testchip contenant un processeur Leon et un eFPGA Menta a été conçu lors d'un projet européen visant à définir l'électronique devant équiper l'armement de demain
• un testchip en GF 14nm a été fabriqué en 2016 pour XXX
• il semblerait qu'ils est étés sélectionnés pour intégrer un SoC destiné à faire de la 5G

Et «off the record», on a eu de nombreux de prospects qui ont évalués notre technologie et celle de la concurrence. D'après les retours qu'on a eu (les commerciaux sont un peu radins en retours vers les ingénieurs), il semblerait que notre solution était globalement la favorite (notamment grâce à l’extrême simplicité d'utilisation d'Origami Programmer) mais au final personne ne signait jamais.
Donc jusqu'à mon départ en 2018, elle tournait surtout grâce à l'argent injecté par les investisseurs.