From 4c3cc78a7af5c77726c58f035fa54244e24e9feb Mon Sep 17 00:00:00 2001 From: Alex AUVOLAT Date: Wed, 15 Jan 2014 11:00:26 +0100 Subject: Move documentation ; add template for report on CPU. --- doc/minijazz.pdf | Bin 0 -> 133184 bytes doc/plan_micro.pdf | Bin 0 -> 80846 bytes doc/plan_micro.tm | 256 ++++++++++++++++++++++++++++++++++++++++++++++ doc/projet13.pdf | Bin 0 -> 173967 bytes doc/rapport_cpu.tex | 120 ++++++++++++++++++++++ doc/rapport_simulateur.tm | 119 +++++++++++++++++++++ doc/tp1_simulateur.pdf | Bin 0 -> 103007 bytes 7 files changed, 495 insertions(+) create mode 100644 doc/minijazz.pdf create mode 100644 doc/plan_micro.pdf create mode 100644 doc/plan_micro.tm create mode 100644 doc/projet13.pdf create mode 100644 doc/rapport_cpu.tex create mode 100644 doc/rapport_simulateur.tm create mode 100644 doc/tp1_simulateur.pdf (limited to 'doc') diff --git a/doc/minijazz.pdf b/doc/minijazz.pdf new file mode 100644 index 0000000..06b90c6 Binary files /dev/null and b/doc/minijazz.pdf differ diff --git a/doc/plan_micro.pdf b/doc/plan_micro.pdf new file mode 100644 index 0000000..d1e0dcc Binary files /dev/null and b/doc/plan_micro.pdf differ diff --git a/doc/plan_micro.tm b/doc/plan_micro.tm new file mode 100644 index 0000000..158ffb5 --- /dev/null +++ b/doc/plan_micro.tm @@ -0,0 +1,256 @@ + + + + +<\body> + ||>>> + + Nous proposons ici une spécification pour un processeur minimaliste 16 bit + RISC. + + + + La machine dispose de 8 registres \S généraux \T, tous de taille 16 bits : + + \; + + <\itemize> + 0. Registre ou zéro (valant tout le temps 0...) + + 1. Registre + + 2. Registre + + 3. Registre + + 4. Registre + + 5. Registre , écrit par certaines instructions + (multiplication, division...) et utilisé préférentiellement comme + registre temporaire pour certaines instructions composées + + 6. Registre , ou (return adresse), écrit + par l'instruction + + 7. Registre , ou (stack pointer), utilisé + par les instructions et + + + Ces 8 registres sont tous manipulables par les instructions prenant un + registre comme argument. De plus, le processeur dispose d'un registre + manipulable uniquement par certaines instructions spécifiques, le registre + (program counter : contient l'adresse de l'instruction + courante). + + Les numéros de registres sont donc codés sur 3 bits. + + + + La mémoire est adressée sur 16 bits et les mots mémoire font 8 bits, il y a + donc 64ko disponnibles. + + Le CPU est little-endian (le mot 0x1234 est codé 34 puis 12) + + On définit plusieurs zones de mémoire : + + |>||>||>>>>|Memory map> + + Les bits suivants sont utilisés pour la MMIO : + + >>>>|>||>||>>>>|Addresses MMIO> + + + + Les instructions sont codées sur 16 bits. Les tableaux suivants montrent + les instructions avec les bits de poids forts à gauche et les bits de poids + faibles à droite (convention contraire à celle exprimée dans le + ). + + + + ||||||>|>|>|>>>|||>>>> + + >|||||||||>|>|>|>>|>>|>>>>> + + >||||||>|>|>|>>>>> + + ||||||||>|>|>|>>|>>>>> + + >||||||>|>|>>>>> + + + + Certain noms d'instuctions sont en , il s'agit de signifier + qu'il s'agit d'un alias (optionnel) pour une autre instruction. + + |>>|>|>>|>|>|>>|||||R+R>>|>|||||R-R>>|>|||||lo\R|)>>>|>|||||hi\R|)>> + si R>>|>|||||q,R|)>>>|>|||||r,R|)>> + si R>>|>||||||>||||||>||||||>||||||>|||||\R|)>>>|>|||||\R|)>>>|>|||||\R|)>>>|>|||||not + \R|)>>>|>|||||\R|)>>>|>||||>||>|||||\R|)>> + (logical)>|>|||||\R|)>> + (arith)>|>||||>||>||||>||>|||||=R?1:0|)>>>|>|||||\R?1:0|)>>>|>|||||\\R?1:0|)>>>|>|||||\R?1:0|)>>>|>|||||\\R?1:0|)>>>|>|||||\R?1:0|)>>>|>|||||>>| + signé>>|||||d|)>>>| + signé>>|||||PC+d>>|>||||| + ; PC\PC+d>>|>||>|||R>>|>||>||| + ; PC\R>>|>|||||=R> then R>>|>|||||\R> then R>>|>|||||\R> then R>>|>|||||\R> then + R>>|>|||||\R> then R>>|>|||||\R> then + R>>|>|||||PC+d>>| + signé>>||||>||>||||>||>||||||>|||||mem+d|)>> + (16 bits)>|>|||||+d|)>\R> + (16 bits)>|>|||||\mem+d|)> + ; R\0> (8 bits)>|>|||||+d|)>\R> + (8 bits)>|>|||||mem+R|)>> + (16 bits)>|>|||||+R|)>\R> + (16 bits)>|>|||||\mem+R|)> + ; R\0> (8 bits)>|>|||||+R|)>\R> + (8 bits)>|>|||||\d>>|>|||||\d + ; R\0>>| non + signé)>>|||||\d>>|>|||||\d + ; R\0>>|>|||>||sign_extend>>| + signé)>>||||>||>||||>||>||||>|>>|>>>>|Instructions + reconnues par le microproceseur> + + L'assembleur propose également quelques instructions \S étendues \T + permettant de faciliter la programmation : + + |>|>|>>|>|G-2 ;mem\R + >>|>>|||>, >>|>|mem ; + G\G+2>>|, >>|||, 2>>|>>|R>>|, >, >>||R+d>>|>|>>|not + R>>|,Z>>>|, + addr>| then addr>>|>|||>|, addr>|0> then + addr>>|>|||>>>>|Instructions + supplémentaires (produites par l'assembleur)> + + \ + + +<\initial> + <\collection> + + + + + + +<\references> + <\collection> + > + > + > + > + > + > + > + > + > + > + > + > + > + > + > + > + > + + + +<\auxiliary> + <\collection> + <\associate|table> + > + + > + + > + + > + + <\associate|toc> + |math-font-series||Registres> + |.>>>>|> + + + |math-font-series||Mémoire> + |.>>>>|> + + + |math-font-series||Jeu + d'instruction> |.>>>>|> + + + |Types d'instructions + |.>>>>|> + > + + |Format de base + |.>>>>|> + > + + |Format |R> + |.>>>>|> + > + + |Format |I> + |.>>>>|> + > + + |Format K + |.>>>>|> + > + + |Format |J> + |.>>>>|> + > + + |math-font-series||Tableau + d'instructions> |.>>>>|> + + + + \ No newline at end of file diff --git a/doc/projet13.pdf b/doc/projet13.pdf new file mode 100644 index 0000000..c603cfc Binary files /dev/null and b/doc/projet13.pdf differ diff --git a/doc/rapport_cpu.tex b/doc/rapport_cpu.tex new file mode 100644 index 0000000..d7901db --- /dev/null +++ b/doc/rapport_cpu.tex @@ -0,0 +1,120 @@ +\documentclass[11pt, a4paper]{article} + +\usepackage[utf8]{inputenc} + +\usepackage[margin=1.0in]{geometry} +\usepackage[french]{babel} + +\newcommand{\prog}[1]{{\tt#1}} +\newcommand{\underscore}{$\_\,$} + +\begin{document} + + + +\title{Programmation d'un simulateur de net-lists \\ \normalsize{\textsc{Projet de Système digital}}} +\author{Jonathan Laurent} +\maketitle + + +Le programme \prog{netsim} permet de simuler un circuit digital synchrone représenté par une net-list. Il propose notamment les fonctionnalités suivantes : + +\begin{itemize} +\item Un \textit{mode interactif} suffisament riche pour permettre un déboguage efficace des net-lists +\item Le maintien d'un \textit{historique} des états de la machine permettant d'annuler certaines actions +\item La \textit{vérification} de la cohérence des net-lists passées en entrée +\end{itemize} + +\section{Guide d'utilisation} +\subsection{Commande et options} + +Le programme se lance avec la commande + +\begin{center}\prog{./netsim NETLIST\underscore{}FILE [--rom ROM\underscore{}FILE] [-f INPUT\underscore{}FILE] }\end{center} + +où \prog{NETLIST\underscore{}FILE} désigne un fichier contenant le circuit à simuler, \prog{ROM\underscore{}FILE} contient le contenu des mémoires \textsc{rom}s et \prog{INPUT\underscore{}FILE} contient une suite de directives à executer avant le démarrage du \textit{mode interactif}. + +\medskip + +Dans la suite de ce document : +\begin{itemize} +\item \prog{val} désigne une valeur, c'est à dire l'état d'une nappe de fils où les bits sont présentés dans l'ordre \emph{décroissant} +\item \prog{addr} représente une valeur codant pour une adresse +\item \prog{id} désigne l'identifiant d'une variable présente dans le fichier net-list courant +\item \prog{cell} désigne une variable ou un emplacement \textsc{ram} de la forme \prog{id : addr} où \prog{addr} est une valeur codant pour une adresse + +\end{itemize} + +\subsection{Format des fichiers ROM} + +Un fichier \textsc{rom} est composé d'une suite de blocs. Un bloc est composé d'un entête de la forme suivante +\begin{center}\prog{ROM id ADDRSIZE n$_1$ WORDSIZE n$_2$ }\end{center} +où les deux arguments numériques sont fournis en écriture décimale. Le contenu de la mémoire correspondant à un entête est décrit par une suite de valeurs ordonnées dans le sens des adresses croissantes. Il est possible de sauter directement à une adresse spécifiée avec la directive +\begin{center}\prog{ADDR addr :}\end{center} +Un exemple est fourni dans le dossier \prog{samples} du programme. + +\subsection{Le language de scripts d'interaction} + +\medskip + +Après affichage de l'invite de commande \prog{>}, l'utilisateur peut saisir plusieurs directives, séparées par des points ou des sauts de lignes. La directive la plus simple consiste à entrer une séquence de valeurs \prog{val} séparées par des espaces, et correspondant à chaque entrée du circuit, dans l'ordre de leur déclaration au sein du fichier net-list. Le logiciel exécute alors un cycle machine à partir de ces entrées et affiche les nouvelles valeurs des sorties. Il est également possible de saisir une liste d'affectations suivant l'exemple suivant : +\begin{center} +\prog{a = 0, b = 0110, c = 10} +\end{center} +Les entrées su circuit qui n'auront pas été mentionnées dans la liste garderont leur valeur précédente. Il est également possible d'utiliser une des directives suivantes : + +\medskip +\begin{center} +\begin{itemize} + \item \prog{\%inputs id$_1$ ... id$_n$} spécifie une nouvelle liste ordonnée des entrées du circuit + \item \prog{\%outputs cell$_1$ ... cell$_n$} spécifie la liste des sorties du circuit + \item \prog{\%show cell$_1$ ... cell$_n$} affiche la valeur des variables et emplacements \textsc{ram} indiqués. En l'absence d'arguments, la valeur des sorties est affichée + \item \prog{\%run n} exécute $n$ cycles machine + \item \prog{\%echo off} désactive l'affichage automatique des sorties après exécution d'un cycle. Pour réactiver cette fonctionnalité, remplacer \prog{off} par \prog{on} + \item \prog{\%echo on} active l'affichage des sorties + \item \prog{\%undo n} annule les $n$ dernières commandes ayant eu pour effet d'exécuter des cycles machine. Si l'argument n'est pas spécifié, $n=1$ + \item \prog{\%redo n} annule un appel anterieur de \prog{\%undo n}, si aucune opération d'écriture n'a été excutée d'ici là + \item \prog{\%history n} redéfinit la valeur de la capacité de l'historique permettant d'effectuer des \prog{undo} + +\end{itemize} +\end{center} + +Des exemples sont disponnibles dans le dossier \prog{samples} du programme. +\section{Carcatéristiques techniques} + +Une exécution du programme se déroule schématiquement de la manière suivante : + +\paragraph{Au chargement d'un fichier net-list :} +\begin{itemize} +\item Les équations sont triées dans l'ordre topologique et tout cycle d'exécution est signalé +\item Une vérification de la cohérence des types est effectuée +\item La liste d'équations est précompilée (voire suite) +\end{itemize} + +\paragraph{A chaque cycle :} +\begin{itemize} +\item Les valeurs des mémoires \textsc{ram} sont mises à jour en fonction de l'état de la machine à la fin du cycle \emph{précédent}. Le membre gauche d'une équation de type \textsc{ram} ne dépend ainsi dans l'ordre topologique que du paramètre de l'adresse de lecture. +\item Chaque équation modifie l'état courant sur la base de l'état de la machine à la fin du cycle précédent (calcul des valeurs des registres) et de l'état obtenu après exécution des équations antérieures (par rapport à l'ordre topologique) +\end{itemize} + +\medskip + +Pour plus de détails, le lecteur est invité à consulter le fichier \emph{netlist\underscore{}simulator.ml}. + +\subsection{Optimisations} +Afin de rendre le programme raisonnablement efficace, deux optimisations ont été principalement mises en oeuvre : + +\begin{itemize} +\item Chaque variable se voit affecter un identifiant numérique et l'état de toutes les variables de la machine est stockée dans un tableau. Cependant, le type \prog{state} exporté par \prog{Netlist\underscore{}simulator} est persistent (le tableau est recopié à la fin de toutes les fonctions exportées par la signature du module), ce qui permet de gérer plutôt simplement un historique. +\item La liste des équations est précompilée en une liste de fonctions du type \prog{state -> state -> state} de manière à ce que la structure de ses éléments ne soit pas réexplorée à chaque cycle. Pour plus d'explications, consulter \emph{netlist\underscore{}simulator.ml}. +\end{itemize} + +\medskip + +Ces deux améliorations représentent un gain de temps d'un facteur 12 environ environ. A titre indicatif, la simulation de $84000$ cycles du circuit à $300$ variables \prog{clockHMS} prend $3s$. + +\subsection{Améliorations possibles} + +Le système actuel génère des erreurs très imprécises et ne vérifie pas la sémantique des fichiers de \textsc{rom} et des directives d'entrées. + +\end{document} \ No newline at end of file diff --git a/doc/rapport_simulateur.tm b/doc/rapport_simulateur.tm new file mode 100644 index 0000000..a7352cf --- /dev/null +++ b/doc/rapport_simulateur.tm @@ -0,0 +1,119 @@ + + + + +<\body> + |>>|> + + Dans le cadre du cours de + , j'ai écrit un simulateur de circuit capable de faire + fonctionner un circuit préalablement compilé dans le langage MiniJazz. + + Le simulateur que j'ai écrit est codé en C (essentiellement pour la + rapidité d'exécution), et nécessite un pré-traîtement des données par un + programme en Caml. Le simulateur en C ne lit pas directement les netlist + produites par MiniJazz, mais un fichier qui est produit + par le pré-processeur. + + Contenu de l'archive ci-jointe : + + <\verbatim-code> + README + + \ Diverses documentations. À lire. + + \; + + sched/ + + \ Dans ce répertoire se trouve le pré-processeur, qui effectue les + opérations suivantes : + + \ - lecture d'une netlist + + \ - tri topologique + + \ - diverses optimisations + + \ - écriture d'un fichier .net et d'un fichier .dumb contenant le + résultat. + + Pour compiler le pré-processeur : + + $ cd sched/ + + $ ocamlbuild main.byte + + \; + + csim/ + + \ Dans ce répertoire se trouve le simulateur en C. + + Pour le compiler : + + $ cd csim/ + + $ make + + Les options du simulateur sont décrites lors de l'invocation de celui-ci + sans arguments. + + \; + + tests/ + + \ Ce répertoire contient un certain nombre de fichiers de test au format + minijazz. Le Makefile permet d'effectuer les appels au compilateur, au + pré-processeur et au simulateur avec la syntaxe suivante : + + $ cd tests/ + + $ make nadder.sim \ \ \ \ # nadder.mj -\ nadder.net -\ + nadder.dumb -\ csim + + + Les points importants à souligner dans mon travail sont : + + <\itemize> + Définition d'un format de données intermédiaire pour les Netlist, + permettant l'écriture d'un simulateur en C. Définition conjointe de ce + format et de la structure du simulateur, afin d'écrire un simulateur le + mieux optimisé possible. + + Écriture d'un optimiseur de Netlist, qui est capable d'effectuer + plusieurs simplifications, dont : + + <\itemize> + propagation des constantes ; + + détection de variables au contenu identique ; + + suppression de variables inutiles ; + + suppression d'opérations arithmétiques inutiles. + + + L'application de ces passes d'optimisation réduit généralement la taille + d'une Netlist d'environ 30%. + + + Les efforts d'optimisation ont été faits dans l'idée que le simulateur + devra faire fonctionner un processeur MIPS à une fréquence raisonnable + (idéalement, plusieurs centaines, voire milliers, de cycle par seconde). Le + résultat de ce travail se voit sur les programmes et + qui définissent deux horloges qui comptent modulo 60 + puis 60 puis 24 (donc qui comptent sur une journée, à un cycle par + seconde). Avec mon simulateur optimisé, les deux horloges sont capables de + simuler une journée entière de comptage, c'est-à-dire 86400 cycles, en 0.4 + secondes pour le premier et 0.9 secondes pour le second, sur un ordinateur + moderne. + + +<\initial> + <\collection> + + + \ No newline at end of file diff --git a/doc/tp1_simulateur.pdf b/doc/tp1_simulateur.pdf new file mode 100644 index 0000000..0b7a29e Binary files /dev/null and b/doc/tp1_simulateur.pdf differ -- cgit v1.2.3