From 124250b2c2612696bd9418a81a25c72878b420fc Mon Sep 17 00:00:00 2001 From: Brad Hefta-Gaub Date: Fri, 10 Jan 2014 20:38:13 -0800 Subject: [PATCH] changed fmax to std::max --- libraries/shared/src/PacketSender.cpp | 51 ++++++++++++++------------- 1 file changed, 26 insertions(+), 25 deletions(-) diff --git a/libraries/shared/src/PacketSender.cpp b/libraries/shared/src/PacketSender.cpp index a17bc2cfc6..a4d1326067 100644 --- a/libraries/shared/src/PacketSender.cpp +++ b/libraries/shared/src/PacketSender.cpp @@ -8,6 +8,7 @@ // Threaded or non-threaded packet sender. // +#include #include #include @@ -26,7 +27,7 @@ const int PacketSender::MINIMAL_SLEEP_INTERVAL = (USECS_PER_SECOND / TARGET_FPS) const int AVERAGE_CALL_TIME_SAMPLES = 10; -PacketSender::PacketSender(PacketSenderNotify* notify, int packetsPerSecond) : +PacketSender::PacketSender(PacketSenderNotify* notify, int packetsPerSecond) : _packetsPerSecond(packetsPerSecond), _usecsPerProcessCallHint(0), _lastProcessCallTime(0), @@ -66,19 +67,19 @@ bool PacketSender::process() { bool PacketSender::threadedProcess() { bool hasSlept = false; - + if (_lastSendTime == 0) { _lastSendTime = usecTimestampNow(); } - + // in threaded mode, we keep running and just empty our packet queue sleeping enough to keep our PPS on target while (_packets.size() > 0) { // Recalculate our SEND_INTERVAL_USECS each time, in case the caller has changed it on us.. - int packetsPerSecondTarget = (_packetsPerSecond > MINIMUM_PACKETS_PER_SECOND) + int packetsPerSecondTarget = (_packetsPerSecond > MINIMUM_PACKETS_PER_SECOND) ? _packetsPerSecond : MINIMUM_PACKETS_PER_SECOND; uint64_t intervalBetweenSends = USECS_PER_SECOND / packetsPerSecondTarget; - uint64_t sleepInterval = (intervalBetweenSends > SENDING_INTERVAL_ADJUST) ? + uint64_t sleepInterval = (intervalBetweenSends > SENDING_INTERVAL_ADJUST) ? intervalBetweenSends - SENDING_INTERVAL_ADJUST : intervalBetweenSends; // We'll sleep before we send, this way, we can set our last send time to be our ACTUAL last send time @@ -95,10 +96,10 @@ bool PacketSender::threadedProcess() { usleep(usecToSleep); hasSlept = true; } - + // call our non-threaded version of ourselves bool keepRunning = nonThreadedProcess(); - + if (!keepRunning) { break; } @@ -122,9 +123,9 @@ bool PacketSender::threadedProcess() { // just track our call rate (in order to predict our sends per call) but we won't actually send any packets. // // When we are called less frequently than we have packets to send, we will send enough packets per call to keep up with our -// target PPS. +// target PPS. // -// We also keep a running total of packets sent over multiple calls to process() so that we can adjust up or down for +// We also keep a running total of packets sent over multiple calls to process() so that we can adjust up or down for // possible rounding error that would occur if we only considered whole integer packet counts per call to process bool PacketSender::nonThreadedProcess() { uint64_t now = usecTimestampNow(); @@ -136,7 +137,7 @@ bool PacketSender::nonThreadedProcess() { const uint64_t MINIMUM_POSSIBLE_CALL_TIME = 10; // in usecs const uint64_t USECS_PER_SECOND = 1000 * 1000; const float ZERO_RESET_CALLS_PER_SECOND = 1; // used in guard against divide by zero - + // keep track of our process call times, so we have a reliable account of how often our caller calls us uint64_t elapsedSinceLastCall = now - _lastProcessCallTime; _lastProcessCallTime = now; @@ -152,22 +153,22 @@ bool PacketSender::nonThreadedProcess() { if (_packets.size() == 0) { // in non-threaded mode, if there's nothing to do, just return, keep running till they terminate us - return isStillRunning(); + return isStillRunning(); } // This only happens once, the first time we get this far... so we can use it as an accurate initialization - // point for these important timing variables + // point for these important timing variables if (_lastPPSCheck == 0) { _lastPPSCheck = now; // pretend like our lifetime began once call cycle for now, this makes our lifetime PPS start out most accurately _started = now - (uint64_t)averageCallTime; } - + float averagePacketsPerCall = 0; // might be less than 1, if our caller calls us more frequently than the target PPS int packetsSentThisCall = 0; int packetsToSendThisCall = 0; - + // Since we're in non-threaded mode, we need to determine how many packets to send per call to process // based on how often we get called... We do this by keeping a running average of our call times, and we determine // how many packets to send per call @@ -186,40 +187,40 @@ bool PacketSender::nonThreadedProcess() { if (callsPerSecond == 0) { callsPerSecond = ZERO_RESET_CALLS_PER_SECOND; } - + // This is the average number of packets per call... averagePacketsPerCall = _packetsPerSecond / callsPerSecond; packetsToSendThisCall = averagePacketsPerCall; - + // if we get called more than 1 per second, we want to mostly divide the packets evenly across the calls... // but we want to track the remainder and make sure over the course of a second, we are sending the target PPS - // e.g. + // e.g. // 200pps called 60 times per second... // 200/60 = 3.333... so really... // each call we should send 3 // every 3rd call we should send 4... // 3,3,4,3,3,4...3,3,4 = 200... - + // if we get called less than 1 per second, then we want to send more than our PPS each time... // e.g. // 200pps called ever 1332.5ms // 200 / (1000/1332.5) = 200/(0.7505) = 266.5 packets per call - // so... + // so... // every other call we should send 266 packets // then on the next call we should send 267 packets - + // So no mater whether or not we're getting called more or less than once per second, we still need to do some bookkeeping // to make sure we send a few extra packets to even out our flow rate. uint64_t elapsedSinceLastCheck = now - _lastPPSCheck; - + // we might want to tun this in the future and only check after a certain number of call intervals. for now we check // each time and adjust accordingly const float CALL_INTERVALS_TO_CHECK = 1; const float MIN_CALL_INTERVALS_PER_RESET = 5; - + // we will reset our check PPS and time each second (callsPerSecond) or at least 5 calls (if we get called less frequently // than 5 times per second) This gives us sufficient smoothing in our packet adjustments - float callIntervalsPerReset = fmax(callsPerSecond, MIN_CALL_INTERVALS_PER_RESET); + float callIntervalsPerReset = std::max(callsPerSecond, MIN_CALL_INTERVALS_PER_RESET); if (elapsedSinceLastCheck > (averageCallTime * CALL_INTERVALS_TO_CHECK)) { float ppsOverCheckInterval = (float)_packetsOverCheckInterval; @@ -232,7 +233,7 @@ bool PacketSender::nonThreadedProcess() { int adjust = ppsOverCheckInterval - ppsExpectedForCheckInterval; packetsToSendThisCall -= adjust; } - + // now, do we want to reset the check interval? don't want to completely reset, because we would still have // a rounding error. instead, we check to see that we've passed the reset interval (which is much larger than // the check interval), and on those reset intervals we take the second half average and keep that for the next @@ -245,7 +246,7 @@ bool PacketSender::nonThreadedProcess() { elapsedSinceLastCheck = now - _lastPPSCheck; } } - + int packetsLeft = _packets.size(); // Now that we know how many packets to send this call to process, just send them.