/articles/toma

#! /usr/bin/python

 

import sys

import numpy as np

import matplotlib as mpl

import matplotlib.pyplot as plt

import matplotlib.ticker as ticker

import matplotlib.gridspec as gridspec

 

font = 14

mpl.rcParams.update({'font.size': font})

 

 

ops = 3526656000.

 

#colors=['green', 'red']

#colors=['#05500a', '#ff676c']

#colors=['#05500a', 'lightyellow']

#colors=['#303030', '#2b83ba', 'limegreen', '#fdd5a5', '#d3ffd5', 'lightyellow']

#colors=['#303030', '#2b83ba', 'limegreen', '#fdd5a5', '#d3ffd5', 'lightyellow']

colors=['darkred', '#2b83ba', 'limegreen', '#fdd5a5', '#d3ffd5', 'lightyellow']

colors1=['darkgreen', 'darkred', '#fdd5a5', '#d3ffd5', 'lightyellow']

colors2=['limegreen', 'orange', '#d3ffd5', 'lightyellow']

 

 

 

 

titles = np.genfromtxt('../bench/gpu.txt', dtype = 'S32', delimiter=",", usecols = [0])

specs = np.genfromtxt('../bench/specs.txt', names = True, usecols = range(1,10))

# Convert structured numpy array to standard ndarray

specs = specs.view(np.float).reshape(specs.shape + (-1,))

texfl = specs[0]

years = specs[2]

flops = specs[3]

shmem = specs[4]

tconv = specs[5]

 

data = np.genfromtxt('../bench/tex.txt', names = True, usecols = range(1,10))

# Convert structured numpy array to standard ndarray

data = data.view(np.float).reshape(data.shape + (-1,))

# Convert to GUPS

tex_gups = np.vectorize(lambda v: ops / v / 1000 / 1000 if v > 0 else 0.)(data)

 

data = np.genfromtxt('../bench/alu.txt', names = True, usecols = range(1,10))

# Convert structured numpy array to standard ndarray

alu_gups = data.view(np.float).reshape(data.shape + (-1,))

 

#Extract

std = np.round(tex_gups[0])

tex_f1 = np.amax(tex_gups[0:12:4], axis=0)

tex_f2 = np.amax(tex_gups[1:12:4], axis=0)

tex_f4 = np.amax(tex_gups[2:12:4], axis=0)

tex_h4 = np.amax(tex_gups[3:12:4], axis=0)

 

#Standard

lin_simple = tex_f1

nn_simple = tex_f1

 

# Compute maximum for precise and approximate modes

plin_tex = np.amax([tex_f1, tex_f2], axis=0)

alin_tex = plin_tex

pnn_tex = np.amax([plin_tex, tex_f4], axis=0)

ann_tex = np.amax([pnn_tex, tex_h4], axis=0)

 

#Linear & Hybrid

lin_f1 = np.amax(alu_gups[0:8:4], axis=0)

lin_f2 = np.amax(alu_gups[1:8:4], axis=0)

lin_f4 = np.amax(alu_gups[2:8:4], axis=0)

lin_h4 = np.amax(alu_gups[3:8:4], axis=0)

 

#Individual

alu_fx = np.amax(alu_gups[0:3], axis=0)

alu_xx = np.amax(alu_gups[0:4], axis=0)

hyb_fx = np.amax(alu_gups[4:7], axis=0)

hyb_xx = np.amax(alu_gups[4:8], axis=0)

 

#oversampling & NN

ovs_f1 = alu_gups[8];

ovs_xx = np.amax(alu_gups[8:12], axis=0)

nn_f1 = alu_gups[12];

nn_fx = np.amax(alu_gups[12:15], axis=0)

#nn_hx = np.amax(alu_gups[15], axis=0)

nn_hx = alu_gups[15]

 

# Compute maximum for precise and approximate modes

plin = np.amax([lin_f1, lin_f2, lin_f4, plin_tex], axis=0)

alin = np.amax([plin, lin_h4, ovs_xx, alin_tex], axis=0)

pnn = np.amax([nn_fx, pnn_tex], axis=0)

ann = np.amax([pnn, nn_hx, ann_tex], axis=0)

 

# Single-slice mode

plin_slice = np.amax([tex_f1, lin_f1], axis=0)

alin_slice = np.amax([plin_slice, ovs_f1], axis=0)

pnn_slice = np.amax([tex_f1, nn_f1], axis=0)

ann_slice = pnn_slice

 

 

# Compute speed-up

#def speedup(x): return (x - std) / std

def speedup(x): return x / std

 

#print speedup(plin)

#print speedup(alin)

 

N = len(data[0])

idx = np.arange(N)

idx = np.fliplr([idx])[0]

 

#print idx

 

bar_width = 1.0

bar_gap = 0.2

group_gap = 0.6

 

mult = 2 * (bar_width + bar_gap) + group_gap;

 

def get_change(x, r): return [x[n]/x[n-1] for n in r]

flops_change = get_change(flops, range(1,6))

texfl_change = get_change(texfl, range(1,6))

shmem_change = get_change(shmem, range(1,6))

tconv_change = get_change(tconv, range(1,6))

std_change = get_change(std, range(1,6))

plin_change = get_change(plin, range(1,6))

pnn_change = get_change(pnn, range(1,6))

 

 

seq = range(5)

seq1 = range(6)

seq2 = range(3)

#seq = years[0:6]

 

def speedup0(x,y): return x / x[0]

 

 

fig = plt.figure(figsize=(10, 6)) 

gs = gridspec.GridSpec(1, 3, width_ratios=[3, 0, 3]) 

plots = [ plt.subplot(gs[0]), plt.subplot(gs[2]) ]

 

p = plots[0]

 

p.set_xticks(seq1)

p.set_xticklabels(titles[0:6])

p.set_ylabel('speed-up relative to GTX295 (times)')

p.set_ylim(0, 14)

p_spec = p.plot(seq1, speedup0(flops[0:6], flops[0:6]), "-o", color=colors[0], markersize=3)

p_tex = p.plot(seq1, speedup0(texfl[0:6], texfl[0:6]), "-o", color=colors[1], markersize=3)

p_shm = p.plot(seq1, speedup0(shmem[0:6], shmem[0:6]), "-o", color=colors[2], markersize=3)

p_cnv = p.plot(seq1, speedup0(tconv[0:6], tconv[0:6]), "-o", color=colors[3], markersize=3)

 

fig.subplots_adjust(bottom=0.3)

legend = plt.figlegend(

    (p_spec[0], p_tex[0], p_shm[0], p_cnv[0]), 

    ("FP throughput (Peak)", "Texture throuhgput (Peak)", "Shared memory bandwidth (Peak)", "Throughput of type-conversions (Peak)",), 

    loc='lower center', bbox_to_anchor=(0.44,0.04), ncol=2)

 

p = plots[1]

 

#p.set_xticks(seq2)

#p.set_xticklabels(titles[6:9])

#p.set_ylim(0, 10)

#p.set_ylabel('speed-up (times)')

#p_spec = p.plot(seq2, speedup0(flops[6:9], flops[6:9]), "-o", color=colors[0], markersize=3)

#p_std = p.plot(seq2, speedup0(std[6:9], flops[6:9]), "-o", color=colors[1], markersize=3)

#p_lin = p.plot(seq2, speedup0(plin[6:9], flops[6:9]), "-o", color=colors[2], markersize=3)

#p_nn = p.plot(seq2, speedup0(pnn[6:9], flops[6:9]), "-o", color=colors[3], markersize=3)

 

#p.set_xticks(seq)

#p.set_xticklabels(titles[1:6])

#p.set_ylim(1, 5)

#p_spec = p.plot(seq, flops_change, "-o", color=colors[0], markersize=3)

#p_std = p.plot(seq, std_change, "-o", color=colors[1], markersize=3)

#p_lin = p.plot(seq, plin_change, "-o", color=colors[2], markersize=3)

#p_nn = p.plot(seq, pnn_change, "-o", color=colors[3], markersize=3)

 

bar_width = 1.0

bar_gap = 0.2

group_gap = 1.8

 

mult = 4 * (bar_width + bar_gap) + group_gap;

 

p.set_ylabel('speed-up & slow-down relative\nto previous architecture (times)')

 

p.set_xticks(0.45 * mult + mult * np.arange(5))

p.set_xticklabels(titles[1:6])

 

@ticker.FuncFormatter

def yformatter(x, pos):

    return  ("%.1f" % (x + 1)) if  (x >= 0) else ("2/%u" % abs(2 * x - 2)) if (round(x) != x) else ("1/%u" % abs(x - 1))

 

p.set_ylim(-1, 2.1)

p.yaxis.set_major_formatter(yformatter)

 

 

def speedup1(x): return (x - 1) if (x >=1) else (-1/x + 1)

 

 

for idx in range(5):

    p_tconv = p.bar(mult * idx + 3 * (bar_width + bar_gap), speedup1(tconv_change[idx]), bar_width, color=colors[3], edgecolor='black')

    p_shmem = p.bar(mult * idx + 2 * (bar_width + bar_gap), speedup1(shmem_change[idx]), bar_width, color=colors[2], edgecolor='black')

    p_texfl = p.bar(mult * idx + 1 * (bar_width + bar_gap), speedup1(texfl_change[idx]), bar_width, color=colors[1], edgecolor='black')

    p_spec = p.bar(mult * idx + 0 * (bar_width + bar_gap), speedup1(flops_change[idx]), bar_width, color=colors[0], edgecolor='black')

 

 

 

va = [0,  -.05, 0, -.05, 0, -.05, 0 ]

for t, y in zip( plots[0].get_xticklabels( ), va ):

    t.set_y( y )

for t, y in zip( plots[1].get_xticklabels( ), va ):

    t.set_y( y )

 

 

plt.savefig('speedup-steps.png', dpi=300, bbox_inches='tight')#, bbox_extra_artists=(legend,))

 

plt.close()