Script TP1 T1

T1/TP/TP1/cacti_7/_script.py

@@ -5,49 +5,273 @@ Ceci est un script permettant de tester différentes configurations
 de cache pour cacti
 """
 
-import os
+import subprocess
+import matplotlib.pyplot as plt
+import numpy as np
 
-chemin_fichier_config = "_fichiers/configs/"
+global nom_fichier_config
-chemin_fichier_result = "_fichiers/resultats/"
+global chemin_fichier_config
-
-configurations = [[1,0,0,0],[1,0,1,1],[1,0,0,1],[1,1,1,1]]
 
 nom_fichier_config = "cache.cfg"
+chemin_fichier_config = ""
 
 i = 0
 
-#----------- Cette section permet de configurer le nombre de ports entrée/sortie du fichier ---------
+def lancer_simu():
-with open(chemin_fichier_config + nom_fichier_config, "r") as fichier:
+    # Cette fonctionn permet de lancer la simulation et de récupérer les résultats
+    global chemin_fichier_config
+    global nom_fichier_config
+    resultat = subprocess.run(['./cacti', '-infile', chemin_fichier_config + nom_fichier_config ], stdout=subprocess.PIPE)
+    
+    resultat = str(resultat.stdout)
+    resultat = resultat.split("\\n")
+    return resultat
+
+def parser_elements(resultat):
+    # Cette fonction permet de parser les résultats
+    val_tps = 0
+    val_energie = 0
+    val_aire = 0
+    
+    for ligne in resultat:
+        if "Access time (ns):" in ligne:
+            val_tps = float(ligne.split(':')[1])
+            
+        if "Total dynamic read energy per access (nJ):" in ligne:
+            val_energie = float(ligne.split(':')[1])
+            
+        if "Cache height x width (mm):" in ligne:
+            string_aire = ligne.split(':')[1]
+            hauteur = float(string_aire.split('x')[0])
+            largeur = float(string_aire.split('x')[1])
+            val_aire = hauteur*largeur
+            
+    return [val_tps, val_energie, val_aire]
+
+#---------------- Fonctions pour simuler selon la taille du cache et l'associativité --------------------
+def config_taille_associativite(config):
+    #----------- Cette section permet de configurer le nombre de ports entrée/sortie du fichier ---------
+    global chemin_fichier_config
+    global nom_fichier_config
+    
+    with open(chemin_fichier_config + nom_fichier_config, "r") as fichier:
+        Lignes = fichier.readlines()
+        index = 0
+        lignes_configurees = 0
+        
+        for ligne in Lignes:
+            if "<configs_taille_cache>" in ligne:
+                Lignes[index + 1] = "-size (bytes) {}\n".format(config[0])
+                lignes_configurees += 1
+            if "<configs_associativite>" in ligne:
+                Lignes[index + 1] = "-associativity {}\n".format(config[1])
+                lignes_configurees += 1
+            if lignes_configurees == len(config):
+                break
+            index += 1
+        
+    with open(chemin_fichier_config + nom_fichier_config, "w") as fichier:
+        fichier.writelines(Lignes)        
+
+def simulation_taille_associativite(configurations_taille,configurations_associativite):   
+    liste_valeurs_taille = []
+    liste_valeurs_associativite = []
+
+    #--------- Faire tourner les simulations -------
+    for conf in configurations_taille:
+        config_taille_associativite(conf)
+        liste_valeurs_taille.append(parser_elements(lancer_simu()))
+        
+    for conf in configurations_associativite:
+        config_taille_associativite(conf)
+        liste_valeurs_associativite.append(parser_elements(lancer_simu()))
+        
+    #------------------- Faire l'affichage -------------------------
+    liste_valeurs_taille = np.array(liste_valeurs_taille)
+    liste_valeurs_associativite = np.array(liste_valeurs_associativite)
+    
+    fig, ax = plt.subplots(1, 3, figsize=(20, 5))
+    
+    ax2 = [0,0,0]
+    
+    ax[0].plot(configurations_taille[:,0], liste_valeurs_taille[:,0], 'o-')
+    ax[0].set_xlabel("Taille (octets)")
+    ax[0].set_ylabel("Temps d'accès (ns)")
+    ax2[0] = ax[0].twiny()
+    ax2[0].plot(configurations_associativite[:,1], liste_valeurs_associativite[:,0], 'o-', color='red')
+    ax2[0].set_xlabel("Associativité")
+    ax[0].set_title("Étude sur le temps d'accès")
+    ax[0].legend(["Taille (octets)"], loc='best')
+    ax2[0].legend(["Associativité"], loc='best')
+    
+    ax[1].plot(configurations_taille[:,0], liste_valeurs_taille[:,1], 'o-')
+    ax[1].set_xlabel("Taille (octets)")
+    ax[1].set_ylabel("Energie (read) (nJ)")
+    ax2[1] = ax[1].twiny()
+    ax2[1].plot(configurations_associativite[:,1], liste_valeurs_associativite[:,1], 'o-', color='red')
+    ax2[1].set_xlabel("Associativité")
+    ax[1].set_title("Étude sur la consommation")
+    ax[1].legend(["Taille (octets)"], loc='best')
+    ax2[1].legend(["Associativité"], loc='best')
+    
+    ax[2].plot(configurations_taille[:,0], liste_valeurs_taille[:,2], 'o-')
+    ax[2].set_xlabel("Taille (octets)")
+    ax[2].set_ylabel("Aire (mm²)")
+    ax2[2] = ax[2].twiny()
+    ax2[2].plot(configurations_associativite[:,1], liste_valeurs_associativite[:,0], 'o-', color='red')
+    ax2[2].set_xlabel("Associativite")
+    ax[2].set_title("Étude sur l'aire du cache")
+    ax[2].legend(["Taille (octets)"], loc='best')
+    ax2[2].legend(["Associativite"], loc='best')
+
+    fig.show()
+    
+#------------------- Fonctions pour simuler selon les entrées et sorties du cache ------------------------
+def config_entrees_sortie(config):
+    #----------- Cette section permet de configurer le nombre de ports entrée/sortie du fichier ---------
+    global chemin_fichier_config
+    global nom_fichier_config
+    
+    with open(chemin_fichier_config + nom_fichier_config, "r") as fichier:
         Lignes = fichier.readlines()
         index = 0
         
         for ligne in Lignes:
             if "<configs_ports>" in ligne:
-            Lignes[index + 1] = "-read-write port {}\n".format(configurations[i][0])
+                Lignes[index + 1] = "-read-write port {}\n".format(config[0])
-            Lignes[index + 2] = "-exclusive read port {}\n".format(configurations[i][1])
+                Lignes[index + 2] = "-exclusive read port {}\n".format(config[1])
-            Lignes[index + 3] = "-exclusive write port {}\n".format(configurations[i][2])
+                Lignes[index + 3] = "-exclusive write port {}\n".format(config[2])
-            Lignes[index + 4] = "-single ended read ports {}\n".format(configurations[i][3])
+                Lignes[index + 4] = "-single ended read ports {}\n".format(config[3])
                 break
             index += 1
         
-with open(chemin_fichier_config + nom_fichier_config, "w") as fichier:
+    with open(chemin_fichier_config + nom_fichier_config, "w") as fichier:
         fichier.writelines(Lignes)        
 
+def simulation_entrees_sorties(configurations_read,configurations_write,configurations_readwrite):   
+    liste_valeurs_read = []
+    liste_valeurs_write = []
+    liste_valeurs_readwrite = []
     
-#----------- Section pour lancer la simulation sur cacti -------------------------------   
+    #--------- Faire tourner les simulations -------
+    for conf in configurations_read:
+        config_entrees_sortie(conf)
+        liste_valeurs_read.append(parser_elements(lancer_simu()))
         
-commande = "./cacti -infile {}".format(chemin_fichier_config + nom_fichier_config)
+    for conf in configurations_write:
-flux = os.popen(commande)
+        config_entrees_sortie(conf)
-resultat = flux.read().split('\n')
+        liste_valeurs_write.append(parser_elements(lancer_simu()))
         
-for ligne in resultat:
+    for conf in configurations_readwrite:
-    if "Access time (ns):" in ligne:
+        config_entrees_sortie(conf)
-        val_tps = float(ligne.split(':')[1])
+        liste_valeurs_readwrite.append(parser_elements(lancer_simu()))
-        print(val_tps)
         
+    #------------------- Faire l'affichage -------------------------
+    liste_valeurs_read = np.array(liste_valeurs_read)
+    liste_valeurs_write = np.array(liste_valeurs_write)
+    liste_valeurs_readwrite = np.array(liste_valeurs_readwrite)
+    
+    liste_val_tps = [liste_valeurs_read[:,0], liste_valeurs_write[:,0], liste_valeurs_readwrite[:,0]]
+    liste_val_energie = [liste_valeurs_read[:,1], liste_valeurs_write[:,1], liste_valeurs_readwrite[:,1]]
+    liste_val_aire = [liste_valeurs_read[:,2], liste_valeurs_write[:,2], liste_valeurs_readwrite[:,2]]
+    
+    fig, ax = plt.subplots(1, 3, figsize=(20, 5))
+    
+    ax[0].plot(configurations_read[:,0], np.transpose(liste_val_tps), 'o-')
+    ax[0].set_xlabel("Nombre de ports")
+    ax[0].set_ylabel("Temps d'accès (ns)")
+    ax[0].set_title("Étude de l'impact des prots du cache sur le temps d'accès")
+    ax[0].legend(["Ports d'entrée", 'Ports de sortie', "Ports d'entrée/sortie"], loc='best')
+    
+    ax[1].plot(configurations_read[:,0], np.transpose(liste_val_energie), 'o-')
+    ax[1].set_xlabel("Nombre de ports")
+    ax[1].set_ylabel("Energie (read) (nJ)")
+    ax[1].set_title("Étude de l'impact des prots du cache sur la consommation")
+    ax[1].legend(["Ports d'entrée", 'Ports de sortie', "Ports d'entrée/sortie"], loc='best')
+    
+    ax[2].plot(configurations_read[:,0], np.transpose(liste_val_aire), 'o-')
+    ax[2].set_xlabel("Nombre de ports")
+    ax[2].set_ylabel("Aire (mm²)")
+    ax[2].set_title("Étude de l'impact des prots du cache sur l'aire du cache")
+    ax[2].legend(["Ports d'entrée", 'Ports de sortie', "Ports d'entrée/sortie"], loc='best')
+    fig.show()
+
+#---------------- Fonctions pour simuler selon le mode d'accès --------------------
+def config_mode_acces(config):
+    #----------- Cette section permet de configurer le nombre de ports entrée/sortie du fichier ---------
+    global chemin_fichier_config
+    global nom_fichier_config
+    
+    with open(chemin_fichier_config + nom_fichier_config, "r") as fichier:
+        Lignes = fichier.readlines()
+        index = 0
+        
+        for ligne in Lignes:
+            if "<mode_acces>" in ligne:
+                Lignes[index + 1] = '-access mode (normal, sequential, fast) - "{}"\n'.format(config)
+                break
+            index += 1
+        
+    with open(chemin_fichier_config + nom_fichier_config, "w") as fichier:
+        fichier.writelines(Lignes)        
+
+def simulation_mode_acces(configurations_mode):   
+    liste_valeurs_mode = []
+
+    #--------- Faire tourner les simulations -------
+    for conf in configurations_mode:
+        config_mode_acces(conf)
+        liste_valeurs_mode.append(parser_elements(lancer_simu()))
+        
+    #------------------- Faire l'affichage -------------------------
+    liste_valeurs_mode = np.array(liste_valeurs_mode)
+    
+    fig, ax = plt.subplots(1, 3, figsize=(20, 5))
+    
+    ax[0].plot(configurations_mode, liste_valeurs_mode[:,0], 'o-')
+    ax[0].set_xlabel("Mode d'accès")
+    ax[0].set_ylabel("Temps d'accès (ns)")
+    ax[0].set_title("Étude sur le temps d'accès")
+    
+    ax[1].plot(configurations_mode, liste_valeurs_mode[:,1], 'o-')
+    ax[1].set_xlabel("Mode d'accès")
+    ax[1].set_ylabel("Energie (read) (nJ)")
+    ax[1].set_title("Étude sur la consommation")
+    
+    ax[2].plot(configurations_mode, liste_valeurs_mode[:,2], 'o-')
+    ax[2].set_xlabel("Mode d'accès")
+    ax[2].set_ylabel("Aire (mm²)")
+    ax[2].set_title("Étude sur l'aire du cache")
+
+    fig.show()
+
+
+# #----------Pour lancer la simulation selon la taille et l'associativite -------
+# #configurations_taille = np.array([[2048,2],[4096,2],[32768,2],[131072,2],[262144,2], [1048576,2], [2097152,2], [4194304,2],[1073741824,2]])
+# #Génération automatique
+# valeur = 1024
+# configurations_taille = []
+# for i in range(11,30):
+#     valeur = valeur * 2
+#     configurations_taille.append([valeur,2])
+    
+# configurations_taille = np.array(configurations_taille)
+# configurations_associativite = np.array([[4096,2],[4096,4],[4096,8],[4096,16]])
+
+# simulation_taille_associativite(configurations_taille,configurations_associativite)
+
+
+##----------Pour lancer la simulation selon les entrées et sorties -------
+# configurations_read = np.array([[1,0,0,0],[2,0,0,0],[3,0,0,0],[4,0,0,0]])
+# configurations_write = np.array([[0,1,0,0],[0,2,0,0],[0,3,0,0],[0,4,0,0]])
+# configurations_readwrite = np.array([[0,0,1,0],[0,0,2,0],[0,0,3,0],[0,0,4,0]])
+
+# simulation_entrees_sorties(configurations_read,configurations_write,configurations_readwrite)
 
 
 #flux = os.popen(commande)
 #print(flux.read())
 
-
+#----------- Pour lancer la simulation selon les modes d'accès au cache --------
+configurations_mode = ["normal","sequential","fast"]
+simulation_mode_acces(configurations_mode)