source: umon/main/common/timestuff.c @ b987a75

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * timestuff.c
 *
 * These functions support the monitor's ability to deal with elapsed
 * time on targets with or without hardware-timer support.
 *
 * The INCLUDE_HWTMR definition in config.h determines which mode
 * the timer will run in.
 *
 * The monitor does not require any hardware-assist for maintaining
 * elapsed time.  With no hardware assist (INCLUDE_HWTMR set to 0),
 * the value of LOOPS_PER_SECOND must be established in config.h, and
 * can be calibrated using the '-c' option in the sleep command.  Even
 * with this calibration the accuracy of this mechanism is limited;
 * however, since there is no code in the monitor that really requires
 * extremely accurate timing this may be ok.
 * 
 * On the other hand, it is preferrable to have accuracy, so on targets
 * that have a pollable clock,  the hooks can be put in place to allow
 * that clock to be used as the hardware assist for the monitor's 
 * elapsed time measurements.  The INCLUDE_HWTMR is set to 1, and 
 * TIMER_TICKS_PER_MSEC defines the number of ticks of the timer that
 * correspond to 1 millisecond of elapsed time.  The function target_timer() 
 * is assumed to be established and must return an unsigned long value
 * that is the content of the polled hardware timer.
 *
 * Regardless of the hardware-assist or not, the following interface is
 * used by the code in the monitor...
 *
 *      #include "timer.h"
 *
 *      struct elapsed_tmr tmr;
 *
 *      startElapsedTimer(&tmr,TIMEOUT):
 *      do {
 *              SOMETHING();
 *      } while(!msecElapsed(&tmr));
 *
 * Refer to the functions startElapsedTimer() and msecElapsed() below for
 * more details.
 * 
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */

#include "config.h"
#include "stddefs.h"
#include "cli.h"
#include "genlib.h"
#include "ether.h"
#include "timer.h"
#include "cpuio.h"

/* startElapsedTimer() & msecElapsed():
 * The timer is started by loading the values timeout_low and timeout_high
 * with the number of ticks that must elapse for the timer to expire.
 *
 * In the case of the non-hardware-assisted timer, the expiration count
 * is based on the value of LoopsPerMillisecond (derived from the 
 * LOOPS_PER_SECOND definition in config.h).  Each time msecElapsed()
 * is called the elapsed count is incremented until it exceeds the timeout
 * timeout_low timeout_high values recorded by startElapsedTimer().
 * 
 * The case of the hardware-assisted timer is similar except that now
 * the number of ticks initialized in timeout_low and timeout_high are
 * based on the tick rate of the hardware timer (TIMER_TICKS_PER_MSEC).
 * This value is expected to be set in config.h.  Each time msecElapsed()
 * is called, it samples the timer and adds to the running total of ticks
 * until it matches or exceeds the timeout_low and timeout_high values.
 *
 * Notice that 64-bit values are used (high & low) because a 32-bit value
 * isn't large enough to deal with the tick rates (per second) of various
 * CPUs. 
 */
void
startElapsedTimer(struct elapsed_tmr *tmr, long milliseconds)
{
        unsigned long new_tm_low;
        unsigned long stepmsecs, stepticks, remainder;

#if INCLUDE_HWTMR
        tmr->tmrflags = HWTMR_ENABLED;
        tmr->tpm = (unsigned long)TIMER_TICKS_PER_MSEC;
#else
        tmr->tmrflags = 0;
        tmr->tpm = (unsigned long)LoopsPerMillisecond;
#endif
        
        tmr->elapsed_low = 0;
        tmr->elapsed_high = 0;
        tmr->timeout_high = 0;
        tmr->timeout_low = 0;
        
        /* Convert incoming timeout from a millisecond count to a
         * tick count...
         * Maximum number of milliseconds and ticks before 32-bit
         * (tick counter) unsigned long overlaps
         */
        stepmsecs = 0xffffffff / tmr->tpm;
        stepticks = stepmsecs * tmr->tpm;
        remainder = (milliseconds % stepmsecs);

        /* Take care of the step remainder
         */
        tmr->timeout_low = remainder * tmr->tpm;
        milliseconds -= remainder;

        for (;milliseconds; milliseconds -= stepmsecs) {
                new_tm_low = tmr->timeout_low + stepticks;

                if (new_tm_low < tmr->timeout_low)
                        tmr->timeout_high++;
                tmr->timeout_low = new_tm_low;
        }
        
#if INCLUDE_HWTMR
        tmr->tmrval = target_timer();
#else
        tmr->tmrval = 0;
#endif

}

int
msecElapsed(struct elapsed_tmr *tmr)
{
        ulong new_elapsed_low, new_tmrval, elapsed;

        /* If timeout has already occurred, then we can assume that this
         * function being called without a matching startElapsedTimer() call.
         */
        if (ELAPSED_TIMEOUT(tmr))
                return(1);

#if INCLUDE_HWTMR
        new_tmrval = target_timer();
#else
        new_tmrval = tmr->tmrval + 1;
#endif

        /* Record how many ticks elapsed since the last call to msecElapsed
         * and add that value to the total number of ticks that have elapsed.
         */
        elapsed = new_tmrval - tmr->tmrval;
        new_elapsed_low = tmr->elapsed_low + elapsed;

        if (new_elapsed_low < tmr->elapsed_low)
                tmr->elapsed_high++;

        /* If the total elapsed number of ticks exceeds the timeout number
         * of ticks, then we can return 1 to indicate that the requested
         * amount of time has elapsed.  Otherwise, we record the values and
         * return 0.
         */
        if ((tmr->elapsed_high >= tmr->timeout_high) &&
                (new_elapsed_low >= tmr->timeout_low)) {
                tmr->tmrflags |= TIMEOUT_OCCURRED;
                return(1);
        }
        
        tmr->tmrval = new_tmrval;
        tmr->elapsed_low = new_elapsed_low;
        return(0);
}

/* msecRemainging():
 * Used to query how many milliseconds were left (if any) in the timeout.
 */
ulong
msecRemaining(struct elapsed_tmr *tmr)
{
        ulong high, low, msectot, leftover, divisor;

        if (ELAPSED_TIMEOUT(tmr))
                return(0);
        
        high = tmr->timeout_high - tmr->elapsed_high;
        low = tmr->timeout_low - tmr->elapsed_low;

        msectot = leftover = 0;

#if INCLUDE_HWTMR
        divisor = (ulong)TIMER_TICKS_PER_MSEC;
#else
        divisor = (ulong)LoopsPerMillisecond;
#endif

        while(1) {
                while (low > divisor) {
                        msectot++;
                        low -= divisor;
                }
                leftover += low;
                if (high == 0)
                        break;
                else {
                        high--;
                        low = 0xffffffff;
                }
        } 

        while(leftover > divisor) {
                msectot++;
                low -= divisor;
        }
        return(msectot);
}

/* monDelay():
 * Delay for specified number of milliseconds.
 * Refer to msecElapsed() description for a discussion on the
 * accuracy of this delay.
 */
void
monDelay(int milliseconds)
{
        struct elapsed_tmr tmr;

        startElapsedTimer(&tmr,milliseconds);
        while(!msecElapsed(&tmr)) {
                WATCHDOG_MACRO;
                pollethernet();
        }
}

/* monTimer():
 * Provide the API with the ability to start a millisecond-granularity
 * timer with some countdown value, and poll it waiting for completion.
 */
int
monTimer(int cmd, void *arg)
{
        int rc = 0;
        struct elapsed_tmr *tmr = (struct elapsed_tmr *)arg;

        switch(cmd) {
                case TIMER_START:
                        startElapsedTimer(tmr,tmr->start);
                        break;
                case TIMER_ELAPSED:
                        msecElapsed(tmr);
                        if (ELAPSED_TIMEOUT(tmr))
                                rc = 1;
                        break;
                case TIMER_QUERY:
#if INCLUDE_HWTMR
                        tmr->tmrflags = HWTMR_ENABLED;
                        tmr->tpm = (unsigned long)TIMER_TICKS_PER_MSEC;
                        tmr->currenttmrval = target_timer();
#else
                        tmr->tmrflags = 0;
                        tmr->tpm = (unsigned long)LoopsPerMillisecond;
                        tmr->currenttmrval = 0;
#endif
                        break;
                default:
                        rc = -1;
                        break;
        }
        return(rc);
}

#if INCLUDE_TFSSCRIPT

/* Sleep():
 *      Simple delay loop accessible by the command line.
 *      This loop count is dependent on the underlying hardware.
 *      The LoopsPerMillisecond count is loaded with a default at startup, or
 *  it can be calibrated by the user via the -c option.
 *      Note that this LoopsPerMillisecond value is used in a few other places
 *      in the monitor also for time-dependent stuff.
 *      NOTES:
 *      - This is obviously not real accurate (not intended to be), but allows the
 *        monitor to be independent of the underlying hardware.
 *      - The delay time is very dependent on ethernet activity, since the call
 *        to pollethernet() part of the loop.
 */


char *SleepHelp[] = {
        "Second or msec delay (not precise)",
        "-[clmv:] {count}",
#if INCLUDE_VERBOSEHELP
        " -c  calibrate new LPS count",
        " -l  store LPS count",
        " -m  millisecond",
        " -v {LPSvarname}",
#endif
        0,
};

int
Sleep(int argc,char *argv[])
{
        int opt, calibrate, count, multiplier;

        multiplier = 1000;
        calibrate = 0;
        while ((opt=getopt(argc,argv,"clmv:")) != -1) {
                switch(opt) {
                case 'c':
                        calibrate = 2;
                        break;
                case 'l':
                        calibrate = 1;
                        break;
                case 'm':
                        multiplier = 1;
                        break;
                case 'v':
                        shell_sprintf(optarg,"%d",LoopsPerMillisecond*1000);
                        return(CMD_SUCCESS);
                default:
                        return(CMD_PARAM_ERROR);
                }
        }

        /* If no args, just print the current LPS value and return... */
        if (argc == 1) {
#if INCLUDE_HWTMR
                printf("Hardware-based timer, LPS not applicable\n");
#else
                printf("Current LPS = %ld\n",LoopsPerMillisecond * 1000);
#endif
                return(CMD_SUCCESS);
        }

        /* For calibration, take in the count on the command line, then use
         * it to put out 5 dots dot at the rate of the loop to allow the user
         * to adjust it to be about 1 second.
         */
        if (calibrate) {
#if INCLUDE_HWTMR
                printf("Hardware-based timer, doesn't calibrate\n");
#else
                long lps;

                if (argc != optind+1)
                        return(CMD_PARAM_ERROR);

                printf("Current LPS: %ld\n",LoopsPerMillisecond * 1000);
                lps = strtol(argv[optind],0,0);
                LoopsPerMillisecond = lps/1000;
                printf("New LPS: %ld%s\n",LoopsPerMillisecond * 1000,
                        lps % 1000 ? " (truncated by 1000)" : "");

                if (calibrate == 2) {
                        count = 10;
                        while(count-- > 0) {
                                monDelay(1000);
                                putstr(".\007");
                        }
                        putchar('\n');
                }
#endif
                return(CMD_SUCCESS);
        }

        if (argc == optind)
                count = 1;
        else
                count = strtol(argv[optind],(char **)0,0);

        monDelay(count * multiplier);
        return(CMD_SUCCESS);
}
#endif