115 lines
3.5 KiB
OCaml
Executable file
115 lines
3.5 KiB
OCaml
Executable file
(* Exception qui signifie que l'on essaye d'adresser la mémoire à un endroit
|
|
* où elle n'est pas définie.
|
|
*)
|
|
exception OutOfBound
|
|
|
|
(* Interface Memory, qui représente un système de mémoire avec adressage direct.
|
|
*
|
|
* On suppose que la mémoire stocke des octets (on peut le rendre type-generic
|
|
* ceci dit).
|
|
*)
|
|
module type Memory =
|
|
sig
|
|
(* Le type qui contient la mémoire (e.g. list) *)
|
|
type mem_type
|
|
|
|
(* Un type qui contient la mémoire + la taille de son bus d'adressage *)
|
|
type mem = int * mem_type
|
|
|
|
(* Nom de l'implémentation (pour les tests) *)
|
|
val name : string
|
|
|
|
(* bussize : mem -> int
|
|
* Retourne la taille du bus d'adressage de la mémoire, autrement dit le
|
|
* nombre de bits sur lesquels les adresses d'accès peuvent être encodées.
|
|
*
|
|
* Paramètres :
|
|
* m : mem, mémoire à tester
|
|
* Retour :
|
|
* avec m = (clear n), retourne n
|
|
*)
|
|
val bussize : mem -> int
|
|
|
|
(* size : mem -> int
|
|
* Calcule la taille de la mémoire, c'est à dire le nombre (potentiel)
|
|
* d'emplacements accessibles.
|
|
*
|
|
* Paramètres :
|
|
* m : mem, mémoire à tester
|
|
* Retour :
|
|
* nombre de "cases" exploitables dans la mémoire
|
|
*)
|
|
val size : mem -> int
|
|
|
|
(* allocsize : mem -> int
|
|
* Calcule le nombre de cases "physiquement" allouées pour la mémoire,
|
|
* autrement dit la taille qu'elle prend dans la RAM physique de
|
|
* l'ordinateur.
|
|
*
|
|
* Paramètres :
|
|
* m : mem, mémoire à tester
|
|
* Retour :
|
|
* taille effective de la mémoire en mémoire
|
|
*)
|
|
val allocsize : mem -> int
|
|
|
|
(* busyness : mem -> int
|
|
* Calcule le nombre de valeurs stockées dans la mémoire. Pour simplifier,
|
|
* on considère que les cases qui contiennent 0 sont vide.
|
|
*
|
|
* Paramètres :
|
|
* m : mem, mémoire à tester
|
|
* Retour :
|
|
* nombre de cases non-vide de la mémoire
|
|
*)
|
|
val busyness : mem -> int
|
|
|
|
(* clear : int -> mem
|
|
* Initialise une mémoire avec un nombre de *bits d'adressage*, autrement
|
|
* dit le nombre de bits sur lesquels une adresse d'accès peut être
|
|
* exprimée.
|
|
*
|
|
* Paramètres :
|
|
* n : int, nombre de bits d'addressage
|
|
* Retour :
|
|
* mémoire initialisée (contenu aléatoire, des 0 pour simplifier)
|
|
*
|
|
* Pré : n > 0, n < 32 (< 64)
|
|
* Post : si m = clear n, alors toutes les opérations sur m qui se basent
|
|
* sur une adresse codée sur n bits ne doivent pas lever OutOfBound.
|
|
*)
|
|
val clear : int -> mem
|
|
|
|
(* read : mem -> int -> char
|
|
* Réalise la lecture de la mémoire à l'adresse donnée, et retourne la
|
|
* valeur correspondante.
|
|
*
|
|
* Paramètres :
|
|
* m : mem, mémoire à lire
|
|
* addr : int, adresse de lecture
|
|
* Retour :
|
|
* valeur stockée dans m à l'adresse addr
|
|
*
|
|
* Exception : OutOfBound levée si addr n'est pas une adresse valide pour m
|
|
*)
|
|
val read : mem -> int -> char
|
|
|
|
(* write : mem -> int -> char -> mem
|
|
* Réalise l'écriture de la mémoire à l'adresse donnée et avec la valeur
|
|
* donnée, puis retourne la mémoire ainsi modifiée.
|
|
*
|
|
* Paramètres :
|
|
* m : mem, mémoire à modifier
|
|
* addr : int, adresse d'écriture
|
|
* value : char, valeur à écrire
|
|
* Retour :
|
|
* mémoire modifiée
|
|
*
|
|
* Post : si m' = write m addr c alors read m' addr == c
|
|
* Excpetion : OutOfBound levée si addr ne rentre pas sur le nombre de bits
|
|
* d'adressage spécifié dans m
|
|
*)
|
|
val write : mem -> int -> char -> mem
|
|
|
|
end
|