<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 scheme
Step1:  gpu info
Step2:  Understand the input
Step3:  Kernel Info from the single stream
Step4:  model 3 cuda streams
Step5:  start kernel from beginning
Step6:  set the h2d start for all the cuda streams
Step7:  merge all the cuda stream trace together
Step8:  start algorithm
<ASSISTANT_TASK:>
Python Code:
%load_ext autoreload
%autoreload 2
import warnings
import pandas as pd
import numpy as np
import os
import sys # error msg, add the modules
import operator # sorting
from math import *
import matplotlib.pyplot as plt
sys.path.append('../../')
import cuda_timeline
import read_trace
import avgblk
import cke
from model_param import *
#from df_util import *
warnings.filterwarnings("ignore", category=np.VisibleDeprecationWarning)
Explanation: scheme:
1) for data transfer, pick 1st sleep api (h2d) fo stream-0, current cc = 1 (concurrency),
2) check whether there is overalp with stream-
2) if there is overlap, finish cc=1, start from cc++ (cc=2), predit the future ending time
3) during the predicted ending time, check whether there is overlap with stream-2
4) if there is overalap, finish cc=2, start from cc++ (cc=3), predict the future ending time
5) go to step 3) , search through all the cuda streams
6) for each time range, we need to find out how many apis have overlap and which-pair have conflicts or not
End of explanation
gtx950 = DeviceInfo()
gtx950.sm_num = 6
gtx950.sharedmem_per_sm = 49152
gtx950.reg_per_sm = 65536
gtx950.maxthreads_per_sm = 2048
# init SM resources
SM_resList, SM_traceList = init_gpu(gtx950)
#SM_resList[0]
SM_traceList[0]
Explanation: gpu info
End of explanation
trace_s1 = 'trace_s1_5m.csv'
df_trace_s1 = read_trace.Trace2dataframe(trace_s1)
trace_s3 = 'trace_s3_5m.csv'
df_trace_s3 = read_trace.Trace2dataframe(trace_s3)
#df_trace_s1
cuda_timeline.plot_trace(df_trace_s1)
#cuda_timeline.plot_trace(df_trace_s2)
cuda_timeline.plot_trace(df_trace_s3)
Explanation: Understand the input
End of explanation
# extract kernel info from trace
# warning: currently lmted to one kernel
kernel = read_trace.GetKernelInfo(df_trace_s1, gtx950)
Dump_kernel_info(kernel)
Explanation: Kernel Info from the single stream
End of explanation
# for each stream, have a dd for each kernel
stream_kernel_list = []
stream_num = 3
for sid in range(stream_num):
    #print sid
    # key will be the kernel order
    # value will be the kernel info
    kern_dd = {}
    kern_dd[0] = Copy_kernel_info(kernel)
    stream_kernel_list.append(kern_dd)
    
    
Dump_kernel_info(stream_kernel_list[0][0])
Explanation: model 3 cuda streams
End of explanation
df_s1_trace_timing = read_trace.Get_timing_from_trace(df_trace_s1)
df_s1 = read_trace.Reset_starting(df_s1_trace_timing)
df_s1
Explanation: start kernel from beginning
End of explanation
# find when to start the stream and update the starting pos for the trace
H2D_H2D_OVLP_TH = 3.158431
df_cke_list = cke.init_trace_list(df_s1, stream_num = stream_num, h2d_ovlp_th = H2D_H2D_OVLP_TH)
df_cke_list[0]
df_cke_list[1]
df_cke_list[2]
Explanation: set the h2d start for all the cuda streams
End of explanation
df_all_api = cke.init_sort_api_with_extra_cols(df_cke_list)
df_all_api
Explanation: merge all the cuda stream trace together
End of explanation
# stream_id list
stream_list = [float(x) for x in range(stream_num)]
# pick the 1st sleep api
df_all_api, r1, r1_stream = cke.pick_base_call(df_all_api)
df_all_api = SetWake(df_all_api, r1)
print('row {}, stream-id {}'.format(r1, r1_stream))
# select coming (stream_num - 1) api calls, they are potential concurrency api calls
cc_rows = FindComingCalls(df_all_api, r1, stream_num)
count = 1
active_stream_pool = []
active_stream_pool.append(r1_stream)
for r2 in cc_rows:
    print('active_stream_pool : {}'.format(active_stream_pool))
    #if count == 1: break
    #if count == 2: break
    
    # wake target row
    df_all_api = SetWake(df_all_api, r2)
    r2_stream = GetStreamID(df_all_api, r2)
    print('row {}, stream-id {}'.format(r2, r2_stream))
    
    
    if count == 2: break
        
    # check whether current stream is in the active stream pool
    # where I mean they are from the same stream
    if r2_stream in active_stream_pool:
        # finish previous call
        df_all_api = cke.finish_call(df_all_api, r1)
        # update the time for all the calls in this stream
        df_all_api = cke.UpdateStreamTime(df_all_api)
        # adjust the r2 current pos and pred_end
        df_all_api = UpdateCell(df_all_api, r2, 'current_pos', GetInfo(df_all_api, r2, 'start'))
        df_all_api = UpdateCell(df_all_api, r2, 'pred_end', GetInfo(df_all_api, r2, 'end'))
        break
        
        
    # if it is a new stream, add to the pool
    active_stream_pool.append(r2_stream)
    
    
    #---------------------------------------
    # move the current pos to the r2 start  (to do)
    #---------------------------------------
    
    
    
    #if count == 1: break
    #if count == 2: break
    
#     rangeT = cke.Get_pred_range(df_all_api)
#     print rangeT
    
#     # check whether there is conc during the rangeT
#     cke.Check_ovlp(df_all_api, r1, r2)
    
    
    
    
    #break
    
    
    
    # when they are from different streams
    
    #-----------------------
    # move the current_pos to the starting of coming api r2, and update r1 status
    #-----------------------
    #df_all_api = cke.StartNext_byType(df_all_api, [r1, r2])
    
    #break
    
    df_all_api = cke.MoveCurPos(df_all_api, r2) # start r2, check concurrency,and update the timing
    
    #if count == 1: break
    #if count == 2: break
        
    #break
    
    
    #-----------------------------
    # if one call is done, continue the next round
    #-----------------------------
    rowDone, rowDone_list = cke.CheckRowDone(df_all_api, [r1, r2])
    if rowDone:
        print('soem call is ended, go for next call')
        print rowDone_list
        
        for each in rowDone_list: # throw away the done stream
            active_stream_pool = [x for x in active_stream_pool if x <> each]
            
        print active_stream_pool
        
        count += 1
        
        #break
        continue
        
    
    whichType = cke.CheckType(df_all_api, r1, r2) # check whether the same api
    print whichType
    
    if whichType == None:
        # run noconflict
        pass
    elif whichType in ['h2d', 'd2h']: # data transfer in the same direction
        df_all_api = cke.Predict_transferOvlp(df_all_api, [r1, r2])
        if count == 1: break
        #break
    else:
        # concurrent kernel: todo
        pass
    
    #--------------------
    # check if any api is done, and update the timing for the other apis in that stream
    #--------------------
    df_all_api = cke.UpdateStreamTime(df_all_api)
    count += 1
    #break
    
## after checking the commming call for ovlp
df_all_api
#
# run above
#
Explanation: start algorithm
End of explanation
<END_TASK>