plotter.py

import os
import sys
import json
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import json
from collections import namedtuple
import statistics

OUTPUT_DIR = None
INPUT_DIR = None
HOMEDIR = os.path.expanduser('~')
COMMANDS = {}

def init():
    global COMMANDS, OUTPUT_DIR, INPUT_DIR
    
    OUTPUT_DIR = os.path.join(HOMEDIR, 'postpocket/logs/figures')
    os.makedirs(OUTPUT_DIR, exist_ok=True)
    INPUT_DIR = os.path.join(HOMEDIR, 'postpocket/logs/complete/summary')
    
    COMMANDS['all'] = all
    COMMANDS['debug'] = debug
    COMMANDS['ub-00'] = memcpy_latency__dsa_vs_cpu_no_pfhandling # done >.<
    COMMANDS['ub-01'] = pf_handling_cost # done >.<
    COMMANDS['ub-02'] = memcpy_latency__dsa_pinned_vs_cpu_pfhandling # done >.<
    COMMANDS['ub-03'] = memcpy_latency__dsa_pinned_plus_pinning_vs_cpu_pfhandling # done >.<
    COMMANDS['ub-04'] = matmul_count__per_size_pinning # done >.<
    COMMANDS['ub-05'] = memcpy_latency__with_matmul_with_or_without_pinning # done >.<
    
    COMMANDS['eb-01'] = execution_breakdown_with_pagefault__nop_grpc # done >.<
    COMMANDS['eb-02'] = execution_breakdown_with_pagefault__nop_shmem
    COMMANDS['eb-03'] = execution_breakdown_with_pagefault__echo_grpc
    COMMANDS['eb-04'] = execution_breakdown_with_pagefault__echo_shmem
    COMMANDS['eb-05'] = execution_breakdown_with_pagefault__nop_pin_grpc
    COMMANDS['eb-06'] = execution_breakdown_with_pagefault__nop_pin_shmem
    COMMANDS['eb-07'] = execution_breakdown_with_pagefault__echo_pin_grpc
    COMMANDS['eb-08'] = execution_breakdown_with_pagefault__echo_pin_shmem
    
    COMMANDS['wm-01'] = memcpy_latency__singlecore_waitmode_w_matmul
    COMMANDS['wm-02'] = memcpy_latency__singlecore_waitmode_wo_matmul
    

def main(*args):
    if len(args) != 1:
        print("Usage: python3 plotter.py [COMMAND]", file=sys.stderr)
        print("COMMAND: data file", file=sys.stderr)
        sys.exit(1)

    init()
    command = args[0]
    COMMANDS[command]()
    
def all():
    # convention: yaxis value or yaxis__xaxis value
    pf_handling_cost()
    memcpy_latency__dsa_pinned_vs_cpu_pfhandling()
    matmul_count__per_size_pinning() # 5, 6
    # todo: add
    
def debug():
    # # Sample data
    # data = {'Group': ['A', 'A', 'A', 'B', 'B', 'B'],
    #         'Item1': [10, 20, 30, 5, 15, 25],
    #         'Item2': [5, 10, 15, 8, 12, 16],
    #         'Item3': [3, 6, 9, 2, 4, 6]}
    # df = pd.DataFrame(data)
    
    # latency graph
    cpu_memcpy = np.array([1,2,3,4,5])
    cpu_memset = np.array([10,9,8,7,6])
    cpu_memcmp = np.array([1,2,3,4,5])
    cpu_other = np.array([3,6,7,2,9])
    
    dsa_memcpy = np.array([3,8,5,1,2])
    dsa_memset = np.array([1,8,6,7,2])
    dsa_memcmp = np.array([1,2,3,4,5])
    dsa_other = np.array([2,1,9,5,8])
    
    x_ticks = ['1','5','10','15','20']

    fig, ax = plt.subplots(figsize=(3, 2), dpi=300)
    plt.tight_layout()
    fig.tight_layout()
    
    sns.set_palette("deep")
    sns.set_theme(style='white') # style='whitegrid', 'darkgrid', 'ticks', 'white', 'dark'
    sns.set_context('talk', font_scale=4) # poster, notebook, 
    colors = sns.color_palette(palette='deep')
    color = sns.color_palette().as_hex()

    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)


    ax.set_xlabel('size_in_kb', fontsize=11)
    ax.set_ylabel('latency_in_usec', fontsize=11)

    bar_width = 0.35
    bar_spacing = 0.05
    e=0.0
    plt.rcParams['hatch.linewidth'] = 0.5

    # axes[0].set_xticks(instances)
    ticks=np.arange(len(x_ticks))
    ax.set_xticks(ticks)
    ax.set_xticklabels(x_ticks)
    

    cpu_memcpy_bar = ax.bar(ticks - bar_width/2 - bar_spacing/2, cpu_memcpy, bar_width, color=colors[2], label='cpu_memcpy', linewidth=0.5)
    cpu_color = cpu_memcpy_bar.patches[0].get_facecolor()
    [patch.set_edgecolor(cpu_color) for patch in cpu_memcpy_bar.patches]
    ax.bar(ticks - bar_width/2 - bar_spacing/2,  cpu_memset, bar_width-e, label='cpu_memset',  bottom=cpu_memcpy, color='white', linewidth=0.5, edgecolor=cpu_color, hatch='//////')
    ax.bar(ticks - bar_width/2 - bar_spacing/2,  cpu_memcmp, bar_width-e, label='cpu_memcmp',  bottom=cpu_memcpy + cpu_memset, color='white', linewidth=0.5, edgecolor=cpu_color, hatch='oo')
    ax.bar(ticks - bar_width/2 - bar_spacing/2,  cpu_other, bar_width-e, label='cpu_other',  bottom=cpu_memcpy + cpu_memset + cpu_memcmp, color='white', linewidth=0.5, edgecolor=cpu_color, hatch='XXX')

    dsa_memcpy_bar = ax.bar(ticks + bar_width/2 + bar_spacing/2, dsa_memcpy, bar_width, color=color[1], label='dsa_memcpy', linewidth=0.5)
    dsa_color = dsa_memcpy_bar.patches[0].get_facecolor()
    [patch.set_edgecolor(dsa_color) for patch in dsa_memcpy_bar.patches]
    ax.bar(ticks + bar_width/2 + bar_spacing/2, dsa_memset, bar_width-e, label='dsa_memset',   bottom=dsa_memcpy, color='white', linewidth=0.5, edgecolor=dsa_color, hatch='//////')
    ax.bar(ticks + bar_width/2 + bar_spacing/2, dsa_memcmp, bar_width-e, label='dsa_memcmp',   bottom=dsa_memcpy + dsa_memset, color='white', linewidth=0.5, edgecolor=dsa_color, hatch='oo')
    ax.bar(ticks + bar_width/2 + bar_spacing/2, dsa_other, bar_width-e, label='dsa_other',   bottom=dsa_memcpy + dsa_memset + dsa_memcmp, color='white', linewidth=0.5, edgecolor=dsa_color, hatch='XXX')

    leg = ax.legend(loc='upper left', fontsize=7, bbox_to_anchor=(0, 1.4), 
            facecolor='white', framealpha=1, ncol=2, frameon=False, labelspacing = 0.1, columnspacing=0.5)
    plt.subplots_adjust(bottom=0.25, top=0.8, left=0.2)
    plt.savefig(os.path.join(OUTPUT_DIR, 'debug.png'), dpi=300)

def memcpy_latency__dsa_vs_cpu_no_pfhandling():
    UB_MEMCPY_DICT = read_dict(os.path.join(INPUT_DIR, 'ubench/memcpy/ub_memcpy.json'))
    
    groups = ['CPU+glibc', 'DSA+DTO']
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = [10, 15, 7, 10, 5, 12, 8, 7, 9, 6]
    
    y_vals = _memcpy_latency__dsa_vs_cpu_no_pfhandling_get_yvals(UB_MEMCPY_DICT)
    
    # grouped barplot (group: CPU+libc, DSA+DTO)
    # x-axis: size (256, 512, 1024, 2048, 4096)
    # y-axis: latency (usec)
    _memcpy_latency__dsa_vs_cpu_no_pfhandling_plot(groups, x_ticks, y_vals)
    
def pf_handling_cost():
    UB_MEMCPY_DICT = read_dict(os.path.join(INPUT_DIR, 'ubench/memcpy/ub_memcpy.json'))
    
    groups = ['pagefault', 'TLB miss']
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = [10, 15, 7, 10, 5, 12, 8, 7, 9, 6]
    
    y_vals = _pf_handling_cost_get_yvals(UB_MEMCPY_DICT)
        
    # grouped barplot (group: pagefault, TLB miss)
    # x-axis: size (256, 512, 1024, 2048, 4096)
    # y-axis: normalized latency (CPU_latency/DSA_latency)
    _pf_handling_cost_plot(groups, x_ticks, y_vals)

def memcpy_latency__dsa_pinned_vs_cpu_pfhandling():
    UB_MEMCPY_DICT = read_dict(os.path.join(INPUT_DIR, 'ubench/memcpy/ub_memcpy.json'))

    groups = ['CPU+glibc', 'DSA+DTO']
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = [10, 15, 7, 10, 5, 12, 8, 7, 9, 6] # dummy_data
    
    y_vals = _memcpy_latency__dsa_pinned_vs_cpu_pfhandling_get_yvals(UB_MEMCPY_DICT)
    
    # grouped barplot (group: CPU+libc, DSA+DTO)
    # x-axis: size (256, 512, 1024, 2048, 4096)
    # y-axis: latency (usec)
    _memcpy_latency__dsa_pinned_vs_cpu_pfhandling_plot(groups, x_ticks, y_vals)

def memcpy_latency__dsa_pinned_plus_pinning_vs_cpu_pfhandling():
    UB_MEMCPY_DICT = read_dict(os.path.join(INPUT_DIR, 'ubench/memcpy/ub_memcpy.json'))
    
    groups = ['CPU+glibc', 'DSA+DTO']
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = [10, 15, 7, 10, 5, 12, 8, 7, 9, 6] # dummy_data
        
    y_vals = _memcpy_latency__dsa_pinned_plus_pinning_vs_cpu_pfhandling_get_yvals(UB_MEMCPY_DICT)
    
    # grouped barplot (group: CPU+libc, DSA+DTO)
    # x-axis: size (256, 512, 1024, 2048, 4096)
    # y-axis: latency (usec)
    _memcpy_latency__dsa_pinned_plus_pinning_vs_cpu_pfhandling_plot(groups, x_ticks, y_vals)

def matmul_count__per_size_pinning():
    UB_MEMCPY_DICT = read_dict(os.path.join(INPUT_DIR, 'ubench/memcpy/ub_memcpy.json'))
    
    groups = ['CPU+glibc', 'DSA+DTO']
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = [10, 15, 7, 10, 5, 12, 8, 7, 9, 5] # dummy_data
    
    y_vals = _matmul_count__per_size_pinning_get_yvals(UB_MEMCPY_DICT)
    
    # grouped barplot (group: CPU+libc, DSA+DTO)
    # x-axis: size (256, 512, 1024, 2048, 4096)
    # y-axis: matmul_count/memcpy_latency (count/sec)
    _matmul_count__per_size_pinning_plot(groups, x_ticks, y_vals)

def memcpy_latency__with_matmul_with_or_without_pinning():
    UB_MEMCPY_DICT = read_dict(os.path.join(INPUT_DIR, 'ubench/memcpy/ub_memcpy.json'))
    
    groups = ['CPU+glibc', 'DSA+DTO (pinning_time_excluded)', 'DSA+DTO (pinning_time_included)']
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = [10, 15, 7, 10, 5, 12, 8, 7, 9, 5, 8, 2, 4, 10, 3] # dummy_data
    
    y_vals = _memcpy_latency__with_matmul_with_or_without_pinning_get_yvals(UB_MEMCPY_DICT)
    
    # grouped barplot (group: CPU+libc, DSA+DTO (pinning_time_excluded), DSA+DTO (pinning_time_included))
    # x-axis: size (256, 512, 1024, 2048, 4096)
    # y-axis: latency (usec)
    _memcpy_latency__with_matmul_with_or_without_pinning_plot(groups, x_ticks, y_vals)

def execution_breakdown_with_pagefault__nop_grpc():
    EB_DICT = read_dict(os.path.join(INPUT_DIR, 'execution_breakdown/eb.json'))
    PF_DICT = read_dict(os.path.join(INPUT_DIR, 'pagefault/pf.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']    
    y_vals = _execution_breakdown_with_pagefault__nop_grpc_get_yvals(EB_DICT, PF_DICT)
    
    _execution_breakdown_with_pagefault__plot('eb-01.png', x_ticks, *y_vals)
                                                
def execution_breakdown_with_pagefault__nop_shmem():
    EB_DICT = read_dict(os.path.join(INPUT_DIR, 'execution_breakdown/eb.json'))
    PF_DICT = read_dict(os.path.join(INPUT_DIR, 'pagefault/pf.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _execution_breakdown_with_pagefault__nop_shmem_get_yvals(EB_DICT, PF_DICT)
    
    _execution_breakdown_with_pagefault__plot('eb-02.png', x_ticks, *y_vals)
    
def execution_breakdown_with_pagefault__echo_grpc():
    EB_DICT = read_dict(os.path.join(INPUT_DIR, 'execution_breakdown/eb.json'))
    PF_DICT = read_dict(os.path.join(INPUT_DIR, 'pagefault/pf.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _execution_breakdown_with_pagefault__echo_grpc_get_yvals(EB_DICT, PF_DICT)
    
    _execution_breakdown_with_pagefault__plot('eb-03.png', x_ticks, *y_vals)
    
def execution_breakdown_with_pagefault__echo_shmem():
    EB_DICT = read_dict(os.path.join(INPUT_DIR, 'execution_breakdown/eb.json'))
    PF_DICT = read_dict(os.path.join(INPUT_DIR, 'pagefault/pf.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _execution_breakdown_with_pagefault__echo_shmem_get_yvals(EB_DICT, PF_DICT)
    
    _execution_breakdown_with_pagefault__plot('eb-04.png', x_ticks, *y_vals)
    
def execution_breakdown_with_pagefault__nop_pin_grpc():
    EB_DICT = read_dict(os.path.join(INPUT_DIR, 'execution_breakdown/eb.json'))
    PF_DICT = read_dict(os.path.join(INPUT_DIR, 'pagefault/pf.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _execution_breakdown_with_pagefault__nop_pin_grpc_get_yvals(EB_DICT, PF_DICT)
    
    _execution_breakdown_with_pagefault__plot('eb-05.png', x_ticks, *y_vals)
    
def execution_breakdown_with_pagefault__nop_pin_shmem():
    EB_DICT = read_dict(os.path.join(INPUT_DIR, 'execution_breakdown/eb.json'))
    PF_DICT = read_dict(os.path.join(INPUT_DIR, 'pagefault/pf.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _execution_breakdown_with_pagefault__nop_pin_shmem_get_yvals(EB_DICT, PF_DICT)
    
    _execution_breakdown_with_pagefault__plot('eb-06.png', x_ticks, *y_vals)
    
def execution_breakdown_with_pagefault__echo_pin_grpc():
    EB_DICT = read_dict(os.path.join(INPUT_DIR, 'execution_breakdown/eb.json'))
    PF_DICT = read_dict(os.path.join(INPUT_DIR, 'pagefault/pf.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _execution_breakdown_with_pagefault__echo_pin_grpc_get_yvals(EB_DICT, PF_DICT)
    
    _execution_breakdown_with_pagefault__plot('eb-07.png', x_ticks, *y_vals)
    
def execution_breakdown_with_pagefault__echo_pin_shmem():
    EB_DICT = read_dict(os.path.join(INPUT_DIR, 'execution_breakdown/eb.json'))
    PF_DICT = read_dict(os.path.join(INPUT_DIR, 'pagefault/pf.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _execution_breakdown_with_pagefault__echo_pin_shmem_get_yvals(EB_DICT, PF_DICT)
    
    _execution_breakdown_with_pagefault__plot('eb-08.png', x_ticks, *y_vals)
    
def memcpy_latency__singlecore_waitmode_w_matmul():
    WM_DICT = read_dict(os.path.join(INPUT_DIR, 'ubench/waitmode/ub_waitmode.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _memcpy_latency__singlecore_waitmode_get_yvals(WM_DICT, with_matmul=True)
    
    _memcpy_latency__singlecore_waitmode_plot('wm-01.png', x_ticks, *y_vals)

def memcpy_latency__singlecore_waitmode_wo_matmul():
    WM_DICT = read_dict(os.path.join(INPUT_DIR, 'ubench/waitmode/ub_waitmode.json'))
    
    x_ticks = ['256', '512', '1024', '2048', '4096']
    y_vals = _memcpy_latency__singlecore_waitmode_get_yvals(WM_DICT, with_matmul=False)
    
    _memcpy_latency__singlecore_waitmode_plot('wm-02.png', x_ticks, *y_vals)
    
def _memcpy_latency__dsa_vs_cpu_no_pfhandling_plot(groups, x_ticks, y_vals):
    data = {
        'size_in_kb': [x for x in x_ticks for _ in range(len(groups))],
        'latency_in_usec': y_vals,
        'Group': groups * len(x_ticks)
    }

    df = pd.DataFrame(data)
    plt.tight_layout()
    
    sns.set_palette("deep")
    sns.set_theme(style='white') # style='whitegrid', 'darkgrid', 'ticks', 'white', 'dark'
    sns.set_context('talk', font_scale=4) # poster, notebook, talk, ... #font_scale=1.5
    # colors = sns.color_palette(palette='deep')

    # Barplot 생성
    sns.set_theme(style='whitegrid')
    plt.figure(figsize=(8, 6))
    sns.barplot(x='size_in_kb', y='latency_in_usec', hue='Group', data=df)
    plt.legend(title=None)
    sns.despine(top=True, right=True, left=True, bottom=True)
    plt.savefig(os.path.join(OUTPUT_DIR, 'ub-00.png'), dpi=300)
    
def _memcpy_latency__dsa_vs_cpu_no_pfhandling_get_yvals(ub_memcpy_dict):
    y_vals = [0] * 10
    memory_sizes = [256, 512, 1024, 2048, 4096]
    
    for i, size in enumerate(memory_sizes):
        y_vals[i * 2] = np.array(ub_memcpy_dict['memcpy']['cpu'][False][size]['values']['memcpy_latency']).flatten().mean()
        y_vals[i * 2 + 1] = np.array(ub_memcpy_dict['memcpy']['dsa'][False][size]['values']['memcpy_latency']).flatten().mean()
        
        print(f'cpu_memcpy: {y_vals[i * 2]}, dsa_memcpy: {y_vals[i * 2 + 1]}')
        print('')
        
    print(y_vals)
    return y_vals
    
def _pf_handling_cost_plot(groups, x_ticks, y_vals):   
    data = {
        'size_in_kb': [x for x in x_ticks for _ in range(len(groups))],
        'normalized_latency': y_vals,
        'Group': groups * len(x_ticks)
    }

    df = pd.DataFrame(data)
    plt.tight_layout()
    
    sns.set_palette("deep")
    sns.set_theme(style='white') # style='whitegrid', 'darkgrid', 'ticks', 'white', 'dark'
    sns.set_context('talk', font_scale=4) # poster, notebook, talk, ... #font_scale=1.5
    # colors = sns.color_palette(palette='deep')

    # Barplot 생성
    sns.set_theme(style='whitegrid')
    plt.figure(figsize=(8, 6))
    sns.barplot(x='size_in_kb', y='normalized_latency', hue='Group', data=df)
    plt.legend(title=None)
    plt.ylabel('CPU+libc_latency/DSA+DTO_latency\n(Normalized by DSA latency)')
    sns.despine(top=True, right=True, left=True, bottom=True)
    plt.savefig(os.path.join(OUTPUT_DIR, 'ub-01.png'), dpi=300)
    
def _pf_handling_cost_get_yvals(ub_memcpy_dict):
    y_vals = [0] * 10
    memory_sizes = [256, 512, 1024, 2048, 4096]

    for i, size in enumerate(memory_sizes):
        # Calculate for CPU
        exp0_cpu = np.array(ub_memcpy_dict['memcpy']['cpu'][False][size]['values']['memcpy_latency']).flatten().mean()
        exp2_cpu = np.array(ub_memcpy_dict['memcpy_after_mlockall']['cpu'][False][size]['values']['memcpy_latency']).flatten().mean()
        exp3_cpu = np.array(ub_memcpy_dict['memcpy_to_the_same_address']['cpu'][False][size]['values']['memcpy_latency']).flatten().mean()
        cpu_pf_cost = exp0_cpu - exp2_cpu
        cpu_tlb_cost = exp0_cpu - exp3_cpu
        
        # Calculate for DSA
        exp0_dsa = np.array(ub_memcpy_dict['memcpy']['dsa'][False][size]['values']['memcpy_latency']).flatten().mean()
        exp2_dsa = np.array(ub_memcpy_dict['memcpy_after_mlockall']['dsa'][False][size]['values']['memcpy_latency']).flatten().mean()
        exp3_dsa = np.array(ub_memcpy_dict['memcpy_to_the_same_address']['dsa'][False][size]['values']['memcpy_latency']).flatten().mean()
        dsa_pf_cost = exp0_dsa - exp2_dsa
        dsa_tlb_cost = exp0_dsa - exp3_dsa
        print(f'cpu_memcpy: {exp0_cpu}, cpu_memcpy_w/pin: {exp2_cpu}, cpu_memcpy_to_the_same_addr: {exp3_cpu}')
        print(f'dsa_memcpy: {exp0_dsa}, dsa_memcpy_w/pin: {exp2_dsa}, dsa_memcpy_to_the_same_addr: {exp3_dsa}')
        print(f'cpu_pf_cost: {cpu_pf_cost}, dsa_pf_cost: {dsa_pf_cost}, ratio={dsa_pf_cost/cpu_pf_cost}')
        print(f'cpu_tlb_cost: {cpu_tlb_cost}, dsa_tlb_cost: {dsa_tlb_cost}, ratio={dsa_tlb_cost/cpu_tlb_cost}')
        
        print('')

        # Store results in y_vals
        y_vals[i * 2] = dsa_pf_cost / cpu_pf_cost
        y_vals[i * 2 + 1] = dsa_tlb_cost / cpu_tlb_cost
    print(y_vals)
    return y_vals

def _memcpy_latency__dsa_pinned_vs_cpu_pfhandling_plot(groups, x_ticks, y_vals):   
    data = {
        'size_in_kb': [x for x in x_ticks for _ in range(len(groups))],
        'latency_in_usec': y_vals,
        'Group': groups * len(x_ticks)
    }

    df = pd.DataFrame(data)
    plt.tight_layout()
    
    sns.set_palette("deep")
    sns.set_theme(style='white') # style='whitegrid', 'darkgrid', 'ticks', 'white', 'dark'
    sns.set_context('talk', font_scale=4) # poster, notebook, talk, ... #font_scale=1.5
    # colors = sns.color_palette(palette='deep')

    sns.set_theme(style='whitegrid')
    plt.figure(figsize=(8, 6))
    sns.barplot(x='size_in_kb', y='latency_in_usec', hue='Group', data=df)
    plt.legend(title=None)
    sns.despine(top=True, right=True, left=True, bottom=True)
    plt.savefig(os.path.join(OUTPUT_DIR, 'ub-02.png'), dpi=300)
    
def _memcpy_latency__dsa_pinned_vs_cpu_pfhandling_get_yvals(ub_memcpy_dict):
    y_vals = [0] * 10
    memory_sizes = [256, 512, 1024, 2048, 4096]
    
    for i, size in enumerate(memory_sizes):
        y_vals[i * 2] = np.array(ub_memcpy_dict['memcpy']['cpu'][False][size]['values']['memcpy_latency']).flatten().mean()
        y_vals[i * 2 + 1] = np.array(ub_memcpy_dict['memcpy_after_mlockall']['dsa'][False][size]['values']['memcpy_latency']).flatten().mean()

        print(f'cpu_memcpy: {y_vals[i * 2]}, dsa_memcpy: {y_vals[i * 2 + 1]}')
        print('')
        
    print(y_vals)
    return y_vals

def _memcpy_latency__dsa_pinned_plus_pinning_vs_cpu_pfhandling_plot(groups, x_ticks, y_vals):
    data = {
        'size_in_kb': [x for x in x_ticks for _ in range(len(groups))],
        'latency_in_usec': y_vals,
        'Group': groups * len(x_ticks)
    }

    df = pd.DataFrame(data)
    plt.tight_layout()
    
    sns.set_palette("deep")
    sns.set_theme(style='white') # style='whitegrid', 'darkgrid', 'ticks', 'white', 'dark'
    sns.set_context('talk', font_scale=4) # poster, notebook, talk, ... #font_scale=1.5
    # colors = sns.color_palette(palette='deep')

    sns.set_theme(style='whitegrid')
    plt.figure(figsize=(8, 6))
    sns.barplot(x='size_in_kb', y='latency_in_usec', hue='Group', data=df)
    plt.legend(title=None)
    sns.despine(top=True, right=True, left=True, bottom=True)
    plt.savefig(os.path.join(OUTPUT_DIR, 'ub-03.png'), dpi=300)
    
def _memcpy_latency__dsa_pinned_plus_pinning_vs_cpu_pfhandling_get_yvals(ub_memcpy_dict):
    y_vals = [0] * 10
    memory_sizes = [256, 512, 1024, 2048, 4096]
    
    for i, size in enumerate(memory_sizes):
        y_vals[i * 2] = np.array(ub_memcpy_dict['memcpy']['cpu'][False][size]['values']['memcpy_latency']).flatten().mean()
        y_vals[i * 2 + 1] = np.array(ub_memcpy_dict['memcpy_plus_mlock']['dsa'][False][size]['values']['memcpy_latency']).flatten().mean()

        print(f'cpu_memcpy: {y_vals[i * 2]}, dsa_memcpy: {y_vals[i * 2 + 1]}')
        print('')
        
    print(y_vals)
    return y_vals

def _matmul_count__per_size_pinning_get_yvals(ub_memcpy_dict):
    y_vals = [0] * 10
    memory_sizes = [256, 512, 1024, 2048, 4096]
    
    for i, size in enumerate(memory_sizes):
        cpu_matmul_count = np.array(ub_memcpy_dict['memcpy_with_matmul_without_pinning']['cpu'][False][size]['values']['matmul_count']).flatten().mean()
        cpu_memcpy_latency = np.array(ub_memcpy_dict['memcpy_with_matmul_without_pinning']['cpu'][False][size]['values']['memcpy_latency']).sum(axis=1).mean()
        
        # dsa_matmul_count = np.array(ub_memcpy_dict['memcpy_with_matmul_with_pinning']['dsa'][False][size]['values']['matmul_count']).flatten().mean()
        # dsa_memcpy_latency = np.array(ub_memcpy_dict['memcpy_with_matmul_with_pinning']['dsa'][False][size]['values']['memcpy_latency']).sum(axis=1).mean()
        
        dsa_matmul_count_plus_pinning = np.array(ub_memcpy_dict['memcpy_with_matmul_plus_pinning']['dsa'][False][size]['values']['matmul_count']).flatten().mean()
        dsa_memcpy_latency_plus_pinning = np.array(ub_memcpy_dict['memcpy_with_matmul_plus_pinning']['dsa'][False][size]['values']['memcpy_latency']).sum(axis=1).mean()
        
        print(f'cpu_matmul_count: {cpu_matmul_count}, cpu_memcpy_latency: {cpu_memcpy_latency}, count/latency: {cpu_matmul_count/cpu_memcpy_latency*1000*1000}')
        # print(f'dsa_matmul_count: {dsa_matmul_count}, dsa_memcpy_latency: {dsa_memcpy_latency}, count/latency: {dsa_matmul_count/dsa_memcpy_latency*1000*1000}')
        print(f'dsa_matmul_count_plus_pinning: {dsa_matmul_count_plus_pinning}, dsa_memcpy_latency_plus_pinning: {dsa_memcpy_latency_plus_pinning}, count/latency: {dsa_matmul_count_plus_pinning/dsa_memcpy_latency_plus_pinning*1000*1000}')
        print('')
        
        y_vals[i * 2] = cpu_matmul_count / cpu_memcpy_latency * 1000 * 1000
        # y_vals[i * 2 + 1] = dsa_matmul_count / dsa_memcpy_latency * 1000 * 1000
        y_vals[i * 2 + 1] = dsa_matmul_count_plus_pinning / dsa_memcpy_latency_plus_pinning * 1000 * 1000

    print(y_vals)
    return y_vals
    
def _matmul_count__per_size_pinning_plot(groups, x_ticks, y_vals):
    data = {
        'size_in_kb': [x for x in x_ticks for _ in range(len(groups))],
        'count_per_sec': y_vals,
        'Group': groups * len(x_ticks)
    }
    
    df = pd.DataFrame(data)
    plt.tight_layout()
    
    sns.set_palette("deep")
    sns.set_theme(style='white') # style='whitegrid', 'darkgrid', 'ticks', 'white', 'dark'
    sns.set_context('talk', font_scale=4) # poster, notebook, talk, ... #font_scale=1.5
    
    sns.set_theme(style='whitegrid')
    plt.figure(figsize=(8, 6))
    sns.barplot(x='size_in_kb', y='count_per_sec', hue='Group', data=df)
    plt.legend(title=None)
    sns.despine(top=True, right=True, left=True, bottom=True)
    plt.savefig(os.path.join(OUTPUT_DIR, 'ub-04.png'), dpi=300)
    
def _memcpy_latency__with_matmul_with_or_without_pinning_get_yvals(ub_memcpy_dict):
    y_vals = [0] * 15
    memory_sizes = [256, 512, 1024, 2048, 4096]
    
    for i, size in enumerate(memory_sizes):
        y_vals[i * 3] = np.array(ub_memcpy_dict['memcpy_with_matmul_without_pinning']['cpu'][False][size]['values']['memcpy_latency']).sum(axis=1).mean()
        y_vals[i * 3 + 1] = np.array(ub_memcpy_dict['memcpy_with_matmul_with_pinning']['dsa'][False][size]['values']['memcpy_latency']).sum(axis=1).mean()
        y_vals[i * 3 + 2] = np.array(ub_memcpy_dict['memcpy_with_matmul_plus_pinning']['dsa'][False][size]['values']['memcpy_latency']).sum(axis=1).mean()

        print(f'cpu_memcpy: {y_vals[i * 3]}, dsa_memcpy: {y_vals[i * 3 + 1]}, dsa_memcpy_plus_pinning: {y_vals[i * 3 + 2]}')
        print('')
        
    print(y_vals)
    return y_vals
    
def _memcpy_latency__with_matmul_with_or_without_pinning_plot(groups, x_ticks, y_vals):
    data = {
        'size_in_kb': [x for x in x_ticks for _ in range(len(groups))],
        'latency_in_usec': y_vals,
        'Group': groups * len(x_ticks)
    }

    df = pd.DataFrame(data)
    plt.tight_layout()
    
    sns.set_palette("deep")
    sns.set_theme(style='white') # style='whitegrid', 'darkgrid', 'ticks', 'white', 'dark'
    sns.set_context('talk', font_scale=4) # poster, notebook, talk, ... #font_scale=1.5
    # colors = sns.color_palette(palette='deep')

    sns.set_theme(style='whitegrid')
    plt.figure(figsize=(8, 6))
    sns.lineplot(x='size_in_kb', y='latency_in_usec', hue='Group', data=df)
    plt.legend(title=None)
    sns.despine(top=True, right=True, left=True, bottom=True)
    plt.savefig(os.path.join(OUTPUT_DIR, 'ub-05.png'), dpi=300)
    
def _execution_breakdown_with_pagefault__nop_grpc_get_yvals(eb_dict, pf_dict):
    cpu_memcpy_list = []
    cpu_memset_list = []
    cpu_memcmp_list = []
    cpu_other_list = []
    
    dsa_memcpy_list = []
    dsa_memset_list = []
    dsa_memcmp_list = []
    dsa_other_list = []
    
    pagefault_list = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
        
    for i, size in enumerate(memory_sizes):    
        cpu_time = \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['time']).sum(axis=1).mean()
        cpu_memcpymove = \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['memmove']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean() + \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['memcpy']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        cpu_memset = \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['memset']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        cpu_memcmp = \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['memcmp']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop']['cpu']['grpc'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        cpu_other = cpu_time - cpu_memcpymove - cpu_memset - cpu_memcmp
        
        dsa_time = np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['time']).sum(axis=1).mean()
        dsa_memcpymove = \
            np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['memmove']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean() + \
            np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['memcpy']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        dsa_memset = \
            np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['memset']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        dsa_memcmp = \
            np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['memcmp']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop']['dsa']['grpc'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        dsa_other = dsa_time - dsa_memcpymove - dsa_memset - dsa_memcmp
        
        pagefault = \
            int(np.array(pf_dict['pf']['nop']['dsa']['grpc'][False][size]['values']['client']['minpf']).sum(axis=1).mean() +\
            np.array(pf_dict['pf']['nop']['dsa']['grpc'][False][size]['values']['server']['minpf']).flatten().mean())
        
        cpu_memcpy_list.append(cpu_memcpymove)
        cpu_memset_list.append(cpu_memset)
        cpu_memcmp_list.append(cpu_memcmp)
        cpu_other_list.append(cpu_other)
        dsa_memcpy_list.append(dsa_memcpymove)
        dsa_memset_list.append(dsa_memset)
        dsa_memcmp_list.append(dsa_memcmp)
        dsa_other_list.append(dsa_other)
        pagefault_list.append(pagefault)
        
        print(f'cpu_time: {cpu_time:0.2f}, cpu_memcpymove: {cpu_memcpymove:0.2f} ({cpu_memcpymove/cpu_time*100:0.2f}%), cpu_memset: {cpu_memset:0.2f} ({cpu_memset/cpu_time*100:0.2f}), cpu_memcmp: {cpu_memcmp:0.2f} ({cpu_memcmp/cpu_time*100:0.2f}), cpu_other: {cpu_other:0.2f} ({cpu_other/cpu_time*100:0.2f})')
        print(f'dsa_time: {dsa_time:0.2f}, dsa_memcpymove: {dsa_memcpymove:0.2f} ({dsa_memcpymove/dsa_time*100:0.2f}%), dsa_memset: {dsa_memset:0.2f} ({dsa_memset/dsa_time*100:0.2f}), dsa_memcmp: {dsa_memcmp:0.2f} ({dsa_memcmp/dsa_time*100:0.2f}), dsa_other: {dsa_other:0.2f} ({dsa_other/dsa_time*100:0.2f})')
        print(f'pagefault: {pagefault}')
        print('')
        
    y_vals = [cpu_memcpy_list, cpu_memset_list, cpu_memcmp_list, cpu_other_list, dsa_memcpy_list, dsa_memset_list, dsa_memcmp_list, dsa_other_list, pagefault_list]
    print(y_vals)
    return y_vals
    
def _execution_breakdown_with_pagefault__nop_shmem_get_yvals(eb_dict, pf_dict):
    cpu_memcpy_list = []
    cpu_memset_list = []
    cpu_memcmp_list = []
    cpu_other_list = []
    
    dsa_memcpy_list = []
    dsa_memset_list = []
    dsa_memcmp_list = []
    dsa_other_list = []
    
    pagefault_list = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
        
    for i, size in enumerate(memory_sizes):    
        cpu_time = \
            np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['time']).sum(axis=1).mean()
        cpu_memcpymove = 0
        if 'memmove' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memmove']:
                cpu_memcpymove += np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memmove']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memmove']:
                cpu_memcpymove += np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean()
        if 'memcpy' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memcpy']:
                cpu_memcpymove += np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memcpy']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memcpy']:
                cpu_memcpymove += np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        cpu_memset = 0
        if 'memset' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memset']:
                cpu_memset += np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memset']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memset']:
                cpu_memset += np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        cpu_memcmp = 0
        if 'memcmp' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memcmp']:
                cpu_memcmp += np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memcmp']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memcmp']:
                cpu_memcmp += np.array(eb_dict['eb']['nop']['cpu']['shmem'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        cpu_other = cpu_time - cpu_memcpymove - cpu_memset - cpu_memcmp
        
        dsa_time = np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['time']).sum(axis=1).mean()
        dsa_memcpymove = 0
        if 'memmove' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memmove']:
                dsa_memcpymove += np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memmove']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memmove']:
                dsa_memcpymove += np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean()
        if 'memcpy' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memcpy']:
                dsa_memcpymove += np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memcpy']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memcpy']:
                dsa_memcpymove += np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        dsa_memset = 0
        if 'memset' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memset']:
                dsa_memset += np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memset']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memset']:
                dsa_memset += np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        dsa_memcmp = 0
        if 'memcmp' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memcmp']:
                dsa_memcmp += np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memcmp']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memcmp']:
                dsa_memcmp += np.array(eb_dict['eb']['nop']['dsa']['shmem'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        dsa_other = dsa_time - dsa_memcpymove - dsa_memset - dsa_memcmp
                
        pagefault = \
            int(np.array(pf_dict['pf']['nop']['dsa']['shmem'][False][size]['values']['client']['minpf']).sum(axis=1).mean() +\
            np.array(pf_dict['pf']['nop']['dsa']['shmem'][False][size]['values']['server']['minpf']).flatten().mean())

        
        cpu_memcpy_list.append(cpu_memcpymove)
        cpu_memset_list.append(cpu_memset)
        cpu_memcmp_list.append(cpu_memcmp)
        cpu_other_list.append(cpu_other)
        dsa_memcpy_list.append(dsa_memcpymove)
        dsa_memset_list.append(dsa_memset)
        dsa_memcmp_list.append(dsa_memcmp)
        dsa_other_list.append(dsa_other)
        pagefault_list.append(pagefault)
        
        print(f'cpu_time: {cpu_time:0.2f}, cpu_memcpymove: {cpu_memcpymove:0.2f} ({cpu_memcpymove/cpu_time*100:0.2f}%), cpu_memset: {cpu_memset:0.2f} ({cpu_memset/cpu_time*100:0.2f}), cpu_memcmp: {cpu_memcmp:0.2f} ({cpu_memcmp/cpu_time*100:0.2f}), cpu_other: {cpu_other:0.2f} ({cpu_other/cpu_time*100:0.2f})')
        print(f'dsa_time: {dsa_time:0.2f}, dsa_memcpymove: {dsa_memcpymove:0.2f} ({dsa_memcpymove/dsa_time*100:0.2f}%), dsa_memset: {dsa_memset:0.2f} ({dsa_memset/dsa_time*100:0.2f}), dsa_memcmp: {dsa_memcmp:0.2f} ({dsa_memcmp/dsa_time*100:0.2f}), dsa_other: {dsa_other:0.2f} ({dsa_other/dsa_time*100:0.2f})')
        print(f'pagefault: {pagefault}')
        print('')
        
    y_vals = [cpu_memcpy_list, cpu_memset_list, cpu_memcmp_list, cpu_other_list, dsa_memcpy_list, dsa_memset_list, dsa_memcmp_list, dsa_other_list, pagefault_list]
    print(y_vals)
    return y_vals

def _execution_breakdown_with_pagefault__echo_grpc_get_yvals(eb_dict, pf_dict):
    cpu_memcpy_list = []
    cpu_memset_list = []
    cpu_memcmp_list = []
    cpu_other_list = []
    
    dsa_memcpy_list = []
    dsa_memset_list = []
    dsa_memcmp_list = []
    dsa_other_list = []
    
    pagefault_list = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
        
    for i, size in enumerate(memory_sizes):    
        cpu_time = \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['time']).sum(axis=1).mean()
        cpu_memcpymove = \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['memmove']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean() + \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['memcpy']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        cpu_memset = \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['memset']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        cpu_memcmp = \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['memcmp']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo']['cpu']['grpc'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        cpu_other = cpu_time - cpu_memcpymove - cpu_memset - cpu_memcmp
        
        dsa_time = np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['time']).sum(axis=1).mean()
        dsa_memcpymove = \
            np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['memmove']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean() + \
            np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['memcpy']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        dsa_memset = \
            np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['memset']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        dsa_memcmp = \
            np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['memcmp']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo']['dsa']['grpc'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        dsa_other = dsa_time - dsa_memcpymove - dsa_memset - dsa_memcmp
        
        pagefault = \
            int(np.array(pf_dict['pf']['echo']['dsa']['grpc'][False][size]['values']['client']['minpf']).sum(axis=1).mean() +\
            np.array(pf_dict['pf']['echo']['dsa']['grpc'][False][size]['values']['server']['minpf']).flatten().mean())
        
        cpu_memcpy_list.append(cpu_memcpymove)
        cpu_memset_list.append(cpu_memset)
        cpu_memcmp_list.append(cpu_memcmp)
        cpu_other_list.append(cpu_other)
        dsa_memcpy_list.append(dsa_memcpymove)
        dsa_memset_list.append(dsa_memset)
        dsa_memcmp_list.append(dsa_memcmp)
        dsa_other_list.append(dsa_other)
        pagefault_list.append(pagefault)
        
        print(f'cpu_time: {cpu_time:0.2f}, cpu_memcpymove: {cpu_memcpymove:0.2f} ({cpu_memcpymove/cpu_time*100:0.2f}%), cpu_memset: {cpu_memset:0.2f} ({cpu_memset/cpu_time*100:0.2f}), cpu_memcmp: {cpu_memcmp:0.2f} ({cpu_memcmp/cpu_time*100:0.2f}), cpu_other: {cpu_other:0.2f} ({cpu_other/cpu_time*100:0.2f})')
        print(f'dsa_time: {dsa_time:0.2f}, dsa_memcpymove: {dsa_memcpymove:0.2f} ({dsa_memcpymove/dsa_time*100:0.2f}%), dsa_memset: {dsa_memset:0.2f} ({dsa_memset/dsa_time*100:0.2f}), dsa_memcmp: {dsa_memcmp:0.2f} ({dsa_memcmp/dsa_time*100:0.2f}), dsa_other: {dsa_other:0.2f} ({dsa_other/dsa_time*100:0.2f})')
        print(f'pagefault: {pagefault}')
        print('')
        
    y_vals = [cpu_memcpy_list, cpu_memset_list, cpu_memcmp_list, cpu_other_list, dsa_memcpy_list, dsa_memset_list, dsa_memcmp_list, dsa_other_list, pagefault_list]
    print(y_vals)
    return y_vals

def _execution_breakdown_with_pagefault__echo_shmem_get_yvals(eb_dict, pf_dict):
    cpu_memcpy_list = []
    cpu_memset_list = []
    cpu_memcmp_list = []
    cpu_other_list = []
    
    dsa_memcpy_list = []
    dsa_memset_list = []
    dsa_memcmp_list = []
    dsa_other_list = []
    
    pagefault_list = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
        
    for i, size in enumerate(memory_sizes):    
        cpu_time = \
            np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['time']).sum(axis=1).mean()
        cpu_memcpymove = 0
        if 'memmove' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memmove']:
                cpu_memcpymove += np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memmove']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memmove']:
                cpu_memcpymove += np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean()
        if 'memcpy' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memcpy']:
                cpu_memcpymove += np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memcpy']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memcpy']:
                cpu_memcpymove += np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        cpu_memset = 0
        if 'memset' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memset']:
                cpu_memset += np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memset']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memset']:
                cpu_memset += np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        cpu_memcmp = 0
        if 'memcmp' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memcmp']:
                cpu_memcmp += np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memcmp']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memcmp']:
                cpu_memcmp += np.array(eb_dict['eb']['echo']['cpu']['shmem'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        cpu_other = cpu_time - cpu_memcpymove - cpu_memset - cpu_memcmp
        
        dsa_time = np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['time']).sum(axis=1).mean()
        dsa_memcpymove = 0
        if 'memmove' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memmove']:
                dsa_memcpymove += np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memmove']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memmove']:
                dsa_memcpymove += np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean()
        if 'memcpy' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memcpy']:
                dsa_memcpymove += np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memcpy']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memcpy']:
                dsa_memcpymove += np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        dsa_memset = 0
        if 'memset' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memset']:
                dsa_memset += np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memset']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memset']:
                dsa_memset += np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        dsa_memcmp = 0
        if 'memcmp' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memcmp']:
                dsa_memcmp += np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memcmp']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memcmp']:
                dsa_memcmp += np.array(eb_dict['eb']['echo']['dsa']['shmem'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        dsa_other = dsa_time - dsa_memcpymove - dsa_memset - dsa_memcmp
                
        pagefault = \
            int(np.array(pf_dict['pf']['echo']['dsa']['shmem'][False][size]['values']['client']['minpf']).sum(axis=1).mean() +\
            np.array(pf_dict['pf']['echo']['dsa']['shmem'][False][size]['values']['server']['minpf']).flatten().mean())

        
        cpu_memcpy_list.append(cpu_memcpymove)
        cpu_memset_list.append(cpu_memset)
        cpu_memcmp_list.append(cpu_memcmp)
        cpu_other_list.append(cpu_other)
        dsa_memcpy_list.append(dsa_memcpymove)
        dsa_memset_list.append(dsa_memset)
        dsa_memcmp_list.append(dsa_memcmp)
        dsa_other_list.append(dsa_other)
        pagefault_list.append(pagefault)
        
        print(f'cpu_time: {cpu_time:0.2f}, cpu_memcpymove: {cpu_memcpymove:0.2f} ({cpu_memcpymove/cpu_time*100:0.2f}%), cpu_memset: {cpu_memset:0.2f} ({cpu_memset/cpu_time*100:0.2f}), cpu_memcmp: {cpu_memcmp:0.2f} ({cpu_memcmp/cpu_time*100:0.2f}), cpu_other: {cpu_other:0.2f} ({cpu_other/cpu_time*100:0.2f})')
        print(f'dsa_time: {dsa_time:0.2f}, dsa_memcpymove: {dsa_memcpymove:0.2f} ({dsa_memcpymove/dsa_time*100:0.2f}%), dsa_memset: {dsa_memset:0.2f} ({dsa_memset/dsa_time*100:0.2f}), dsa_memcmp: {dsa_memcmp:0.2f} ({dsa_memcmp/dsa_time*100:0.2f}), dsa_other: {dsa_other:0.2f} ({dsa_other/dsa_time*100:0.2f})')
        print(f'pagefault: {pagefault}')
        print('')
        
    y_vals = [cpu_memcpy_list, cpu_memset_list, cpu_memcmp_list, cpu_other_list, dsa_memcpy_list, dsa_memset_list, dsa_memcmp_list, dsa_other_list, pagefault_list]
    print(y_vals)
    return y_vals

def _execution_breakdown_with_pagefault__nop_pin_grpc_get_yvals(eb_dict, pf_dict):
    cpu_memcpy_list = []
    cpu_memset_list = []
    cpu_memcmp_list = []
    cpu_other_list = []
    
    dsa_memcpy_list = []
    dsa_memset_list = []
    dsa_memcmp_list = []
    dsa_other_list = []
    
    pagefault_list = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
        
    for i, size in enumerate(memory_sizes):    
        cpu_time = \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['time']).sum(axis=1).mean()
        cpu_memcpymove = \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['memmove']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean() + \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['memcpy']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        cpu_memset = \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['memset']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        cpu_memcmp = \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['memcmp']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['grpc'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        cpu_other = cpu_time - cpu_memcpymove - cpu_memset - cpu_memcmp
        
        dsa_time = np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['time']).sum(axis=1).mean()
        dsa_memcpymove = \
            np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['memmove']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean() + \
            np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['memcpy']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        dsa_memset = \
            np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['memset']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        dsa_memcmp = \
            np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['memcmp']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['nop-pinned']['dsa']['grpc'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        dsa_other = dsa_time - dsa_memcpymove - dsa_memset - dsa_memcmp
        
        pagefault = \
            int(np.array(pf_dict['pf']['nop-pinned']['dsa']['grpc'][False][size]['values']['client']['minpf']).sum(axis=1).mean() +\
            np.array(pf_dict['pf']['nop-pinned']['dsa']['grpc'][False][size]['values']['server']['minpf']).flatten().mean())
        
        cpu_memcpy_list.append(cpu_memcpymove)
        cpu_memset_list.append(cpu_memset)
        cpu_memcmp_list.append(cpu_memcmp)
        cpu_other_list.append(cpu_other)
        dsa_memcpy_list.append(dsa_memcpymove)
        dsa_memset_list.append(dsa_memset)
        dsa_memcmp_list.append(dsa_memcmp)
        dsa_other_list.append(dsa_other)
        pagefault_list.append(pagefault)
        
        print(f'cpu_time: {cpu_time:0.2f}, cpu_memcpymove: {cpu_memcpymove:0.2f} ({cpu_memcpymove/cpu_time*100:0.2f}%), cpu_memset: {cpu_memset:0.2f} ({cpu_memset/cpu_time*100:0.2f}), cpu_memcmp: {cpu_memcmp:0.2f} ({cpu_memcmp/cpu_time*100:0.2f}), cpu_other: {cpu_other:0.2f} ({cpu_other/cpu_time*100:0.2f})')
        print(f'dsa_time: {dsa_time:0.2f}, dsa_memcpymove: {dsa_memcpymove:0.2f} ({dsa_memcpymove/dsa_time*100:0.2f}%), dsa_memset: {dsa_memset:0.2f} ({dsa_memset/dsa_time*100:0.2f}), dsa_memcmp: {dsa_memcmp:0.2f} ({dsa_memcmp/dsa_time*100:0.2f}), dsa_other: {dsa_other:0.2f} ({dsa_other/dsa_time*100:0.2f})')
        print(f'pagefault: {pagefault}')
        print('')
        
    y_vals = [cpu_memcpy_list, cpu_memset_list, cpu_memcmp_list, cpu_other_list, dsa_memcpy_list, dsa_memset_list, dsa_memcmp_list, dsa_other_list, pagefault_list]
    print(y_vals)
    return y_vals

def _execution_breakdown_with_pagefault__nop_pin_shmem_get_yvals(eb_dict, pf_dict):
    cpu_memcpy_list = []
    cpu_memset_list = []
    cpu_memcmp_list = []
    cpu_other_list = []
    
    dsa_memcpy_list = []
    dsa_memset_list = []
    dsa_memcmp_list = []
    dsa_other_list = []
    
    pagefault_list = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
        
    for i, size in enumerate(memory_sizes):    
        cpu_time = \
            np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['time']).sum(axis=1).mean()
        cpu_memcpymove = 0
        if 'memmove' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memmove']:
                cpu_memcpymove += np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memmove']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memmove']:
                cpu_memcpymove += np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean()
        if 'memcpy' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memcpy']:
                cpu_memcpymove += np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memcpy']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memcpy']:
                cpu_memcpymove += np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        cpu_memset = 0
        if 'memset' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memset']:
                cpu_memset += np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memset']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memset']:
                cpu_memset += np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        cpu_memcmp = 0
        if 'memcmp' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memcmp']:
                cpu_memcmp += np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memcmp']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memcmp']:
                cpu_memcmp += np.array(eb_dict['eb']['nop-pinned']['cpu']['shmem'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        cpu_other = cpu_time - cpu_memcpymove - cpu_memset - cpu_memcmp
        
        dsa_time = np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['time']).sum(axis=1).mean()
        dsa_memcpymove = 0
        if 'memmove' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memmove']:
                dsa_memcpymove += np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memmove']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memmove']:
                dsa_memcpymove += np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean()
        if 'memcpy' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memcpy']:
                dsa_memcpymove += np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memcpy']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memcpy']:
                dsa_memcpymove += np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        dsa_memset = 0
        if 'memset' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memset']:
                dsa_memset += np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memset']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memset']:
                dsa_memset += np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        dsa_memcmp = 0
        if 'memcmp' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memcmp']:
                dsa_memcmp += np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memcmp']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memcmp']:
                dsa_memcmp += np.array(eb_dict['eb']['nop-pinned']['dsa']['shmem'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        dsa_other = dsa_time - dsa_memcpymove - dsa_memset - dsa_memcmp
                
        pagefault = \
            int(np.array(pf_dict['pf']['nop-pinned']['dsa']['shmem'][False][size]['values']['client']['minpf']).sum(axis=1).mean() +\
            np.array(pf_dict['pf']['nop-pinned']['dsa']['shmem'][False][size]['values']['server']['minpf']).flatten().mean())

        
        cpu_memcpy_list.append(cpu_memcpymove)
        cpu_memset_list.append(cpu_memset)
        cpu_memcmp_list.append(cpu_memcmp)
        cpu_other_list.append(cpu_other)
        dsa_memcpy_list.append(dsa_memcpymove)
        dsa_memset_list.append(dsa_memset)
        dsa_memcmp_list.append(dsa_memcmp)
        dsa_other_list.append(dsa_other)
        pagefault_list.append(pagefault)
        
        print(f'cpu_time: {cpu_time:0.2f}, cpu_memcpymove: {cpu_memcpymove:0.2f} ({cpu_memcpymove/cpu_time*100:0.2f}%), cpu_memset: {cpu_memset:0.2f} ({cpu_memset/cpu_time*100:0.2f}), cpu_memcmp: {cpu_memcmp:0.2f} ({cpu_memcmp/cpu_time*100:0.2f}), cpu_other: {cpu_other:0.2f} ({cpu_other/cpu_time*100:0.2f})')
        print(f'dsa_time: {dsa_time:0.2f}, dsa_memcpymove: {dsa_memcpymove:0.2f} ({dsa_memcpymove/dsa_time*100:0.2f}%), dsa_memset: {dsa_memset:0.2f} ({dsa_memset/dsa_time*100:0.2f}), dsa_memcmp: {dsa_memcmp:0.2f} ({dsa_memcmp/dsa_time*100:0.2f}), dsa_other: {dsa_other:0.2f} ({dsa_other/dsa_time*100:0.2f})')
        print(f'pagefault: {pagefault}')
        print('')
        
    y_vals = [cpu_memcpy_list, cpu_memset_list, cpu_memcmp_list, cpu_other_list, dsa_memcpy_list, dsa_memset_list, dsa_memcmp_list, dsa_other_list, pagefault_list]
    print(y_vals)
    return y_vals

def _execution_breakdown_with_pagefault__echo_pin_grpc_get_yvals(eb_dict, pf_dict):
    cpu_memcpy_list = []
    cpu_memset_list = []
    cpu_memcmp_list = []
    cpu_other_list = []
    
    dsa_memcpy_list = []
    dsa_memset_list = []
    dsa_memcmp_list = []
    dsa_other_list = []
    
    pagefault_list = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
        
    for i, size in enumerate(memory_sizes):    
        cpu_time = \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['time']).sum(axis=1).mean()
        cpu_memcpymove = \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['memmove']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean() + \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['memcpy']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        cpu_memset = \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['memset']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        cpu_memcmp = \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['memcmp']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['grpc'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        cpu_other = cpu_time - cpu_memcpymove - cpu_memset - cpu_memcmp
        
        dsa_time = np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['time']).sum(axis=1).mean()
        dsa_memcpymove = \
            np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['memmove']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean() + \
            np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['memcpy']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        dsa_memset = \
            np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['memset']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        dsa_memcmp = \
            np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['memcmp']['server']['call_time']).flatten().mean() + \
            np.array(eb_dict['eb']['echo-pinned']['dsa']['grpc'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        dsa_other = dsa_time - dsa_memcpymove - dsa_memset - dsa_memcmp
        
        pagefault = \
            int(np.array(pf_dict['pf']['echo-pinned']['dsa']['grpc'][False][size]['values']['client']['minpf']).sum(axis=1).mean() +\
            np.array(pf_dict['pf']['echo-pinned']['dsa']['grpc'][False][size]['values']['server']['minpf']).flatten().mean())
        
        cpu_memcpy_list.append(cpu_memcpymove)
        cpu_memset_list.append(cpu_memset)
        cpu_memcmp_list.append(cpu_memcmp)
        cpu_other_list.append(cpu_other)
        dsa_memcpy_list.append(dsa_memcpymove)
        dsa_memset_list.append(dsa_memset)
        dsa_memcmp_list.append(dsa_memcmp)
        dsa_other_list.append(dsa_other)
        pagefault_list.append(pagefault)
        
        print(f'cpu_time: {cpu_time:0.2f}, cpu_memcpymove: {cpu_memcpymove:0.2f} ({cpu_memcpymove/cpu_time*100:0.2f}%), cpu_memset: {cpu_memset:0.2f} ({cpu_memset/cpu_time*100:0.2f}), cpu_memcmp: {cpu_memcmp:0.2f} ({cpu_memcmp/cpu_time*100:0.2f}), cpu_other: {cpu_other:0.2f} ({cpu_other/cpu_time*100:0.2f})')
        print(f'dsa_time: {dsa_time:0.2f}, dsa_memcpymove: {dsa_memcpymove:0.2f} ({dsa_memcpymove/dsa_time*100:0.2f}%), dsa_memset: {dsa_memset:0.2f} ({dsa_memset/dsa_time*100:0.2f}), dsa_memcmp: {dsa_memcmp:0.2f} ({dsa_memcmp/dsa_time*100:0.2f}), dsa_other: {dsa_other:0.2f} ({dsa_other/dsa_time*100:0.2f})')
        print(f'pagefault: {pagefault}')
        print('')
        
    y_vals = [cpu_memcpy_list, cpu_memset_list, cpu_memcmp_list, cpu_other_list, dsa_memcpy_list, dsa_memset_list, dsa_memcmp_list, dsa_other_list, pagefault_list]
    print(y_vals)
    return y_vals

def _execution_breakdown_with_pagefault__echo_pin_shmem_get_yvals(eb_dict, pf_dict):
    cpu_memcpy_list = []
    cpu_memset_list = []
    cpu_memcmp_list = []
    cpu_other_list = []
    
    dsa_memcpy_list = []
    dsa_memset_list = []
    dsa_memcmp_list = []
    dsa_other_list = []
    
    pagefault_list = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
        
    for i, size in enumerate(memory_sizes):    
        cpu_time = \
            np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['time']).sum(axis=1).mean()
        cpu_memcpymove = 0
        if 'memmove' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memmove']:
                cpu_memcpymove += np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memmove']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memmove']:
                cpu_memcpymove += np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean()
        if 'memcpy' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memcpy']:
                cpu_memcpymove += np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memcpy']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memcpy']:
                cpu_memcpymove += np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        cpu_memset = 0
        if 'memset' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memset']:
                cpu_memset += np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memset']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memset']:
                cpu_memset += np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        cpu_memcmp = 0
        if 'memcmp' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memcmp']:
                cpu_memcmp += np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memcmp']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memcmp']:
                cpu_memcmp += np.array(eb_dict['eb']['echo-pinned']['cpu']['shmem'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        cpu_other = cpu_time - cpu_memcpymove - cpu_memset - cpu_memcmp
        
        dsa_time = np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['time']).sum(axis=1).mean()
        dsa_memcpymove = 0
        if 'memmove' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memmove']:
                dsa_memcpymove += np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memmove']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memmove']:
                dsa_memcpymove += np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memmove']['client']['call_time']).sum(axis=1).mean()
        if 'memcpy' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memcpy']:
                dsa_memcpymove += np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memcpy']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memcpy']:
                dsa_memcpymove += np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memcpy']['client']['call_time']).sum(axis=1).mean()
        dsa_memset = 0
        if 'memset' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memset']:
                dsa_memset += np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memset']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memset']:
                dsa_memset += np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memset']['client']['call_time']).sum(axis=1).mean()
        dsa_memcmp = 0
        if 'memcmp' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']:
            if 'server' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memcmp']:
                dsa_memcmp += np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memcmp']['server']['call_time']).sum(axis=1).mean()
            if 'client' in eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memcmp']:
                dsa_memcmp += np.array(eb_dict['eb']['echo-pinned']['dsa']['shmem'][False][size]['values']['memcmp']['client']['call_time']).sum(axis=1).mean()
        dsa_other = dsa_time - dsa_memcpymove - dsa_memset - dsa_memcmp
                
        pagefault = \
            int(np.array(pf_dict['pf']['echo-pinned']['dsa']['shmem'][False][size]['values']['client']['minpf']).sum(axis=1).mean() +\
            np.array(pf_dict['pf']['echo-pinned']['dsa']['shmem'][False][size]['values']['server']['minpf']).flatten().mean())

        
        cpu_memcpy_list.append(cpu_memcpymove)
        cpu_memset_list.append(cpu_memset)
        cpu_memcmp_list.append(cpu_memcmp)
        cpu_other_list.append(cpu_other)
        dsa_memcpy_list.append(dsa_memcpymove)
        dsa_memset_list.append(dsa_memset)
        dsa_memcmp_list.append(dsa_memcmp)
        dsa_other_list.append(dsa_other)
        pagefault_list.append(pagefault)
        
        print(f'cpu_time: {cpu_time:0.2f}, cpu_memcpymove: {cpu_memcpymove:0.2f} ({cpu_memcpymove/cpu_time*100:0.2f}%), cpu_memset: {cpu_memset:0.2f} ({cpu_memset/cpu_time*100:0.2f}), cpu_memcmp: {cpu_memcmp:0.2f} ({cpu_memcmp/cpu_time*100:0.2f}), cpu_other: {cpu_other:0.2f} ({cpu_other/cpu_time*100:0.2f})')
        print(f'dsa_time: {dsa_time:0.2f}, dsa_memcpymove: {dsa_memcpymove:0.2f} ({dsa_memcpymove/dsa_time*100:0.2f}%), dsa_memset: {dsa_memset:0.2f} ({dsa_memset/dsa_time*100:0.2f}), dsa_memcmp: {dsa_memcmp:0.2f} ({dsa_memcmp/dsa_time*100:0.2f}), dsa_other: {dsa_other:0.2f} ({dsa_other/dsa_time*100:0.2f})')
        print(f'pagefault: {pagefault}')
        print('')
        
    y_vals = [cpu_memcpy_list, cpu_memset_list, cpu_memcmp_list, cpu_other_list, dsa_memcpy_list, dsa_memset_list, dsa_memcmp_list, dsa_other_list, pagefault_list]
    print(y_vals)
    return y_vals
    
def _execution_breakdown_with_pagefault__plot(filename,
                                              x_ticks,
                                              cpu_memcpy,
                                              cpu_memset,
                                              cpu_memcmp,
                                              cpu_other,
                                              dsa_memcpy,
                                              dsa_memset,
                                              dsa_memcmp,
                                              dsa_other,
                                              pagefault):
    
    # print(f'x_ticks: {x_ticks}')
    # print(f'cpu_memcpy: {cpu_memcpy}')
    # print(f'cpu_memset: {cpu_memset}')
    # print(f'cpu_memcmp: {cpu_memcmp}')
    # print(f'cpu_other: {cpu_other}')
    # print(f'dsa_memcpy: {dsa_memcpy}')
    # print(f'dsa_memset: {dsa_memset}')
    # print(f'dsa_memcmp: {dsa_memcmp}')
    # print(f'dsa_other: {dsa_other}')
    # print(f'pagefault: {pagefault}')
    
    x_ticks = np.array(x_ticks)
    cpu_memcpy = np.array(cpu_memcpy)
    cpu_memset = np.array(cpu_memset)
    cpu_memcmp = np.array(cpu_memcmp)
    cpu_other = np.array(cpu_other)
    dsa_memcpy = np.array(dsa_memcpy)
    dsa_memset = np.array(dsa_memset)
    dsa_memcmp = np.array(dsa_memcmp)
    dsa_other = np.array(dsa_other)
    pagefault = np.array(pagefault)

    fig, ax = plt.subplots(figsize=(3, 2), dpi=300)
    plt.tight_layout()
    fig.tight_layout()
    
    sns.set_palette("deep")
    sns.set_theme(style='white') # style='whitegrid', 'darkgrid', 'ticks', 'white', 'dark'
    sns.set_context('talk', font_scale=4) # poster, notebook, 
    colors = sns.color_palette(palette='deep')
    color = sns.color_palette().as_hex()

    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)


    ax.set_xlabel('size_in_kb', fontsize=11)
    ax.set_ylabel('latency_in_usec', fontsize=11)

    bar_width = 0.35
    bar_spacing = 0.05
    e=0.0
    plt.rcParams['hatch.linewidth'] = 0.5

    # axes[0].set_xticks(instances)
    ticks=np.arange(len(x_ticks))
    ax.set_xticks(ticks)
    ax.set_xticklabels(x_ticks)
    

    cpu_memcpy_bar = ax.bar(ticks - bar_width/2 - bar_spacing/2, cpu_memcpy, bar_width, color=colors[2], label='cpu_memcpy', linewidth=0.5)
    cpu_color = cpu_memcpy_bar.patches[0].get_facecolor()
    [patch.set_edgecolor(cpu_color) for patch in cpu_memcpy_bar.patches]
    ax.bar(ticks - bar_width/2 - bar_spacing/2,  cpu_memset, bar_width-e, label='cpu_memset',  bottom=cpu_memcpy, color='white', linewidth=0.5, edgecolor=cpu_color, hatch='//////')
    ax.bar(ticks - bar_width/2 - bar_spacing/2,  cpu_memcmp, bar_width-e, label='cpu_memcmp',  bottom=cpu_memcpy + cpu_memset, color='white', linewidth=0.5, edgecolor=cpu_color, hatch='oo')
    ax.bar(ticks - bar_width/2 - bar_spacing/2,  cpu_other, bar_width-e, label='cpu_other',  bottom=cpu_memcpy + cpu_memset + cpu_memcmp, color='white', linewidth=0.5, edgecolor=cpu_color, hatch='XXX')

    dsa_memcpy_bar = ax.bar(ticks + bar_width/2 + bar_spacing/2, dsa_memcpy, bar_width, color=color[1], label='dsa_memcpy', linewidth=0.5)
    dsa_color = dsa_memcpy_bar.patches[0].get_facecolor()
    [patch.set_edgecolor(dsa_color) for patch in dsa_memcpy_bar.patches]
    ax.bar(ticks + bar_width/2 + bar_spacing/2, dsa_memset, bar_width-e, label='dsa_memset',   bottom=dsa_memcpy, color='white', linewidth=0.5, edgecolor=dsa_color, hatch='//////')
    ax.bar(ticks + bar_width/2 + bar_spacing/2, dsa_memcmp, bar_width-e, label='dsa_memcmp',   bottom=dsa_memcpy + dsa_memset, color='white', linewidth=0.5, edgecolor=dsa_color, hatch='oo')
    ax.bar(ticks + bar_width/2 + bar_spacing/2, dsa_other, bar_width-e, label='dsa_other',   bottom=dsa_memcpy + dsa_memset + dsa_memcmp, color='white', linewidth=0.5, edgecolor=dsa_color, hatch='XXX')
    
    ax2 = ax.twinx()
    ax2.plot(ticks, pagefault, color='red', marker='o', label='Page Faults')
    ax2.set_ylabel('Page Faults', fontsize=11)
    ax2.yaxis.set_visible(False)
    ax2.spines['top'].set_visible(False)
    ax2.spines['right'].set_visible(False)
    ax2.spines['left'].set_visible(False)
    ax2.spines['bottom'].set_visible(False)
    for i, txt in enumerate(pagefault):
        ax2.text(ticks[i], int(pagefault[i]), str(txt), color='blue', fontsize=8, ha='center')

    lines, labels = ax.get_legend_handles_labels()
    lines2, labels2 = ax2.get_legend_handles_labels()
    # ax2.legend(lines + lines2, labels + labels2, loc='upper left', fontsize=7, bbox_to_anchor=(0, 1.4))

    leg = ax.legend(loc='upper left', fontsize=7, bbox_to_anchor=(0, 1.4), 
            facecolor='white', framealpha=1, ncol=2, frameon=False, labelspacing = 0.1, columnspacing=0.5)
    plt.subplots_adjust(bottom=0.25, top=0.8, left=0.2)
    plt.savefig(os.path.join(OUTPUT_DIR, filename), dpi=300)

def _memcpy_latency__singlecore_waitmode_get_yvals(wm_dict, with_matmul):
    cpu_latency = []
    yield_latency = []
    umwait_latency = []
    busypoll_latency = []
    
    memory_sizes = [256, 512, 1024, 2048, 4096]
    
    if with_matmul:
        key = 'memcpy_with_matmul_with_pinning'
    else:
        key = 'memcpy_after_mlockall'
        
    for i, size in enumerate(memory_sizes):
        cpu_latency.append(np.array(wm_dict[key]['cpu'][False][size]['values']['memcpy_latency']).flatten().mean())
        yield_latency.append(np.array(wm_dict[key]['yield'][False][size]['values']['memcpy_latency']).flatten().mean())
        umwait_latency.append(np.array(wm_dict[key]['umwait'][False][size]['values']['memcpy_latency']).flatten().mean())
        busypoll_latency.append(np.array(wm_dict[key]['busypoll'][False][size]['values']['memcpy_latency']).flatten().mean())
        
    y_vals = [cpu_latency, yield_latency, umwait_latency, busypoll_latency]
        
    return y_vals

def _memcpy_latency__singlecore_waitmode_plot(filename, x_tick, cpu_latency, yield_latency, umwait_latency, busypoll_latency):
    # Create a DataFrame
    data = {
        'x_tick': [x for x in x_tick for _ in range(4)],
        'latency': [val for pair in zip(cpu_latency, yield_latency, umwait_latency, busypoll_latency) for val in pair],
        'Group': ['CPU Latency', 'Yield Latency', 'UMWait Latency', 'BusyPoll Latency'] * len(x_tick)
    }

    df = pd.DataFrame(data)

    # Plotting
    sns.set_theme(style='whitegrid')
    plt.figure(figsize=(8, 6))
    sns.barplot(x='x_tick', y='latency', hue='Group', data=df)
    plt.legend(title=None)
    sns.despine(top=True, right=True, left=True, bottom=True)
    plt.savefig(os.path.join(OUTPUT_DIR, filename), dpi=300)
    
    
def read_dict(path):
    def convert_keys(d):
        def convert_key(key):
            # 문자열 키를 불린 또는 정수로 변환
            if key in ["true", "True"]:
                return True
            elif key in ["false", "False"]:
                return False
            try:
                return int(key)
            except ValueError:
                return key

        new_dict = {}
        for key, value in d.items():
            new_key = convert_key(key)
            # 값이 딕셔너리인 경우 재귀적으로 처리
            if isinstance(value, dict):
                new_dict[new_key] = convert_keys(value)
            else:
                new_dict[new_key] = value

        return new_dict

    data = json.load(open(path))
    return convert_keys(data)                      

def calculate_stats(numbers):
    Stats = namedtuple('Stats', ['mean', 'stdev', 'n'])
    mean_val = statistics.mean(numbers)
    stdev_val = statistics.stdev(numbers) if len(numbers) > 1 else 0
    n_val = len(numbers)
    return Stats(mean=mean_val, stdev=stdev_val, n=n_val)

if __name__ == '__main__':
    main(*sys.argv[1:])