def print_rrc_process_dalay(entryList, carrier=const.TMOBILE, network_type=const.WCDMA):
rrc_timer_map = rtw.getCompleteRRCStateTransitionMap(entryList, network_type, carrier)
stateOfInterest = util.get_rrc_trans_group(network_type, carrier)
UPPER_BOUND = 20
for state in stateOfInterest:
for startTS in rrc_timer_map[state]:
if rrc_timer_map[state][startTS][0] - startTS < UPPER_BOUND:
print const.RRC_MAP[state] + const.DEL + str(
abs(rrc_timer_map[state][startTS][0] - startTS)
) + const.DEL + util.convert_ts_in_human(startTS)
def print_rrc_process_dalay(entryList,
carrier=const.TMOBILE,
network_type=const.WCDMA):
rrc_timer_map = rtw.getCompleteRRCStateTransitionMap(entryList, \
network_type, \
carrier)
stateOfInterest = util.get_rrc_trans_group(network_type, carrier)
UPPER_BOUND = 20
for state in stateOfInterest:
for startTS in rrc_timer_map[state]:
if rrc_timer_map[state][startTS][0] - startTS < UPPER_BOUND:
print const.RRC_MAP[state] + const.DEL + str(abs(rrc_timer_map[state][startTS][0] - startTS)) \
+ const.DEL + util.convert_ts_in_human(startTS)
def check_data_trans_during_rrc_trans(entryList, carrier=const.TMOBILE, network_type=const.WCDMA):
rrc_timer_map = rtw.getCompleteRRCStateTransitionMap(entryList, network_type, carrier)
stateOfInterest = util.get_rrc_trans_group(network_type, carrier)
UPPER_BOUND = 20
target_log_ID_set = set([const.UL_PDU_ID, const.DL_PDU_ID])
# target_log_ID_set = set([const.PRACH_PARA_ID])
for state in stateOfInterest:
for startTS in sorted(rrc_timer_map[state].keys()):
if rrc_timer_map[state][startTS][0] - startTS < UPPER_BOUND:
next_sig_id = util.find_next_log(entryList, rrc_timer_map[state][startTS][1][-1], const.SIG_MSG_ID)
# next_sig_id = rrc_timer_map[state][startTS][1][-1]
if next_sig_id != None and util.check_whether_log_of_interest_occur(
entryList, next_sig_id, rrc_timer_map[state][startTS][2][-1], target_log_ID_set
):
print const.RRC_MAP[state] + const.DEL + util.convert_ts_in_human(startTS)
def check_data_trans_during_rrc_trans(entryList,
carrier=const.TMOBILE,
network_type=const.WCDMA):
rrc_timer_map = rtw.getCompleteRRCStateTransitionMap(entryList, \
network_type, \
carrier)
stateOfInterest = util.get_rrc_trans_group(network_type, carrier)
UPPER_BOUND = 20
target_log_ID_set = set([const.UL_PDU_ID, \
const.DL_PDU_ID])
#target_log_ID_set = set([const.PRACH_PARA_ID])
for state in stateOfInterest:
for startTS in sorted(rrc_timer_map[state].keys()):
if rrc_timer_map[state][startTS][0] - startTS < UPPER_BOUND:
next_sig_id = util.find_next_log(
entryList, rrc_timer_map[state][startTS][1][-1],
const.SIG_MSG_ID)
#next_sig_id = rrc_timer_map[state][startTS][1][-1]
if next_sig_id != None and \
util.check_whether_log_of_interest_occur(entryList, next_sig_id, \
rrc_timer_map[state][startTS][2][-1], target_log_ID_set):
print const.RRC_MAP[
state] + const.DEL + util.convert_ts_in_human(startTS)
def facebook_analysis(entryList, qoeFile, client_ip, carrier=const.TMOBILE, \
network_type=const.WCDMA):
# import the user level trace
qoeEvent = QoE(qoeFile)
# get the network event map
netEventMap = qoeEvent.getNetworkEventMap()
#netEventMap = qoeEvent.getActionTimerMap()
# get the timer map
rrc_trans_timer_map = rtw.getCompleteRRCStateTransitionMap(entryList, network_type, carrier)
# get all the flows and flow time map
#fa.parse_http_fields(entryList)
flows = fa.extractTCPFlows(entryList)
# filter out the black list for background traffic
blackListURLs = ["b-api.facebook.com"]
newflows = fa.filterOutBlackListDNSurls(flows, blackListURLs)
flowTimerMap = fa.convertIntoFlowTimerMap(newflows)
#sortedFlowStartTime = sorted(flowTimerMap.keys())
if DEBUG:
print "&"*80
print "&"*80
for ts in netEventMap:
print str(ts * 1000) + const.DEL + netEventMap[ts][1].action + \
const.DEL + netEventMap[ts][1].event
# Output the following event
header = "Action" + const.DEL + \
"Event" + const.DEL + \
"User_latency(s)" + const.DEL + \
"Network_latency(s)" + const.DEL + \
"Network_latency_ratio" + const.DEL + \
"START_IP_TS" + const.DEL + \
"END_IP_TS" + const.DEL + \
"RRC_Type" + const.DEL + \
"Diff_whole_action_vs_SF"
#print header
entryLen = len(entryList)
# display the result
for startTS in sorted(netEventMap.keys()):
endTS = netEventMap[startTS][0]
startEntry = netEventMap[startTS][1]
line = startEntry.action + const.DEL + \
startEntry.event + const.DEL
# user latency
user_latency = endTS - startTS
line += str(user_latency) + const.DEL
# network latency using flow analysis
#flowStartTS = util.binary_search_largest_smaller_value(startTS - const.QOE_TIME_OFFSET, \
# sortedFlowStartTime)
(flow, ipList) = findCorrespondingIPPackets(entryList, startTS, endTS)
network_latency = 0.0
if ipList != None and len(ipList) > 1:
network_latency = ipList[-1].timestamp - ipList[0].timestamp
line += str(network_latency) + const.DEL
# network latency ratio
#line += str(min(1.0, network_latency / user_latency)) + const.DEL
line += str(network_latency / user_latency) + const.DEL
# IP timestamp
if ipList != None and len(ipList) > 1:
line += util.convert_ts_in_human(ipList[0].timestamp) + const.DEL + \
util.convert_ts_in_human(ipList[-1].timestamp) + const.DEL
else:
line += "N/A" + const.DEL + "N/A" + const.DEL
# RRC state transition analysis
if ipList != None and len(ipList) > 1:
rrc_trans_state_bool_map = util.gen_RRC_trans_state_list_map(carrier, \
network_type, \
item="bool")
for rrc_trans_state in rrc_trans_state_bool_map.keys():
overlap_timer = util.find_overlapped_transition_period(ipList[0].timestamp, \
ipList[-1].timestamp, \
rrc_trans_timer_map, \
rrc_trans_state, \
mode="both")
if overlap_timer > 0:
rrc_trans_state_bool_map[rrc_trans_state] = True
if network_type == const.WCDMA:
if carrier == const.TMOBILE:
if rrc_trans_state_bool_map[const.DCH_TO_FACH_ID] == True:
line += const.RRC_MAP[const.DCH_TO_FACH_ID] + const.DEL
elif rrc_trans_state_bool_map[const.PCH_TO_FACH_ID] == True and \
rrc_trans_state_bool_map[const.FACH_TO_DCH_ID] == True:
line += const.RRC_MAP[const.PCH_TO_FACH_ID] + "+" + \
const.RRC_MAP[const.FACH_TO_DCH_ID] + const.DEL
elif rrc_trans_state_bool_map[const.FACH_TO_DCH_ID] == True:
line += const.RRC_MAP[const.FACH_TO_DCH_ID] + const.DEL
else:
line += "Normal" + const.DEL
elif carrier == const.ATT:
if rrc_trans_state_bool_map[const.DCH_TO_DISCONNECTED_ID] == True:
line += const.RRC_MAP[const.DCH_TO_DISCONNECTED_ID] + const.DEL
elif rrc_trans_state_bool_map[const.DISCONNECTED_TO_DCH_ID] == True:
line += const.RRC_MAP[const.DISCONNECTED_TO_DCH_ID] + const.DEL
else:
line += "Normal" + const.DEL
else:
line += "N/A" + const.DEL
# append the difference between the whole action and the SF flag
"""
if ipList != None and len(ipList) > 1:
eventChainIndex = netEventMap[startTS][-1]
eventChain = qoeEvent.actionMap[startEntry.action][eventChainIndex]
(actionflow, actionIpList) = findCorrespondingIPPackets(entryList, \
eventChain[0].timestamp, eventChain[-1].timestamp)
if actionIpList != None and len(actionIpList) > 0:
line += str(actionIpList[-1].timestamp - actionIpList[0].timestamp - \
network_latency) + const.DEL
else:
line += "0.0" + const.DEL
"""
eventChainIndex = netEventMap[startTS][-1]
eventChain = qoeEvent.actionMap[startEntry.action][eventChainIndex]
line += util.convert_ts_in_human(eventChain[0].timestamp) + const.DEL + \
util.convert_ts_in_human(startTS) + const.DEL + \
util.convert_ts_in_human(endTS) + const.DEL
if ipList != None and len(ipList) > 1:
print line
else:
print >> sys.stderr, line
