# The figure 1 initialization time with all database sizes and block size 512 KB
import os
import math
from matplotlib import pyplot as plt
import re
import numpy as np
from pyparsing import col
# step 1 select the corresponding files from the totalLog directory
# step 2 summarize all the elements in above files and get their average
# step 3 draw the figure with database sizes as its x-axis and delay as it y-axis
# step 4 draw the breakdown cost for the Jump-ORAM, Path-ORAM and S3ORAM
def takeDBsizeJump(ele):
pos = ele.find('GB')
db = float(ele[:pos])
return db
def takeBlockSize(ele):
return float(re.findall(r"_(.+?)KB", ele)[0])
def takeDBsizeS3(ele):
return float(re.findall(r"KB_(.+?)GB_", ele)[0])
# The Jump-ORAM
path = 'totalLog'
#init_x_axis = ['0.5', '1', '2.5', '5', '10', '20']
init_x_axis = [0.5, 1, 2.5, 5, 10, 20]
#init_x_axis_vary_blocksize = ['4', '8', '16', '32', '64', '128', '256', '512']
init_x_axis_vary_blocksize = [4, 8, 16, 32, 64, 128, 256, 512]
# Jump-ORAM
init_jump_y_axis = []
init_jump_breakdown_y_axis = []
jump_init_512KB_names = []
jump_init_20GB_names = []
init_jump_y_axis_20GB = []
init_jump_breakdown_y_axis_20GB = []
# Path-ORAM
init_path_y_axis = []
init_path_breakdown_y_axis = []
path_init_512KB_names = []
path_init_20GB_names = []
init_path_y_axis_20GB = []
init_path_breakdown_y_axis_20GB = []
# S3ORAM
init_s3_y_axis = []
init_s3_breakdown_y_axis = []
s3_init_512KB_names = []
s3_init_20GB_names = []
init_s3_y_axis_20GB = []
init_s3_breakdown_y_axis_20GB = []
#direct_access
init_direct_y_axis = []
init_direct_breakdown_y_axis = []
direct_init_512KB_names = []
direct_init_20GB_names = []
init_direct_y_axis_20GB = []
init_direct_breakdown_y_axis_20GB = []
path_list = os.listdir(path)
for filename in path_list:
fname_list = filename.split('_')
if 'JUMP' in fname_list:
if 'build' in fname_list:
if "512KB" in fname_list:
jump_init_512KB_names.append(filename)
if '20GB' in fname_list:
jump_init_20GB_names.append(filename)
if 'Path' in fname_list:
if 'build' in fname_list:
for fname in fname_list:
if "512KB" in fname:
path_init_512KB_names.append(filename)
if '20GB' in fname_list:
path_init_20GB_names.append(filename)
if 'S3ORAM' in fname_list:
if 'build' in fname_list:
if "512KB" in fname_list:
s3_init_512KB_names.append(filename)
if "20GB" in fname_list:
s3_init_20GB_names.append(filename)
if 'DIRECT' in fname_list:
if 'build' in fname_list:
if "512KB" in fname_list:
direct_init_512KB_names.append(filename)
if "20GB" in fname_list:
direct_init_20GB_names.append(filename)
# sort out the names with 20GB in increasing order
path_init_20GB_names.sort(key = takeBlockSize)
jump_init_20GB_names.sort(key = takeBlockSize)
direct_init_20GB_names.sort(key = takeBlockSize)
s3_init_20GB_names.sort(key = takeBlockSize, reverse = True)
path_init_20GB_names.pop()
jump_init_20GB_names.pop()
direct_init_20GB_names.pop()
s3_init_20GB_names.pop()
'''The presentation for 20 GB'''
# print(s3_init_20GB_names)
# print(path_init_20GB_names)
# print(jump_init_20GB_names)
# print(direct_init_20GB_names)
path_init_512KB_names.sort(key = takeDBsizeJump)
jump_init_512KB_names.sort(key = takeDBsizeJump)
direct_init_512KB_names.sort(key = takeDBsizeJump)
s3_init_512KB_names.sort(key = takeDBsizeS3)
# '''test codes'''
print(s3_init_512KB_names)
print(path_init_512KB_names)
print(jump_init_512KB_names)
print(direct_init_512KB_names)
def getAxisY(names, y_axis, breakdown_y_axis):
for name in names:
file_name = path + '/' + name
sum = 0.0
breakdown_y_axis_ele = []
with open(file_name, 'r') as f:
data = f.read().split()
for d in data:
breakdown_y_axis_ele.append(float(d) / math.pow(10, 9))
sum += float(d)
y_axis.append(sum / math.pow(10, 9))
breakdown_y_axis.append(breakdown_y_axis_ele)
def getAxisY_jump(names, y_axis, breakdown_y_axis):
for name in names:
file_name = path + '/' + name
sum = 0.0
breakdown_y_axis_ele = []
with open(file_name, 'r') as f:
data = f.read().split()
for d in data:
temp = float(d) * 1.5
breakdown_y_axis_ele.append(temp / math.pow(10, 9))
sum += temp
y_axis.append(sum / math.pow(10, 9))
breakdown_y_axis.append(breakdown_y_axis_ele)
# for name in jump_init_512KB_names:
# file_name = path + '/' + name
# sum = 0.0
# init_jump_breakdown_y_axis_ele = []
# with open(file_name, 'r') as f:
# data = f.read().split()
# for d in data:
# init_jump_breakdown_y_axis_ele.append(float(d) / math.pow(10, 9))
# sum += float(d)
# init_jump_y_axis.append(sum / math.pow(10, 9))
# init_jump_breakdown_y_axis.append(init_jump_breakdown_y_axis_ele)
pre_build_name = 'processedData/build_20GB_allBlock_'
#pre_build_name = 'processedData/build_512KB_allDB_'
'''write processed data into file'''
# jump-ORAM
# getAxisY_jump(jump_init_512KB_names, init_jump_y_axis, init_jump_breakdown_y_axis)
# jump_init_name = pre_build_name + "jump.txt"
# with open(jump_init_name, 'w') as f:
# f.write("The whole initialization time for all database sizes:n")
# for v in init_jump_y_axis:
# f.write(str(v) + ' ')
# f.write("nThe breakdown cost of initialization time fo all database sizes:n")
# for values in init_jump_breakdown_y_axis:
# for v in values:
# f.write(str(v) + ' ')
# f.write('n')
# for i in init_jump_breakdown_y_axis:
# print(i)
# for i in init_jump_y_axis:
# print(i)
# path-ORAM
# getAxisY(path_init_512KB_names, init_path_y_axis, init_path_breakdown_y_axis)
# path_init_name = pre_build_name + "path.txt"
# with open(path_init_name, 'w') as f:
# f.write("The whole initialization time for all database sizes:n")
# for v in init_path_y_axis:
# f.write(str(v) + ' ')
# f.write("nThe breakdown cost of initialization time fo all database sizes:n")
# for values in init_path_breakdown_y_axis:
# for v in values:
# f.write(str(v) + ' ')
# f.write('n')
'''jump-ORAM with 20GB database'''
getAxisY(jump_init_20GB_names, init_jump_y_axis_20GB, init_jump_breakdown_y_axis_20GB)
jump_init_name = pre_build_name + "jump.txt"
with open(jump_init_name, 'w') as f:
f.write("The whole initialization time for all database sizes:n")
for v in init_jump_y_axis_20GB:
f.write(str(v) + ' ')
f.write("nThe breakdown cost of initialization time fo all database sizes:n")
for values in init_jump_breakdown_y_axis_20GB:
for v in values:
f.write(str(v) + ' ')
f.write('n')
'''Path-ORAM with 20GB database'''
getAxisY(path_init_20GB_names, init_path_y_axis_20GB, init_path_breakdown_y_axis_20GB)
path_init_name = pre_build_name + "path.txt"
with open(path_init_name, 'w') as f:
f.write("The whole initialization time for all database sizes:n")
for v in init_path_y_axis_20GB:
f.write(str(v) + ' ')
f.write("nThe breakdown cost of initialization time fo all database sizes:n")
for values in init_path_breakdown_y_axis_20GB:
for v in values:
f.write(str(v) + ' ')
f.write('n')
# s3ORAM
# getAxisY(s3_init_512KB_names, init_s3_y_axis, init_s3_breakdown_y_axis)
# s3_init_name = pre_build_name + "s3oram.txt"
# with open(s3_init_name, 'w') as f:
# f.write("The whole initialization time for all database sizes:n")
# for v in init_s3_y_axis:
# f.write(str(v) + ' ')
# f.write("nThe breakdown cost of initialization time fo all database sizes:n")
# for values in init_s3_breakdown_y_axis:
# for v in values:
# f.write(str(v) + ' ')
# f.write('n')
'''S3-ORAM with 20GB database'''
getAxisY(s3_init_20GB_names, init_s3_y_axis_20GB, init_s3_breakdown_y_axis_20GB)
s3_init_name = pre_build_name + "s3oram.txt"
with open(s3_init_name, 'w') as f:
f.write("The whole initialization time for all database sizes:n")
for v in init_s3_y_axis_20GB:
f.write(str(v) + ' ')
f.write("nThe breakdown cost of initialization time fo all database sizes:n")
for values in init_s3_breakdown_y_axis_20GB:
for v in values:
f.write(str(v) + ' ')
f.write('n')
# direct_access
# getAxisY(direct_init_512KB_names, init_direct_y_axis, init_direct_breakdown_y_axis)
# direct_init_name = pre_build_name + "direct.txt"
# with open(direct_init_name, 'w') as f:
# f.write("The whole initialization time for all database sizes:n")
# for v in init_direct_y_axis:
# f.write(str(v) + ' ')
# f.write("nThe breakdown cost of initialization time fo all database sizes:n")
# for values in init_direct_breakdown_y_axis:
# for v in values:
# f.write(str(v) + ' ')
# f.write('n')
'''direct-ORAM with 20GB database'''
getAxisY(direct_init_20GB_names, init_direct_y_axis_20GB, init_direct_breakdown_y_axis_20GB)
direct_init_name = pre_build_name + "direct.txt"
with open(direct_init_name, 'w') as f:
f.write("The whole initialization time for all database sizes:n")
for v in init_direct_y_axis_20GB:
f.write(str(v) + ' ')
f.write("nThe breakdown cost of initialization time fo all database sizes:n")
for values in init_direct_breakdown_y_axis_20GB:
for v in values:
f.write(str(v) + ' ')
f.write('n')
# draw the line graph
'''512KB'''
# plt.plot(init_x_axis, init_path_y_axis, 'x:b', label = '$Path$-$ORAM$')
# plt.plot(init_x_axis, init_s3_y_axis, marker = 'o', linestyle = '--' ,color = "#800080", label = '$S^{3}$'+ '$ORAM$')
# plt.plot(init_x_axis, init_jump_y_axis, 's-b', label = '$Jump$-$ORAM$')
# plt.plot(init_x_axis, init_direct_y_axis, '^-.r', label = "$Direct$-$Access$")
# plt.legend()
# plt.xlabel("Database size (GB)")
# plt.ylabel("Delay (second)")
# plt.show()
'''20GB'''
plt.plot(init_x_axis_vary_blocksize, init_path_y_axis_20GB, 'x:b', label = '$Path$-$ORAM$')
plt.plot(init_x_axis_vary_blocksize, init_s3_y_axis_20GB, marker = 'o', linestyle = '--' ,color = "#800080", label = '$S^{3}$'+ '$ORAM$')
plt.plot(init_x_axis_vary_blocksize, init_jump_y_axis_20GB, 's-b', label = '$Jump$-$ORAM$')
plt.plot(init_x_axis_vary_blocksize, init_direct_y_axis_20GB, '^-.r', label = "$Direct$-$Access$")
plt.legend()
plt.xlabel("Block size (KB)")
plt.ylabel("Delay (second)")
plt.show()
#draw three bar graph
'''Jump-ORAM'''
# layer = []
# row_num = len(init_jump_breakdown_y_axis)
# col_num = len(init_jump_breakdown_y_axis[0])
# for j in range(0, col_num):
# temp_layer = []
# for i in range(0, row_num):
# temp_layer.append(init_jump_breakdown_y_axis[i][j])
# layer.append(temp_layer)
# layer_0 = np.array(layer[0])
# layer_1 = np.array(layer[1])
# layer_2 = np.array(layer[2])
# jump_label = ['Build metadata', 'Create database', 'Send database to the server']
# p1 = plt.bar(init_x_axis, layer_0, width = 0.4, bottom=layer_1+layer_2, label=jump_label[0], color = 'red')
# p2 = plt.bar(init_x_axis, layer_1, width = 0.4, label = jump_label[1], color='orange', bottom=layer_2)
# p3 = plt.bar(init_x_axis, layer_2, width = 0.4, label = jump_label[2], color='purple')
# plt.xlabel("Database size (GB)")
# plt.ylabel("Delay (second)")
# plt.legend()
# plt.show()
'''Path-ORAM'''
# layer = []
# row_num = len(init_path_breakdown_y_axis)
# col_num = len(init_path_breakdown_y_axis[0])
# for j in range(0, col_num):
# temp_layer = []
# for i in range(0, row_num):
# temp_layer.append(init_path_breakdown_y_axis[i][j])
# layer.append(temp_layer)
# print(layer)
# layer_0 = np.array(layer[0])
# layer_1 = np.array(layer[1])
# layer_2 = np.array(layer[2])
# layer_3 = np.array(layer[3])
# path_label = ['Create database with dummy blocks', 'Build metadata','Insert real blocks into database', 'Send database to the server']
# p1 = plt.bar(init_x_axis, layer_0, width = 0.4, label=path_label[0], color = 'orange', bottom = layer_3+layer_1+layer_2)
# p2 = plt.bar(init_x_axis, layer_1, width = 0.4, label = path_label[1], color='red', bottom = layer_2+layer_3)
# p3 = plt.bar(init_x_axis, layer_2, width = 0.4, bottom=layer_3, label = path_label[2], color='orange', hatch='/')
# p4 = plt.bar(init_x_axis, layer_3, width = 0.4, label = path_label[3], color='purple')
# plt.xlabel("Database size (GB)")
# plt.ylabel("Delay (second)")
# plt.legend()
# plt.show()
'''S3-ORAM'''
# layer = []
# row_num = len(init_s3_breakdown_y_axis)
# col_num = len(init_s3_breakdown_y_axis[0])
# for j in range(0, col_num):
# temp_layer = []
# for i in range(0, row_num):
# temp_layer.append(init_s3_breakdown_y_axis[i][j])
# layer.append(temp_layer)
# print(layer)
# layer_0 = np.array(layer[0]) + np.array(layer[2])
# layer_1 = np.array(layer[1])
# layer_2 = np.array(layer[3])
# path_label = ['Build metadata','Create database', 'Send database to the server']
# p1 = plt.bar(init_x_axis, layer_0, width = 0.4, label=path_label[0], color = 'red', bottom=layer_1+layer_2)
# p2 = plt.bar(init_x_axis, layer_1, width = 0.4, label = path_label[1], color='orange', bottom=layer_2)
# p3 = plt.bar(init_x_axis, layer_2, width = 0.4, label = path_label[2], color='purple')
# plt.xlabel("Database size (GB)")
# plt.ylabel("Delay (second)")
# plt.legend()
# plt.show()
The code 2
from itertools import combinations
import os
import re
import math
from this import d
from xmlrpc import client
import matplotlib.pyplot as plt
import numpy as np
'''parameters'''
# x_axis
#access_x_axis_vary_db_size = [0.5, 1, 2.5, 5, 10, 20]
access_x_axis_vary_db_size = ['0.5', '1', '2.5', '5', '10', '20']
access_x_axis_vary_block_size = [4, 8, 16, 32, 64, 128, 256, 512]
#access_x_axis_vary_block_size = ['4', '8', '16', '32', '64', '128', '256', '512']
# files
path_directory = 'totalLog'
dir_list = os.listdir(path_directory)
# Jump-ORAM
'''varying block sizes for 20GB database'''
access_jump_y_axis_20GB_names = []
access_breakdown_jump_y_axis_20GB_names = []
access_jump_y_axis_20GB_values = []
'''varying database sizes for 512KB block size'''
access_jump_y_axis_512KB_names = []
access_breakdown_jump_y_axis_512KB_names = []
access_jump_y_axis_512KB_values = []
access_breakdown_jump_y_axis_512KB_values = []
# Direct-Access
'''varying block sizes for 20GB database'''
access_direct_y_axis_20GB_names = []
access_breakdown_direct_y_axis_20GB_names = []
access_direct_y_axis_20GB_values = []
'''varying database sizes for 512KB block size'''
access_direct_y_axis_512KB_names = []
access_breakdown_direct_y_axis_512KB_names = []
access_direct_y_axis_512KB_values = []
# Path-ORAM
'''varying block sizes for 20GB database'''
access_path_y_axis_20GB_names = []
access_breakdown_path_y_axis_20GB_names = []
access_path_y_axis_20GB_values = []
'''varying database sizes for 512KB block size'''
access_path_y_axis_512KB_names = []
access_breakdown_path_y_axis_512KB_names = []
access_path_y_axis_512KB_values = []
access_breakdown_path_y_axis_512KB_values = []
access_encrypted_path_y_axis_512KB_names = []
access_encrypted_path_y_axis_512KB_values = []
access_decrypted_path_y_axis_512KB_names = []
access_decrypted_path_y_axis_512KB_values = []
access_recvData_path_y_axis_512KB_names = []
access_recvData_path_y_axis_512KB_values = []
access_sendData_path_y_axis_512KB_names = []
access_sendData_path_y_axis_512KB_values = []
access_downToDisk_path_y_axis_512KB_names = []
access_downToDisk_path_y_axis_512KB_values = []
evict_downToDisk_path_y_axis_512KB_names = []
evict_downToDisk_path_y_axis_512KB_values = []
evict_encrypted_path_y_axis_512KB_names = []
evict_encrypted_path_y_axis_512KB_values = []
evict_decrypted_path_y_axis_512KB_names = []
evict_decrypted_path_y_axis_512KB_values = []
evict_recvData_path_y_axis_512KB_names = []
evict_recvData_path_y_axis_512KB_values = []
evict_sendData_path_y_axis_512KB_names = []
evict_sendData_path_y_axis_512KB_values = []
# S3-ORAM
'''varying block sizes for 20GB database'''
access_s3_y_axis_20GB_names = []
access_breakdown_s3_y_axis_20GB_names = []
access_s3_y_axis_20GB_values = []
access_s3_server_0_y_axis_20GB_names = []
access_s3_server_1_y_axis_20GB_names = []
access_s3_server_2_y_axis_20GB_names = []
'''varying database sizes for 512KB block size'''
access_s3_y_axis_512KB_names = []
access_s3_server_0_y_axis_512KB_names = []
access_s3_server_1_y_axis_512KB_names = []
access_s3_server_2_y_axis_512KB_names = []
access_s3_y_axis_512KB_values = []
access_breakdown_s3_y_axis_512KB_values = []
access_client_s3_y_axis_512KB_values = []
access_s3_server_0_y_axis_512KB_values = []
access_s3_server_1_y_axis_512KB_values = []
access_s3_server_2_y_axis_512KB_values = []
# functions for sorting files
def takeBlockSize(ele):
return float(re.findall(r"_(.*?)KB", ele)[0])
def takeDBSize(ele):
return float(re.findall(r"^(.*?)GB", ele)[0])
def takeDBsizeS3(ele):
return float(re.findall(r"KB_(.*?)GB", ele)[0])
# get the corresponding file names
for file_name in dir_list:
fname_list = file_name.split('_')
if 'JUMP' in fname_list:
if 'access' in fname_list:
if '20GB' in fname_list:
if 'breakdown' in fname_list:
access_breakdown_jump_y_axis_20GB_names.append(file_name)
else:
access_jump_y_axis_20GB_names.append(file_name)
if '512KB' in fname_list:
if 'breakdown' in fname_list:
access_breakdown_jump_y_axis_512KB_names.append(file_name)
else:
access_jump_y_axis_512KB_names.append(file_name)
if 'DIRECT' in fname_list:
if 'access' in fname_list:
if '20GB' in fname_list:
if 'breakdown' in fname_list:
access_breakdown_direct_y_axis_20GB_names.append(file_name)
else:
access_direct_y_axis_20GB_names.append(file_name)
if '512KB' in fname_list:
if 'breakdown' in fname_list:
access_breakdown_direct_y_axis_512KB_names.append(file_name)
else:
access_direct_y_axis_512KB_names.append(file_name)
if 'Path' in fname_list:
if 'ORAM' in fname_list:
if 'access' in fname_list:
if '20GB' in fname_list:
access_path_y_axis_20GB_names.append(file_name)
if re.findall(r"_(.*?)KB", file_name)[0] == '512':
access_path_y_axis_512KB_names.append(file_name)
else:
if 'access' in fname_list:
if re.findall(r"_(.*?)KB", file_name)[0] == '512':
if 'encrypted' in fname_list:
access_encrypted_path_y_axis_512KB_names.append(file_name)
elif 'decrypted' in fname_list:
access_decrypted_path_y_axis_512KB_names.append(file_name)
elif 'revcData' in fname_list:
access_recvData_path_y_axis_512KB_names.append(file_name)
elif 'sendData' in fname_list:
access_sendData_path_y_axis_512KB_names.append(file_name)
elif 'downToDisk' in fname_list:
if re.findall(r"_(.*?)KB", file_name)[0] == '512':
if 'evict' in fname_list:
evict_downToDisk_path_y_axis_512KB_names.append(file_name)
else:
access_downToDisk_path_y_axis_512KB_names.append(file_name)
elif 'evict' in fname_list:
if re.findall(r"_(.*?)KB", file_name)[0] == '512':
if 'encrypted' in fname_list:
evict_encrypted_path_y_axis_512KB_names.append(file_name)
elif 'decrypted' in fname_list:
evict_decrypted_path_y_axis_512KB_names.append(file_name)
elif 'recvData' in fname_list:
evict_recvData_path_y_axis_512KB_names.append(file_name)
elif 'sendData' in fname_list:
evict_sendData_path_y_axis_512KB_names.append(file_name)
if 'S3ORAM' in fname_list:
if 'access' in fname_list:
if '20GB' in fname_list:
access_s3_y_axis_20GB_names.append(file_name)
if '512KB' in fname_list:
access_s3_y_axis_512KB_names.append(file_name)
else:
if 'SERVER' in fname_list:
if '20GB' in fname_list:
if '0' in fname_list:
access_s3_server_0_y_axis_20GB_names.append(file_name)
elif '1' in fname_list:
access_s3_server_1_y_axis_20GB_names.append(file_name)
elif '2' in fname_list:
access_s3_server_2_y_axis_20GB_names.append(file_name)
if '512KB' in fname_list:
if '0' in fname_list:
access_s3_server_0_y_axis_512KB_names.append(file_name)
elif '1' in fname_list:
access_s3_server_1_y_axis_512KB_names.append(file_name)
elif '2' in fname_list:
access_s3_server_2_y_axis_512KB_names.append(file_name)
# print(access_jump_y_axis_512KB_names)
# print(access_breakdown_jump_y_axis_512KB_names)
# print(access_direct_y_axis_512KB_names)
# print(access_breakdown_direct_y_axis_512KB_names)
# print(access_path_y_axis_512KB_names)
# print(access_s3_y_axis_512KB_names)
# print(access_s3_server_0_y_axis_512KB_names)
# print(access_s3_server_1_y_axis_512KB_names)
# print(access_s3_server_2_y_axis_512KB_names)
# sort out the files list in increasing order
'''varying block sizes for 20GB database'''
access_jump_y_axis_20GB_names.sort(key = takeBlockSize)
access_breakdown_jump_y_axis_20GB_names.sort(key = takeBlockSize)
access_direct_y_axis_20GB_names.sort(key = takeBlockSize)
access_breakdown_direct_y_axis_20GB_names.sort(key = takeBlockSize)
access_path_y_axis_20GB_names.sort(key = takeBlockSize)
access_breakdown_path_y_axis_20GB_names.sort(key = takeBlockSize)
access_s3_y_axis_20GB_names.sort(key = takeBlockSize, reverse = True)
access_s3_server_0_y_axis_20GB_names.sort(key = takeBlockSize, reverse = True)
access_s3_server_1_y_axis_20GB_names.sort(key = takeBlockSize, reverse = True)
access_s3_server_2_y_axis_20GB_names.sort(key = takeBlockSize, reverse = True)
'''varying database sizes for 512KB block size'''
access_jump_y_axis_512KB_names.sort(key = takeDBSize)
access_breakdown_jump_y_axis_512KB_names.sort(key = takeDBSize)
access_direct_y_axis_512KB_names.sort(key = takeDBSize)
access_path_y_axis_512KB_names.sort(key = takeDBSize)
access_s3_y_axis_512KB_names.sort(key = takeDBsizeS3)
access_s3_server_0_y_axis_512KB_names.sort(key = takeDBsizeS3)
access_s3_server_1_y_axis_512KB_names.sort(key = takeDBsizeS3)
access_s3_server_2_y_axis_512KB_names.sort(key = takeDBsizeS3)
# the breakdown cost file for Path-ORAM
access_encrypted_path_y_axis_512KB_names.sort(key = takeDBSize)
access_decrypted_path_y_axis_512KB_names.sort(key = takeDBSize)
access_recvData_path_y_axis_512KB_names.sort(key = takeDBSize)
access_sendData_path_y_axis_512KB_names.sort(key = takeDBSize)
evict_encrypted_path_y_axis_512KB_names.sort(key = takeDBSize)
evict_decrypted_path_y_axis_512KB_names.sort(key = takeDBSize)
evict_recvData_path_y_axis_512KB_names.sort(key = takeDBSize)
evict_sendData_path_y_axis_512KB_names.sort(key = takeDBSize)
access_downToDisk_path_y_axis_512KB_names.sort(key = takeDBSize)
evict_downToDisk_path_y_axis_512KB_names.sort(key = takeDBSize)
# remove the file with 1024KB
access_jump_y_axis_20GB_names.pop()
access_breakdown_jump_y_axis_20GB_names.pop()
access_direct_y_axis_20GB_names.pop()
access_breakdown_direct_y_axis_20GB_names.pop()
access_path_y_axis_20GB_names.pop()
#access_breakdown_path_y_axis_20GB_names.pop()
access_s3_y_axis_20GB_names.pop()
access_s3_server_0_y_axis_20GB_names.pop()
access_s3_server_1_y_axis_20GB_names.pop()
access_s3_server_2_y_axis_20GB_names.pop()
'''test the breakdown cost file for Path-ORAM'''
# print(access_encrypted_path_y_axis_512KB_names)
# print(access_decrypted_path_y_axis_512KB_names)
# print(access_recvData_path_y_axis_512KB_names)
# print(access_sendData_path_y_axis_512KB_names)
# print(evict_encrypted_path_y_axis_512KB_names)
# print(evict_decrypted_path_y_axis_512KB_names)
# print(evict_recvData_path_y_axis_512KB_names)
# print(evict_sendData_path_y_axis_512KB_names)
# print(access_downToDisk_path_y_axis_512KB_names)
# print(evict_downToDisk_path_y_axis_512KB_names)
# print(access_s3_y_axis_20GB_names)
# print(access_s3_server_0_y_axis_20GB_names)
# print(access_s3_server_1_y_axis_20GB_names)
# print(access_s3_server_2_y_axis_20GB_names)
#print(access_breakdown_path_y_axis_20GB_names)
#print(access_path_y_axis_20GB_names)
# print(access_jump_y_axis_512KB_names)
#print(access_breakdown_jump_y_axis_512KB_names)
# print(access_direct_y_axis_512KB_names)
# print(access_breakdown_direct_y_axis_512KB_names)
# print(access_path_y_axis_512KB_names)
# print(access_s3_y_axis_512KB_names)
# print(access_s3_server_0_y_axis_512KB_names)
# print(access_s3_server_1_y_axis_512KB_names)
# print(access_s3_server_2_y_axis_512KB_names)
# append the breakdown cost names into access_breakdown_path_y_axis_512KB_names
access_breakdown_path_y_axis_512KB_names.append(access_encrypted_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(access_decrypted_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(access_recvData_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(access_sendData_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(evict_encrypted_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(evict_decrypted_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(evict_recvData_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(evict_sendData_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(access_downToDisk_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_names.append(evict_downToDisk_path_y_axis_512KB_names)
access_breakdown_path_y_axis_512KB_values_list = []
# append all the breakdown cost values into access_breakdown_path_y_axis_512KB_values_list
access_breakdown_path_y_axis_512KB_values_list.append(access_encrypted_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(access_decrypted_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(access_recvData_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(access_sendData_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(evict_encrypted_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(evict_decrypted_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(evict_recvData_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(evict_sendData_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(access_downToDisk_path_y_axis_512KB_values)
access_breakdown_path_y_axis_512KB_values_list.append(evict_downToDisk_path_y_axis_512KB_values)
'''collect the data from the file in above list and fill up the access_jump_y_axis_20GB_values'''
def getAxisVal(names, y_axis_values):
for name in names:
file_name = path_directory + '/' + name
with open(file_name, 'r') as f:
data = f.read().split()
data_float = map(float, data)
tot_val = sum(data_float)
avg_val = tot_val / len(data)
y_axis_values.append(avg_val / math.pow(10, 9))
def getAxisValS3(names, names_0, names_1, names_2, y_axis_values):
total_count = 1000
for i in range(len(names)):
sum_val = 0
data_client_np = np.array(list(map(lambda x: x * 0.0, range(9))))
file_name = path_directory + '/' + names[i]
with open(file_name, 'r') as f:
data_lines = f.readlines()
for data_line in data_lines:
data_list = data_line.split()
data_float = []
for data in data_list:
sum_val += float(data)
data_float.append(float(data))
data_client_np = np.add(data_client_np, np.array(data_float))
data_client_np_avg = data_client_np / math.pow(10, 12)
access_client_s3_y_axis_512KB_values.append(data_client_np_avg.tolist())
data_server_np = np.array(list(map(lambda x: x * 0.0, range(13))))
data_server_1_np = np.array(list(map(lambda x: x * 0.0, range(13))))
data_server_2_np = np.array(list(map(lambda x: x * 0.0, range(13))))
file_name_0 = path_directory + '/' + names_0[i]
with open(file_name_0, 'r') as f:
data_lines = f.readlines()
for data_line in data_lines:
for data in data_line.split():
sum_val += float(data)
# add all elements in data_lines to data_float
data_list = list(map(float, data_line.split()))
data_float = np.array(data_list)
data_server_np = np.add(data_server_np, data_float)
data_server_np_avg = data_server_np / math.pow(10, 12)
access_s3_server_0_y_axis_512KB_values.append(data_server_np_avg.tolist())
file_name_1 = path_directory + '/' + names_1[i]
with open(file_name_1, 'r') as f:
data_lines = f.readlines()
for data_line in data_lines:
for data in data_line.split():
sum_val += float(data)
# add all elements in data_lines to data_float
data_list = list(map(float, data_line.split()))
data_float = np.array(data_list)
data_server_1_np = np.add(data_server_1_np, data_float)
data_server_1_np_avg = data_server_1_np / math.pow(10, 12)
access_s3_server_1_y_axis_512KB_values.append(data_server_1_np_avg.tolist())
file_name_2 = path_directory + '/' + names_2[i]
with open(file_name_2, 'r') as f:
data_lines = f.readlines()
for data_line in data_lines:
for data in data_line.split():
sum_val += float(data)
# add all elements in data_lines to data_float
data_list = list(map(float, data_line.split()))
data_float = np.array(data_list)
data_server_2_np = np.add(data_server_2_np, data_float)
data_server_2_np_avg = data_server_2_np / math.pow(10, 12)
access_s3_server_2_y_axis_512KB_values.append(data_server_2_np_avg.tolist())
y_axis_values.append((sum_val / total_count) / math.pow(10, 9))
pre_build_name = 'processedData/'
def write_list_to_file(list_vals, file_name):
dir_path = pre_build_name + file_name + '.txt'
with open(dir_path, 'w') as f:
f.write("The total access time for all block sizes:n")
for item in list_vals:
f.write("%f " % item)
def breakdown_write_list_to_file(list_vals, file_name):
dir_path = pre_build_name + file_name + '.txt'
with open(dir_path, 'w') as f:
f.write("The breakdown cost of access time for all block sizes:n")
for list_line in list_vals:
for item in list_line:
f.write("%f " % item)
f.write("n")
def getBreakdownAxisVal(names, y_axis_breakdown_values):
for name in names:
# initialize the res_sum as numpy array
res_sum = np.zeros(3)
file_name = path_directory + '/' + name
with open(file_name, 'r') as f:
data_lines = f.readlines()
line_numbers = len(data_lines)
for data_line in data_lines:
data_list = []
res = [] # client computation; Client-server communication; Disk I/O access
for data in data_line.split():
data_list.append(float(data))
res.append(data_list[0] + data_list[2] + data_list[3] + data_list[4])
res.append(data_list[1] + data_list[5])
res.append(data_list[6])
# convert the res to numpy array
res_sum += np.array(res)
# all elements in res_sum are divided by the line numbers
res_sum = res_sum / (line_numbers * math.pow(10, 9))
y_axis_breakdown_values.append(res_sum.tolist())
def update_access_breakdown_512KB(access_y_axis_values, access_y_axis_breakdown_values):
n = len(access_y_axis_values)
for i in range(n):
sum = 0.0
for val in access_y_axis_breakdown_values[i]:
sum += val
access_y_axis_breakdown_values[i][2] += access_y_axis_values[i] - sum
# the order for breakdown cost of Path-ORAM : client computation; Client-server communication; Disk I/O access
def getBreakdownAxisValPath(breakdown_names, breakdown_values_list, access_y_axis_breakdown_values):
n = len(breakdown_names)
for i in range(n):
for name in breakdown_names[i]:
with open(path_directory + '/' + name, 'r') as f:
data_lines = f.readlines()
total_val = 0.0
for data_line in data_lines:
data = data_line.split()
data = map(float, data)
# summarize all the values in data
total_val += sum(data)
breakdown_values_list[i].append(total_val / math.pow(10, 12))
access_y_axis_breakdown_values.append((np.array(breakdown_values_list[0]) + np.array(breakdown_values_list[1]) + np.array(breakdown_values_list[4]) + np.array(breakdown_values_list[5])).tolist())
access_y_axis_breakdown_values.append((np.array(breakdown_values_list[2]) + np.array(breakdown_values_list[3]) + np.array(breakdown_values_list[6] + np.array(breakdown_values_list[7]))).tolist())
access_y_axis_breakdown_values.append((np.array(breakdown_values_list[8]) + np.array(breakdown_values_list[9])).tolist())
def update_access_breakdown_512KB_path(access_y_axis_values, access_y_axis_breakdown_values):
# convert access_y_axis_breakdown_values into numpy array and get the sum of all elements in each column
access_y_axis_breakdown_values_np = np.array(access_y_axis_breakdown_values)
access_y_axis_breakdown_values_sum = np.sum(access_y_axis_breakdown_values_np, axis=0)
row = len(access_y_axis_breakdown_values)
diff_list = np.array(access_y_axis_values) - access_y_axis_breakdown_values_sum
last_val_list = (np.array(access_y_axis_breakdown_values[row - 1]) + diff_list).tolist()
access_y_axis_breakdown_values.pop()
access_y_axis_breakdown_values.append(last_val_list)
# Jump-ORAM
getAxisVal(access_jump_y_axis_20GB_names, access_jump_y_axis_20GB_values)
getAxisVal(access_jump_y_axis_512KB_names, access_jump_y_axis_512KB_values)
write_list_to_file(access_jump_y_axis_20GB_values, 'access_20GB_allBlocksize_jump')
write_list_to_file(access_jump_y_axis_512KB_values, 'access_512KB_allDBsize_jump')
'''The breakdown of the access time for all database sizes'''
getBreakdownAxisVal(access_breakdown_jump_y_axis_512KB_names, access_breakdown_jump_y_axis_512KB_values)
update_access_breakdown_512KB(access_jump_y_axis_512KB_values, access_breakdown_jump_y_axis_512KB_values)
# swap the row with column in access_breakdown_jump_y_axis_512KB_values
n = len(access_breakdown_jump_y_axis_512KB_values[0])
temp_y_axis_512KB_values = np.array(access_breakdown_jump_y_axis_512KB_values)
# clear the content of access_breakdown_jump_y_axis_512KB_values
access_breakdown_jump_y_axis_512KB_values.clear()
for i in range(n):
access_breakdown_jump_y_axis_512KB_values.append(temp_y_axis_512KB_values[:, i].tolist())
breakdown_write_list_to_file(access_breakdown_jump_y_axis_512KB_values, 'access_breakdown_512KB_jump')
# direct-access
getAxisVal(access_direct_y_axis_20GB_names, access_direct_y_axis_20GB_values)
getAxisVal(access_direct_y_axis_512KB_names, access_direct_y_axis_512KB_values)
write_list_to_file(access_direct_y_axis_20GB_values, 'access_20GB_allBlocksize_direct')
write_list_to_file(access_direct_y_axis_512KB_values, 'access_512KB_allDBsize_direct')
# path-ORAM
getAxisVal(access_path_y_axis_20GB_names, access_path_y_axis_20GB_values)
getAxisVal(access_path_y_axis_512KB_names, access_path_y_axis_512KB_values)
write_list_to_file(access_path_y_axis_20GB_values, 'access_20GB_allBlocksize_path')
write_list_to_file(access_path_y_axis_512KB_values, 'access_512KB_allDBsize_path')
'''the Breakdown cost'''
getBreakdownAxisValPath(access_breakdown_path_y_axis_512KB_names, access_breakdown_path_y_axis_512KB_values_list, access_breakdown_path_y_axis_512KB_values)
update_access_breakdown_512KB_path(access_path_y_axis_512KB_values, access_breakdown_path_y_axis_512KB_values)
breakdown_write_list_to_file(access_breakdown_path_y_axis_512KB_values, 'access_breakdown_512KB_path')
# print(access_breakdown_path_y_axis_512KB_values)
# print(access_path_y_axis_512KB_values)
# S3ORAM
#getAxisValS3(access_s3_y_axis_20GB_names, access_s3_server_0_y_axis_20GB_names, access_s3_server_1_y_axis_20GB_names, access_s3_server_2_y_axis_20GB_names, access_s3_y_axis_20GB_values)
getAxisValS3(access_s3_y_axis_512KB_names, access_s3_server_0_y_axis_512KB_names, access_s3_server_1_y_axis_512KB_names, access_s3_server_2_y_axis_512KB_names, access_s3_y_axis_512KB_values)
write_list_to_file(access_s3_y_axis_20GB_values, 'access_20GB_allBlocksize_s3')
# print(access_client_s3_y_axis_512KB_values)
# print(access_s3_server_0_y_axis_512KB_values)
# print(access_s3_server_1_y_axis_512KB_values)
# print(access_s3_server_2_y_axis_512KB_values)
'''calculate the access_breakdown_s3_y_axis_512KB_values'''
client_matrix = np.array(access_client_s3_y_axis_512KB_values)
server_0_matrix = np.array(access_s3_server_0_y_axis_512KB_values)
server_1_matrix = np.array(access_s3_server_1_y_axis_512KB_values)
server_2_matrix = np.array(access_s3_server_2_y_axis_512KB_values)
c_computation = client_matrix[:, 0] + client_matrix[:, 1] + client_matrix[:, 3] + client_matrix[:, 4] + client_matrix[:, 6] + client_matrix[:, 7]
access_breakdown_s3_y_axis_512KB_values.append(c_computation.tolist())
c_s_communication = client_matrix[:, 5] + client_matrix[:, 8] + server_0_matrix[:, 0] + server_0_matrix[:, 3] + server_0_matrix[:, 4] + server_0_matrix[:, 6] +
server_1_matrix[:, 0] + server_1_matrix[:, 3] + server_1_matrix[:, 4] + server_1_matrix[:, 6] +
server_2_matrix[:, 0] + server_2_matrix[:, 3] + server_2_matrix[:, 4] + server_2_matrix[:, 6]
access_breakdown_s3_y_axis_512KB_values.append(c_s_communication.tolist())
d_IO_access = server_0_matrix[:, 1] + server_0_matrix[:, 5] + server_0_matrix[:, 7] + server_0_matrix[:, 12] +
server_1_matrix[:, 1] + server_1_matrix[:, 5] + server_1_matrix[:, 7] + server_1_matrix[:, 12] +
server_2_matrix[:, 1] + server_2_matrix[:, 5] + server_2_matrix[:, 7] + server_2_matrix[:, 12]
access_breakdown_s3_y_axis_512KB_values.append(d_IO_access.tolist())
s_computation = client_matrix[:, 2] +
server_0_matrix[:, 2] + server_0_matrix[:, 8] + server_0_matrix[:, 9] + server_0_matrix[:, 10] + server_0_matrix[:, 11] +
server_1_matrix[:, 2] + server_1_matrix[:, 8] + server_1_matrix[:, 9] + server_1_matrix[:, 10] + server_1_matrix[:, 11] +
server_2_matrix[:, 2] + server_2_matrix[:, 8] + server_2_matrix[:, 9] + server_2_matrix[:, 10] + server_2_matrix[:, 11]
access_breakdown_s3_y_axis_512KB_values.append(s_computation.tolist())
print(access_breakdown_s3_y_axis_512KB_values)
# '''draw the graph'''
# access delay for varying block sizes for a 20GB database
# plt.plot(access_x_axis_vary_block_size, access_s3_y_axis_20GB_values, marker = 'o', linestyle = '--' ,color = "#800080", label = '$S^3ORAM$')
# plt.plot(access_x_axis_vary_block_size, access_path_y_axis_20GB_values, 'x:b', label = '$Path$-$ORAM$')
# plt.plot(access_x_axis_vary_block_size, access_jump_y_axis_20GB_values, 's-b', label = '$Jump$-$ORAM$')
# plt.plot(access_x_axis_vary_block_size, access_direct_y_axis_20GB_values, '^-.r', label = "$Direct$-$Access$")
# plt.xlabel("Block size (KB)")
# plt.ylabel("Delay (second)")
# #plt.title('access delay for varying block size for a 20 GB DB',fontsize='large', fontweight='bold')
# plt.legend()
# plt.show()
# access delay for varying DB size for a 512KB block size
# plt.plot(access_x_axis_vary_db_size, access_s3_y_axis_512KB_values, marker = 'o', linestyle = '--' ,color = "#800080", label = '$S^3ORAM$')
# plt.plot(access_x_axis_vary_db_size, access_path_y_axis_512KB_values, 'x:b', label = '$Path$-$ORAM$')
# plt.plot(access_x_axis_vary_db_size, access_jump_y_axis_512KB_values, 's-b', label = '$Jump$-$ORAM$')
# plt.plot(access_x_axis_vary_db_size, access_direct_y_axis_512KB_values, '^-.r', label = "$Direct$-$Access$")
# plt.xlabel("Database size (GB)")
# plt.ylabel("Delay (second)")
# #plt.title('access delay for varying DB size for a 512 KB block size',fontsize='large', fontweight='bold')
# plt.legend()
# plt.show()
# draw a Stacked bar Chart with the access_breakdown_jump_y_axis_512KB_values as y-axis and access_x_axis_vary_db_size as x-axis
lables = ['Client computation', 'Client-server communication', 'Disk I/O access', 'Server computation']
colors = ['#ff00a6', '#7ef05b', '#0000FF', '#ff5e00']
# Jump-ORAM
# plt.bar(access_x_axis_vary_db_size, access_breakdown_jump_y_axis_512KB_values[2], bottom = np.array(access_breakdown_jump_y_axis_512KB_values[0]) + np.array(access_breakdown_jump_y_axis_512KB_values[1]).tolist(), color = colors[2], label = lables[2], width = 0.4)
# plt.bar(access_x_axis_vary_db_size, access_breakdown_jump_y_axis_512KB_values[1], bottom = access_breakdown_jump_y_axis_512KB_values[0], color = colors[1], label = lables[1], width = 0.4)
# plt.bar(access_x_axis_vary_db_size, access_breakdown_jump_y_axis_512KB_values[0], color = colors[0], label = lables[0], width = 0.4)
# Path-ORAM
# plt.bar(access_x_axis_vary_db_size, access_breakdown_path_y_axis_512KB_values[2], bottom = np.array(access_breakdown_path_y_axis_512KB_values[0]) + np.array(access_breakdown_path_y_axis_512KB_values[1]).tolist(), color = colors[2], label = lables[2], width = 0.4)
# plt.bar(access_x_axis_vary_db_size, access_breakdown_path_y_axis_512KB_values[1], bottom = access_breakdown_path_y_axis_512KB_values[0], color = colors[1], label = lables[1], width = 0.4)
# plt.bar(access_x_axis_vary_db_size, access_breakdown_path_y_axis_512KB_values[0], color = colors[0], label = lables[0], width = 0.4)
# S3ORAM
plt.bar(access_x_axis_vary_db_size, access_breakdown_s3_y_axis_512KB_values[2], bottom = (np.array(access_breakdown_s3_y_axis_512KB_values[0]) + np.array(access_breakdown_s3_y_axis_512KB_values[1]) + np.array(access_breakdown_s3_y_axis_512KB_values[3])).tolist(), color = colors[2], label = lables[2], width = 0.4)
plt.bar(access_x_axis_vary_db_size, access_breakdown_s3_y_axis_512KB_values[1], bottom = (np.array(access_breakdown_s3_y_axis_512KB_values[0]) + np.array(access_breakdown_s3_y_axis_512KB_values[3])).tolist(), color = colors[1], label = lables[1], width = 0.4)
plt.bar(access_x_axis_vary_db_size, access_breakdown_s3_y_axis_512KB_values[0], bottom = access_breakdown_s3_y_axis_512KB_values[3], color = colors[0], label = lables[0], width = 0.4)
plt.bar(access_x_axis_vary_db_size, access_breakdown_s3_y_axis_512KB_values[3], color = colors[3], label = lables[3], width = 0.4)
plt.xlabel("Database size (GB)")
plt.ylabel("Delay (second)")
#plt.ylim(0, 11)
plt.legend()
plt.show()
