123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704 |
- #!/usr/bin/python3
- import sys
- import os
- import subprocess
- import numpy as np
- from numpy import genfromtxt
- import numpy.polynomial.polynomial as poly
- from operator import add
- import operator
- #import matplotlib as mpl
- #if os.environ.get('DISPLAY','') == '':
- # mpl.use('Agg')
- import matplotlib.pyplot as plt
- def quadratic_function(x, a, b, c):
- return a*x*x + b*x + c
- def linear_function(x, a, b):
- return a*x + b
- PLOT_PATHORAM = False
- PLOT_LSIPRM = False
- PLOT_CIRCUITORAM = False
- PLOT_ZEROTRACE = False
- if(len(sys.argv)>1):
- if(int(sys.argv[1])==1):
- PLOT_ZEROTRACE = True
- if(PLOT_ZEROTRACE):
- PLOT_CIRCUITORAM = True
- #List of plot files
- LF_PATHORAM='log_ZTPATHORAM'
- LF_CIRCUITORAM='log_ZTCIRCUITORAM'
- LF_LSIPRM='log_ZTLSORAM_IPRM'
- LF_LSOPRM='log_ZTLSORAM'
- FOLDER_XPIR='./XPIR/'
- LF_SEALPIR='log_SEALPIR'
- LF_SEALPIR_D1='log_SEALPIR_D1'
- DESC_SIZE=16384
- n= 10
- n_stop = 12000
- N = []
- while(n < n_stop):
- N.append(n)
- n = int(n * 8 / 5)
- print(N)
- plt.rc('font', size=18) # controls default text sizes
- plt.rc('axes', titlesize=18) # fontsize of the axes title
- plt.rc('axes', labelsize=18) # fontsize of the x and y labels
- plt.rc('xtick', labelsize=16) # fontsize of the tick labels
- plt.rc('ytick', labelsize=16) # fontsize of the tick labels
- plt.rc('legend', fontsize=14) # legend fontsize
- plt.rc('figure', titlesize=18) # fontsize of the figure title
- ########################
- LSIPRM_gtime=[]
- LSIPRM_ptime=[]
- LSIPRM_etime=[]
- LSIPRM_gtime_err=[]
- LSIPRM_ptime_err=[]
- LSIPRM_etime_err=[]
- LSIPRM_query_size=[]
- LSIPRM_response_size=[]
- LSIPRM_time = []
- LSIPRM_time_err = []
- LSOPRM_gtime=[]
- LSOPRM_ptime=[]
- LSOPRM_etime=[]
- LSOPRM_gtime_err=[]
- LSOPRM_ptime_err=[]
- LSOPRM_etime_err=[]
- LSOPRM_query_size=[]
- LSOPRM_response_size=[]
- LSOPRM_time = []
- LSOPRM_time_err = []
- CircuitORAM_gtime=[]
- CircuitORAM_ptime=[]
- CircuitORAM_etime=[]
- CircuitORAM_gtime_err=[]
- CircuitORAM_ptime_err=[]
- CircuitORAM_etime_err=[]
- CircuitORAM_query_size=[]
- CircuitORAM_response_size=[]
- CircuitORAM_time = []
- CircuitORAM_time_err = []
- PathORAM_gtime=[]
- PathORAM_ptime=[]
- PathORAM_etime=[]
- PathORAM_gtime_err=[]
- PathORAM_ptime_err=[]
- PathORAM_etime_err=[]
- PathORAM_query_size=[]
- PathORAM_response_size=[]
- PathORAM_time = []
- PathORAM_time_err = []
- XPIR_gtime=[]
- XPIR_ptime=[]
- XPIR_etime=[]
- XPIR_gtime_err=[]
- XPIR_ptime_err=[]
- XPIR_etime_err=[]
- XPIR_query_size=[]
- XPIR_response_size=[]
- XPIR_time = []
- XPIR_time_err =[]
- SealPIR_gtime=[]
- SealPIR_ptime=[]
- SealPIR_etime=[]
- SealPIR_gtime_err=[]
- SealPIR_ptime_err=[]
- SealPIR_etime_err=[]
- SealPIR_query_size=[]
- SealPIR_response_size=[]
- SealPIR_time = []
- SealPIR_time_err = []
- POINT_STYLES = [".","v","s","+","x","d",">","^","*","o","D"]
- ########################
- # NOTE N just needs to be picked once,
- # All plot files should have the same N range
- if(PLOT_PATHORAM):
- with open(LF_PATHORAM, 'r') as lfile:
- for line in lfile:
- values=line.split(',')
- PathORAM_gtime.append(float(values[1]))
- PathORAM_gtime_err.append(float(values[2]))
- PathORAM_ptime.append(float(values[3]))
- PathORAM_ptime_err.append(float(values[4]))
- PathORAM_etime.append(float(values[5]))
- PathORAM_etime_err.append(float(values[6]))
- PathORAM_query_size.append(int(values[7]))
- PathORAM_response_size.append(int(values[8]))
- if(PLOT_CIRCUITORAM):
- with open(LF_CIRCUITORAM, 'r') as lfile:
- for line in lfile:
- values=line.split(',')
- CircuitORAM_gtime.append(float(values[1]))
- CircuitORAM_gtime_err.append(float(values[2]))
- CircuitORAM_ptime.append(float(values[3]))
- CircuitORAM_ptime_err.append(float(values[4]))
- CircuitORAM_etime.append(float(values[5]))
- CircuitORAM_etime_err.append(float(values[6]))
- #CircuitORAM_query_size = int(values[7])
- #CircuitORAM_response_size = int(values[8])
- if(PLOT_LSIPRM):
- with open(LF_LSIPRM, 'r') as lfile:
- for line in lfile:
- values=line.split(',')
- LSIPRM_gtime.append(float(values[1]))
- LSIPRM_gtime_err.append(float(values[2]))
- LSIPRM_ptime.append(float(values[3]))
- LSIPRM_ptime_err.append(float(values[4]))
- LSIPRM_etime.append(float(values[5]))
- LSIPRM_etime_err.append(float(values[6]))
- #LSIPRM_query_size = int(values[7])
- #LSIPRM_response_size = int(values[8])
- if(PLOT_ZEROTRACE):
- with open(LF_LSOPRM, 'r') as lfile:
- for line in lfile:
- values=line.split(',')
- LSOPRM_gtime.append(float(values[1]))
- LSOPRM_gtime_err.append(float(values[2]))
- LSOPRM_ptime.append(float(values[3]))
- LSOPRM_ptime_err.append(float(values[4]))
- LSOPRM_etime.append(float(values[5]))
- LSOPRM_etime_err.append(float(values[6]))
- LSOPRM_query_size.append(int(values[7]))
- LSOPRM_response_size.append(int(values[8]))
- #SealPIR logs don't contain N
- with open(LF_SEALPIR, 'r') as lfile:
- for line in lfile:
- values = line.split(',')
- SealPIR_gtime.append(float(values[0]))
- SealPIR_gtime_err.append(float(values[1]))
- SealPIR_ptime.append(float(values[2]))
- SealPIR_ptime_err.append(float(values[3]))
- SealPIR_etime.append(float(values[4]))
- SealPIR_etime_err.append(float(values[5]))
- SealPIR_query_size.append(int(values[6]))
- SealPIR_response_size.append(int(values[7]))
- SealPIR_PPT=float(values[8])
- ########################
- XPIR_QE_TIME=[]
- XPIR_RE_TIME=[]
- XPIR_PQ_TIME=[]
- XPIR_REQUEST_SIZE=[]
- XPIR_RESPONSE_SIZE=[]
- XPIR_QE_STD=[]
- XPIR_RE_STD=[]
- XPIR_PQ_STD=[]
- XPIR_CLIENT_TIME=[]
- XPIR_CLIENT_STD=[]
- XPIR_d=[]
- XPIR_alpha=[]
- for n in N:
- FILE_NAME=FOLDER_XPIR+"XPIR_"+str(n)+"_"+str(DESC_SIZE)+"_0"
- qe_time=[]
- re_time=[]
- pq_time=[]
- client_time=[]
- request_size=0
- response_size=0
- d=0
- alpha=0
- with open(FILE_NAME,'r') as file_handle:
- ctr=0
- for line in file_handle:
- if(ctr!=0):
- words=(line.strip()).split(',')
- qe_time.append(float(words[0]))
- d=int(words[4])
- alpha=int(words[5])
- pq_time.append(float(words[6]))
- re_time.append(float(words[1]))
- client_time.append(float(words[0])+float(words[1]))
- request_size=(float(words[2]))
- response_size=(float(words[3]))
- ctr=ctr+1
- XPIR_REQUEST_SIZE.append(request_size)
- XPIR_RESPONSE_SIZE.append(response_size)
- XPIR_QE_TIME.append(np.mean(qe_time))
- XPIR_PQ_TIME.append(np.mean(pq_time))
- XPIR_RE_TIME.append(np.mean(re_time))
- XPIR_CLIENT_TIME.append(np.mean(client_time))
- XPIR_QE_STD.append(np.std(qe_time))
- XPIR_PQ_STD.append(np.std(pq_time))
- XPIR_RE_STD.append(np.std(re_time))
- XPIR_CLIENT_STD.append(np.std(client_time))
- XPIR_d.append(d)
- XPIR_alpha.append(alpha)
- ########################
- LSIPRM_ctime = np.add(LSIPRM_gtime, LSIPRM_etime)
- LSIPRM_ctime_err = np.add(LSIPRM_gtime_err, LSIPRM_etime_err)
- LSOPRM_ctime = np.add(LSOPRM_gtime, LSOPRM_etime)
- LSOPRM_ctime_err = np.add(LSOPRM_gtime_err, LSOPRM_etime_err)
- PathORAM_ctime = np.add(PathORAM_gtime, PathORAM_etime)
- PathORAM_ctime_err = np.add(PathORAM_gtime_err, PathORAM_etime_err)
- CircuitORAM_ctime = np.add(CircuitORAM_gtime, CircuitORAM_etime)
- CircuitORAM_ctime_err = np.add(CircuitORAM_gtime_err, CircuitORAM_etime_err)
- XPIR_ctime = np.add(XPIR_QE_TIME, XPIR_RE_TIME)
- XPIR_ctime_err = np.add(XPIR_QE_STD, XPIR_RE_STD)
- SealPIR_ctime = np.add(SealPIR_gtime, SealPIR_etime)
- SealPIR_ctime_err = np.add(SealPIR_gtime_err, SealPIR_etime_err)
- LSIPRM_time = np.add(LSIPRM_ctime, LSIPRM_ptime)
- LSIPRM_time_err = np.add(LSIPRM_ctime_err, LSIPRM_ptime_err)
- LSOPRM_time = np.add(LSOPRM_ctime, LSOPRM_ptime)
- LSOPRM_time_err = np.add(LSOPRM_ctime_err, LSOPRM_ptime_err)
- PathORAM_time = np.add(PathORAM_ctime, PathORAM_ptime)
- PathORAM_time_err = np.add(PathORAM_ctime_err, PathORAM_ptime_err)
- CircuitORAM_time = np.add(CircuitORAM_ctime, CircuitORAM_ptime)
- CircuitORAM_time_err = np.add(CircuitORAM_ctime_err, CircuitORAM_ptime_err)
- XPIR_time = np.add(XPIR_ctime, XPIR_PQ_TIME)
- XPIR_time_err = np.add(XPIR_ctime_err, XPIR_PQ_STD)
- SealPIR_time = np.add(SealPIR_ctime, SealPIR_ptime)
- SealPIR_time_err = np.add(SealPIR_ctime_err, SealPIR_ptime_err)
- plt.xlabel('Number of Hidden Service Descriptors')
- plt.ylabel('Server computation time per query (in ms)')
- plt.grid(True)
- plt.yscale('log')
- plt.xscale('log')
- c_ctr=0
- if(PLOT_PATHORAM):
- points1 = plt.plot(N, PathORAM_ptime, POINT_STYLES[c_ctr], label='PathORAM', color = str("C")+str(c_ctr))
- if(PLOT_CIRCUITORAM):
- points2 = plt.plot(N, CircuitORAM_ptime, POINT_STYLES[c_ctr+1], label='CircuitORAM', color = str("C")+str(c_ctr+1))
- if(PLOT_LSIPRM):
- points3 = plt.plot(N, LSIPRM_ptime, POINT_STYLES[c_ctr+2], label='Linear Scan (inside PRM)', color = str("C")+str(c_ctr+2))
- if(PLOT_ZEROTRACE):
- points4 = plt.plot(N, LSOPRM_ptime, POINT_STYLES[c_ctr+3], label='Linear Scan (outside PRM)', color = str("C")+str(c_ctr+3))
- points5 = plt.plot(N, XPIR_PQ_TIME, POINT_STYLES[c_ctr+4], label='XPIR', color = str("C")+str(c_ctr+4))
- points6 = plt.plot(N, SealPIR_ptime, POINT_STYLES[c_ctr+5], label='SealPIR', color = str("C")+str(c_ctr+5))
- points7 = plt.plot(N, SealPIR_ptime, POINT_STYLES[c_ctr+6], label='Trivial PIR', color = str("C")+str(c_ctr+6))
- if(PLOT_PATHORAM):
- errbar1 = plt.errorbar(N, PathORAM_ptime, PathORAM_ptime_err, None, 'r', ls='none', mew=3)
- if(PLOT_CIRCUITORAM):
- errbar2 = plt.errorbar(N, CircuitORAM_ptime, CircuitORAM_ptime_err, None, 'r', ls='none', mew=3)
- if(PLOT_LSIPRM):
- errbar3 = plt.errorbar(N, LSIPRM_ptime, LSIPRM_ptime_err, None, 'r', ls='none', mew=3)
- if(PLOT_ZEROTRACE):
- errbar4 = plt.errorbar(N, LSOPRM_ptime, LSOPRM_ptime_err, None, 'r', ls='none', mew=3)
- errbar5 = plt.errorbar(N, XPIR_PQ_TIME, XPIR_PQ_STD, None, 'r', ls='none', mew=3)
- errbar6 = plt.errorbar(N, SealPIR_ptime, SealPIR_ptime_err , None, 'r', ls='none', mew=3)
- if(PLOT_PATHORAM):
- plt.setp(points1, 'mew', '3.0')
- if(PLOT_CIRCUITORAM):
- plt.setp(points2, 'mew', '3.0')
- if(PLOT_LSIPRM):
- plt.setp(points3, 'mew', '3.0')
- if(PLOT_ZEROTRACE):
- plt.setp(points4, 'mew', '3.0')
- plt.setp(points5, 'mew', '3.0')
- plt.setp(points6, 'mew', '3.0')
- plt.setp(points7, 'mew', '0.0')
- #plt.setp(line1, 'linewidth', '2.0')
- #plt.setp(line2, 'linewidth', '2.0')
- ax = plt.subplot()
- handles, labels = ax.get_legend_handles_labels()
- labels_sort = [3,4,5,6,2,1,7]
- hl = sorted(zip(handles, labels, labels_sort),
- key=operator.itemgetter(2))
- handles2, labels2, labels_sort= zip(*hl)
- #ax.legend(handles2, labels2, loc = 7)
- plt.title('Server computation time (in ms) vs \nnumber of hidden service descriptors')
- ax.legend(handles2, labels2, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=7, shadow=True, handletextpad=0.1, columnspacing=0.5)
- plt.savefig('server_time_microbenchmark.png', bbox_inches='tight')
- plt.close()
- ############################################################
- plt.xlabel('Number of Hidden Service Descriptors')
- plt.ylabel('Client query generation time per query (in ms)')
- plt.grid(True)
- plt.yscale('log')
- plt.xscale('log')
- c_ctr=0
- if(PLOT_PATHORAM):
- points1 = plt.plot(N, PathORAM_ctime, POINT_STYLES[c_ctr], label='PathORAM', color = str("C")+str(c_ctr))
- if(PLOT_CIRCUITORAM):
- points2 = plt.plot(N, CircuitORAM_ctime, POINT_STYLES[c_ctr+1], label='CircuitORAM', color = str("C")+str(c_ctr+1))
- if(PLOT_LSIPRM):
- points3 = plt.plot(N, LSIPRM_ctime, POINT_STYLES[c_ctr+2], label='Linear Scan (inside PRM)', color = str("C")+str(c_ctr+2))
- if(PLOT_ZEROTRACE):
- points4 = plt.plot(N, LSOPRM_gtime, POINT_STYLES[c_ctr+3], label='ZeroTrace', color = str("C")+str(c_ctr+3))
- points5 = plt.plot(N, XPIR_QE_TIME, POINT_STYLES[c_ctr+4], label='XPIR', color = str("C")+str(c_ctr+4))
- points6 = plt.plot(N, SealPIR_gtime, POINT_STYLES[c_ctr+5], label='SealPIR', color = str("C")+str(c_ctr+5))
- if(PLOT_PATHORAM):
- errbar1 = plt.errorbar(N, PathORAM_ctime, PathORAM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_CIRCUITORAM):
- errbar2 = plt.errorbar(N, CircuitORAM_ctime, CircuitORAM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_LSIPRM):
- errbar3 = plt.errorbar(N, LSIPRM_ctime, LSIPRM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_ZEROTRACE):
- errbar4 = plt.errorbar(N, LSOPRM_gtime, LSOPRM_gtime_err, None, 'r', ls='none', mew=3)
- errbar5 = plt.errorbar(N, XPIR_QE_TIME, XPIR_QE_STD, None, 'r', ls='none', mew=3)
- errbar6 = plt.errorbar(N, SealPIR_gtime, SealPIR_gtime_err , None, 'r', ls='none', mew=3)
- if(PLOT_PATHORAM):
- plt.setp(points1, 'mew', '3.0')
- if(PLOT_CIRCUITORAM):
- plt.setp(points2, 'mew', '3.0')
- if(PLOT_LSIPRM):
- plt.setp(points3, 'mew', '3.0')
- if(PLOT_ZEROTRACE):
- plt.setp(points4, 'mew', '3.0')
- plt.setp(points5, 'mew', '3.0')
- plt.setp(points6, 'mew', '3.0')
- #plt.setp(line1, 'linewidth', '2.0')
- #plt.setp(line2, 'linewidth', '2.0')
- ax = plt.subplot()
- handles, labels = ax.get_legend_handles_labels()
- labels_sort = [3,2,1]
- hl = sorted(zip(handles, labels, labels_sort),
- key=operator.itemgetter(2))
- handles2, labels2, labels_sort= zip(*hl)
- #ax.legend(handles2, labels2, loc = 7)
- plt.title('Client query generation time (in ms) \nvs number of hidden service descriptors')
- ax.legend(handles2, labels2, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=2, shadow=True)
- plt.savefig('client_query_time_microbenchmark.png', bbox_inches='tight')
- plt.close()
- print("Done with client query time graph..")
- ############################################################
- plt.xlabel('Number of Hidden Service Descriptors')
- plt.ylabel('Client reply extraction time per query (in ms)')
- plt.grid(True)
- plt.yscale('log')
- plt.xscale('log')
- c_ctr=0
- if(PLOT_PATHORAM):
- points1 = plt.plot(N, PathORAM_ctime, POINT_STYLES[c_ctr], label='PathORAM', color = str("C")+str(c_ctr))
- if(PLOT_CIRCUITORAM):
- points2 = plt.plot(N, CircuitORAM_ctime, POINT_STYLES[c_ctr+1], label='CircuitORAM', color = str("C")+str(c_ctr+1))
- if(PLOT_LSIPRM):
- points3 = plt.plot(N, LSIPRM_ctime, POINT_STYLES[c_ctr+2], label='Linear Scan (inside PRM)', color = str("C")+str(c_ctr+2))
- if(PLOT_ZEROTRACE):
- points4 = plt.plot(N, LSOPRM_etime, POINT_STYLES[c_ctr+3], label='ZeroTrace', color = str("C")+str(c_ctr+3))
- points5 = plt.plot(N, XPIR_RE_TIME, POINT_STYLES[c_ctr+4], label='XPIR', color = str("C")+str(c_ctr+4))
- points6 = plt.plot(N, SealPIR_etime, POINT_STYLES[c_ctr+5], label='SealPIR', color = str("C")+str(c_ctr+5))
- if(PLOT_PATHORAM):
- errbar1 = plt.errorbar(N, PathORAM_ctime, PathORAM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_CIRCUITORAM):
- errbar2 = plt.errorbar(N, CircuitORAM_ctime, CircuitORAM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_LSIPRM):
- errbar3 = plt.errorbar(N, LSIPRM_ctime, LSIPRM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_ZEROTRACE):
- errbar4 = plt.errorbar(N, LSOPRM_etime, LSOPRM_etime_err, None, 'r', ls='none', mew=3)
- errbar5 = plt.errorbar(N, XPIR_RE_TIME, XPIR_RE_STD, None, 'r', ls='none', mew=3)
- errbar6 = plt.errorbar(N, SealPIR_etime, SealPIR_etime_err , None, 'r', ls='none', mew=3)
- if(PLOT_PATHORAM):
- plt.setp(points1, 'mew', '3.0')
- if(PLOT_CIRCUITORAM):
- plt.setp(points2, 'mew', '3.0')
- if(PLOT_LSIPRM):
- plt.setp(points3, 'mew', '3.0')
- if(PLOT_ZEROTRACE):
- plt.setp(points4, 'mew', '3.0')
- plt.setp(points5, 'mew', '3.0')
- plt.setp(points6, 'mew', '3.0')
- #plt.setp(line1, 'linewidth', '2.0')
- #plt.setp(line2, 'linewidth', '2.0')
- ax = plt.subplot()
- handles, labels = ax.get_legend_handles_labels()
- labels_sort = [3,2,1]
- hl = sorted(zip(handles, labels, labels_sort),
- key=operator.itemgetter(2))
- handles2, labels2, labels_sort= zip(*hl)
- #ax.legend(handles2, labels2, loc = 7)
- plt.title('Client reply extraction time (in ms) \nvs number of hidden service descriptors')
- ax.legend(handles2, labels2, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=2, shadow=True)
- plt.savefig('client_reply_time_microbenchmark.png', bbox_inches='tight')
- plt.close()
- print("Done with client reply extraction time graph..")
- ############################################################
- plt.xlabel('Number of Hidden Service Descriptors')
- plt.ylabel('Client computation time per query (in ms)')
- plt.grid(True)
- plt.yscale('log')
- plt.xscale('log')
- c_ctr=0
- if(PLOT_PATHORAM):
- points1 = plt.plot(N, PathORAM_ctime, POINT_STYLES[c_ctr], label='PathORAM', color = str("C")+str(c_ctr))
- if(PLOT_CIRCUITORAM):
- points2 = plt.plot(N, CircuitORAM_ctime, POINT_STYLES[c_ctr+1], label='CircuitORAM', color = str("C")+str(c_ctr+1))
- if(PLOT_LSIPRM):
- points3 = plt.plot(N, LSIPRM_ctime, POINT_STYLES[c_ctr+2], label='Linear Scan (inside PRM)', color = str("C")+str(c_ctr+2))
- if(PLOT_ZEROTRACE):
- points4 = plt.plot(N, LSOPRM_ctime, POINT_STYLES[c_ctr+3], label='ZeroTrace', color = str("C")+str(c_ctr+3))
- points5 = plt.plot(N, XPIR_ctime, POINT_STYLES[c_ctr+4], label='XPIR', color = str("C")+str(c_ctr+4))
- points6 = plt.plot(N, SealPIR_ctime, POINT_STYLES[c_ctr+5], label='SealPIR', color = str("C")+str(c_ctr+5))
- if(PLOT_PATHORAM):
- errbar1 = plt.errorbar(N, PathORAM_ctime, PathORAM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_CIRCUITORAM):
- errbar2 = plt.errorbar(N, CircuitORAM_ctime, CircuitORAM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_LSIPRM):
- errbar3 = plt.errorbar(N, LSIPRM_ctime, LSIPRM_ctime_err, None, 'r', ls='none', mew=3)
- if(PLOT_ZEROTRACE):
- errbar4 = plt.errorbar(N, LSOPRM_ctime, LSOPRM_ctime_err, None, 'r', ls='none', mew=3)
- errbar5 = plt.errorbar(N, XPIR_ctime, XPIR_ctime_err, None, 'r', ls='none', mew=3)
- errbar6 = plt.errorbar(N, SealPIR_ctime, SealPIR_ctime_err , None, 'r', ls='none', mew=3)
- if(PLOT_PATHORAM):
- plt.setp(points1, 'mew', '3.0')
- if(PLOT_CIRCUITORAM):
- plt.setp(points2, 'mew', '3.0')
- if(PLOT_LSIPRM):
- plt.setp(points3, 'mew', '3.0')
- if(PLOT_ZEROTRACE):
- plt.setp(points4, 'mew', '3.0')
- plt.setp(points5, 'mew', '3.0')
- plt.setp(points6, 'mew', '3.0')
- #plt.setp(line1, 'linewidth', '2.0')
- #plt.setp(line2, 'linewidth', '2.0')
- ax = plt.subplot()
- handles, labels = ax.get_legend_handles_labels()
- labels_sort = [3,2,1]
- hl = sorted(zip(handles, labels, labels_sort),
- key=operator.itemgetter(2))
- handles2, labels2, labels_sort= zip(*hl)
- #ax.legend(handles2, labels2, loc = 7)
- plt.title('Client computation time (in ms) vs \nnumber of hidden service descriptors')
- ax.legend(handles2, labels2, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=2, shadow=True)
- plt.savefig('client_time_microbenchmark.png', bbox_inches='tight')
- plt.close()
- print("Done with client computation time graph..")
- ###################################################################
- plt.xlabel('Number of Hidden Service Descriptors')
- plt.ylabel('Total time per query (in ms)')
- plt.grid(True)
- plt.yscale('log')
- plt.xscale('log')
- c_ctr=0
- if(PLOT_PATHORAM):
- points1 = plt.plot(N, PathORAM_time, POINT_STYLES[c_ctr], label='PathORAM', color = str("C")+str(c_ctr))
- if(PLOT_CIRCUITORAM):
- points2 = plt.plot(N, CircuitORAM_time, POINT_STYLES[c_ctr+1], label='CircuitORAM', color = str("C")+str(c_ctr+1))
- if(PLOT_LSIPRM):
- points3 = plt.plot(N, LSIPRM_time, POINT_STYLES[c_ctr+2], label='Linear Scan (inside PRM)', color = str("C")+str(c_ctr+2))
- if(PLOT_ZEROTRACE):
- points4 = plt.plot(N, LSOPRM_time, POINT_STYLES[c_ctr+3], label='Linear Scan (outside PRM)', color = str("C")+str(c_ctr+3))
- points5 = plt.plot(N, XPIR_time, POINT_STYLES[c_ctr+4], label='XPIR', color = str("C")+str(c_ctr+4))
- points6 = plt.plot(N, SealPIR_time, POINT_STYLES[c_ctr+5], label='SealPIR', color = str("C")+str(c_ctr+5))
- #points7 = plt.plot(N, SealPIR_D1_time, POINT_STYLES[c_ctr+6], label='SealPIR D=1', color = str("C")+str(c_ctr+5))
- if(PLOT_PATHORAM):
- errbar1 = plt.errorbar(N, PathORAM_time, PathORAM_time_err, None, 'r', ls='none', mew=3)
- if(PLOT_CIRCUITORAM):
- errbar2 = plt.errorbar(N, CircuitORAM_time, CircuitORAM_time_err, None, 'r', ls='none', mew=3)
- if(PLOT_LSIPRM):
- errbar3 = plt.errorbar(N, LSIPRM_time, LSIPRM_time_err, None, 'r', ls='none', mew=3)
- if(PLOT_ZEROTRACE):
- errbar4 = plt.errorbar(N, LSOPRM_time, LSOPRM_time_err, None, 'r', ls='none', mew=3)
- errbar5 = plt.errorbar(N, XPIR_time, XPIR_time_err, None, 'r', ls='none', mew=3)
- errbar6 = plt.errorbar(N, SealPIR_time, SealPIR_time_err , None, 'r', ls='none', mew=3)
- if(PLOT_PATHORAM):
- plt.setp(points1, 'mew', '3.0')
- if(PLOT_CIRCUITORAM):
- plt.setp(points2, 'mew', '3.0')
- if(PLOT_LSIPRM):
- plt.setp(points3, 'mew', '3.0')
- if(PLOT_ZEROTRACE):
- plt.setp(points4, 'mew', '3.0')
- plt.setp(points5, 'mew', '3.0')
- plt.setp(points6, 'mew', '3.0')
- #plt.setp(points7, 'mew', '3.0')
- #plt.setp(line1, 'linewidth', '2.0')
- #plt.setp(line2, 'linewidth', '2.0')
- ax = plt.subplot()
- handles, labels = ax.get_legend_handles_labels()
- #labels_sort = [4,5,6,7,3,2,1]
- labels_sort = [3,4,5,6,2,1]
- hl = sorted(zip(handles, labels, labels_sort),
- key=operator.itemgetter(2))
- handles2, labels2, labels_sort= zip(*hl)
- #ax.legend(handles2, labels2, loc = 7)
- plt.title('Total computation time (in ms) vs number of hidden service descriptors')
- ax.legend(handles2, labels2, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=2, shadow=True)
- plt.savefig('total_time_microbenchmark.png', bbox_inches='tight')
- plt.close()
- print("Done with total time graph..")
- ###################################################################
- plt.xlabel('Number of Hidden Service Descriptors')
- plt.ylabel('Request size per query (in bytes)')
- plt.grid(True)
- plt.yscale('log')
- plt.xscale('log')
- c_ctr=0
- if(PLOT_ZEROTRACE):
- points4 = plt.plot(N, LSOPRM_query_size, POINT_STYLES[c_ctr+3], label='ZeroTrace', color = str("C")+str(c_ctr+3))
- points5 = plt.plot(N, XPIR_REQUEST_SIZE, POINT_STYLES[c_ctr+4], label='XPIR', color = str("C")+str(c_ctr+4))
- points6 = plt.plot(N, SealPIR_query_size, POINT_STYLES[c_ctr+5], label='SealPIR', color = str("C")+str(c_ctr+5))
- if(PLOT_ZEROTRACE):
- plt.setp(points4, 'mew', '3.0')
- plt.setp(points5, 'mew', '3.0')
- plt.setp(points6, 'mew', '3.0')
- ax = plt.subplot()
- handles, labels = ax.get_legend_handles_labels()
- labels_sort = [3,1,2]
- hl = sorted(zip(handles, labels, labels_sort),
- key=operator.itemgetter(2))
- handles2, labels2, labels_sort= zip(*hl)
- #ax.legend(handles2, labels2, loc = 7)
- plt.title('Request size (in bytes) vs \nnumber of hidden service descriptors')
- ax.legend(handles2, labels2, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=2, shadow=True)
- plt.savefig('request_size.png', bbox_inches='tight')
- plt.close()
- print("Done with request size graph..")
- ###################################################################
- plt.xlabel('Number of Hidden Service Descriptors')
- plt.ylabel('Response size per query (in bytes)')
- plt.grid(True)
- plt.yscale('log')
- plt.xscale('log')
- c_ctr=0
- TrivialPIR_size = np.multiply(N, DESC_SIZE)
- if(PLOT_ZEROTRACE):
- points4 = plt.plot(N, LSOPRM_response_size, POINT_STYLES[c_ctr+3], label='ZeroTrace', color = str("C")+str(c_ctr+3))
- points5 = plt.plot(N, XPIR_RESPONSE_SIZE, POINT_STYLES[c_ctr+4], label='XPIR', color = str("C")+str(c_ctr+4))
- points6 = plt.plot(N, SealPIR_response_size, POINT_STYLES[c_ctr+5], label='SealPIR', color = str("C")+str(c_ctr+5))
- points7 = plt.plot(N, TrivialPIR_size, POINT_STYLES[c_ctr+6], label='Trivial PIR', color = str("C")+str(c_ctr+6))
- if(PLOT_ZEROTRACE):
- plt.setp(points4, 'mew', '3.0')
- plt.setp(points5, 'mew', '3.0')
- plt.setp(points6, 'mew', '3.0')
- plt.setp(points7, 'mew', '3.0')
- ax = plt.subplot()
- handles, labels = ax.get_legend_handles_labels()
- labels_sort = [4,2,3,1]
- hl = sorted(zip(handles, labels, labels_sort),
- key=operator.itemgetter(2))
- handles2, labels2, labels_sort= zip(*hl)
- #ax.legend(handles2, labels2, loc = 7)
- plt.title('Response size (in bytes) vs \nnumber of hidden service descriptors')
- ax.legend(handles2, labels2, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=4, shadow=True)
- plt.savefig('response_size.png', bbox_inches='tight')
- plt.close()
- print("Done with response size graph..")
- ###################################################################
- plt.xlabel('Number of Hidden Service Descriptors')
- plt.ylabel('Total bandwidth per query (in bytes)')
- plt.grid(True)
- plt.yscale('log')
- plt.xscale('log')
- c_ctr=0
- LSOPRM_bw = np.add(LSOPRM_query_size, LSOPRM_response_size)
- XPIR_bw = np.add(XPIR_REQUEST_SIZE, XPIR_RESPONSE_SIZE)
- SealPIR_bw = np.add(SealPIR_query_size, SealPIR_response_size)
- if(PLOT_ZEROTRACE):
- points4 = plt.plot(N, LSOPRM_bw, POINT_STYLES[c_ctr+3], label='ZeroTrace', color = str("C")+str(c_ctr+3))
- points5 = plt.plot(N, XPIR_bw, POINT_STYLES[c_ctr+4], label='XPIR', color = str("C")+str(c_ctr+4))
- points6 = plt.plot(N, SealPIR_bw, POINT_STYLES[c_ctr+5], label='SealPIR', color = str("C")+str(c_ctr+5))
- points7 = plt.plot(N, TrivialPIR_size, POINT_STYLES[c_ctr+6], label='Trivial PIR', color = str("C")+str(c_ctr+6))
- if(PLOT_ZEROTRACE):
- plt.setp(points4, 'mew', '3.0')
- plt.setp(points5, 'mew', '3.0')
- plt.setp(points6, 'mew', '3.0')
- plt.setp(points7, 'mew', '3.0')
- ax = plt.subplot()
- handles, labels = ax.get_legend_handles_labels()
- #labels_sort = [4,1,3,2]
- labels_sort = [4,3,2,1]
- hl = sorted(zip(handles, labels, labels_sort),
- key=operator.itemgetter(2))
- handles2, labels2, labels_sort= zip(*hl)
- #ax.legend(handles2, labels2, loc = 7)
- plt.title('Total bandwidth required (in bytes) vs \nnumber of hidden service descriptors')
- ax.legend(handles2, labels2, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=4, shadow=True)
- plt.savefig('total_bw.png', bbox_inches='tight')
- plt.close()
- print("Done with total bandwidth graph..")
- ###################################################################
|