|
74 |
uint32_t m_txrate; ///< current transmit rate |
74 |
uint32_t m_txrate; ///< current transmit rate |
75 |
|
75 |
|
76 |
bool m_initialized; ///< for initializing tables |
76 |
bool m_initialized; ///< for initializing tables |
|
|
77 |
|
78 |
MinstrelRate m_minstrelTable; ///< minstrel table |
79 |
SampleRate m_sampleTable; ///< sample table |
77 |
}; |
80 |
}; |
78 |
|
81 |
|
79 |
NS_OBJECT_ENSURE_REGISTERED (MinstrelWifiManager); |
82 |
NS_OBJECT_ENSURE_REGISTERED (MinstrelWifiManager); |
|
206 |
// to make sure that the set of supported rates has been initialized |
209 |
// to make sure that the set of supported rates has been initialized |
207 |
// before we perform our own initialization. |
210 |
// before we perform our own initialization. |
208 |
m_nsupported = GetNSupported (station); |
211 |
m_nsupported = GetNSupported (station); |
209 |
m_minstrelTable = MinstrelRate (m_nsupported); |
212 |
station->m_minstrelTable = MinstrelRate (m_nsupported); |
210 |
m_sampleTable = SampleRate (m_nsupported, std::vector<uint32_t> (m_sampleCol)); |
213 |
station->m_sampleTable = SampleRate (m_nsupported, std::vector<uint32_t> (m_sampleCol)); |
211 |
InitSampleTable (station); |
214 |
InitSampleTable (station); |
212 |
RateInit (station); |
215 |
RateInit (station); |
213 |
station->m_initialized = true; |
216 |
station->m_initialized = true; |
|
278 |
if (!station->m_isSampling) |
281 |
if (!station->m_isSampling) |
279 |
{ |
282 |
{ |
280 |
/// use best throughput rate |
283 |
/// use best throughput rate |
281 |
if (station->m_longRetry < m_minstrelTable[station->m_txrate].adjustedRetryCount) |
284 |
if (station->m_longRetry < station->m_minstrelTable[station->m_txrate].adjustedRetryCount) |
282 |
{ |
285 |
{ |
283 |
; ///< there's still a few retries left |
286 |
; ///< there's still a few retries left |
284 |
} |
287 |
} |
285 |
|
288 |
|
286 |
/// use second best throughput rate |
289 |
/// use second best throughput rate |
287 |
else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
290 |
else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
288 |
m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
291 |
station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
289 |
{ |
292 |
{ |
290 |
station->m_txrate = station->m_maxTpRate2; |
293 |
station->m_txrate = station->m_maxTpRate2; |
291 |
} |
294 |
} |
292 |
|
295 |
|
293 |
/// use best probability rate |
296 |
/// use best probability rate |
294 |
else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
297 |
else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
295 |
m_minstrelTable[station->m_maxTpRate2].adjustedRetryCount + |
298 |
station->m_minstrelTable[station->m_maxTpRate2].adjustedRetryCount + |
296 |
m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
299 |
station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
297 |
{ |
300 |
{ |
298 |
station->m_txrate = station->m_maxProbRate; |
301 |
station->m_txrate = station->m_maxProbRate; |
299 |
} |
302 |
} |
300 |
|
303 |
|
301 |
/// use lowest base rate |
304 |
/// use lowest base rate |
302 |
else if (station->m_longRetry > (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
305 |
else if (station->m_longRetry > (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
303 |
m_minstrelTable[station->m_maxTpRate2].adjustedRetryCount + |
306 |
station->m_minstrelTable[station->m_maxTpRate2].adjustedRetryCount + |
304 |
m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
307 |
station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
305 |
{ |
308 |
{ |
306 |
station->m_txrate = 0; |
309 |
station->m_txrate = 0; |
307 |
} |
310 |
} |
|
314 |
if (station->m_sampleRateSlower) |
317 |
if (station->m_sampleRateSlower) |
315 |
{ |
318 |
{ |
316 |
/// use best throughput rate |
319 |
/// use best throughput rate |
317 |
if (station->m_longRetry < m_minstrelTable[station->m_txrate].adjustedRetryCount) |
320 |
if (station->m_longRetry < station->m_minstrelTable[station->m_txrate].adjustedRetryCount) |
318 |
{ |
321 |
{ |
319 |
; ///< there are a few retries left |
322 |
; ///< there are a few retries left |
320 |
} |
323 |
} |
321 |
|
324 |
|
322 |
/// use random rate |
325 |
/// use random rate |
323 |
else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
326 |
else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
324 |
m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
327 |
station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
325 |
{ |
328 |
{ |
326 |
station->m_txrate = station->m_sampleRate; |
329 |
station->m_txrate = station->m_sampleRate; |
327 |
} |
330 |
} |
328 |
|
331 |
|
329 |
/// use max probability rate |
332 |
/// use max probability rate |
330 |
else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
333 |
else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
331 |
m_minstrelTable[station->m_sampleRate].adjustedRetryCount + |
334 |
station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount + |
332 |
m_minstrelTable[station->m_maxTpRate].adjustedRetryCount )) |
335 |
station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount )) |
333 |
{ |
336 |
{ |
334 |
station->m_txrate = station->m_maxProbRate; |
337 |
station->m_txrate = station->m_maxProbRate; |
335 |
} |
338 |
} |
336 |
|
339 |
|
337 |
/// use lowest base rate |
340 |
/// use lowest base rate |
338 |
else if (station->m_longRetry > (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
341 |
else if (station->m_longRetry > (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
339 |
m_minstrelTable[station->m_sampleRate].adjustedRetryCount + |
342 |
station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount + |
340 |
m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
343 |
station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)) |
341 |
{ |
344 |
{ |
342 |
station->m_txrate = 0; |
345 |
station->m_txrate = 0; |
343 |
} |
346 |
} |
|
347 |
else |
350 |
else |
348 |
{ |
351 |
{ |
349 |
/// use random rate |
352 |
/// use random rate |
350 |
if (station->m_longRetry < m_minstrelTable[station->m_txrate].adjustedRetryCount) |
353 |
if (station->m_longRetry < station->m_minstrelTable[station->m_txrate].adjustedRetryCount) |
351 |
{ |
354 |
{ |
352 |
; ///< keep using it |
355 |
; ///< keep using it |
353 |
} |
356 |
} |
354 |
|
357 |
|
355 |
/// use the best rate |
358 |
/// use the best rate |
356 |
else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
359 |
else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
357 |
m_minstrelTable[station->m_sampleRate].adjustedRetryCount)) |
360 |
station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount)) |
358 |
{ |
361 |
{ |
359 |
station->m_txrate = station->m_maxTpRate; |
362 |
station->m_txrate = station->m_maxTpRate; |
360 |
} |
363 |
} |
361 |
|
364 |
|
362 |
/// use the best probability rate |
365 |
/// use the best probability rate |
363 |
else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
366 |
else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
364 |
m_minstrelTable[station->m_maxTpRate].adjustedRetryCount + |
367 |
station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount + |
365 |
m_minstrelTable[station->m_sampleRate].adjustedRetryCount)) |
368 |
station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount)) |
366 |
{ |
369 |
{ |
367 |
station->m_txrate = station->m_maxProbRate; |
370 |
station->m_txrate = station->m_maxProbRate; |
368 |
} |
371 |
} |
369 |
|
372 |
|
370 |
/// use the lowest base rate |
373 |
/// use the lowest base rate |
371 |
else if (station->m_longRetry > (m_minstrelTable[station->m_txrate].adjustedRetryCount + |
374 |
else if (station->m_longRetry > (station->m_minstrelTable[station->m_txrate].adjustedRetryCount + |
372 |
m_minstrelTable[station->m_maxTpRate].adjustedRetryCount + |
375 |
station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount + |
373 |
m_minstrelTable[station->m_sampleRate].adjustedRetryCount)) |
376 |
station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount)) |
374 |
{ |
377 |
{ |
375 |
station->m_txrate = 0; |
378 |
station->m_txrate = 0; |
376 |
} |
379 |
} |
|
393 |
return; |
396 |
return; |
394 |
} |
397 |
} |
395 |
|
398 |
|
396 |
m_minstrelTable[station->m_txrate].numRateSuccess++; |
399 |
station->m_minstrelTable[station->m_txrate].numRateSuccess++; |
397 |
m_minstrelTable[station->m_txrate].numRateAttempt++; |
400 |
station->m_minstrelTable[station->m_txrate].numRateAttempt++; |
398 |
|
401 |
|
399 |
UpdateRetry (station); |
402 |
UpdateRetry (station); |
400 |
|
403 |
|
401 |
m_minstrelTable[station->m_txrate].numRateAttempt += station->m_retry; |
404 |
station->m_minstrelTable[station->m_txrate].numRateAttempt += station->m_retry; |
402 |
station->m_packetCount++; |
405 |
station->m_packetCount++; |
403 |
|
406 |
|
404 |
if (m_nsupported >= 1) |
407 |
if (m_nsupported >= 1) |
|
418 |
|
421 |
|
419 |
UpdateRetry (station); |
422 |
UpdateRetry (station); |
420 |
|
423 |
|
421 |
m_minstrelTable[station->m_txrate].numRateAttempt += station->m_retry; |
424 |
station->m_minstrelTable[station->m_txrate].numRateAttempt += station->m_retry; |
422 |
station->m_err++; |
425 |
station->m_err++; |
423 |
|
426 |
|
424 |
if (m_nsupported >= 1) |
427 |
if (m_nsupported >= 1) |
|
469 |
MinstrelWifiManager::GetNextSample (MinstrelWifiRemoteStation *station) |
472 |
MinstrelWifiManager::GetNextSample (MinstrelWifiRemoteStation *station) |
470 |
{ |
473 |
{ |
471 |
uint32_t bitrate; |
474 |
uint32_t bitrate; |
472 |
bitrate = m_sampleTable[station->m_index][station->m_col]; |
475 |
bitrate = station->m_sampleTable[station->m_index][station->m_col]; |
473 |
station->m_index++; |
476 |
station->m_index++; |
474 |
|
477 |
|
475 |
/// bookeeping for m_index and m_col variables |
478 |
/// bookeeping for m_index and m_col variables |
|
550 |
|
553 |
|
551 |
/// is this rate slower than the current best rate |
554 |
/// is this rate slower than the current best rate |
552 |
station->m_sampleRateSlower = |
555 |
station->m_sampleRateSlower = |
553 |
(m_minstrelTable[idx].perfectTxTime > m_minstrelTable[station->m_maxTpRate].perfectTxTime); |
556 |
(station->m_minstrelTable[idx].perfectTxTime > station->m_minstrelTable[station->m_maxTpRate].perfectTxTime); |
554 |
|
557 |
|
555 |
/// using the best rate instead |
558 |
/// using the best rate instead |
556 |
if (station->m_sampleRateSlower) |
559 |
if (station->m_sampleRateSlower) |
|
596 |
{ |
599 |
{ |
597 |
|
600 |
|
598 |
/// calculate the perfect tx time for this rate |
601 |
/// calculate the perfect tx time for this rate |
599 |
txTime = m_minstrelTable[i].perfectTxTime; |
602 |
txTime = station->m_minstrelTable[i].perfectTxTime; |
600 |
|
603 |
|
601 |
/// just for initialization |
604 |
/// just for initialization |
602 |
if (txTime.GetMicroSeconds () == 0) |
605 |
if (txTime.GetMicroSeconds () == 0) |
|
605 |
} |
608 |
} |
606 |
|
609 |
|
607 |
NS_LOG_DEBUG ("m_txrate=" << station->m_txrate << |
610 |
NS_LOG_DEBUG ("m_txrate=" << station->m_txrate << |
608 |
"\t attempt=" << m_minstrelTable[i].numRateAttempt << |
611 |
"\t attempt=" << station->m_minstrelTable[i].numRateAttempt << |
609 |
"\t success=" << m_minstrelTable[i].numRateSuccess); |
612 |
"\t success=" << station->m_minstrelTable[i].numRateSuccess); |
610 |
|
613 |
|
611 |
/// if we've attempted something |
614 |
/// if we've attempted something |
612 |
if (m_minstrelTable[i].numRateAttempt) |
615 |
if (station->m_minstrelTable[i].numRateAttempt) |
613 |
{ |
616 |
{ |
614 |
/** |
617 |
/** |
615 |
* calculate the probability of success |
618 |
* calculate the probability of success |
616 |
* assume probability scales from 0 to 18000 |
619 |
* assume probability scales from 0 to 18000 |
617 |
*/ |
620 |
*/ |
618 |
tempProb = (m_minstrelTable[i].numRateSuccess * 18000) / m_minstrelTable[i].numRateAttempt; |
621 |
tempProb = (station->m_minstrelTable[i].numRateSuccess * 18000) / station->m_minstrelTable[i].numRateAttempt; |
619 |
|
622 |
|
620 |
/// bookeeping |
623 |
/// bookeeping |
621 |
m_minstrelTable[i].successHist += m_minstrelTable[i].numRateSuccess; |
624 |
station->m_minstrelTable[i].successHist += station->m_minstrelTable[i].numRateSuccess; |
622 |
m_minstrelTable[i].attemptHist += m_minstrelTable[i].numRateAttempt; |
625 |
station->m_minstrelTable[i].attemptHist += station->m_minstrelTable[i].numRateAttempt; |
623 |
m_minstrelTable[i].prob = tempProb; |
626 |
station->m_minstrelTable[i].prob = tempProb; |
624 |
|
627 |
|
625 |
/// ewma probability (cast for gcc 3.4 compatibility) |
628 |
/// ewma probability (cast for gcc 3.4 compatibility) |
626 |
tempProb = static_cast<uint32_t> (((tempProb * (100 - m_ewmaLevel)) + (m_minstrelTable[i].ewmaProb * m_ewmaLevel) ) / 100); |
629 |
tempProb = static_cast<uint32_t> (((tempProb * (100 - m_ewmaLevel)) + (station->m_minstrelTable[i].ewmaProb * m_ewmaLevel) ) / 100); |
627 |
|
630 |
|
628 |
m_minstrelTable[i].ewmaProb = tempProb; |
631 |
station->m_minstrelTable[i].ewmaProb = tempProb; |
629 |
|
632 |
|
630 |
/// calculating throughput |
633 |
/// calculating throughput |
631 |
m_minstrelTable[i].throughput = tempProb * (1000000 / txTime.GetMicroSeconds ()); |
634 |
station->m_minstrelTable[i].throughput = tempProb * (1000000 / txTime.GetMicroSeconds ()); |
632 |
|
635 |
|
633 |
} |
636 |
} |
634 |
|
637 |
|
635 |
/// bookeeping |
638 |
/// bookeeping |
636 |
m_minstrelTable[i].prevNumRateAttempt = m_minstrelTable[i].numRateAttempt; |
639 |
station->m_minstrelTable[i].prevNumRateAttempt = station->m_minstrelTable[i].numRateAttempt; |
637 |
m_minstrelTable[i].prevNumRateSuccess = m_minstrelTable[i].numRateSuccess; |
640 |
station->m_minstrelTable[i].prevNumRateSuccess = station->m_minstrelTable[i].numRateSuccess; |
638 |
m_minstrelTable[i].numRateSuccess = 0; |
641 |
station->m_minstrelTable[i].numRateSuccess = 0; |
639 |
m_minstrelTable[i].numRateAttempt = 0; |
642 |
station->m_minstrelTable[i].numRateAttempt = 0; |
640 |
|
643 |
|
641 |
/// Sample less often below 10% and above 95% of success |
644 |
/// Sample less often below 10% and above 95% of success |
642 |
if ((m_minstrelTable[i].ewmaProb > 17100) || (m_minstrelTable[i].ewmaProb < 1800)) |
645 |
if ((station->m_minstrelTable[i].ewmaProb > 17100) || (station->m_minstrelTable[i].ewmaProb < 1800)) |
643 |
{ |
646 |
{ |
644 |
/** |
647 |
/** |
645 |
* retry count denotes the number of retries permitted for each rate |
648 |
* retry count denotes the number of retries permitted for each rate |
646 |
* # retry_count/2 |
649 |
* # retry_count/2 |
647 |
*/ |
650 |
*/ |
648 |
m_minstrelTable[i].adjustedRetryCount = m_minstrelTable[i].retryCount >> 1; |
651 |
station->m_minstrelTable[i].adjustedRetryCount = station->m_minstrelTable[i].retryCount >> 1; |
649 |
if (m_minstrelTable[i].adjustedRetryCount > 2) |
652 |
if (station->m_minstrelTable[i].adjustedRetryCount > 2) |
650 |
{ |
653 |
{ |
651 |
m_minstrelTable[i].adjustedRetryCount = 2; |
654 |
station->m_minstrelTable[i].adjustedRetryCount = 2; |
652 |
} |
655 |
} |
653 |
} |
656 |
} |
654 |
else |
657 |
else |
655 |
{ |
658 |
{ |
656 |
m_minstrelTable[i].adjustedRetryCount = m_minstrelTable[i].retryCount; |
659 |
station->m_minstrelTable[i].adjustedRetryCount = station->m_minstrelTable[i].retryCount; |
657 |
} |
660 |
} |
658 |
|
661 |
|
659 |
/// if it's 0 allow one retry limit |
662 |
/// if it's 0 allow one retry limit |
660 |
if (m_minstrelTable[i].adjustedRetryCount == 0) |
663 |
if (station->m_minstrelTable[i].adjustedRetryCount == 0) |
661 |
{ |
664 |
{ |
662 |
m_minstrelTable[i].adjustedRetryCount = 1; |
665 |
station->m_minstrelTable[i].adjustedRetryCount = 1; |
663 |
} |
666 |
} |
664 |
} |
667 |
} |
665 |
|
668 |
|
|
669 |
/// go find max throughput, second maximum throughput, high probability succ |
672 |
/// go find max throughput, second maximum throughput, high probability succ |
670 |
for (uint32_t i = 0; i < m_nsupported; i++) |
673 |
for (uint32_t i = 0; i < m_nsupported; i++) |
671 |
{ |
674 |
{ |
672 |
NS_LOG_DEBUG ("throughput" << m_minstrelTable[i].throughput << |
675 |
NS_LOG_DEBUG ("throughput" << station->m_minstrelTable[i].throughput << |
673 |
"\n ewma" << m_minstrelTable[i].ewmaProb); |
676 |
"\n ewma" << station->m_minstrelTable[i].ewmaProb); |
674 |
|
677 |
|
675 |
if (max_tp < m_minstrelTable[i].throughput) |
678 |
if (max_tp < station->m_minstrelTable[i].throughput) |
676 |
{ |
679 |
{ |
677 |
index_max_tp = i; |
680 |
index_max_tp = i; |
678 |
max_tp = m_minstrelTable[i].throughput; |
681 |
max_tp = station->m_minstrelTable[i].throughput; |
679 |
} |
682 |
} |
680 |
|
683 |
|
681 |
if (max_prob < m_minstrelTable[i].ewmaProb) |
684 |
if (max_prob < station->m_minstrelTable[i].ewmaProb) |
682 |
{ |
685 |
{ |
683 |
index_max_prob = i; |
686 |
index_max_prob = i; |
684 |
max_prob = m_minstrelTable[i].ewmaProb; |
687 |
max_prob = station->m_minstrelTable[i].ewmaProb; |
685 |
} |
688 |
} |
686 |
} |
689 |
} |
687 |
|
690 |
|
|
690 |
/// find the second highest max |
693 |
/// find the second highest max |
691 |
for (uint32_t i = 0; i < m_nsupported; i++) |
694 |
for (uint32_t i = 0; i < m_nsupported; i++) |
692 |
{ |
695 |
{ |
693 |
if ((i != index_max_tp) && (max_tp < m_minstrelTable[i].throughput)) |
696 |
if ((i != index_max_tp) && (max_tp < station->m_minstrelTable[i].throughput)) |
694 |
{ |
697 |
{ |
695 |
index_max_tp2 = i; |
698 |
index_max_tp2 = i; |
696 |
max_tp = m_minstrelTable[i].throughput; |
699 |
max_tp = station->m_minstrelTable[i].throughput; |
697 |
} |
700 |
} |
698 |
} |
701 |
} |
699 |
|
702 |
|
|
710 |
NS_LOG_DEBUG ("max tp=" << index_max_tp << "\nmax tp2=" << index_max_tp2 << "\nmax prob=" << index_max_prob); |
713 |
NS_LOG_DEBUG ("max tp=" << index_max_tp << "\nmax tp2=" << index_max_tp2 << "\nmax prob=" << index_max_prob); |
711 |
|
714 |
|
712 |
/// reset it |
715 |
/// reset it |
713 |
RateInit (station); |
716 |
//RateInit (station); |
714 |
} |
717 |
} |
715 |
|
718 |
|
716 |
void |
719 |
void |
|
720 |
|
723 |
|
721 |
for (uint32_t i = 0; i < m_nsupported; i++) |
724 |
for (uint32_t i = 0; i < m_nsupported; i++) |
722 |
{ |
725 |
{ |
723 |
m_minstrelTable[i].numRateAttempt = 0; |
726 |
station->m_minstrelTable[i].numRateAttempt = 0; |
724 |
m_minstrelTable[i].numRateSuccess = 0; |
727 |
station->m_minstrelTable[i].numRateSuccess = 0; |
725 |
m_minstrelTable[i].prob = 0; |
728 |
station->m_minstrelTable[i].prob = 0; |
726 |
m_minstrelTable[i].ewmaProb = 0; |
729 |
station->m_minstrelTable[i].ewmaProb = 0; |
727 |
m_minstrelTable[i].prevNumRateAttempt = 0; |
730 |
station->m_minstrelTable[i].prevNumRateAttempt = 0; |
728 |
m_minstrelTable[i].prevNumRateSuccess = 0; |
731 |
station->m_minstrelTable[i].prevNumRateSuccess = 0; |
729 |
m_minstrelTable[i].successHist = 0; |
732 |
station->m_minstrelTable[i].successHist = 0; |
730 |
m_minstrelTable[i].attemptHist = 0; |
733 |
station->m_minstrelTable[i].attemptHist = 0; |
731 |
m_minstrelTable[i].throughput = 0; |
734 |
station->m_minstrelTable[i].throughput = 0; |
732 |
m_minstrelTable[i].perfectTxTime = GetCalcTxTime (GetSupported (station, i)); |
735 |
station->m_minstrelTable[i].perfectTxTime = GetCalcTxTime (GetSupported (station, i)); |
733 |
m_minstrelTable[i].retryCount = 1; |
736 |
station->m_minstrelTable[i].retryCount = 1; |
734 |
m_minstrelTable[i].adjustedRetryCount = 1; |
737 |
station->m_minstrelTable[i].adjustedRetryCount = 1; |
735 |
} |
738 |
} |
736 |
} |
739 |
} |
737 |
|
740 |
|
|
759 |
newIndex = (i + uv) % numSampleRates; |
762 |
newIndex = (i + uv) % numSampleRates; |
760 |
|
763 |
|
761 |
/// this loop is used for filling in other uninitilized places |
764 |
/// this loop is used for filling in other uninitilized places |
762 |
while (m_sampleTable[newIndex][col] != 0) |
765 |
while (station->m_sampleTable[newIndex][col] != 0) |
763 |
{ |
766 |
{ |
764 |
newIndex = (newIndex + 1) % m_nsupported; |
767 |
newIndex = (newIndex + 1) % m_nsupported; |
765 |
} |
768 |
} |
766 |
m_sampleTable[newIndex][col] = i; |
769 |
station->m_sampleTable[newIndex][col] = i; |
767 |
|
770 |
|
768 |
} |
771 |
} |
769 |
} |
772 |
} |
|
779 |
{ |
782 |
{ |
780 |
for (uint32_t j = 0; j < m_sampleCol; j++) |
783 |
for (uint32_t j = 0; j < m_sampleCol; j++) |
781 |
{ |
784 |
{ |
782 |
std::cout << m_sampleTable[i][j] << "\t"; |
785 |
std::cout << station->m_sampleTable[i][j] << "\t"; |
783 |
} |
786 |
} |
784 |
std::cout << std::endl; |
787 |
std::cout << std::endl; |
785 |
} |
788 |
} |
|
792 |
|
795 |
|
793 |
for (uint32_t i = 0; i < m_nsupported; i++) |
796 |
for (uint32_t i = 0; i < m_nsupported; i++) |
794 |
{ |
797 |
{ |
795 |
std::cout << "index(" << i << ") = " << m_minstrelTable[i].perfectTxTime << "\n"; |
798 |
std::cout << "index(" << i << ") = " << station->m_minstrelTable[i].perfectTxTime << "\n"; |
796 |
} |
799 |
} |
797 |
} |
800 |
} |
798 |
|
801 |
|