In [1]:
import warnings
import pandas as pd
import numpy as np
import os
import sys # error msg
import operator # sorting
from math import *
from read_trace import *
from avgblkmodel import *
from model_cke import *
warnings.filterwarnings("ignore", category=np.VisibleDeprecationWarning)
In [ ]:
gtx950 = DeviceInfo()
gtx950.sm_num = 6
gtx950.sharedmem_per_sm = 49152
gtx950.reg_per_sm = 65536
gtx950.maxthreads_per_sm = 2048
In [ ]:
data_size = 23000
trace_file = './1cke/trace_' + str(data_size) + '.csv'
df_trace = trace2dataframe(trace_file) # read the trace to the dataframe
In [ ]:
df_trace
In [ ]:
df_single_stream = model_param_from_trace_v1(df_trace)
df_s1 = reset_starting(df_single_stream)
In [ ]:
# extract kernel info
streaminfo = get_stream_info(df_trace)
current_kern_info = streaminfo[0].kernel_info[0]
grid_dim = float(current_kern_info.grid_x) * float(current_kern_info.grid_y) * float(current_kern_info.grid_z)
block_dim = float(current_kern_info.blk_x) * float(current_kern_info.blk_y) * float(current_kern_info.blk_z)
reg_per_thread = float(current_kern_info.regs_per_thread)
sm_per_blk = float(current_kern_info.sm_per_block)
# kernel runtime in ms
current_kern = streaminfo[0].kernel[0]
kern_runtime_ms = float(current_kern.end_time_ms) - float(current_kern.start_time_ms)
kernel = KernelInfo()
kernel.blockDim = block_dim
kernel.gridDim = grid_dim
kernel.reg_per_thread = reg_per_thread
kernel.sharedmem_per_blk = sm_per_blk
kernel.runtime_ms = kern_runtime_ms
kernel.avg_blk_time = compute_avgblktime(gtx950, kernel)
#print kernel_avg_blk_time
In [ ]:
stream_num = 2
df_cke_list = []
for x in range(stream_num):
df_cke_list.append(df_s1.copy(deep=True))
In [ ]:
H2D_H2D_OVLP_TH = 3.158431
for i in range(1,stream_num):
# compute the time for the init data transfer
stream_startTime = find_whentostart_comingStream(df_cke_list[i-1], H2D_H2D_OVLP_TH)
print('stream_startTime : {}'.format(stream_startTime))
df_cke_list[i].start += stream_startTime
df_cke_list[i].end += stream_startTime
In [ ]:
prev_stm_h2ds_start, prev_stm_h2ds_end = find_h2ds_timing(df_cke_list[0])
print("prev stream h2ds : {} - {}".format(prev_stm_h2ds_start, prev_stm_h2ds_end))
curr_stm_h2ds_start, curr_stm_h2ds_end = find_h2ds_timing(df_cke_list[1])
print("curr stream h2ds : {} - {}".format(curr_stm_h2ds_start, curr_stm_h2ds_end))
In [ ]:
if curr_stm_h2ds_start >=prev_stm_h2ds_start and curr_stm_h2ds_start < prev_stm_h2ds_end:
h2ds_ovlp_between_stream = True
else:
h2ds_ovlp_between_stream = False
print("h2ds_ovlp_between_stream : {}".format(h2ds_ovlp_between_stream))
In [ ]:
prev_stm_kern_start, prev_stm_kern_end = find_kern_timing(df_cke_list[0])
print("prev stream kern : {} - {}".format(prev_stm_kern_start, prev_stm_kern_end))
curr_stm_kern_start, curr_stm_kern_end = find_kern_timing(df_cke_list[1])
print("curr stream kern : {} - {}".format(curr_stm_kern_start, curr_stm_kern_end))
In [ ]:
if prev_stm_kern_start <= curr_stm_kern_start < prev_stm_kern_end:
kern_ovlp_between_stream = True
else:
kern_ovlp_between_stream = False
print("kern_ovlp_between_stream : {}".format(kern_ovlp_between_stream))
In [ ]:
# get the overlapping kernel info from both stream
# since the ovlp kernels are identical, we duplicate twice
kernel_num = 2
kernels = [kernel for i in range(kernel_num)]
pred_cke_time, kernels_start_end = model_cke_from_same_kernel(gtx950, kernels)
In [ ]:
pred_cke_time
In [ ]:
kernels_start_end
In [ ]:
df_cke_list[0]
In [ ]:
df_cke_list[1]
In [ ]:
def api_order(df_trace):
order_ls = []
for index,row in df_trace.iterrows():
order_ls.append([str(row.api_type), index])
return order_ls
In [ ]:
cke1_api_list = api_order(df_cke_list[1])
print cke1_api_list
In [ ]:
def find_api_pos(ls, api_name, order):
count = 0
index = 0
found = 0
for api in ls:
if api[0] == api_name:
count = count + 1
if count == order:
found = 1
index = api[1]
break;
return found, index
In [ ]:
# found, pos = find_api_pos(cke1_api_list, "kern", 1)
# print("found : {}, pos : {}".format(found, pos))
In [ ]:
# adjust kernel timing
df_current = df_cke_list[1]
df_current_kern = df_current.loc[df_current.api_type == "kern"]
#print df_current_kern.start
#print df_current_kern.end
df_prev = df_cke_list[0]
df_prev_kern = df_prev.loc[df_prev.api_type == "kern"]
#print df_prev_kern.start
kern_start_update = float(df_prev_kern.start) + kernels_start_end[1][0]
print kern_start_update
kern_end_update = float(df_prev_kern.start) + kernels_start_end[1][1]
print kern_end_update
# we need to adjust the timing for the following api calls too
# find out the kern_d2h ovhd
df_current_d2h = df_current.loc[df_current.api_type == "d2h"]
#print df_current_d2h.start
#print df_current_kern.end
kern_d2h_ovhd = float(df_current_d2h.start) - float(df_current_kern.end)
print kern_d2h_ovhd
d2h_new_start = kern_end_update + kern_d2h_ovhd
print d2h_new_start
d2h_delta = d2h_new_start - float(df_current_d2h.start)
print d2h_delta
### update
found, pos = find_api_pos(cke1_api_list, "kern", 1) # find the 1st kern in the api list
print("found : {}, pos : {}".format(found, pos))
df_current.set_value(pos, 'start', kern_start_update)
df_current.set_value(pos, 'end', kern_end_update)
df_current.set_value(pos, 'duration', kern_end_update - kern_start_update)
#df_current_kern.start = kern_start_update
#df_current_kern.end = kern_end_update
#df_current_kern.duration = kern_end_update - kern_start_update
found, pos = find_api_pos(cke1_api_list, "d2h", 1) # find the 1st kern in the api list
print("found : {}, pos : {}".format(found, pos))
df_current.set_value(pos, 'start', d2h_new_start)
df_current.set_value(pos, 'end', df_current_d2h.end + d2h_delta)
#df_current_d2h.start = d2h_new_start
#df_current_d2h.end = df_current_d2h.end + d2h_delta
In [ ]:
df_cke_list[0]
In [ ]:
df_cke_list[1]
In [ ]:
prev_stm_d2h_start, prev_stm_d2h_end = find_d2h_timing(df_cke_list[0])
print("prev stream d2h : {} - {}".format(prev_stm_d2h_start, prev_stm_d2h_end))
curr_stm_d2h_start, curr_stm_d2h_end = find_d2h_timing(df_cke_list[1])
print("curr stream d2h : {} - {}".format(curr_stm_d2h_start, curr_stm_d2h_end))
In [ ]:
if prev_stm_d2h_start <= curr_stm_d2h_start < prev_stm_d2h_end:
d2h_ovlp_between_stream = True
else:
d2h_ovlp_between_stream = False
print("d2h_ovlp_between_stream : {}".format(d2h_ovlp_between_stream))