def checkWhetherFlowBoundedByQoE(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(const.QOE_TIME_OFFSET) sortedEventTimes = sorted(netEventMap.keys()) # get flows and flowMap flows = fa.extractTCPFlows(entryList) flowTimerMap = fa.convertIntoFlowTimerMap(flows) nonMappedFlow = [] for flowStartTime in flowTimerMap.keys(): netStartTime = util.binary_search_largest_smaller_value(flowStartTime, sortedEventTimes) if netStartTime != None: if netEventMap[netStartTime][0] < flowTimerMap[flowStartTime][0]: nonMappedFlow.append(flowTimerMap[flowStartTime][1]) print "Non-mapped flow length is " + str(flowTimerMap[flowStartTime][0] - flowStartTime) print "*"*50 print "*"*50 print "Non-mapped ratio %.3f / %.3f = %.3f" % (float(len(nonMappedFlow)), float(len(flows)), \ float(len(nonMappedFlow)) / float(len(flows))) print "Non mapped flow length distribution is " + str(util.quartileResult(\ sorted([f.flow[-1].timestamp - f.flow[0].timestamp for f in nonMappedFlow])))
def checkWhetherQoEMappingToLowerLayer(entryList, qoeFile, client_ip, \ carrier=const.TMOBILE, \ network_type=const.WCDMA): # import the user level trace qoeEvent = QoE(qoeFile) # get the action timer map with a offset value #timerMap = qoeEvent.getActionTimerMap(const.QOE_TIME_OFFSET) timerMap = qoeEvent.getNetworkEventMap(const.QOE_TIME_OFFSET) sortedTimerKey = sorted(timerMap.keys()) lowerBound = timerMap[sortedTimerKey[0]] # get the number of network flows flows = fa.extractTCPFlows(entryList) print "# of QoE network events: " + str(len(timerMap)) print "# of TCP flows: " + str(len(flows)) # interation through all the IP packets to evalute the seperation on QoE labeled trace ipResult = {"outRange": 0.0, \ "total": 0.0} for i in range(len(entryList)): entry = entryList[i] if entry.logID == const.PROTOCOL_ID: ipResult["total"] += 1 [isInRange, tsInput] = util.checkWhetherEntryInTimerMap(entry, timerMap) if isInRange != True and tsInput != None: ipResult["outRange"] += 1 # IP time, nearest action, if tsInput in timerMap: print util.convert_ts_in_human(entry.timestamp) + \ const.DEL + timerMap[tsInput][1].action + \ const.DEL + util.convert_ts_in_human(timerMap[tsInput][1].timestamp) + \ const.DEL + util.convert_ts_in_human(timerMap[tsInput][2].timestamp) #elif tsInput > lowerBound: # print "Out of range: " + util.convert_ts_in_human(entry.timestamp) print "*" * 50 print "*" * 50 ratio = ipResult["outRange"] / ipResult["total"] print "%.3f / %.3f = %.3f" % (ipResult["outRange"], ipResult["total"], ratio)
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