2022-09-29_sparseccl_grouped.py

#!/usr/bin/python

# Hello world python program

# Lancer le script : python3 ./2022-02-08_sparseccl.py

import matplotlib.pyplot as plt
import numpy as np
import statistics as stat

## ============ CHARGEMENT ============

#FLAT_ARRAYS = False
FLAT_ONLY = True
tableau_horizontal = True # vertical pas encore géré

VERSION_ATTENDUE = 108
CHECK_VERSION = False

computer_name = "cassidi" # aussi utilisé pour le nom du fichier d'entrée

# TODO affichage de la figure 4 et 3
# Il faut charger deux fichiers, un flatten et l'autre graphPtr.
# Tout charger dans une même liste (header_list) avec un flag pour indiquer
# s'il s'agit d'un graphe de pointeur ou d'une structure aplatie.
# flag IS_FLATTEN qui indique si c'est flatten ou graphe de ptr


# ============= Gestion de la taille
my_dpi = 96
output_image_name = "le nom de ma belle image"
output_image_name_ver = "ACAT-v2" #"5-4_brouillon" # 3_dl

image_width = 1280
image_height = 1
image_scale_factor = image_width / 640
line_width = image_scale_factor * 1.5

if FLAT_ONLY:
    image_height = (image_width / 640) * 160 #198
    plt.figure(figsize=(image_width/my_dpi, image_height/my_dpi) , dpi=my_dpi)
    output_image_name = "sparseccl_onlyFlat_" + output_image_name_ver + "_" + computer_name + ".png"
else:
    image_height = (image_width / 640) * 258 # 273
    plt.figure(figsize=(image_width/my_dpi, image_height/my_dpi), dpi=my_dpi)
    output_image_name = "sparseccl_ptrAndFlat_" + output_image_name_ver + "_" + computer_name + ".png"

MY_SIZE = (10 * image_scale_factor)
TITLE_SIZE = (12 * image_scale_factor)

#plt.rc('font', size=MY_SIZE)          # controls default text sizes
plt.rc('axes', titlesize=TITLE_SIZE)     # fontsize of the axes title
plt.rc('axes', labelsize=MY_SIZE)     # fontsize of the x and y labels
plt.rc('xtick', labelsize=MY_SIZE)    # fontsize of the tick labels
plt.rc('ytick', labelsize=MY_SIZE)    # fontsize of the tick labels
plt.rc('legend', fontsize=MY_SIZE)    # legend fontsize
#plt.rc('figure', titlesize=MY_SIZE)   # fontsize of the figure title
# plt.rcParams.update({'font.size': MY_SIZE})

# fin gestion de la taille =============

# Lecture du fichier d'entrée
# filepath = 'acts06_generalFlatten_sandor_AT_ld100_RUN1.t'
# filepath = 'acts06_generalFlatten_blopNvidia_AT_ld10_RUN1.t'
# filepath = 'acts06_generalGraphPtr_uniqueModules_sandor_AT_ld1_RUN1.t'
# filepath = 'acts06_generalGraphPtr_uniqueModules_blopNvidia_AT_ld10_RUN1.t'
# Bug manifeste sur le ld10 /!\

def usm_code_to_str(usm_code):
    if (usm_code == 0): return "shared"
    if (usm_code == 1): return "device"
    if (usm_code == 2): return "host"
    if (usm_code == 3): return "accessors"
    if (usm_code == 20): return "CPU"
    return "<unknown>"

# Tous les headers : a chaque header est associé une série de paramètres
header_list = []

import sys

global_kernel_count = 0

global_kernel_retain = 2

def load_file(filename, isFlatten, multiplyFactor):
    global global_kernel_count
    global global_kernel_retain
    global VERSION_ATTENDUE

    # absolute_filepath = "../output_bench/" + filename
    absolute_filepath = "output_bench/" + filename


    with open(absolute_filepath) as fp:
        version = fp.readline() # version du fichier actuel (doit être 106 et non plus 105)
        print("Version du fichier : {}".format(version))

        if ( (int(version) != VERSION_ATTENDUE) and CHECK_VERSION ):
            #print("ERREUR, VERSION DU FICHIER NON COMPATIBLE : " + str(int(version)) + ".  VERSION ATTENDUE = 106")
            sys.exit("ERREUR, VERSION DU FICHIER NON COMPATIBLE : " + str(int(version)) + ".  VERSION ATTENDUE = " + str(VERSION_ATTENDUE))

        print("isFlatten = " + str(isFlatten))

        header_line = fp.readline()

        while header_line:

            header_split_words = header_line.split(" ")
            header_split_words.remove("\n")
            print(header_split_words)

            header = {} # dictionnaire vide
            header["DATASET_NUMBER"] = header_split_words[0]
            header["in_total_size"] = header_split_words[1]
            header["out_total_size"] = header_split_words[2]
            # skip 2 champs
            header["REPEAT_COUNT_REALLOC"] = header_split_words[5]
            # skip 3 champs
            header["sycl_mode"] = int(header_split_words[9])
            print("---- SYCL mode = " + str(header["sycl_mode"]) + "----")
            print("SYCL mode = " + usm_code_to_str(header["sycl_mode"]))
            # if (header["sycl_mode"] == 0):  print("SYCL mode = shared")
            # if (header["sycl_mode"] == 1):  print("SYCL mode = device")
            # if (header["sycl_mode"] == 2):  print("SYCL mode = host")
            # if (header["sycl_mode"] == 3):  print("SYCL mode = accessors")
            # if (header["sycl_mode"] == 20): print("SYCL mode = CPU")
            # 0 shared, 1 device, 2 host, 3 accessors, 20 glibc
            # skip 5 champs
            header["mstrat"] = header_split_words[15]
            header["implicit_use_unique_module"] = header_split_words[16]
            header["iterations"] = [] # liste d'itérations

            header["IS_FLATTEN"] = isFlatten # True or False

            #print(header)

            # print(" _____ REPEAT_COUNT_REALLOC = " + header["REPEAT_COUNT_REALLOC"])

            for i in range(int(header["REPEAT_COUNT_REALLOC"])):
                iter_line = fp.readline()
                iter_list = iter_line.split(" ")
                iter_list.remove("\n")
                iteration = {}
                iteration["t_alloc_native"]  = int(iter_list[0]) * multiplyFactor
                iteration["t_alloc_sycl"]  = int(iter_list[1]) * multiplyFactor
                iteration["t_fill"]  = int(iter_list[2]) * multiplyFactor
                iteration["t_copy"]  = int(iter_list[3]) * multiplyFactor
                iteration["t_read"]  = int(iter_list[4]) * multiplyFactor
                iteration["t_dealloc_sycl"]  = int(iter_list[5]) * multiplyFactor
                iteration["t_dealloc_native"]  = int(iter_list[6]) * multiplyFactor
                iteration["kernel_count"]  = int(iter_list[7])

                
                iteration["t_kernel"] = [] # liste de valeurs temps kernel
                global_kernel_count = int(iteration["kernel_count"])
                # print(" _____ kernel_count = " + iter_list[7])
                # print(" _____ global_kernel_count = " + str(global_kernel_count))
                for ik in range(global_kernel_retain):
                    v = int(iter_list[8 + ik]) * multiplyFactor
                    #if (ik <= 1):
                    iteration["t_kernel"].append(v)

                # iteration["t_alloc_only"]  = int(iter_list[0]) * multiplyFactor
                # iteration["t_fill_only"]   = int(iter_list[3]) * multiplyFactor
                # iteration["t_alloc_fill"]  = int(iter_list[8]) * multiplyFactor
                # iteration["t_copy_kernel"] = int(iter_list[9]) * multiplyFactor
                # iteration["t_read"]        = int(iter_list[10]) * multiplyFactor
                # iteration["t_free_mem"]    = int(iter_list[11]) * multiplyFactor
                #iteration["t_flatten_alloc"] = iter_list[12] osef, c'est la même chose que t_alloc_only
                #iteration["t_flatten_fill"] = iter_list[13]
                header["iterations"].append(iteration)

                #print("Itération {}:".format(i))
                #print(iteration)

            header_list.append(header)
            # print(" __ end header ___ global_kernel_count = " + str(global_kernel_count))
        
            # Lecture de la prochaine ligne
            header_line = fp.readline()
        # while line fermé
    # with file fermé
    # print(" ________ FNALLY :  global_kernel_count = " + str(global_kernel_count))

#print("header_list:")
#print(header_list)

# Chargement des résultats en flatten
# load_file('acts06_generalFlatten_blopNvidia_AT_ld100_RUN1.t', True)
#load_file('sandor_2022-02-09/acts06_generalFlatten_sandor_AT_ld100_RUN5_malloc_device_fix.t', True, 1)
#load_file('sandor_2022-02-09/acts06_generalFlatten_sandor_AT_ld100_RUN2.t', True, 1)

# Marchait avec ces 2 fichiers : (mêmes résultats que pour le papier)
# load_file('sccl107_generalFlatten_sandor_AT_ld100_RUN1.t', True, 1) # <- papier
# load_file('sccl107_generalGraphPtr_uniqueModules_sandor_AT_ld10_RUN1.t', False, 1) # <- papier



# load_file('sccl108_generalFlatten_sandor_AT_ld100_RUN3.t', True, 1)
# load_file('sccl107_generalFlatten_sandor_AT_ld100_RUN1.t', True, 1) # <- papier


# décommenté par défaut :
# load_file('sccl108_generalGraphPtr_uniqueModules_sandor_AT_ld100_RUN3.t', False, 1)

load_file("sccl108_generalFlatten_" + computer_name + "_AT_ld10_RUN1.t", True, 1)
load_file("sccl108_generalGraphPtr_uniqueModules_" + computer_name + "_AT_ld10_RUN1.t", False, 1)


# load_file('sccl107_generalFlatten_sandor_AT_ld100_RUN1.t', True, 1)
# load_file('sccl107_generalGraphPtr_uniqueModules_sandor_AT_ld10_RUN1.t', False, 1)

# sccl108_generalGraphPtr_uniqueModules_cassidi_AT_ld100_RUN1.t


# load_file('sccl107_generalGraphPtr_uniqueModules_sandor_AT_ld10_RUN1.t', False, 1) # <- papier

#load_file('acts06_generalFlatten_sandor_AT_ld100_RUN1_2021-11-24.t', True, 1)

print(" ________ AFTER LOAD :  global_kernel_count = " + str(global_kernel_count))

global_drawn_x_variables_number = 6 + global_kernel_retain

# Chargement des résultats en graphe de pointeurs
# load_file('acts06_generalGraphPtr_uniqueModules_blopNvidia_AT_ld10_RUN1.t', False)
#   load_file('acts06_generalGraphPtr_uniqueModules_sandor_AT_ld100_RUN1.t', False, 1)


## ============ DESSIN ============

# liste de valeurs en x et liste de valeurs en y

# x_list = []
# y_list = []

x_list_shared_flat = []
y_list_shared_flat = []
y_median_shared_flat = []

x_list_shared_ptr = []
y_list_shared_ptr = []
y_median_shared_ptr = []

x_list_host_flat = []
y_list_host_flat = []
y_median_host_flat = []

x_list_host_ptr = []
y_list_host_ptr = []
y_median_host_ptr = []

x_list_device = []
y_list_device = []
y_median_device = []

x_list_glibc_flat = []
y_list_glibc_flat = []
y_median_glibc_flat = []

x_list_glibc_ptr = []
y_list_glibc_ptr = []
y_median_glibc_ptr = []

x_list_acc = []
y_list_acc = []
y_median_acc = []

x_list_curve_drawn = []
x_list_curve_drawn.append("alloc")
x_list_curve_drawn.append("fill")
x_list_curve_drawn.append("copy+ker1")
x_list_curve_drawn.append("ker2")
x_list_curve_drawn.append("dealloc")

divide_by = 1000 # div par 100 seulement pour "simuler" + de données

def nz(value):
    # if (value < 0):
    #     return 0
    return value

# 0 shared, 1 device, 2 host, 3 accessors, 20 glibc
# Préparation des données : sélection du run 5 uniquement
for header in header_list:
    found = False
    print("SYCL mode = " + usm_code_to_str(header["sycl_mode"]) + " flatten = " + str(header["IS_FLATTEN"]))
    # print(header["sycl_mode"] + header["IS_FLATTEN"])

    if (header["IS_FLATTEN"]) :
        # shared flatten
        if header["sycl_mode"] == 0:
            x_list = x_list_shared_flat
            y_list = y_list_shared_flat
            y_median = y_median_shared_flat
            found = True

        # device flatten
        if header["sycl_mode"] == 1:
            x_list = x_list_device
            y_list = y_list_device
            y_median = y_median_device
            found = True

        # host flatten
        if header["sycl_mode"] == 2:
            x_list = x_list_host_flat
            y_list = y_list_host_flat
            y_median = y_median_host_flat
            found = True

        # accessors flatten
        if header["sycl_mode"] == 3:
            x_list = x_list_acc
            y_list = y_list_acc
            y_median = y_median_acc
            found = True

        # glibc flatten
        if header["sycl_mode"] == 20:
            x_list = x_list_glibc_flat
            y_list = y_list_glibc_flat
            y_median = y_median_glibc_flat
            found = True
        
        # osef glibc (20)
        
    else: # IS_FLATTEN = False

        # shared
        if header["sycl_mode"] == 0:
            x_list = x_list_shared_ptr
            y_list = y_list_shared_ptr
            y_median = y_median_shared_ptr
            found = True

        # host
        if header["sycl_mode"] == 2:
            x_list = x_list_host_ptr
            y_list = y_list_host_ptr
            y_median = y_median_host_ptr
            found = True
        
        # glibc graph ptr
        if header["sycl_mode"] == 20:
            x_list = x_list_glibc_ptr
            y_list = y_list_glibc_ptr
            y_median = y_median_glibc_ptr
            found = True
        # osef glibc (20)
        
    
    # N'est trouvé qu'une seule fois (un seul header correspond)
    if found:

        x_list.append("native-a")
        x_list.append("sycl-a")
        x_list.append("fill")
        x_list.append("copy")
        for ik in range(global_kernel_retain):
            x_list.append("ker" + str(ik + 1))
        x_list.append("sycl-d")
        x_list.append("native-d")

        for ips in range(len(x_list)):
            y_list.append([])
        

        icount = 0
        for iteration in header["iterations"]:
            
            y_list[0].append(nz(iteration["t_alloc_native"])  / divide_by)
            y_list[1].append(nz(iteration["t_alloc_sycl"])    / divide_by)
            y_list[2].append(nz(iteration["t_fill"])          / divide_by)
            y_list[3].append(nz(iteration["t_copy"])          / divide_by)
            # read osef
            # CONTINUER D'ICI

            ker_list = iteration["t_kernel"]
            
            # normalement len(ker_list) == global_kernel_retain
            if (len(ker_list) != global_kernel_retain):
                sys.exit("--- ERREUR, len(ker_list)(" + str(len(ker_list)) + ") != global_kernel_retain(" + str(global_kernel_retain) + ")")

            # Ajout des temps de kernel
            for ik in range(global_kernel_retain):
                y_list[4 + ik].append(nz(ker_list[ik]          / divide_by))
                #y_list[4 + ik].append(nz(iteration["ker" + str(ik)]    / divide_by))

            ik = 4 + global_kernel_retain
            y_list[ik].append(nz(iteration["t_dealloc_sycl"])       / divide_by)
            y_list[ik + 1].append(nz(iteration["t_dealloc_native"])     / divide_by)

            # y_list[0].append(iteration["t_alloc_only"]  / divide_by)
            # y_list[1].append(iteration["t_fill_only"]   / divide_by)
            # y_list[2].append(iteration["t_copy_kernel"] / divide_by)
            # y_list[3].append(iteration["t_free_mem"]    / divide_by)
            icount += 1
        
        # Calcul des médianes de chaque courbe
        for ii in range(len(x_list)):
            y_median.append(stat.median(y_list[ii]))

        # y_median.append(stat.median(y_list[1]))
        # y_median.append(stat.median(y_list[2]))
        # y_median.append(stat.median(y_list[3]))


def draw_violin_plot(name, color, y_list, y_median, linestyle):
    c = color
    bp_ = plt.violinplot(y_list, showextrema=False)
    for pc in bp_['bodies']:
        pc.set_facecolor(c)
        pc.set_edgecolor(c) # #D43F3A black
        pc.set_alpha(1)

def draw_boxplot(name, color, y_list, y_median, linestyle):
    c = color
    bp_ = plt.boxplot(y_list,
          notch=False, patch_artist=True,
          boxprops=dict(facecolor=c, color=c),
          capprops=dict(color=c),
          whiskerprops=dict(color=c),
          flierprops=dict(color=c, markeredgecolor=c),
          medianprops=dict(color=c))


def merge_some_points(y_list):
    y_list_cpy = []
    ri = 0
    print(y_list)
    print("-----")
    # Allocation de la liste contenant les listes des valeurs
    while ri < len(y_list):
        l_cpy = []
        l1 = y_list[ri]
        print("y_list[" + str(ri) + "] : ")
        print(y_list[ri])
        if ( (ri == 0) or (ri == 3) or (ri == 6) ):
            l2 = y_list[ri + 1]
            # somme des deux listes
            for rii in range(len(l1)):
                l_cpy.append(l1[rii] + l2[rii])
            ri += 2
        else:
            for rii in range(len(l1)):
                l_cpy.append(l1[rii])
            ri += 1

        y_list_cpy.append(l_cpy)
    return y_list_cpy


def draw_curve(name, color, y_list, y_median, linestyle):
    # Copie et fusion ici des valeurs de l'alloc, dealloc

    # Liste de liste de valeurs (une liste de valeurs pour chaque position x)
    y_list_cpy = merge_some_points(y_list)
    

    # y_list_cpy.append(y_list[0])# + y_list[1]) # native-a + sycl-a
    # y_list_cpy.append(y_list[2]) # fill
    # y_list_cpy.append(y_list[3])# + y_list[4]) # copy + kernel1
    # y_list_cpy.append(y_list[5]) # kernel 2
    # y_list_cpy.append(y_list[6])# + y_list[7]) # sycl-d + native-d

    # Liste de valeurs
    y_median_cpy = []
    y_median_cpy.append(y_median[0] + y_median[1]) # native-a + sycl-a
    y_median_cpy.append(y_median[2]) # fill
    y_median_cpy.append(y_median[3] + y_median[4]) # copy + kernel1
    y_median_cpy.append(y_median[5]) # kernel 2
    y_median_cpy.append(y_median[6] + y_median[7]) # sycl-d + native-d

    draw_violin_plot(name, color, y_list_cpy, y_median_cpy, linestyle)
    plt.plot(range(1, 6), y_median_cpy, color=color, label=name, linestyle=linestyle, linewidth=line_width)

# def draw_curve(name, color, y_list, y_median, linestyle):
#     draw_violin_plot(name, color, y_list, y_median, linestyle)
#     plt.plot(range(1, global_drawn_x_variables_number+1), y_median, color=color, label=name, linestyle=linestyle, linewidth=line_width)

plt.rcParams['grid.linestyle'] = "-"
plt.rcParams['grid.alpha'] = 0.15
plt.rcParams['grid.color'] = "black" ##cccccc
plt.grid(linewidth=line_width/2)


if FLAT_ONLY:
    plt.title(computer_name + " - SparseCCL - flat arrays")
    draw_curve("USM device", "green", y_list_device, y_median_device, "solid")
    draw_curve("accessors", "maroon", y_list_acc, y_median_acc, "dashed")
    draw_curve("USM shared", "blue", y_list_shared_flat, y_median_shared_flat, "dotted")
    # draw_curve("USM host", "red", y_list_host_flat, y_median_host_flat, "dashdot")
else:
    plt.title("SparseCCL - pointer graph vs flat arrays")
    #draw_curve("USM device", "green", y_list_device, y_median_device, "solid")
    draw_curve("shared flat", "blue", y_list_shared_flat, y_median_shared_flat, "solid")
    print("len y_list_shared_flat = " + str(len(y_list_shared_flat)))
    print("len y_median_shared_flat = " + str(len(y_median_shared_flat)))
    print("len y_list_shared_ptr = " + str(len(y_list_shared_ptr)))
    print("len y_median_shared_ptr = " + str(len(y_median_shared_ptr)))

    print("len y_list_host_ptr = " + str(len(y_list_host_ptr)))
    print("len y_median_host_ptr = " + str(len(y_median_host_ptr)))
    draw_curve("shared ptr", "navy", y_list_shared_ptr, y_median_shared_ptr, "dashdot")
    #draw_curve("host flat", "red", y_list_host_flat, y_median_host_flat, "solid")
    draw_curve("host ptr", "maroon", y_list_host_ptr, y_median_host_ptr, "dashdot")




# ======== Dessin du tableau ======== 


def array_value_to_str(val):
    if (val < 0):
        return "-"
    if (val < 0.01):
        return str(round(val * 1000)/1000)
    elif (val < 0.1):
        return str(round(val * 100)/100)
    elif (val < 1):
        return str(round(val * 10)/10)
    else:
        return str(round(val))

# Ancienne version
# def draw_tab_item(y_median_g):
#     st = ""
#     su = 0
#     for im in range(4): # de 0 à 3 compris
#         st = st + array_value_to_str(y_median_g[im])
#         su += round(y_median_g[im])
#         if (im != 3):
#             st = st + " & "
#         else:
#             st = st + " & " + array_value_to_str(su) + " \\\\"
#     return st

# def dlog(str):
#     print("DEBUG - " + str)

def draw_tab_item(cname, short_name, y_median_g):
    st = cname + " & "
    ssum = 0
    # dlog("")
    # dlog("cname = " + cname)
    # dlog("global_drawn_x_variables_number = " + str(global_drawn_x_variables_number))
    # dlog("len(y_median_g) = " + str(len(y_median_g)))

    # Les premiers champs + 2 kernels
    for im in range(global_drawn_x_variables_number): # de 0 à 5 compris

        ssum += round(y_median_g[im])
        st = st + array_value_to_str(y_median_g[im])
        if (im != global_drawn_x_variables_number-1):
            st = st + " & "
    # skip de 6 et 7, deux kernels
    # dealloc sycl + dealloc host
    # for im in range(8, 10): # de 8 à 9 compris
    #     ssum += round(y_median_g[im])
    #     st = st + array_value_to_str(y_median_g[im])
    #     if (im != global_drawn_x_variables_number-1):
    #         st = st + " & "

        #else: # affichage du total et fin de ligne
    
    sum_str = array_value_to_str(ssum)
    st = st + " & " + sum_str + " \\\\" # + " & " + short_name
    return st

def draw_tab_item_vert(y_median_a, y_median_b, index):
    return (
    array_value_to_str(y_median_a[index]) + " & "
    + array_value_to_str(y_median_b[index]) + " \\\\")

def draw_tab_item_vert3(y_median_a, y_median_b, y_median_c, index):
    return (
    array_value_to_str(y_median_a[index]) + " & "
    + array_value_to_str(y_median_b[index]) + " & "
    + array_value_to_str(y_median_c[index]) + " \\\\" )

# TODO : stocker dans des listes distinctes les cas USM copie explicite et USM accès direct
#        pour pouvoir les réutiliser ensuite dans le graphique.



# Affichage dans le terminal du tableau à mettre dans le LaTeX
def draw_tab():

    print("\\def\\barr{\\begin{tabular}{c}}")
    print("\\def\\earr{\\end{tabular}}")
    print("")
    print("\\begin{center}")
    if tableau_horizontal:
        print("\\resizebox{\\linewidth}{!}{%")
        print("\\begin{tabular}{||l c c c c c c c c c||} ")
        print("\\hline")
        print("\\barr \\textbf{" + computer_name + "} \\earr")
        print("& \\barr alloc \\\\ native \\earr")
        print("& \\barr alloc   \\\\ sycl \\earr")
        print("& \\barr fill \\earr")
        print("& \\barr copy \\earr")
        print("& \\barr ker\\textsubscript{1} \\earr")
        print("& \\barr ker\\textsubscript{2} \\earr")
        print("& \\barr dealloc \\\\ sycl \\earr")
        print("& \\barr dealloc \\\\ native \\earr")
        print("& \\barr total \\earr")
        print("\\\\ [0.5ex]")

        # tableau flat seulement
        if (FLAT_ONLY):
        
            print("\\hline\\hline")
            print(draw_tab_item("USM device", "dev", y_median_device))
            print("\\hline")
            print(draw_tab_item("accessors", "acc", y_median_acc))
            print("\\hline")
            print(draw_tab_item("USM shared", "sha", y_median_shared_flat))
            print("\\hline")
            print(draw_tab_item("USM host", "hos", y_median_host_flat))
        else: # tableau flat vs graphe ptr

            print("\\hline\\hline")
            # Bien penser à vérifier que les valeurs sont les mêmes partout dans la publi
            print(draw_tab_item("USM shared flat", "s\\_f", y_median_shared_flat))
            print("\\hline")
            print(draw_tab_item("USM shared ptr", "s\\_p", y_median_shared_ptr))
            print("\\hline")
            # print("TODO : mettre host flat ici")
            # print("\\hline")
            # Host flat à remplacer par la valeur déjà dans le papier
            print(draw_tab_item("USM host flat", "h\\_f", y_median_host_flat))
            print("\\hline")
            print(draw_tab_item("USM host ptr", "h\\_p", y_median_host_ptr))
            print("\\hline")
            print(draw_tab_item("cpu flat", "c\\_f", y_median_glibc_flat))
            print("\\hline")
            print(draw_tab_item("cpu ptr", "c\\_p", y_median_glibc_ptr))

    #else:
        # Tableau vertical pas encore géré

    print("\\hline")
    print("\\end{tabular}}")
    print("\\end{center}")
    print("")


# TODO : relancer un bench sur Sandor (ou ls-cassidi si on y arrive)
# ls-cassidi :
# 2 CPU : Intel(R) Xeon(R) Gold 5218R CPU @ 2.10GHz
# GPU : Quadro RTX A6000
# 187 GiB RAM



# plt.title("SparseCCL - flat arrays")
# #draw_curve("USM device", "green", y_list_device, y_median_device, "solid")
# draw_curve("shared flat", "blue", y_list_shared_flat, y_median_shared_flat, "solid")
# draw_curve("shared ptr", "green", y_list_shared_ptr, y_median_shared_ptr, "dotted")
# #draw_curve("USM host", "maroon", y_list_acc, y_median_acc, "dashed")
# #draw_curve("USM host", "maroon", y_list_host, y_median_host, "dashed")

# Faire l'affichage du tableau de valeurs (x100) et voir ce que ça donne
# par rapport aux précédentes valeurs 

# if FLAT_ONLY:
#     plt.figure(figsize=(800/my_dpi, 800/my_dpi), dpi=my_dpi)
# else:
#     plt.figure(figsize=(800/my_dpi, 800/my_dpi), dpi=my_dpi)

draw_tab()

plt.ylabel('Elapsed time (ms)')
#plt.ylim([-5, 100])
plt.legend()
#plt.xticks(range(1, global_drawn_x_variables_number+1), x_list_device) # = x_list_shared et x_list_acc
plt.xticks(range(1, 6), x_list_curve_drawn) # = x_list_shared et x_list_acc

plt.savefig(output_image_name, format='png') #, dpi=my_dpi)

plt.show()
print ("Hello World!")