def first_hop_latency_evaluation(entryList, pduID): tcp_rtt_list = [] first_hop_rtt_list = [] transmission_delay_ratio_rtt_list = [] ota_delay_ratio_rtt_list = [] entryLen = len(entryList) for i in range(entryLen): entry = entryList[i] if entry.rtt["tcp"] != None and entry.rtt["tcp"] > 0: # perform cross-layer mapping mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_uplink( entryList, i, pduID) if mapped_RLCs: transmission_delay, rlc_rtt_list = calc_first_hop_latency( mapped_RLCs) tcp_rtt_list.append(entry.rtt["tcp"]) first_hop_rtt_list.append(transmission_delay + util.meanValue(rlc_rtt_list)) transmission_delay_ratio_rtt_list.append( min(transmission_delay / entry.rtt["tcp"], 1.0)) ota_delay_ratio_rtt_list.append( min(util.meanValue(rlc_rtt_list) / entry.rtt["tcp"], 1.0)) return (tcp_rtt_list, first_hop_rtt_list, transmission_delay_ratio_rtt_list, ota_delay_ratio_rtt_list)
def crossLayerMappingRLCRetxInfo(entryList, direction, client_ip, RLCMap, network_type): # A cross-layer RLC retx map clMap = {} log_of_interest_id = util.get_logID_of_interest(network_type, direction) for i in range(len(entryList)): transportEntry = entryList[i] if transportEntry.logID == const.PROTOCOL_ID: if transportEntry.ip["dst_ip"] == client_ip or \ transportEntry.ip["src_ip"] == client_ip: mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_uplink(entryList, i , log_of_interest_id) if mapped_RLCs: (count, total) = countRLCRetx([rlc[0] for rlc in mapped_RLCs], RLCMap, log_of_interest_id) if total > 0: clMap[transportEntry] = min(float(count) / float(total), 1.0) return clMap
def first_hop_latency_evaluation(entryList, pduID): tcp_rtt_list = [] first_hop_rtt_list = [] transmission_delay_ratio_rtt_list = [] ota_delay_ratio_rtt_list = [] entryLen = len(entryList) for i in range(entryLen): entry = entryList[i] if entry.rtt["tcp"] != None and entry.rtt["tcp"] > 0: # perform cross-layer mapping mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_uplink(entryList, i , pduID) if mapped_RLCs: transmission_delay, rlc_rtt_list = calc_first_hop_latency(mapped_RLCs) tcp_rtt_list.append(entry.rtt["tcp"]) first_hop_rtt_list.append(transmission_delay + util.meanValue(rlc_rtt_list)) transmission_delay_ratio_rtt_list.append(min(transmission_delay / entry.rtt["tcp"], 1.0)) ota_delay_ratio_rtt_list.append(min(util.meanValue(rlc_rtt_list) / entry.rtt["tcp"], 1.0)) return (tcp_rtt_list, first_hop_rtt_list, transmission_delay_ratio_rtt_list, ota_delay_ratio_rtt_list)
def rlc_retx_based_on_gap(QCATEntries, direction): index = 0 entry_length = len(QCATEntries) gap_retx_per_rrc_map = {} gap_retx_list_map = {} tot_rlc_num = 0.0 while index < entry_length: cur_entry = QCATEntries[index] cur_gap = cur_entry.udp["gap"] if cur_entry.ip["tlp_id"] == const.UDP_ID and cur_gap >= 0: # find the last gap_period message last_map_index = find_last_same_gap_entry_index( QCATEntries, index, cur_gap) if GAP_DEBUG: print "Current index is %d" % index print "Last map index is %d" % last_map_index # map the current UDP packet to the RLC layer PDUs first_rlc_list, first_sn_list = clw.cross_layer_mapping_WCDMA_uplink( QCATEntries, index, const.UL_PDU_ID) last_rlc_list, last_sn_list = clw.cross_layer_mapping_WCDMA_uplink( QCATEntries, last_map_index, const.UL_PDU_ID) # get the corresponding RLC log message if first_rlc_list and last_rlc_list and last_sn_list: rlc_begin_index = first_rlc_list[0][1] tmp_rlc_end_index = last_rlc_list[-1][1] rlc_end_index = clw.find_nearest_status( QCATEntries, tmp_rlc_end_index, max(last_sn_list)) if GAP_DEBUG: print "First RLC mapped index is ", rlc_begin_index print "Last RLC mapped index is ", rlc_end_index if rlc_begin_index < rlc_end_index: total_count_map, retx_count_map, retx_num, total_num = find_retx_within_a_range( QCATEntries, rlc_begin_index, rlc_end_index, direction) """ if GAP_DEBUG: print "Cur_gap is %f" % cur_gap print "retx_num is %f" % retx_num """ tot_rlc_num += total_num if gap_retx_list_map.has_key(cur_gap): gap_retx_list_map[cur_gap].append(retx_num) else: gap_retx_list_map[cur_gap] = [retx_num] if gap_retx_per_rrc_map.has_key(cur_gap): gap_retx_per_rrc_map[cur_gap][ "retx"] = util.merge_two_dict( gap_retx_per_rrc_map[cur_gap]["retx"], retx_count_map) gap_retx_per_rrc_map[cur_gap][ "total"] = util.merge_two_dict( gap_retx_per_rrc_map[cur_gap]["total"], total_count_map) else: gap_retx_per_rrc_map[cur_gap] = { "retx": retx_count_map, "total": total_count_map } index = last_map_index index += 1 # recalculate the whole group by the ratio of dividing the total group number #for gap, retx_list in gap_retx_list_map.items(): #gap_retx_list_map[gap] = [i/tot_rlc_num for i in retx_list] # display the retransmission result if True: #print "Ready to show results ...." for k in sorted(gap_retx_list_map.keys()): mean, stdev = util.meanStdevPair(gap_retx_list_map[k], upper_bound=0.5) print "%f\t%f\t%f" % (k, mean, stdev / 3.0) #print "%f\t%s" % (k, util.listToStr(util.quartileResult(gap_retx_list_map[k]))) #print "%f\t%s" % (k, gap_retx_list_map[k]) return gap_retx_per_rrc_map, gap_retx_list_map
def UDP_loss_cross_analysis(QCATEntries, loss_index_list, logID): # Loss over cellular network if # 1. exceeding max Retx count # 2. there is a reset PDU in between the mapped RLC list and the next control message udp_loss_in_cellular = { "reset": rw.initFullRRCMap(0.0), "max_retx": rw.initFullRRCMap(0.0) } udp_loss_in_internet = rw.initFullRRCMap(0.0) entry_len = len(QCATEntries) max_retx_count_overall = 0.0 for loss_index in loss_index_list: cur_entry = QCATEntries[loss_index] mapped_rlc_tuple_list, mapped_sn_list = clw.cross_layer_mapping_WCDMA_uplink( QCATEntries, loss_index, logID) if mapped_rlc_tuple_list and cur_entry.rrcID: first_mapped_rlc_index = mapped_rlc_tuple_list[0][1] last_mapped_rlc_index = mapped_rlc_tuple_list[-1][1] first_mapped_rlc_sn = min( QCATEntries[first_mapped_rlc_index].ul_pdu[0]["sn"]) last_mapped_rlc_sn = min( QCATEntries[last_mapped_rlc_index].ul_pdu[0]["sn"]) max_tx_config = cur_entry.ul_config["max_tx"] next_ack_index = clw.findNextCtrlMsg(QCATEntries, loss_index, ctrl_type="ack", cur_seq=last_mapped_rlc_sn) next_list_index = clw.findNextCtrlMsg(QCATEntries, loss_index, ctrl_type="list", cur_seq=last_mapped_rlc_sn) ctrl_index = entry_len if next_ack_index: ctrl_index = min(next_ack_index, ctrl_index) if next_list_index: ctrl_index = min(next_list_index, ctrl_index) # check reset reset_index = clw.find_reset_ack(QCATEntries, last_mapped_rlc_index + 1, ctrl_index) # check for exceeding retx count rlc_tx_map = clw.find_SN_within_interval( QCATEntries, first_mapped_rlc_index + 1, ctrl_index) max_tx_count_num = 0 if rlc_tx_map: max_tx_count_num = max([len(i) for i in rlc_tx_map.values()]) if max_tx_count_num > max_retx_count_overall: max_retx_count_overall = max_tx_count_num if reset_index: udp_loss_in_cellular["reset"][cur_entry.rrcID] += 1 if DEBUG: print "-------------- Detect Reset --------------" elif max_tx_config and max_tx_count_num >= max_tx_config: udp_loss_in_cellular["max_retx"][cur_entry.rrcID] += 1 if DEBUG: print "%%%%%%%%%%%% Max retx configued: ", max_tx_config print "%%%%%%%%%%%% Cur retx configued: ", max_tx_count_num else: udp_loss_in_internet[cur_entry.rrcID] += 1 """ # print out retransmission over PCH promotion # investigate high PCH loss rate #if cur_entry.rrcID and cur_entry.rrcID == const.PCH_TO_FACH_ID: print "%"* 100 print "%"* 40 + "Curious Case:" + "%"* 40 pw.printUDPEntry(cur_entry) print "%"* 100 print "%"* 100 # find the lower bound of the range max_index = clw.find_nearest_status(QCATEntries, loss_index, max(mapped_sn_list)) print "is max index correct %s" % (max_index > loss_index) target_sn_set = set(mapped_sn_list) dup_sn_map, rlc_tx_index_list = clw.loss_analysis_with_rlc_retx(QCATEntries, loss_index, max_index, target_sn_set) print "max # of retx is %d" % max([len(i) for i in dup_sn_map.values()]) pw.print_loss_case(QCATEntries, loss_index, rlc_tx_index_list) """ if CUR_DEBUG: print "Max RLC retx is ", max_retx_count_overall return udp_loss_in_cellular, udp_loss_in_internet
def parse_http_fields(entryList): count = 0 goodCount = 0 DEL = "\t" if HTTP_EXTRA: # Assign TCP RTT dw.calc_tcp_rtt(entryList) log_of_interest_id = get_logID_of_interest("wcdma", "up") # Uniqueness analysis non_unique_rlc_tuples, dummy = vw.uniqueness_analysis(entryList, log_of_interest_id) # RLC retransmission analysis [RLCULReTxCountMap, RLCDLReTxCountMap] = rw.procRLCReTx(entryList, detail="simple") for i in range(len(entryList)): entry = entryList[i] if entry.logID == const.PROTOCOL_ID and \ entry.tcp["dst_port"] == const.HTTP_DST_PORT: http_payload = entry.hex_dump["payload"][(const.Payload_Header_Len + \ entry.ip["header_len"] + \ entry.tcp["header_len"]):] http_payload_by_field = "".join(http_payload).decode("hex").split(const.HTTP_LINE_DEL) for field in http_payload_by_field: splitted_field = field.split(const.HTTP_FIELD_DEL) if splitted_field[0].lower() == "host": entry.http["host"] = splitted_field[1] elif splitted_field[0].lower() == "referer": entry.http["referer"] = splitted_field[1] elif splitted_field[0].lower() == "timer": entry.http["timer"] = float(splitted_field[1]) # move on to the next entry when we get what we want if TIMER_CHECK: if entry.http["host"] and \ entry.http["timer"] and \ entry.http["host"] in const.HOST_OF_INTEREST: print entry.http line = "" if HTTP_EXTRA: if entry.http["host"] or entry.http["referer"]: count += 1 line += util.convert_ts_in_human(entry.timestamp) + DEL + \ str(const.RRC_MAP[entry.rrcID]) + DEL + \ str(entry.http) + DEL # check whether interference exist mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_uplink(entryList, i, log_of_interest_id) if mapped_RLCs: if vw.is_valid_cross_layer_mapping(mapped_RLCs, mapped_sn, log_of_interest_id, non_unique_rlc_tuples): if entry.rtt["tcp"]: paraCountMap = count_prach_aich_status(entryList, mapped_RLCs[0][-1], mapped_RLCs[-1][-1], const.PRACH_PARA_ID) line += str(paraCountMap[const.PRACH_ABORT]) + DEL line += str(paraCountMap[const.PRACH_DONE]) + DEL eventCountMap = count_prach_aich_status(entryList, mapped_RLCs[0][-1], mapped_RLCs[-1][-1], const.EVENT_ID) line += str(eventCountMap[const.PRACH_ABORT]) + DEL line += str(eventCountMap[const.PRACH_DONE]) + DEL if paraCountMap[const.PRACH_ABORT] > 0 or \ paraCountMap[const.PRACH_DONE] > 0 or \ eventCountMap[const.PRACH_ABORT] > 0 or \ eventCountMap[const.PRACH_DONE] > 0: goodCount += 1 line += "Interred_request" else: line += "ERROR: fail to estimate TCP rtt" else: line += "ERROR: not unique mapping" else: line += "ERROR: not mapped RLC PDUs" print line if HTTP_EXTRA: print "*"*80 print "In total, " + str(count) + " requests." print "Interfered URL is " + str(goodCount)
def check_mapping_feasibility_uniqueness(entryList, client_ip, direction, network_type="wcdma"): # determine the log of interest log_of_interest_id = None # Determine the log of interest we wanna focus on log_of_interest_id = util.get_logID_of_interest(network_type, direction) non_unique_rlc_tuples, uniqueCount = uniqueness_analysis(entryList, log_of_interest_id) print "Non unique RLC tuple length is %d" % (len(non_unique_rlc_tuples)) # count the key appear twice or more dupChainCount = 0.0 dupPDUCount = 0.0 totalChainCount = 0.0 totalPDUCount = 0.0 DEL = "," sortedDuplicateCount = {} # key is count, value is the chain bytes for key, val in uniqueCount.items(): totalPDUCount += len(key) / 4 * val totalChainCount += val if val > 1: dupPDUCount += len(key) / 4 * val dupChainCount += val sortedDuplicateCount[val] = key # cross-layer analysis to check the untrusted mapping for transport layer transport_layer_total_count = {const.TCP_ID: 0.0, const.UDP_ID: 0.0} valid_transport_layer_mapping_count = {const.TCP_ID: 0.0, const.UDP_ID: 0.0} valid_RLC_first_hop_esimation_count = {const.TCP_ID: 0.0, const.UDP_ID: 0.0} for i in range(len(entryList)): entry = entryList[i] if entry.logID == const.PROTOCOL_ID: # Exclude TCP ACK without payload and TSL without payload """ if entry.ip["tlp_id"] == const.TCP_ID and\ (entry.ip["total_len"] == 40 or \ entry.ip["total_len"] == 52 or \ entry.ip["total_len"] == 83): continue """ mapped_RLCs = mapped_sn = None if log_of_interest_id == const.UL_PDU_ID and entry.ip["src_ip"] == client_ip: if entry.ip["tlp_id"] in transport_layer_total_count: transport_layer_total_count[entry.ip["tlp_id"]] += 1 mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_uplink(entryList, i, log_of_interest_id) elif log_of_interest_id == const.DL_PDU_ID and entry.ip["dst_ip"] == client_ip: if entry.ip["tlp_id"] in transport_layer_total_count: transport_layer_total_count[entry.ip["tlp_id"]] += 1 mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_downlink(entryList, i, log_of_interest_id) if mapped_RLCs: if is_valid_cross_layer_mapping(mapped_RLCs, mapped_sn, log_of_interest_id, non_unique_rlc_tuples): if entry.ip["tlp_id"] in valid_transport_layer_mapping_count: valid_transport_layer_mapping_count[entry.ip["tlp_id"]] += 1 if is_valid_first_hop_latency_estimation(mapped_RLCs, mapped_sn, log_of_interest_id): if entry.ip["tlp_id"] in valid_RLC_first_hop_esimation_count: valid_RLC_first_hop_esimation_count[entry.ip["tlp_id"]] += 1 # output results print "Chain_occurance" + DEL + "Chain_PDU_length" + DEL + "Chain_value" for sortedKey in sorted(sortedDuplicateCount.keys(), reverse=True): print str(sortedKey) + DEL + str(len(sortedDuplicateCount[sortedKey]) / 4) + DEL + str( sortedDuplicateCount[sortedKey] ) print "$" * 80 print "Unique Chain ratio %f / %f = %f" % ( totalChainCount - dupChainCount, totalChainCount, 1 - dupChainCount / totalChainCount, ) print "Unique PDUs ratio %f / %f = %f" % ( totalPDUCount - dupPDUCount, totalPDUCount, 1 - dupPDUCount / totalPDUCount, ) print "Unique TCP ratio %f / %f = %f" % ( valid_transport_layer_mapping_count[const.TCP_ID], transport_layer_total_count[const.TCP_ID], valid_transport_layer_mapping_count[const.TCP_ID] / transport_layer_total_count[const.TCP_ID], ) print "Unique UDP ratio %f / %f = %f" % ( valid_transport_layer_mapping_count[const.UDP_ID], transport_layer_total_count[const.UDP_ID], valid_transport_layer_mapping_count[const.UDP_ID] / transport_layer_total_count[const.UDP_ID], ) print "Valid TCP first hop esitmation ratio %f / %f = %f" % ( valid_RLC_first_hop_esimation_count[const.TCP_ID], transport_layer_total_count[const.TCP_ID], valid_RLC_first_hop_esimation_count[const.TCP_ID] / transport_layer_total_count[const.TCP_ID], ) print "Valid UDP first hop esitmation ratio %f / %f = %f" % ( valid_RLC_first_hop_esimation_count[const.UDP_ID], transport_layer_total_count[const.UDP_ID], valid_RLC_first_hop_esimation_count[const.UDP_ID] / transport_layer_total_count[const.UDP_ID], )
def check_mapping_feasibility_uniqueness(entryList, client_ip, direction, network_type="wcdma"): # determine the log of interest log_of_interest_id = None # Determine the log of interest we wanna focus on log_of_interest_id = util.get_logID_of_interest(network_type, direction) non_unique_rlc_tuples, uniqueCount = uniqueness_analysis( entryList, log_of_interest_id) print "Non unique RLC tuple length is %d" % (len(non_unique_rlc_tuples)) # count the key appear twice or more dupChainCount = 0.0 dupPDUCount = 0.0 totalChainCount = 0.0 totalPDUCount = 0.0 DEL = "," sortedDuplicateCount = {} # key is count, value is the chain bytes for key, val in uniqueCount.items(): totalPDUCount += len(key) / 4 * val totalChainCount += val if val > 1: dupPDUCount += len(key) / 4 * val dupChainCount += val sortedDuplicateCount[val] = key # cross-layer analysis to check the untrusted mapping for transport layer transport_layer_total_count = {const.TCP_ID: 0.0, const.UDP_ID: 0.0} valid_transport_layer_mapping_count = { const.TCP_ID: 0.0, const.UDP_ID: 0.0 } valid_RLC_first_hop_esimation_count = { const.TCP_ID: 0.0, const.UDP_ID: 0.0 } for i in range(len(entryList)): entry = entryList[i] if entry.logID == const.PROTOCOL_ID: # Exclude TCP ACK without payload and TSL without payload """ if entry.ip["tlp_id"] == const.TCP_ID and\ (entry.ip["total_len"] == 40 or \ entry.ip["total_len"] == 52 or \ entry.ip["total_len"] == 83): continue """ mapped_RLCs = mapped_sn = None if (log_of_interest_id == const.UL_PDU_ID and \ entry.ip["src_ip"] == client_ip): if entry.ip["tlp_id"] in transport_layer_total_count: transport_layer_total_count[entry.ip["tlp_id"]] += 1 mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_uplink( entryList, i, log_of_interest_id) elif (log_of_interest_id == const.DL_PDU_ID and \ entry.ip["dst_ip"] == client_ip): if entry.ip["tlp_id"] in transport_layer_total_count: transport_layer_total_count[entry.ip["tlp_id"]] += 1 mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_downlink( entryList, i, log_of_interest_id) if mapped_RLCs: if is_valid_cross_layer_mapping(mapped_RLCs, mapped_sn, log_of_interest_id, non_unique_rlc_tuples): if entry.ip[ "tlp_id"] in valid_transport_layer_mapping_count: valid_transport_layer_mapping_count[ entry.ip["tlp_id"]] += 1 if is_valid_first_hop_latency_estimation( mapped_RLCs, mapped_sn, log_of_interest_id): if entry.ip[ "tlp_id"] in valid_RLC_first_hop_esimation_count: valid_RLC_first_hop_esimation_count[ entry.ip["tlp_id"]] += 1 # output results print "Chain_occurance" + DEL + "Chain_PDU_length" + DEL + "Chain_value" for sortedKey in sorted(sortedDuplicateCount.keys(), reverse=True): print str(sortedKey) + DEL + \ str(len(sortedDuplicateCount[sortedKey]) / 4) + DEL + \ str(sortedDuplicateCount[sortedKey]) print "$" * 80 print "Unique Chain ratio %f / %f = %f" % (totalChainCount - dupChainCount, totalChainCount, 1 - dupChainCount / totalChainCount) print "Unique PDUs ratio %f / %f = %f" % (totalPDUCount - dupPDUCount, totalPDUCount, 1 - dupPDUCount / totalPDUCount) print "Unique TCP ratio %f / %f = %f" % (valid_transport_layer_mapping_count[const.TCP_ID], \ transport_layer_total_count[const.TCP_ID], \ valid_transport_layer_mapping_count[const.TCP_ID] / \ transport_layer_total_count[const.TCP_ID]) print "Unique UDP ratio %f / %f = %f" % (valid_transport_layer_mapping_count[const.UDP_ID], \ transport_layer_total_count[const.UDP_ID], \ valid_transport_layer_mapping_count[const.UDP_ID] / \ transport_layer_total_count[const.UDP_ID]) print "Valid TCP first hop esitmation ratio %f / %f = %f" % \ (valid_RLC_first_hop_esimation_count[const.TCP_ID], \ transport_layer_total_count[const.TCP_ID], \ valid_RLC_first_hop_esimation_count[const.TCP_ID] / \ transport_layer_total_count[const.TCP_ID]) print "Valid UDP first hop esitmation ratio %f / %f = %f" % \ (valid_RLC_first_hop_esimation_count[const.UDP_ID], \ transport_layer_total_count[const.UDP_ID], \ valid_RLC_first_hop_esimation_count[const.UDP_ID] / \ transport_layer_total_count[const.UDP_ID])
def rlc_retx_based_on_gap (QCATEntries, direction): index = 0 entry_length = len(QCATEntries) gap_retx_per_rrc_map = {} gap_retx_list_map = {} tot_rlc_num = 0.0 while index < entry_length: cur_entry = QCATEntries[index] cur_gap = cur_entry.udp["gap"] if cur_entry.ip["tlp_id"] == const.UDP_ID and cur_gap >= 0: # find the last gap_period message last_map_index = find_last_same_gap_entry_index(QCATEntries, index, cur_gap) if GAP_DEBUG: print "Current index is %d" % index print "Last map index is %d" % last_map_index # map the current UDP packet to the RLC layer PDUs first_rlc_list, first_sn_list = clw.cross_layer_mapping_WCDMA_uplink(QCATEntries, index, const.UL_PDU_ID) last_rlc_list, last_sn_list = clw.cross_layer_mapping_WCDMA_uplink(QCATEntries, last_map_index, const.UL_PDU_ID) # get the corresponding RLC log message if first_rlc_list and last_rlc_list and last_sn_list: rlc_begin_index = first_rlc_list[0][1] tmp_rlc_end_index = last_rlc_list[-1][1] rlc_end_index = clw.find_nearest_status(QCATEntries, tmp_rlc_end_index, max(last_sn_list)) if GAP_DEBUG: print "First RLC mapped index is ", rlc_begin_index print "Last RLC mapped index is ", rlc_end_index if rlc_begin_index < rlc_end_index: total_count_map, retx_count_map, retx_num, total_num = find_retx_within_a_range(QCATEntries, rlc_begin_index, rlc_end_index, direction) """ if GAP_DEBUG: print "Cur_gap is %f" % cur_gap print "retx_num is %f" % retx_num """ tot_rlc_num += total_num if gap_retx_list_map.has_key(cur_gap): gap_retx_list_map[cur_gap].append(retx_num) else: gap_retx_list_map[cur_gap] = [retx_num] if gap_retx_per_rrc_map.has_key(cur_gap): gap_retx_per_rrc_map[cur_gap]["retx"] = util.merge_two_dict(gap_retx_per_rrc_map[cur_gap]["retx"], retx_count_map) gap_retx_per_rrc_map[cur_gap]["total"] = util.merge_two_dict(gap_retx_per_rrc_map[cur_gap]["total"], total_count_map) else: gap_retx_per_rrc_map[cur_gap] = {"retx": retx_count_map, "total": total_count_map} index = last_map_index index += 1 # recalculate the whole group by the ratio of dividing the total group number #for gap, retx_list in gap_retx_list_map.items(): #gap_retx_list_map[gap] = [i/tot_rlc_num for i in retx_list] # display the retransmission result if True: #print "Ready to show results ...." for k in sorted(gap_retx_list_map.keys()): mean, stdev = util.meanStdevPair(gap_retx_list_map[k], upper_bound = 0.5) print "%f\t%f\t%f" % (k, mean, stdev / 3.0) #print "%f\t%s" % (k, util.listToStr(util.quartileResult(gap_retx_list_map[k]))) #print "%f\t%s" % (k, gap_retx_list_map[k]) return gap_retx_per_rrc_map, gap_retx_list_map
def UDP_loss_cross_analysis(QCATEntries, loss_index_list, logID): # Loss over cellular network if # 1. exceeding max Retx count # 2. there is a reset PDU in between the mapped RLC list and the next control message udp_loss_in_cellular = {"reset": rw.initFullRRCMap(0.0), "max_retx": rw.initFullRRCMap(0.0)} udp_loss_in_internet = rw.initFullRRCMap(0.0) entry_len = len(QCATEntries) max_retx_count_overall = 0.0 for loss_index in loss_index_list: cur_entry = QCATEntries[loss_index] mapped_rlc_tuple_list, mapped_sn_list = clw.cross_layer_mapping_WCDMA_uplink(QCATEntries, loss_index, logID) if mapped_rlc_tuple_list and cur_entry.rrcID: first_mapped_rlc_index = mapped_rlc_tuple_list[0][1] last_mapped_rlc_index = mapped_rlc_tuple_list[-1][1] first_mapped_rlc_sn = min(QCATEntries[first_mapped_rlc_index].ul_pdu[0]["sn"]) last_mapped_rlc_sn = min(QCATEntries[last_mapped_rlc_index].ul_pdu[0]["sn"]) max_tx_config = cur_entry.ul_config["max_tx"] next_ack_index = clw.findNextCtrlMsg(QCATEntries, loss_index, ctrl_type = "ack", cur_seq = last_mapped_rlc_sn) next_list_index = clw.findNextCtrlMsg(QCATEntries, loss_index, ctrl_type = "list", cur_seq = last_mapped_rlc_sn) ctrl_index = entry_len if next_ack_index: ctrl_index = min(next_ack_index, ctrl_index) if next_list_index: ctrl_index = min(next_list_index, ctrl_index) # check reset reset_index = clw.find_reset_ack(QCATEntries, last_mapped_rlc_index + 1, ctrl_index) # check for exceeding retx count rlc_tx_map = clw.find_SN_within_interval(QCATEntries, first_mapped_rlc_index + 1, ctrl_index) max_tx_count_num = 0 if rlc_tx_map: max_tx_count_num = max([len(i) for i in rlc_tx_map.values()]) if max_tx_count_num > max_retx_count_overall: max_retx_count_overall = max_tx_count_num if reset_index: udp_loss_in_cellular["reset"][cur_entry.rrcID] += 1 if DEBUG: print "-------------- Detect Reset --------------" elif max_tx_config and max_tx_count_num >= max_tx_config: udp_loss_in_cellular["max_retx"][cur_entry.rrcID] += 1 if DEBUG: print "%%%%%%%%%%%% Max retx configued: " , max_tx_config print "%%%%%%%%%%%% Cur retx configued: " , max_tx_count_num else: udp_loss_in_internet[cur_entry.rrcID] += 1 """ # print out retransmission over PCH promotion # investigate high PCH loss rate #if cur_entry.rrcID and cur_entry.rrcID == const.PCH_TO_FACH_ID: print "%"* 100 print "%"* 40 + "Curious Case:" + "%"* 40 pw.printUDPEntry(cur_entry) print "%"* 100 print "%"* 100 # find the lower bound of the range max_index = clw.find_nearest_status(QCATEntries, loss_index, max(mapped_sn_list)) print "is max index correct %s" % (max_index > loss_index) target_sn_set = set(mapped_sn_list) dup_sn_map, rlc_tx_index_list = clw.loss_analysis_with_rlc_retx(QCATEntries, loss_index, max_index, target_sn_set) print "max # of retx is %d" % max([len(i) for i in dup_sn_map.values()]) pw.print_loss_case(QCATEntries, loss_index, rlc_tx_index_list) """ if CUR_DEBUG: print "Max RLC retx is ", max_retx_count_overall return udp_loss_in_cellular, udp_loss_in_internet
def parse_http_fields(entryList): count = 0 goodCount = 0 DEL = "\t" if HTTP_EXTRA: # Assign TCP RTT dw.calc_tcp_rtt(entryList) log_of_interest_id = get_logID_of_interest("wcdma", "up") # Uniqueness analysis non_unique_rlc_tuples, dummy = vw.uniqueness_analysis( entryList, log_of_interest_id) # RLC retransmission analysis [RLCULReTxCountMap, RLCDLReTxCountMap] = rw.procRLCReTx(entryList, detail="simple") for i in range(len(entryList)): entry = entryList[i] if entry.logID == const.PROTOCOL_ID and \ entry.tcp["dst_port"] == const.HTTP_DST_PORT: http_payload = entry.hex_dump["payload"][(const.Payload_Header_Len + \ entry.ip["header_len"] + \ entry.tcp["header_len"]):] http_payload_by_field = "".join(http_payload).decode("hex").split( const.HTTP_LINE_DEL) for field in http_payload_by_field: splitted_field = field.split(const.HTTP_FIELD_DEL) if splitted_field[0].lower() == "host": entry.http["host"] = splitted_field[1] elif splitted_field[0].lower() == "referer": entry.http["referer"] = splitted_field[1] elif splitted_field[0].lower() == "timer": entry.http["timer"] = float(splitted_field[1]) # move on to the next entry when we get what we want if TIMER_CHECK: if entry.http["host"] and \ entry.http["timer"] and \ entry.http["host"] in const.HOST_OF_INTEREST: print entry.http line = "" if HTTP_EXTRA: if entry.http["host"] or entry.http["referer"]: count += 1 line += util.convert_ts_in_human(entry.timestamp) + DEL + \ str(const.RRC_MAP[entry.rrcID]) + DEL + \ str(entry.http) + DEL # check whether interference exist mapped_RLCs, mapped_sn = clw.cross_layer_mapping_WCDMA_uplink( entryList, i, log_of_interest_id) if mapped_RLCs: if vw.is_valid_cross_layer_mapping( mapped_RLCs, mapped_sn, log_of_interest_id, non_unique_rlc_tuples): if entry.rtt["tcp"]: paraCountMap = count_prach_aich_status( entryList, mapped_RLCs[0][-1], mapped_RLCs[-1][-1], const.PRACH_PARA_ID) line += str( paraCountMap[const.PRACH_ABORT]) + DEL line += str( paraCountMap[const.PRACH_DONE]) + DEL eventCountMap = count_prach_aich_status( entryList, mapped_RLCs[0][-1], mapped_RLCs[-1][-1], const.EVENT_ID) line += str( eventCountMap[const.PRACH_ABORT]) + DEL line += str( eventCountMap[const.PRACH_DONE]) + DEL if paraCountMap[const.PRACH_ABORT] > 0 or \ paraCountMap[const.PRACH_DONE] > 0 or \ eventCountMap[const.PRACH_ABORT] > 0 or \ eventCountMap[const.PRACH_DONE] > 0: goodCount += 1 line += "Interred_request" else: line += "ERROR: fail to estimate TCP rtt" else: line += "ERROR: not unique mapping" else: line += "ERROR: not mapped RLC PDUs" print line if HTTP_EXTRA: print "*" * 80 print "In total, " + str(count) + " requests." print "Interfered URL is " + str(goodCount)