TICS TL - Now Transistor Level

J'ai étudié pendant quelques semaines le premier microprocesseur disponible sur le marché, le Intel 4004.
Il a l'avantage d'être a la fois très complexe et très simple.
Complexe dans le sens ou il permet de faire tout ce qu'on processeur permet de faire, ou presque.
Simple dans le sens ou son architecture 4 bit n'utilise que peu de transistors (dans les 2000).

Bref, c'est un parfait terrain de jeu pour ceux qui aiment les architectures d'ordinateurs, car assez ancien pour être décortiqué.
De plus beaucoup de documentation est disponible sur le net, des schémas, des émulateurs, etc...

Par contre, visualiser et comprendre des transistors c'est assez difficile, du coup j'ai fait une version de TICS totalement différente de la précédente, qui était basée sur des règles strictes pour augmenter les performances au max.
Comme dans TICS, on peut éditer nos circuits sur une bête image bitmap, avec le même système de fils. La différence est qu'on a désormais 3 composants:
- Power (en rouge foncé)
- Ground (en bleu ciel)
- Transistor (en vert foncé)

J'ai crée mon premier circuit intéressant, qui est un compteur + afficheur 7 segments hexa:

=> https://i.imgur.com/09gfslF.gif
On remarque que contrairement a TICS, les boucles et les double sens ne sont plus interdit.
Par contre, certains éléments vont nécessiter un signal d'horloge (le compteur par exemple).

Chose amusante, la structure de la ROM (bloc tout en bas) est très propre et simple.

J'ai aussi réussi à faire une mémoire dynamique dont chaque cellule n'utilise que trois transistors, en me basant
sur les registres du 4004:

=> https://i.imgur.com/yxNZG0s.png
Version lisible a gauche et version compressée a droite.

Il faut quelques étapes pour une lecture ou une écriture, mais la densité de stockage est plutôt épatante.
Dans le 4004 original par contre, il faut un système de lecture et réécriture permanente sans quoi les bits finissent par
s'effacer (d’où le nom: mémoire dynamique).
Dans mon simulateur ce n'est pas le cas, mais je me demande si ça ne pourrait pas être intéressant a ajouter.


Sinon le but de tout ça, ça serait d'en faire un petit puzzle game.
Du coup la je planche sur l'interface, l'éditeur, les puzzles etc...
J'espère que je perdrais pas la motive trop vite, car faire les éditeurs c'est toujours le truc le moins fun.

Je te souhaite vraiment d'y parvenir. C'est un chouette projet.
Si il y a un petit port WebAssembly, ce serait vraiment sympa ;

Merci,
j'utilise que des techos cross platform donc y a pas de raison que je puisse pas.
On verra quand j'aurais mon éditeur

J'ai réussi a reproduire le intel 4003 (qui est un registre a décalage utilisé comme I/O expander du MCS-4):


Et il est fonctionnel bien entendu.

@arthuro si tu passes par la un de ces 4, je cherche un algorithme pour passer d'un graphe a une image (transistors/portes logiques).
Autant passer d'une image a un graphe est trivial, autant dans l'autre sens je ne vois pas du tout quel genre d'algo il faudrait.
Vu que t'as fait diagon j'imagine que t'y vois un peu plus clair que moi a ce niveau.

Genre faire du placement de graphe ? Le meilleur qui se fasse, c'est graphviz, et c'est open source. Par contre, t'auras pas tea jolis symboles de transistor. En ce moment, je suis des cours de Verilog. Si ça se trouve, ça peut faire ce que tu cherches aussi.

Super oni.

A quoi ressemble ton graph? Je suis pas certain de ce que tu souhaite faire.

Est ce que tu as un graph un peu comme un réseau de neurone où les neurone sont les portes logique et les arêtes les fils? Tu souhaite placer les portes sur un espace 2D en essayant de minimiser les croisement et la surface utilisée. C'est bien ça?

C'est simple, pour interpréter mes circuits de transistor, je "parse" l'image et je la convertis en graphe.


https://i.imgur.com/v3VVtqa.png

=>

Graphe:
- un transistor est un sommet
- un GND / VCC est un sommet (unique, a priori)
- puis le tout est relié par des arrêtes

J'ai ensuite un algo pour faire la simulation directement sur ce graphe, avec une propagation et stabilisation du signal.


Maintenant l'idée, c'est justement de permettre de repasser a une image équivalente a celle du dessus, a partir de seulement mes données de graphe.
Le truc intéressant, c'est qu'on sait par exemple qu'un transistor à toujours 3 arrêtes max.

Le but c'est même pas de limiter au maximum les croisements (vu que ça coûte rien dans le simulateur), c'est juste d'avoir un truc relativement compact et pas trop moche visuellement. Mais au final tant que ça marche c'est déjà plutôt pas mal (le top serait que ça parte pas dans tous les sens si y a pas besoin, surtout).

@Craki
Je pourrais essayer de voir quel algo ils utilisent ouais, par contre mon truc est moins "général" (3 arrêtes max depuis une node transistor) donc y a probablement moyen d'avoir un truc plus simple ou efficace.

Sinon bien vu, j'aimerais faire un verilog like pour avoir une abstraction haut niveau.
Autant générer des graphes depuis un langage descriptif ça me parait pas trop compliqué, autant transformer mes graphes en une image pas trop dégueux ça me dépasse un peu.

Et bien c'est compliqué (voir très compliqué).

Quelques idées:

1) Il faut trouver une position (x,y) pour chaque éléments. On peut minimiser 2 termes:
A) Pour l'ensemble des arêtes, la somme du carré de leurs longueurs.
B) Pour l'ensemble des couples de noeuds, on veut minimiser exp(distance - R) (R une constante fixé)

A + B est différentiable en la position des noeuds. Utiliser une descente de gradient pour trouver une solution pas trop mauvaise.

2) Placer les noeuds selon 1), placer les arêtes en utilisant un algorithme de plus courts chemins.
Si impossible, augmenter R et recommencer.

3) Utiliser un algorithme de type liquid rescale pour compacter un peu plus le graph.

Tu en dis quoi? Bon, c'est au moins 10 nuits de travail et le résultat n'est pas garantis.

Ahah, franchement j'ose pas encore me lancer, c'est vrai que tout ce a quoi j'ai pensé a l'air bougrement complexe, et tu ne fais que confirmer.

Je pense qu'une chose pourra m'aider, c'est de faire des blocs logiques de base, pré-faits, puis utiliser l'assemblage automatique qu'entre ces blocs logiques.
Comme ça au final, ça diminuera beaucoup la complexité, sans qu'on perde totalement le côté automatique de la chose.

Mais bon, il faut quand même que j'arrive a implémenter un algo fonctionnel (même si a la limite je m'en fou des longueurs de câbles entre gros blocs logiques).

J'ai réussi a faire une partie qui me tenait beaucoup a cœur, la simulation de "layout" (comme ce qui est directement gravé sur silicium).

Une xnor fonctionnelle: http://wyvup.com/?c=A25hrnt
Bleu = metal
Rouge = poly
Vert et orange = diff

On a VCC et GND suivis de 2 inputs pour la porte XNOR, la sortie étant le câble qui va jusqu'a tout a droite.

J'arrive enfin a simuler de vrai circuits.
Petite démo d'un counter du 4004 (un seul bit sur l'image, mais ça se chaîne avec des blocs identiques):

https://i.imgur.com/7nPxJYA.gif
et la photographie du DIE:

https://i.imgur.com/tieCg4X.png

Mais t'est complètement dingue !
C'est génial, tu peut simuler une photo d'un die !

ça veut dire que tu peut exporter en vhdl plus ou moins facilement ta simu, et la synthétiser sur une vraie puce, et du coup copier des anciens systèmes !
Ou plus pédagogiquement afficher les diférentes étapes de fonctionnement d'une puce !

C'est juste grandiose, je t'applaudis biens haut !

PS :
Fait une page propre sur un site web, et envoie un mail à hack a day, tu aura des visiteurs, c'est quasiment certain.
Furrtek et Deus ex silicium pourront aussi être intérésés je pense. Mais je m’égare...

Merchi
Ouais, j'y ai pensé, mais pour ça faut que je finisse le projet :p

Par contre ça simule pas n'importe quel DIE, pour l'instant c'est limité a deux technologies (voir 3): celle du 4004 (équivalent a du nmos), a priori pmos (vu que c'est juste complémentaire a nmos), et cmos (comme le 6502).
De plus les circuits sont simplifiés au niveau de la simulation, donc tout ce qui est électronique analogique ça ne passe pas (pas de prise en compte des décalages temporels, des valeurs de résistance différentes, etc).
En revanche, tout le reste ça devrait rouler (je sais que pour le 4004 et le 6502 il n'y a pas de soucis, et niveau pédagogie je pense que le 6502 c'est le must).

Actuellement je décortique le 4004 complètement en me basant sur les schémas que j'ai trouvé sur internet (le 4004 est bien documenté).
Le but est de présenter les composants un a un (comme le counter plus haut), animés, et leur fonctionnement.

J'ai presque finalisé les registres il y a peu (c'était assez tendu car il y avait des condensateurs et des bootstrap qu'il a fallu "parser", sans parler des séquences de lecture/écriture des registres en eux même qui sont pas forcement évident).


Bref la l'idée c'est de finir mon "jeu"/puzzle ludique, qui aura plusieurs modes.
Mais en gros, l’intérêt premier sera d'apprendre les bases du reverse engineering hardware, en partant du plus simple (création de circuits a base de portes logiques) jusqu’à des modes de plus en plus proches du hardware (mode transistors schématisés, comme tout en haut, puis mode layout, comme le post précédent).

Si j'ai la motive, je pourrais pousser le concept encore plus loin avec du reverse engineering software... basé sur du hardware simulé


Du coup la je bosse sur un truc qui change un peu.
J'essaye de faire un shader qui transforme des layouts "binaires" (simples images noir et blanc) en images réalistes comme celle ci: https://i.imgur.com/w0Gg2Dq.png
Et c'est pas évident

Ça servira au dernier mode de jeu.
En gros le joueur aura un layout réaliste comme sur l'image, et il devra redessiner un layout (qui pourra être simulé) par dessus pour faire ses tests, afin de comprendre un circuit et le re-designer sous forme de schémas (de transistors).

Histoire de poster un peu...

Je me suis mis en tête de faire un simulateur hautement optimisé, en espérant réussir a faire tourner une atari (voir une nes) en temps réel depuis des layouts de transistor.
Des fous se sont déjà amusé à digitaliser et faire fonctionner le 6502 avec une simulation transistor level: http://visual6502.org/JSSim/index.html

Le problème c'est que leur algo est très lent (en plus d'être implémenté en javascript).
Sur github un mec a refait l'implé en C et il arrive a une vitesse moyenne de 1/150 ieme des performances originales du chipset (qui est cadencé a 1Mhz ~).
Le but est donc d'arriver a faire une opti d'un ordre de grandeur > 100 ...

Comme j'ai déjà fait une machine virtuelle pour exécuter des circuits logiques de manière très rapide, j'essaye donc de faire une conversion transistors => portes logiques pour espérer ensuite gagner BEAUCOUP de performances dans la simulation.

L'idée est donc de découper le circuit en sous parties, déterminer un équivalent en portes logique de ces sous circuits, puis déterminer l'ordre d’exécution afin de convertir ensuite le tout en instructions pour ma VM NAND (bref, compiler un circuit de transistors). Il faut aussi prendre en compte les mémoires.

Et une petite image bonus:

> chaque couleur représente le niveau de priorité d'un ensemble de sous circuits.

Wow, j'espère que tu va y arriver. En tous cas c'est un beau projet!

Bon, après beaucoup de galères et de travail, j'ai enfin réussi à refaire le circuit complet et fonctionnel du intel 4004.
Voici un programme d'exemple qui tourne, avec une ROM émulée:
https://imgur.com/tJ9ckBk

Et le programme en question:

Code:

FIM P0, $FF
FIM P1, $FF
FIM P2, $FF
FIM P3, $FF
FIM P4, $FF
FIM P5, $FF
FIM P6, $FF
FIM P7, $FF

; hex
; 20 FF 22 FF 24 FF 26 FF 28 FF 2A FF 2C FF 2E FF

Il se contente juste de remplir tous les registres, on peut les voir à droite se remplir petit à petit

Une version réduite du circuit du 4004:

https://i.imgur.com/ncytqHV.png

C'est impressionnant la (petite) taille du truc, malgré la complexité de ce CPU.

J'ai réussi a faire une percée niveau optimisation théorique.
J'ai fait un nouveau simulateur, au niveau logique cette fois, mais avec des portes logiques qui ont toutes un équivalent (bijection) au niveau transistor, et ça marche aussi pour les cellules mémoires et les flip-flop.
Bref, un truc beaucoup mieux que le premier TICS (qui était au niveau logique) car on peut faire des cycles et des mémoires nativement.

La conséquence, c'est qu'en théorie, je peux passer de n'importe quel circuit réel (transistors) et le transformer en circuit logique.
En tout cas, j'arrive a le faire a la main, reste a voir s'il y a moyen de coder un algo de transformation automatique.

Voici un équivalent logique de ce compteur 3 bit qui vient du intel 4004:
Transistors:


Logique:


Sans aucune optimisation, le premier benchmark montre un gain d'efficacité d'un facteur 4, sachant que la, je fais juste une simulation sur un graphe, sans optimiser aucune partie du graphe (remplacement de portes logiques par équivalent plus haut niveau par ex).

De plus on remarquera que le circuit est plus condensé et simple à comprendre.

Maintenant l'idée est de faire une conversion automatique, et vérifier que tout fonctionne sur un gros circuit (par ex le intel 4004 que j'ai reverse).
Ensuite, trouver des idées d'optimisations au niveau logique (a coup de pattern matching j'imagine) pour dépasser le megahertz sur des circuits a 10k transistors.

Les benchmarks pas encore très représentatifs:

Code:

// Benchmark 1 - counter 3-bit
// Iterations | Logic | Transistor Debug | Logic | Transistor Release
// 100k : 366ms, 925ms | 8.33ms, 31.29ms

// Benchmark 2 - counter 10-bit
// Iterations | Logic | Transistor Debug | Logic | Transistor Release
// 100k : 463ms, 1304ms | 9.64ms, 37.95ms

Bonjour Onilink,

Tu dit que blocs logique (and, or, xor, ... mémoire, flip-flip, ...) on un équivalent avec des transistor (oui) et que tu peux faire une transformation automatique d'un circuit depuis des blocs logique vers des transistors.

Deux petites question bêtes:
1. Peut-tu aussi faire la transformation inverse? Ça me semble difficile, où bien ça dépend de ce que l'on entend.
2. Passer d'une porte logique vers des transistor modifie la taille des composants, comment tu t'en sors pour garder les composants connectés entre eux. Comment tu re-route?

Salut Arthuro,

Justement la transformation inverse n'est pas simple mais possible.
J'avais théorisé un algorithme qui semblait fonctionner, mais un peu lourd a calculer, donc je suis allé voir un peu ce qu'il se fait en fouillant dans des publications.
Et effectivement, c'est ce qui semble se faire déjà depuis un moment.

Ça à mis des mots sur des choses que j'avais identifié mais dont j'ignorais la nomenclature.

Par exemple les CCCs: channel-connected-components, ou la méthode de "Réduction en série de parallèles" (qui est le vrai nom de l'algo que j'avais imaginé).

L'idée d'un algorithme automatique pour revenir au niveau logique, c'est de découper le circuit en CCCs, qui seront ensuite simples a traiter.
Sur chaque CCC, on applique la méthode de réduction en série de parallèles, qui permet ensuite d'obtenir facilement une fonction logique.

Par contre je ne sais pas si ça prend en compte les "condensateurs", ces mémoires qui disparaissent au bout de quelques cycles mais qui sont très utilisées dans les registres du 4004 par exemple.

La ou tous les papers semblent s'entendrent, c'est que la grosse difficulté c'est de retourner a un niveau de haute abstraction, donc passer de transistors ou portes logiques vers des fonctions logiques (par exemple additionneur, multiplexer, registre...).
Beaucoup d'algorithmes utilisent du pattern matching plus ou moins complexe, mais je n'y suis pas encore.... mon but pour l'instant c'est juste d'obtenir un circuit logique équivalent.

Pour le tracé logique je ne pensais juste pas le faire pour l'instant, en fait je travaille sur un second éditeur, mais qui sera cette fois nodal.
Ainsi il n'y a plus vraiment de problème de routage, ça permet de faire du prototyping rapidement.
J'essayerais plus tard de faire un système pour faire des tracés automatiques à partir du système nodal, mais c'est pas vraiment ma priorité, étant donné que je veux surtout optimiser les temps de simulation, pour faire de l'émulation "parfaite" de vieux circuits.