Filename | /home/rjamet/Work/Code/sinalgo/runnerv3/Runner/Stats.pm |
Statements | Executed 355884 statements in 10.7s |
Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
---|---|---|---|---|---|
1181 | 3 | 1 | 10.5s | 10.7s | computeOnMessages | Runner::Stats::
1 | 1 | 1 | 6.67ms | 7.04ms | computeAtTheEnd | Runner::Stats::
1 | 1 | 1 | 1.67ms | 10.6ms | BEGIN@8 | Runner::Stats::
502 | 1 | 1 | 189µs | 189µs | CORE:match (opcode) | Runner::Stats::
1 | 1 | 1 | 63µs | 63µs | CORE:sort (opcode) | Runner::Stats::
1 | 1 | 1 | 37µs | 70µs | BEGIN@3 | Runner::Stats::
1 | 1 | 1 | 31µs | 148µs | BEGIN@7 | Runner::Stats::
1 | 1 | 1 | 19µs | 19µs | BEGIN@6 | Runner::Stats::
1 | 1 | 1 | 17µs | 29µs | BEGIN@4 | Runner::Stats::
1 | 1 | 1 | 17µs | 92µs | BEGIN@5 | Runner::Stats::
0 | 0 | 0 | 0s | 0s | __ANON__[Runner/Stats.pm:107] | Runner::Stats::
0 | 0 | 0 | 0s | 0s | __ANON__[Runner/Stats.pm:52] | Runner::Stats::
Line | State ments |
Time on line |
Calls | Time in subs |
Code |
---|---|---|---|---|---|
1 | package Runner::Stats; | ||||
2 | |||||
3 | 2 | 66µs | 2 | 102µs | # spent 70µs (37+33) within Runner::Stats::BEGIN@3 which was called:
# once (37µs+33µs) by Runner::IO::BEGIN@47 at line 3 # spent 70µs making 1 call to Runner::Stats::BEGIN@3
# spent 33µs making 1 call to strict::import |
4 | 2 | 77µs | 2 | 40µs | # spent 29µs (17+11) within Runner::Stats::BEGIN@4 which was called:
# once (17µs+11µs) by Runner::IO::BEGIN@47 at line 4 # spent 29µs making 1 call to Runner::Stats::BEGIN@4
# spent 11µs making 1 call to warnings::import |
5 | 2 | 61µs | 2 | 167µs | # spent 92µs (17+75) within Runner::Stats::BEGIN@5 which was called:
# once (17µs+75µs) by Runner::IO::BEGIN@47 at line 5 # spent 92µs making 1 call to Runner::Stats::BEGIN@5
# spent 75µs making 1 call to Exporter::import |
6 | 2 | 83µs | 1 | 19µs | # spent 19µs within Runner::Stats::BEGIN@6 which was called:
# once (19µs+0s) by Runner::IO::BEGIN@47 at line 6 # spent 19µs making 1 call to Runner::Stats::BEGIN@6 |
7 | 2 | 78µs | 2 | 166µs | # spent 148µs (31+117) within Runner::Stats::BEGIN@7 which was called:
# once (31µs+117µs) by Runner::IO::BEGIN@47 at line 7 # spent 148µs making 1 call to Runner::Stats::BEGIN@7
# spent 18µs making 1 call to List::Util::import |
8 | 2 | 4.78ms | 2 | 10.8ms | # spent 10.6ms (1.67+8.94) within Runner::Stats::BEGIN@8 which was called:
# once (1.67ms+8.94ms) by Runner::IO::BEGIN@47 at line 8 # spent 10.6ms making 1 call to Runner::Stats::BEGIN@8
# spent 213µs making 1 call to Exporter::import |
9 | |||||
10 | 1 | 1µs | my $RA_SAMPLES = 500; | ||
11 | #my $RA_SAMPLES = 10; | ||||
12 | 1 | 200ns | my $RD_SAMPLES = 500; | ||
13 | #my $RD_SAMPLES = 10; | ||||
14 | 1 | 200ns | my $RE_TIMEWINDOW = 100; | ||
15 | |||||
16 | #Used to compute all the means and stddev and so on | ||||
17 | # spent 10.7s (10.5+259ms) within Runner::Stats::computeOnMessages which was called 1181 times, avg 9.07ms/call:
# 1179 times (10.4s+259ms) by main::RUNTIME at line 106 of runner.pl, avg 9.08ms/call
# once (5.61ms+30µs) by main::RUNTIME at line 130 of runner.pl
# once (3.99ms+36µs) by main::RUNTIME at line 112 of runner.pl | ||||
18 | |||||
19 | 1181 | 1.10ms | my $data = shift; | ||
20 | 1181 | 1.57ms | my $command = shift; | ||
21 | |||||
22 | 1181 | 3.61ms | if (!exists $data->{inc_vars}) { | ||
23 | #first run, create the data | ||||
24 | 1 | 5µs | $data->{inc_vars}->{last_id_RA} = 0; | ||
25 | 1 | 1µs | $data->{inc_vars}->{last_id_RA_ack} = 0; | ||
26 | 1 | 800ns | $data->{inc_vars}->{last_id_RD} = 0; | ||
27 | 1 | 2µs | $data->{inc_vars}->{last_id_RD_ack} = 0; | ||
28 | } else { | ||||
29 | #reuse old data | ||||
30 | } | ||||
31 | |||||
32 | #Runner::IO::tprint "### Extracting the uniques send times\n"; | ||||
33 | |||||
34 | 1181 | 1.08ms | $data->{average_rolling} = [] unless exists $data->{average_rolling}; | ||
35 | 1181 | 804µs | $data->{average_rolling_ack} = [] unless exists $data->{average_rolling_ack}; | ||
36 | 1181 | 748µs | $data->{delivery_rolling} = [] unless exists $data->{delivery_rolling}; | ||
37 | 1181 | 825µs | $data->{delivery_rolling_ack} = [] unless exists $data->{delivery_rolling_ack}; | ||
38 | 1181 | 689µs | $data->{energy_rolling} = [] unless exists $data->{energy_rolling}; | ||
39 | |||||
40 | ################################### | ||||
41 | # NUMBER OF HOPS FOR MSG | ||||
42 | ################################### | ||||
43 | |||||
44 | #Runner::IO::tprint "### Computing averages on send times\n"; | ||||
45 | |||||
46 | |||||
47 | #The following thing is not noticeably faster than a simple grep, | ||||
48 | #strangely | ||||
49 | 1181 | 1.29ms | my $lid = $data->{inc_vars}->{last_id_RA}; | ||
50 | my $fi = | ||||
51 | first_index | ||||
52 | 294632 | 178ms | { $_->{id} > $lid } | ||
53 | 1181 | 17.5ms | 1181 | 174ms | @{$data->{msg_data}}; # spent 174ms making 1181 calls to List::MoreUtils::firstidx, avg 147µs/call |
54 | |||||
55 | 1181 | 2.15ms | if (!defined($fi) || $fi eq "") {die()} | ||
56 | 1181 | 420µs | my @sorted; | ||
57 | 1181 | 1.14ms | if($fi >= 0) { | ||
58 | @sorted = grep { | ||||
59 | |||||
60 | $_->{d} == 1 && | ||||
61 | $_->{type} eq "basic" | ||||
62 | 1181 | 1.17s | } @{$data->{msg_data}}[$fi .. @{$data->{msg_data}}-1 ]; | ||
63 | |||||
- - | |||||
66 | 1181 | 2.37ms | while( scalar @sorted >= $RA_SAMPLES) { | ||
67 | 800 | 35.6ms | my @cur = splice @sorted, 0, $RA_SAMPLES; | ||
68 | 800 | 195ms | 800 | 7.16ms | my $h_r = ( sum map{$_->{h}} @cur ) / @cur; # spent 7.16ms making 800 calls to List::Util::sum, avg 9µs/call |
69 | 800 | 173ms | 800 | 5.40ms | my $o_r = ( sum map{$_->{o}} @cur ) / @cur; # spent 5.40ms making 800 calls to List::Util::sum, avg 7µs/call |
70 | 800 | 175ms | 800 | 4.84ms | my $t_r = ( sum map{$_->{tb}} @cur ) / @cur; # spent 4.84ms making 800 calls to List::Util::sum, avg 6µs/call |
71 | 800 | 359ms | 800 | 5.78ms | my $tph_r =( sum map{ ($_->{te} - $_->{tb})/$_->{h} } @cur ) / @cur; # spent 5.78ms making 800 calls to List::Util::sum, avg 7µs/call |
72 | |||||
73 | 800 | 5.66ms | push @{$data->{average_rolling}}, {"h" => $h_r, "t" => $t_r, "tph" => $tph_r, "o"=> $o_r}; | ||
74 | 800 | 148ms | 800 | 4.56ms | $data->{inc_vars}->{last_id_RA} = max map{$_->{id}} @cur; # spent 4.56ms making 800 calls to List::Util::max, avg 6µs/call |
75 | } | ||||
76 | } | ||||
77 | |||||
78 | ################################### | ||||
79 | # DELIVERY RATE FOR MSG | ||||
80 | ################################### | ||||
81 | |||||
82 | #Runner::IO::tprint "### Computing average delivery rates\n"; | ||||
83 | @sorted = grep { | ||||
84 | $_->{type} eq "basic" && | ||||
85 | $_->{id} > $data->{inc_vars}->{last_id_RD} | ||||
86 | 1181 | 1.20s | } @{$data->{msg_data}}; | ||
87 | 1181 | 1.86ms | while (scalar @sorted >= $RD_SAMPLES) { | ||
88 | 1000 | 41.2ms | my @cur = splice @sorted, 0, $RD_SAMPLES; | ||
89 | 1000 | 133ms | my $eaten_r = ( scalar grep { $_->{d} == 0 } @cur ) / @cur; | ||
90 | 1000 | 93.1ms | my $ok_r = ( scalar grep { $_->{d} == 1 } @cur ) / @cur; | ||
91 | 1000 | 84.9ms | my $ttl_r = ( scalar grep { $_->{d} == 2 } @cur ) / @cur; | ||
92 | 1000 | 83.8ms | my $other_r = ( scalar grep { $_->{d} >= 3 } @cur ) / @cur; | ||
93 | |||||
94 | 1000 | 227ms | 1000 | 9.70ms | my $t_r = ( sum map{$_->{tb}} @cur ) / @cur; # spent 9.70ms making 1000 calls to List::Util::sum, avg 10µs/call |
95 | 1000 | 7.16ms | push @{$data->{delivery_rolling}}, | ||
96 | {"eaten" => $eaten_r, "ok" => $ok_r,"ttl"=>$ttl_r, "other"=>$other_r, "t" => $t_r}; | ||||
97 | |||||
98 | 1000 | 170ms | 1000 | 5.47ms | $data->{inc_vars}->{last_id_RD} = max map{$_->{id}} @cur; # spent 5.47ms making 1000 calls to List::Util::max, avg 5µs/call |
99 | } | ||||
100 | |||||
101 | #################################### | ||||
102 | # NBHOPS + DELIVERY RATE FOR ACKS | ||||
103 | #################################### | ||||
104 | |||||
105 | |||||
106 | #FIXME : could be faster by 1/3 if we remove this when not used | ||||
107 | 4755 | 29.1ms | 1181 | 7.00ms | if (any {$_->{type} eq "ack"} @{$data->{msg_data}}) { # spent 7.00ms making 1181 calls to List::Util::any, avg 6µs/call |
108 | |||||
109 | my @sorted = grep { | ||||
110 | ($_->{d} == 1 || $_->{d} == 3) && | ||||
111 | $_->{id} > $data->{inc_vars}->{last_id_RA_ack} && | ||||
112 | $_->{type} eq "ack" | ||||
113 | 1181 | 1.56s | } @{$data->{msg_data}}; | ||
114 | |||||
115 | 1181 | 2.30ms | while( scalar @sorted >= $RA_SAMPLES) { | ||
116 | 770 | 40.1ms | my @cur = splice @sorted, 0, $RA_SAMPLES; | ||
117 | 770 | 167ms | 770 | 6.04ms | my $h_r = ( sum map{$_->{h}} @cur ) / @cur; # spent 6.04ms making 770 calls to List::Util::sum, avg 8µs/call |
118 | 770 | 179ms | 770 | 5.27ms | my $t_r = ( sum map{$_->{tb}} @cur ) / @cur; # spent 5.27ms making 770 calls to List::Util::sum, avg 7µs/call |
119 | 770 | 338ms | 770 | 5.68ms | my $tph_r =( sum map{ ($_->{te} - $_->{tb})/$_->{h} } @cur ) / @cur; # spent 5.68ms making 770 calls to List::Util::sum, avg 7µs/call |
120 | |||||
121 | 770 | 5.40ms | push @{$data->{average_rolling_ack}}, {"h" => $h_r, "t" => $t_r, "tph" => $tph_r}; | ||
122 | 770 | 141ms | 770 | 4.30ms | $data->{inc_vars}->{last_id_RA_ack} = max map{$_->{id}} @cur; # spent 4.30ms making 770 calls to List::Util::max, avg 6µs/call |
123 | |||||
124 | } | ||||
125 | |||||
126 | #Runner::IO::tprint "### Computing average delivery rates for acks\n"; | ||||
127 | @sorted = grep { | ||||
128 | $_->{id} > $data->{inc_vars}->{last_id_RD_ack} && | ||||
129 | $_->{type} eq "ack" | ||||
130 | 1181 | 1.31s | } @{$data->{msg_data}}; | ||
131 | 1181 | 10.9ms | while (scalar @sorted >= $RD_SAMPLES) { | ||
132 | 800 | 32.2ms | my @cur = splice @sorted, 0, $RD_SAMPLES; | ||
133 | 800 | 104ms | my $eaten_r = ( scalar grep { $_->{d} == 0 } @cur ) / @cur; | ||
134 | 800 | 71.8ms | my $ok_r = ( scalar grep { $_->{d} == 1 } @cur ) / @cur; | ||
135 | 800 | 67.9ms | my $ttl_r = ( scalar grep { $_->{d} == 2 } @cur ) / @cur; | ||
136 | 800 | 66.1ms | my $forgot_r =( scalar grep { $_->{d} == 3 } @cur ) / @cur; | ||
137 | 800 | 65.7ms | my $other_r = ( scalar grep { $_->{d} >= 4 } @cur ) / @cur; | ||
138 | |||||
139 | 800 | 180ms | 800 | 7.45ms | my $t_r = ( sum map{$_->{tb}} @cur ) / @cur; # spent 7.45ms making 800 calls to List::Util::sum, avg 9µs/call |
140 | 800 | 5.46ms | push @{$data->{delivery_rolling_ack}}, { | ||
141 | "eaten" => $eaten_r, | ||||
142 | "ok" => $ok_r, | ||||
143 | "ttl"=>$ttl_r, | ||||
144 | "for"=>$forgot_r, | ||||
145 | "other"=>$other_r, | ||||
146 | "t" => $t_r | ||||
147 | }; | ||||
148 | |||||
149 | 800 | 136ms | 800 | 4.32ms | $data->{inc_vars}->{last_id_RD_ack} = max map{$_->{id}} @cur; # spent 4.32ms making 800 calls to List::Util::max, avg 5µs/call |
150 | } | ||||
151 | } else { | ||||
152 | $data->{inc_vars}->{last_id_RD_ack} = $data->{msg_data}->[-1]->{id}; | ||||
153 | $data->{inc_vars}->{last_id_RA_ack} = $data->{msg_data}->[-1]->{id}; | ||||
154 | } | ||||
155 | |||||
- - | |||||
159 | 1181 | 9.99ms | 1181 | 2.15ms | my $last_useful_id = min( # spent 2.15ms making 1181 calls to List::Util::min, avg 2µs/call |
160 | ( | ||||
161 | $data->{inc_vars}->{last_id_RA}, | ||||
162 | $data->{inc_vars}->{last_id_RA_ack}, | ||||
163 | $data->{inc_vars}->{last_id_RD}, | ||||
164 | $data->{inc_vars}->{last_id_RD_ack} | ||||
165 | ) | ||||
166 | ); | ||||
167 | |||||
168 | 1181 | 640ms | my @newdata = grep {$_->{id} > $last_useful_id} @{$data->{msg_data}}; | ||
169 | 1181 | 1.01s | undef @{$data->{msg_data}}; | ||
170 | 1181 | 4.28ms | $data->{msg_data} = \@newdata; | ||
171 | |||||
172 | 1181 | 26.5ms | 1; | ||
173 | } | ||||
174 | |||||
- - | |||||
178 | # spent 7.04ms (6.67+365µs) within Runner::Stats::computeAtTheEnd which was called:
# once (6.67ms+365µs) by main::RUNTIME at line 134 of runner.pl | ||||
179 | |||||
180 | 1 | 900ns | my $data = shift; | ||
181 | 1 | 2µs | my $command = shift; | ||
182 | |||||
183 | #################################### | ||||
184 | # STUFF COMPUTED AFTER EVERYTHING ELSE | ||||
185 | #################################### | ||||
186 | |||||
187 | 1 | 34µs | if (@{$data->{average_rolling}}) { | ||
188 | $data->{simulation}->{mean_nbh} = | ||||
189 | 1 | 705µs | 1 | 17µs | ( sum map {$_->{h}} @{$data->{average_rolling}} ) / @{$data->{average_rolling}}; # spent 17µs making 1 call to List::Util::sum |
190 | $data->{simulation}->{mean_overhead} = | ||||
191 | 1 | 464µs | 1 | 14µs | ( sum map {$_->{o}} @{$data->{average_rolling}} ) / @{$data->{average_rolling}}; # spent 14µs making 1 call to List::Util::sum |
192 | } else { | ||||
193 | Runner::IO::tprint("Problem : too few delivered messages to make an average of the nbhops, possibly they all got lost\n"); | ||||
194 | $data->{simulation}->{mean_nbh} = -1; | ||||
195 | } | ||||
196 | |||||
197 | 1 | 43µs | if (@{$data->{delivery_rolling_ack}}) { | ||
198 | $data->{simulation}->{total_dr_ack_received} = | ||||
199 | 1 | 1.08ms | 1 | 17µs | ( sum map {$_->{ok} + $_->{for}} @{$data->{delivery_rolling_ack}} ) / @{$data->{delivery_rolling_ack}}; # spent 17µs making 1 call to List::Util::sum |
200 | $data->{simulation}->{total_dr_ack_remembered} = | ||||
201 | 1 | 392µs | 1 | 15µs | ( sum map {$_->{ok}} @{$data->{delivery_rolling_ack}} ) / @{$data->{delivery_rolling_ack}}; # spent 15µs making 1 call to List::Util::sum |
202 | } | ||||
203 | |||||
204 | #Fairness as we do it | ||||
205 | my @cleandata = #BEURK | ||||
206 | 1 | 318µs | grep {($_->{t} ne "blackhole") && ($_->{t} ne "sink") && ($_->{t} ne "SFnode")} @{$data->{nodes}}; | ||
207 | |||||
208 | 1 | 2µs | unless(@cleandata) { | ||
209 | carp("No nodes which are not BH ?\n"); | ||||
210 | $data->{simulation}->{nothing_delivered}=1; | ||||
211 | return 1; | ||||
212 | } else { | ||||
213 | |||||
214 | 1 | 4µs | $data->{simulation}->{nothing_delivered}=0; | ||
215 | |||||
216 | 1 | 114µs | 1 | 7µs | my $sqfairness = ((sum map {$_->{dr}} @cleandata) / @cleandata)**2; # spent 7µs making 1 call to List::Util::sum |
217 | 1 | 118µs | 1 | 4µs | my $fairnesssq = (sum map {$_->{dr}**2} @cleandata) / @cleandata; # spent 4µs making 1 call to List::Util::sum |
218 | 1 | 11µs | $data->{simulation}->{fairness} = sqrt($fairnesssq - $sqfairness); | ||
219 | } | ||||
220 | |||||
221 | #Moustache plot DR/node | ||||
222 | @cleandata = | ||||
223 | sort {$a <=> $b} | ||||
224 | map {$_->{dr}} | ||||
225 | 1 | 385µs | 1 | 63µs | grep {$_->{t} ne "blackhole" && $_->{t} ne "sink" && ($_->{t} ne "SFnode")} @{$data->{nodes}}; # spent 63µs making 1 call to Runner::Stats::CORE:sort |
226 | 1 | 6µs | $data->{simulation}->{boxplot}->[0] = $cleandata[int (@cleandata*0.1)]; | ||
227 | 1 | 2µs | $data->{simulation}->{boxplot}->[1] = $cleandata[int (@cleandata*0.25)]; | ||
228 | 1 | 2µs | $data->{simulation}->{boxplot}->[2] = $cleandata[int (@cleandata*0.5)]; | ||
229 | 1 | 1µs | $data->{simulation}->{boxplot}->[3] = $cleandata[int (@cleandata*0.75)]; | ||
230 | 1 | 2µs | $data->{simulation}->{boxplot}->[4] = $cleandata[int (@cleandata*0.9)]; | ||
231 | |||||
232 | #Stacks ORANGE-like | ||||
233 | 322 | 1.65ms | 502 | 189µs | @cleandata = grep {$_->{t} !~ /blackhole/ && $_->{t} !~ /sink/ && ($_->{t} ne "SFnode")} @{$data->{nodes}}; # spent 189µs making 502 calls to Runner::Stats::CORE:match, avg 377ns/call |
234 | 1 | 68µs | $data->{simulation}->{classes}->[0] = grep {$_->{dr} <= 0} @cleandata; | ||
235 | 1 | 87µs | $data->{simulation}->{classes}->[1] = grep {$_->{dr} > 0.0 && $_->{dr} <= 0.33} @cleandata; | ||
236 | 1 | 83µs | $data->{simulation}->{classes}->[2] = grep {$_->{dr} > 0.33 && $_->{dr} <= 0.66} @cleandata; | ||
237 | 1 | 87µs | $data->{simulation}->{classes}->[3] = grep {$_->{dr} > 0.66 && $_->{dr} < 1} @cleandata; | ||
238 | 1 | 52µs | $data->{simulation}->{classes}->[4] = grep {$_->{dr} >= 1} @cleandata; | ||
239 | |||||
240 | 1 | 42µs | if ( @{$data->{delivery_rolling}} ) { | ||
241 | $data->{simulation}->{total_dr} = | ||||
242 | 1 | 788µs | 1 | 20µs | ( sum map {$_->{ok}} @{$data->{delivery_rolling}} ) / @{$data->{delivery_rolling}}; # spent 20µs making 1 call to List::Util::sum |
243 | $data->{simulation}->{total_ttl} = | ||||
244 | 1 | 477µs | 1 | 18µs | ( sum map {$_->{ttl}} @{$data->{delivery_rolling}} ) / @{$data->{delivery_rolling}}; # spent 18µs making 1 call to List::Util::sum |
245 | |||||
246 | } else { | ||||
247 | carp("Everything is terrible, no delivered messages ? ..."); | ||||
248 | } | ||||
249 | |||||
250 | |||||
251 | 1 | 20µs | return 1; | ||
252 | } | ||||
253 | |||||
- - | |||||
256 | 1 | 9µs | 1; | ||
# spent 189µs within Runner::Stats::CORE:match which was called 502 times, avg 377ns/call:
# 502 times (189µs+0s) by Runner::Stats::computeAtTheEnd at line 233, avg 377ns/call | |||||
# spent 63µs within Runner::Stats::CORE:sort which was called:
# once (63µs+0s) by Runner::Stats::computeAtTheEnd at line 225 |