so-tp1/scripts/batchplotter.py

#!/usr/bin/env python3
# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
import json
import numpy as np
import matplotlib.pyplot as plt
import os
import sys
from subprocess import Popen, PIPE
from stats import parseData

bar_width = 0.25
index = []
def plot(process_data, title):
    fig, ax = plt.subplots(figsize=(10,5))
    
    task_output = []
    for p in process_data:
        cmd = ["./simusched",p["tasks"]]
        cmd.extend(p["args"].split(" "))
        process = Popen(cmd, stdout=PIPE)
        (out, _) = process.communicate()
        process.wait()
        out = out.decode("utf-8")
        (parsed,idle) = parseData(out.split("\n"))
        ap  = {}
        ap["idle"] = idle
        ap["processes"] = parsed
        ap["tasks"] = p["tasks"]
        ap["args"] = p["args"]
        task_output.append(ap)


    m_latencies = []
    m_ready = []
    m_cpu = []
    m_cpuio = []
    idletime = []
    for t in task_output:
        m_latencies.append(meanLatency(t))
        m_ready.append(meanReady(t))
        m_cpu.append(meanCPU(t))
        m_cpuio.append(meanCPUIO(t))
        idletime.append(t["idle"])

    plot_data(0, m_latencies, 'r', 'M. Latency')
    plot_data(1, m_ready, 'g', 'M. Ready')
    plot_data(2, m_cpu, 'b', 'M. CPU')
    plot_data(3, m_cpuio, '#deadbe', 'M. CPU+IO')
    plot_data(4, idletime, '#c1c1c1', 'Idle')

    ax.set_ylabel('Time')
    ax.set_title(title)
    ax.set_xticks([ i + 1.5 * bar_width for i in index])
    ax.set_xticklabels( ["%s %s" % (task_output[i]["tasks"], task_output[i]["args"])
                        for i in range(len(process_data))])
    
    for tick in ax.xaxis.get_major_ticks():
        tick.label.set_fontsize(9)

    plt.legend()
    
    plt.tight_layout()
    plt.grid()
    filename='out.png'
    plt.savefig(filename)
    print("salida: %s" % filename)


def meanLatency(pl):
    totLatency = sum([ latency(p) for p in pl["processes"]])
    mean = totLatency / len(pl["processes"])
    return mean

def meanReady(pl):
    totReady = sum([ ready(p) for p in pl["processes"]])
    mean = totReady / len(pl["processes"])
    return mean

def meanCPU(pl):
    totCPU = sum([ cpu(p) for p in pl["processes"]])
    mean = totCPU / len(pl["processes"])
    return mean

def meanCPUIO(pl):
    totCPUIO = sum([ cpu_io(p) for p in pl["processes"]])
    mean = totCPUIO / len(pl["processes"])
    return mean

def latency(p):
    return p["primerTick"]-p["cargaTick"]

def ready(p):
    return (p["ultimoTick"]-p["primerTick"])-(p["ticksBlock"]+p["ticksCpu"])+(p["primerTick"]-p["cargaTick"])

def cpu(p):
    return p["ticksCpu"]

def cpu_io(p):
    return p["ticksBlock"]+p["ticksCpu"]

def plot_data(ind, data, color, label):
    opacity = 1
    plt.bar([i + bar_width*ind for i in index],
        data,
        bar_width,
        alpha=opacity,
        color=color,
        label=(label))

if len(sys.argv) != 2:
    print("1 arg, json file")
    sys.exit(1)

if not os.path.isfile(sys.argv[1]):
    print("'%s' no es un archivo / no existe" % sys.argv[1])
    sys.exit(2)
    
try:
    data = open(sys.argv[1]).read()
    j = json.loads(data)
    index = [ 1.5*i for i in list(range(len(j["list"]))) ]
    plot(j["list"],j["title"])
except Exception as e:
    print("Exception")
    print(data)
    print(e)