void move_ants(t_node **sender, t_final optimal, int ants)
{
int id;
id = 1;
while (ants > 0)
{
sender = next_cycle(sender, &optimal, &id, &ants);
}
}
int sc_main(int argc, char *argv[])
{
int i;
sc_signal<bool> clk;
sc_signal<sc_int<8> > addr;
sc_signal_rv<16> data_in;
sc_signal_rv<16> data_out;
sc_signal<bool> write;
sc_trace_file *my_trace_file;
my_trace_file =
sc_create_vcd_trace_file ("sram_trace");
sc_trace(my_trace_file, clk, "clk");
sc_trace(my_trace_file, addr, "addr");
sc_trace(my_trace_file, data_in, "data_in");
sc_trace(my_trace_file, data_out, "data_out");
sc_trace(my_trace_file, write, "write");
sram sram("Synchronous_RAM");
sram.clk(clk);
sram.addr(addr);
sram.data_in(data_in);
sram.data_out(data_out);
sram.write(write);
addr=22 ; write = 1; data_in=34;
next_cycle (clk);
addr=23 ; write = 1; data_in=42;
next_cycle(clk); next_cycle(clk);
write = 0; addr=25 ;
next_cycle(clk);
write = 0; addr=22 ;
next_cycle(clk); next_cycle(clk);
for(i=0; i<17; i++)
next_cycle(clk);
sc_close_vcd_trace_file (my_trace_file);
return EXIT_SUCCESS;
}
/*
main et sc_main
La fonction main() est déjà définie par la bibliothèque SystemC.
Elle appelle la fonction sc_main, fournie par l'utilisateur, qui est le point d'entrée du code utilisateur.
sc_main a le même prototype que main : int sc_main(int argc, char *argv[]);
Cette fonction a pour rôle d'instancier tous les modules et signaux nécessaires, et de lancer la simulation.
*/
int sc_main(int argc, char *argv[])
{
int i;
/*
Déclaration des signaux
Le registre à décalage possède trois ports, trois signaux sont donc nécessaires à son test.
On instancie donc trois signaux, de type bool (1 bit, en logique 2 valuée).
L'horloge a aussi un type sc_signal<bool>. C'est nous qui nous chargerons de la faire bouger.
Il existe en SystemC une façon plus propre de générer des horloges, en passant par le type sc_clock.
C'est le moteur SystemC qui se charge alors de générer les transitions des objets sc_clock.
*/
sc_signal<bool> clk;
sc_signal<bool> in;
sc_signal<bool> out;
/*
Trace des signaux
SystemC dispose de fonction de traçage de signaux au format VCD (Value Change Dump, visible par gtkwave, ... ).
SystemC permet de tracer les variables scalaires, les vecteurs de bits, les signaux et certains ports.
Pour les objets ne disposant pas de fonctions de traçage (structures, objets, ...) il est toujours possible de définir ses
propres fonctions de traçage, qui consistent généralement à tracer les membres de l'objets. Seuls les objets existant pendant
toute la simulation peuvent être tracés. En d'autres termes, les variables locales ne sont pas traçables.
Avant de tracer un objet, il faut ouvrir un fichier de traces. C'est le but de la fonction sc_create_vcd_trace_file().
Puis on enregistre tous les objets à tracer à l'aide la fonction sc_trace, prenant en argument une référence ou un pointeur
vers l'objet à tracer et un nom associé qui sera utilisé dans la génération des chronogrammes.
Il est impératif, sous peine de crash, de fermer le fichier de trace avant de retourner de sc_main().
Plusieurs fichiers de traces peuvent être générés en même temps, et un même signal peut être tracé dans plusieurs fichiers à la fois.
*/
sc_trace_file *my_trace_file;
my_trace_file = sc_create_vcd_trace_file ("shift_trace");
sc_trace(my_trace_file, clk, "clk");
sc_trace(my_trace_file, in, "in");
sc_trace(my_trace_file, out, "out");
// sc_trace(my_trace_file, shifter->regs, "regs"); // ???????????????????
/*
Instanciation et connexion du module à tester
L'instanciation d'un module se fait comme l'instanciation de n'importe quel objet C++.
On peut le créer de façon statique comme ici (il prend comme argument celui attendu par son constructeur, c-à-d un nom), ou de façon dynamique à
l'aide de new (new est l'équivalent de malloc en C++, il permet d'allouer dynamiquement un objet en passant des arguments à son constructeur).
La connexion est faite ici de façon explicite : chaque port et relié explicitement à un signal : shifter.din(in);
Il est aussi possible, comme en Verilog ou VHDL, d'utiliser une connexion par position (implicite).
*/
shifter shifter("reg_decalage");
shifter.clk(clk);
shifter.din(in);
shifter.dout(out);
// connexion par position : shifter(clk, in, out); ???????????????????
/*
Lancement de la simulation
Une simulation se lance généralement par sc_start, et s'arrête par sc_stop. Comme aucun signal n'est géré automatiquement dans ce système-ci
(pas de sc_clock), il faut gérer la simulation manuellement.
La simulation peut être initialisée par l'appel de la fonction sc_start(SC_ZERO_TIME), qui se charge alors de faire toutes les initialisations
du scheduler SystemC, et d'exécuter une fois tous les processus qui ne sont pas marqués dont_initialize().
Mais cet appel n'est pas obligatoire : il est fait automatiquement pas le scheduler lors du lancement de la simulation s'il n'a pas déjà été fait.
Remarque : le fonction sc_initialize() est obsolète, et remplacée par sc_start(SC_ZERO_TIME).
Les signaux sont alors positionnés à la main, par une simple affectation (in = 0).
Puis le temps est avancé manuellement par la fonction qu'on a appelée next_cycle(), dont le code se trouve en bas du listing :
cette fonction positionne manuellement la ligne d'horloge, et fait à chaque fois avancer la simulation d'une unité de temps (1ns)
grâce à la fonction sc_start().
*/
in = 0;
next_cycle(clk);
in = 1;
next_cycle(clk); next_cycle(clk);
in = 0;
next_cycle(clk);
in = 1;
next_cycle(clk); next_cycle(clk);
in=0;
for(i=0; i<17; i++)
next_cycle(clk);
sc_close_vcd_trace_file (my_trace_file);
return EXIT_SUCCESS;
}
int sc_main(int argc, char * argv[])
{
//les entrées du modèle
sc_signal<bool> clk;//declaration de l'horloge
sc_signal<unsigned char> x;
sc_signal<unsigned char> y;
sc_signal<unsigned char> pgcdOut;
sc_signal<bool> start;
sc_signal<bool> done;
sc_trace_file *my_trace_file;//creation du fichier et de trace et ajout des traces a afficher
my_trace_file = sc_create_vcd_trace_file("PGCD_traces");
sc_trace(my_trace_file, clk, "clk");
sc_trace(my_trace_file, start, "start");
sc_trace(my_trace_file, x, "x");
sc_trace(my_trace_file, y, "y");
sc_trace(my_trace_file, done, "done");
sc_trace(my_trace_file, pgcdOut, "pgcdOut");
PGCD PGCD("PGCD");//creation du module et branchement des files
PGCD.clk(clk);
PGCD.x(x);
PGCD.y(y);
PGCD.pgcdOut(pgcdOut);
PGCD.start(start);
PGCD.done(done);
sc_trace(my_trace_file, PGCD.pgcdReady, "pgcReady");
//on initialise les variables
x = 0;
y = 0;
pgcdOut = 0;
start = 0;
done = 0;
next_cycle(clk);
//on va mettre quelque chose d'interessant a l'entrée
/*//tests basiques
x.write(230);
y.write(90);
next_cycle(clk);
start.write(1);
next_cycle(clk);//cycle lecture calcul
start.write(0);
next_cycle(clk);//cycle calcul et debut affichage
//affichage de debugage
cout << " voci le pgcd: " << pgcdOut.read() << endl;
next_cycle(clk);//cycle fin affichage
next_cycle(clk);
for (int i = 0; i < 40; i++)
next_cycle(clk);
x.write(34);
y.write(22);
next_cycle(clk);
start.write(1);
next_cycle(clk);//cycle lecture calcul
start.write(0);
next_cycle(clk);//cycle calcul et debut affichage
//affichage de debugage
cout << " voci le pgcd: " << pgcdOut.read() << endl;
next_cycle(clk);//cycle fin affichage
next_cycle(clk);
*/
//test exhaustifs
for (int i = 0; i < CHAR_MAX; i++)//on fait tous les pgcd
{
for (int j = 0; j < CHAR_MAX; j++)
{
next_cycle(clk);
x.write(i);
y.write(j);
next_cycle(clk);
start.write(1);
next_cycle(clk);//cycle lecture calcul
start.write(0);
int resultatBon = PGCD.pgcd(i, j);
int resultatPerso = pgcdOut.read();
next_cycle(clk);//cycle calcul et debut affichage
//affichage en cas de difference avec la method ed reference
if (resultatPerso != resultatBon)
{
cout << "Probleme dans le calcul du pgcd, on trouve: "
<< resultatPerso << " au lieu de : " << resultatBon
<< endl;
}
else
cout << " calcul réussi " << endl;
for (int toto = 0; toto < 6; toto++)
next_cycle(clk);//cycle fin affichage
}
}
return EXIT_SUCCESS;
}
