# -*- coding: utf-8 -*-
"""
TP1 T1
Ceci est un script permettant de tester différentes configurations
de cache pour cacti
"""

import subprocess
import matplotlib.pyplot as plt
import numpy as np

global nom_fichier_config
global chemin_fichier_config

nom_fichier_config = "cache.cfg"
chemin_fichier_config = ""

i = 0

def lancer_simu():
    # 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(config[0])
                Lignes[index + 2] = "-exclusive read port {}\n".format(config[1])
                Lignes[index + 3] = "-exclusive write port {}\n".format(config[2])
                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:
        fichier.writelines(Lignes)        

def simulation_entrees_sorties(configurations_read,configurations_write,configurations_readwrite):   
    liste_valeurs_read = []
    liste_valeurs_write = []
    liste_valeurs_readwrite = []
    
    #--------- Faire tourner les simulations -------
    for conf in configurations_read:
        config_entrees_sortie(conf)
        liste_valeurs_read.append(parser_elements(lancer_simu()))
        
    for conf in configurations_write:
        config_entrees_sortie(conf)
        liste_valeurs_write.append(parser_elements(lancer_simu()))
        
    for conf in configurations_readwrite:
        config_entrees_sortie(conf)
        liste_valeurs_readwrite.append(parser_elements(lancer_simu()))
        
    #------------------- 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)