source: ReferenceDesigns/w3_802.11/python/wlan_exp/log/coll_util.py

Last change on this file was 6320, checked in by chunter, 5 years ago

1.8.0 release wlan-exp
File size: 6.1 KB
Line 
1# -*- coding: utf-8 -*-
2"""
3------------------------------------------------------------------------------
4Mango 802.11 Reference Design Experiments Framework - Collision Analysis
5------------------------------------------------------------------------------
6License:   Copyright 2019 Mango Communications, Inc. All rights reserved.
7           Use and distribution subject to terms in LICENSE.txt
8------------------------------------------------------------------------------
9
10This module provides helper functions for finding packet collisions within
11log files.
12
13"""
14
15import numpy as np
16import sys
17
18def _collision_idx_finder_binarysearch(src_ts, src_dur, int_ts, int_dur):
19     
20    num_src = src_ts.shape[0]
21    num_int = int_ts.shape[0]
22   
23    maxlen = num_src+num_int
24    src_coll_idx = np.zeros([maxlen],dtype=np.int)
25    int_coll_idx = np.zeros([maxlen],dtype=np.int)       
26   
27    coll_index = 0
28   
29    for src_idx in range(num_src):       
30       
31        curr_src_ts = src_ts[src_idx]
32        curr_src_dur = src_dur[src_idx] 
33       
34        curr_src_tx_end = curr_src_ts + curr_src_dur
35       
36        num_iter = 0
37       
38        int_idx = num_int/2
39        int_idx_high = num_int-1
40        int_idx_low = 0
41
42        # Start in middle and branch out   
43        while 1:
44            num_iter = num_iter+1
45            if (int_idx == int_idx_low or int_idx == int_idx_high):
46                # We're done. No overlap
47                break           
48           
49            curr_int_ts = int_ts[int_idx]
50            curr_int_dur = int_dur[int_idx]
51           
52            if ( curr_int_ts < (curr_src_tx_end) ) and ( curr_src_ts < (curr_int_ts + curr_int_dur) ):
53                           
54                # We found an overlap
55                src_coll_idx[coll_index] = src_idx
56                int_coll_idx[coll_index] = int_idx
57                coll_index = coll_index+1         
58               
59                # Keep iterating forward on int_idx until there isn't an overlap                                                       
60                while int_idx < (num_int-1):
61                    int_idx = int_idx+1
62                    curr_int_ts = int_ts[int_idx]
63                    curr_int_dur = int_dur[int_idx]                   
64                    if ( curr_int_ts < (curr_src_tx_end) ) and ( curr_src_ts < (curr_int_ts + curr_int_dur) ):
65                        # Found another overlap
66                        src_coll_idx[coll_index] = src_idx
67                        int_coll_idx[coll_index] = int_idx
68                        coll_index = coll_index+1                             
69                    else:
70                        # No more collisions, move on
71                        break                       
72                break
73            elif ( curr_int_ts < curr_src_ts ):
74                # Overlap may be later -- move index forward
75                int_idx_low = int_idx               
76            else:
77                # Overlap may be earlier -- move index back
78                int_idx_high = int_idx
79
80            int_idx = (int_idx_high - int_idx_low)/2 + int_idx_low
81                                                           
82    src_coll_idx = src_coll_idx[0:coll_index]                                                       
83    int_coll_idx = int_coll_idx[0:coll_index]                                                           
84       
85    return (src_coll_idx,int_coll_idx)
86
87# End def
88
89
90
91def _collision_idx_finder_linearsearch(src_ts, src_dur, int_ts, int_dur):
92     
93    num_src = src_ts.shape[0]
94    num_int = int_ts.shape[0]
95   
96    maxlen = num_src+num_int
97    src_coll_idx = np.zeros([maxlen],dtype=np.int)
98    int_coll_idx = np.zeros([maxlen],dtype=np.int)
99   
100    int_idx_start = 0
101    coll_index = 0
102       
103    for src_idx in range(num_src):       
104       
105        curr_src_ts = src_ts[src_idx]
106        curr_src_dur = src_dur[src_idx] 
107       
108        curr_src_tx_end = curr_src_ts + curr_src_dur
109       
110        num_iter = 0
111       
112        for int_idx in range(int_idx_start,num_int):
113            num_iter = num_iter+1
114            curr_int_ts = int_ts[int_idx]
115            curr_int_dur = int_dur[int_idx]
116
117            if ( curr_int_ts < (curr_src_tx_end) ) and ( curr_src_ts < (curr_int_ts + curr_int_dur) ):               
118                # Found an overlap
119                src_coll_idx[coll_index] = src_idx
120                int_coll_idx[coll_index] = int_idx
121                int_idx_start = int_idx
122                coll_index = coll_index + 1
123                # Keep iterating forward on int_idx until there isn't an overlap                                                       
124                while int_idx < (num_int-1):
125                    int_idx = int_idx+1
126                    curr_int_ts = int_ts[int_idx]
127                    curr_int_dur = int_dur[int_idx]                   
128                    if ( curr_int_ts < (curr_src_tx_end) ) and ( curr_src_ts < (curr_int_ts + curr_int_dur) ):
129                        # Found another overlap
130                        src_coll_idx[coll_index] = src_idx
131                        int_coll_idx[coll_index] = int_idx
132                        coll_index = coll_index+1                             
133                    else:
134                        # No more collisions, move on
135                        break                           
136                break
137            elif ( curr_int_ts > (curr_src_tx_end) ):
138                int_idx_start = int_idx
139                break                                                   
140   
141    src_coll_idx = src_coll_idx[0:coll_index]                                                       
142    int_coll_idx = int_coll_idx[0:coll_index]
143   
144    return (src_coll_idx,int_coll_idx)
145
146# End def
147
148
149
150def _collision_idx_finder(src_ts, src_dur, int_ts, int_dur):
151    if sys.version_info[0] == 2:
152        # The binary search method runs considerably faster under Python 2.7 than Python 3.3
153        return _collision_idx_finder_binarysearch(src_ts, src_dur, int_ts, int_dur)
154    else:
155        # The linear search method runs considerably faster under Python 3.3 than Python 2.7
156        return _collision_idx_finder_linearsearch(src_ts, src_dur, int_ts, int_dur)
157
158# End def
Note: See TracBrowser for help on using the repository browser.