Introduce TIME_UNITS_PER_SEC to represent internal clock resolution

[IPROUTE]: Introduce TIME_UNITS_PER_SEC to represent internal clock resolution

Introduce TIME_UNITS_PER_SEC and conversion functions between internal
resolution and resolution expected by the kernel (currently implemented as
NOPs, only needed by HFSC, which currently always uses microseconds).

Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>

diff --git a/tc/q_hfsc.c b/tc/q_hfsc.c
index 4e8c09b7c13b05e26091549ebe250b957534906f..f7a30f26f42f62e1ba465d80a7c69aa656186d7d 100644 (file)
--- a/tc/q_hfsc.c
+++ b/tc/q_hfsc.c
@@ -226,7 +226,7 @@ hfsc_print_sc(FILE *f, char *name, struct tc_service_curve *sc)
 
        fprintf(f, "%s ", name);
        fprintf(f, "m1 %s ", sprint_rate(sc->m1, b1));
-       fprintf(f, "d %s ", sprint_usecs(sc->d, b1));
+       fprintf(f, "d %s ", sprint_usecs(tc_core_ktime2time(sc->d), b1));
        fprintf(f, "m2 %s ", sprint_rate(sc->m2, b1));
 }
 
@@ -320,7 +320,7 @@ hfsc_get_sc1(int *argcp, char ***argvp, struct tc_service_curve *sc)
                return -1;
 
        sc->m1 = m1;
-       sc->d  = d;
+       sc->d  = tc_core_time2ktime(d);
        sc->m2 = m2;
 
        *argvp = argv;
@@ -367,13 +367,13 @@ hfsc_get_sc2(int *argcp, char ***argvp, struct tc_service_curve *sc)
                return -1;
        }
 
-       if (dmax != 0 && ceil(umax * 1000000.0 / dmax) > rate) {
+       if (dmax != 0 && ceil(1.0 * umax * TIME_UNITS_PER_SEC / dmax) > rate) {
                /*
                 * concave curve, slope of first segment is umax/dmax,
                 * intersection is at dmax
                 */
-               sc->m1 = ceil(umax * 1000000.0 / dmax); /* in bps */
-               sc->d  = dmax;
+               sc->m1 = ceil(1.0 * umax * TIME_UNITS_PER_SEC / dmax); /* in bps */
+               sc->d  = tc_core_time2ktime(dmax);
                sc->m2 = rate;
        } else {
                /*
@@ -381,7 +381,7 @@ hfsc_get_sc2(int *argcp, char ***argvp, struct tc_service_curve *sc)
                 * is at dmax - umax / rate
                 */
                sc->m1 = 0;
-               sc->d  = ceil(dmax - umax * 1000000.0 / rate); /* in usec */
+               sc->d  = tc_core_time2ktime(ceil(dmax - umax * TIME_UNITS_PER_SEC / rate));
                sc->m2 = rate;
        }
 

diff --git a/tc/q_tbf.c b/tc/q_tbf.c
index cbfdcd8a7d2d5b93ab8767860bd50e6fce5e7cf1..a102696725938677ef5ed9d7985edee834eb5197 100644 (file)
--- a/tc/q_tbf.c
+++ b/tc/q_tbf.c
@@ -161,9 +161,9 @@ static int tbf_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nl
        }
 
        if (opt.limit == 0) {
-               double lim = opt.rate.rate*(double)latency/1000000 + buffer;
+               double lim = opt.rate.rate*(double)latency/TIME_UNITS_PER_SEC + buffer;
                if (opt.peakrate.rate) {
-                       double lim2 = opt.peakrate.rate*(double)latency/1000000 + mtu;
+                       double lim2 = opt.peakrate.rate*(double)latency/TIME_UNITS_PER_SEC + mtu;
                        if (lim2 < lim)
                                lim = lim2;
                }
@@ -245,9 +245,9 @@ static int tbf_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
        if (show_raw)
                fprintf(f, "limit %s ", sprint_size(qopt->limit, b1));
 
-       latency = 1000000*(qopt->limit/(double)qopt->rate.rate) - tc_core_tick2usec(qopt->buffer);
+       latency = TIME_UNITS_PER_SEC*(qopt->limit/(double)qopt->rate.rate) - tc_core_tick2usec(qopt->buffer);
        if (qopt->peakrate.rate) {
-               double lat2 = 1000000*(qopt->limit/(double)qopt->peakrate.rate) - tc_core_tick2usec(qopt->mtu);
+               double lat2 = TIME_UNITS_PER_SEC*(qopt->limit/(double)qopt->peakrate.rate) - tc_core_tick2usec(qopt->mtu);
                if (lat2 > latency)
                        latency = lat2;
        }

diff --git a/tc/tc_cbq.c b/tc/tc_cbq.c
index 0abcc9da2d49e319de2611877765e6c75f657f2e..c7b3a2da057a0130286be75e3183c6e95f10c21a 100644 (file)
--- a/tc/tc_cbq.c
+++ b/tc/tc_cbq.c
@@ -38,7 +38,7 @@ unsigned tc_cbq_calc_maxidle(unsigned bndw, unsigned rate, unsigned avpkt,
                if (vxmt > maxidle)
                        maxidle = vxmt;
        }
-       return tc_core_usec2tick(maxidle*(1<<ewma_log)*1000000);
+       return tc_core_usec2tick(maxidle*(1<<ewma_log)*TIME_UNITS_PER_SEC);
 }
 
 unsigned tc_cbq_calc_offtime(unsigned bndw, unsigned rate, unsigned avpkt,
@@ -53,5 +53,5 @@ unsigned tc_cbq_calc_offtime(unsigned bndw, unsigned rate, unsigned avpkt,
                offtime *= pow(g, -(double)minburst) - 1;
        else
                offtime *= 1 + (pow(g, -(double)(minburst-1)) - 1)/(1-g);
-       return tc_core_usec2tick(offtime*1000000);
+       return tc_core_usec2tick(offtime*TIME_UNITS_PER_SEC);
 }

diff --git a/tc/tc_core.c b/tc/tc_core.c
index 1ca4583691ad21aba886b454e827810a29c7b4d8..07dc4ba15f79a0d88730fdc2d9083e202c70ac0e 100644 (file)
--- a/tc/tc_core.c
+++ b/tc/tc_core.c
@@ -46,14 +46,24 @@ long tc_core_tick2usec(long tick)
        return tick/tick_in_usec;
 }
 
+long tc_core_time2ktime(long time)
+{
+       return time;
+}
+
+long tc_core_ktime2time(long ktime)
+{
+       return ktime;
+}
+
 unsigned tc_calc_xmittime(unsigned rate, unsigned size)
 {
-       return tc_core_usec2tick(1000000*((double)size/rate));
+       return tc_core_usec2tick(TIME_UNITS_PER_SEC*((double)size/rate));
 }
 
 unsigned tc_calc_xmitsize(unsigned rate, unsigned ticks)
 {
-       return ((double)rate*tc_core_tick2usec(ticks))/1000000;
+       return ((double)rate*tc_core_tick2usec(ticks))/TIME_UNITS_PER_SEC;
 }
 
 /*

diff --git a/tc/tc_core.h b/tc/tc_core.h
index ff00f926bf23090838215f1ab04736ed14cf6de0..b31813d8f8a9c74e63af834b541beb76d1fc0acb 100644 (file)
--- a/tc/tc_core.h
+++ b/tc/tc_core.h
@@ -4,9 +4,13 @@
 #include <asm/types.h>
 #include <linux/pkt_sched.h>
 
+#define TIME_UNITS_PER_SEC     1000000
+
 int  tc_core_usec2big(long usec);
 long tc_core_usec2tick(long usec);
 long tc_core_tick2usec(long tick);
+long tc_core_time2ktime(long time);
+long tc_core_ktime2time(long ktime);
 unsigned tc_calc_xmittime(unsigned rate, unsigned size);
 unsigned tc_calc_xmitsize(unsigned rate, unsigned ticks);
 int tc_calc_rtable(unsigned bps, __u32 *rtab, int cell_log, unsigned mtu, unsigned mpu);

diff --git a/tc/tc_estimator.c b/tc/tc_estimator.c
index 434db0fe7bbc430c300cdcd7c0bd0612d405defd..e559add12818e5ff8f33074ae97426249011903b 100644 (file)
--- a/tc/tc_estimator.c
+++ b/tc/tc_estimator.c
@@ -26,7 +26,7 @@
 int tc_setup_estimator(unsigned A, unsigned time_const, struct tc_estimator *est)
 {
        for (est->interval=0; est->interval<=5; est->interval++) {
-               if (A <= (1<<est->interval)*(1000000/4))
+               if (A <= (1<<est->interval)*(TIME_UNITS_PER_SEC/4))
                        break;
        }
        if (est->interval > 5)

diff --git a/tc/tc_util.c b/tc/tc_util.c
index 8cdb9a1df3c03dde0d0fb534fba2f09274861b7a..62113fc68f498b8454cfc536dda0a48bf3c26e53 100644 (file)
--- a/tc/tc_util.c
+++ b/tc/tc_util.c
@@ -221,13 +221,13 @@ int get_usecs(unsigned *usecs, const char *str)
        if (*p) {
                if (strcasecmp(p, "s") == 0 || strcasecmp(p, "sec")==0 ||
                    strcasecmp(p, "secs")==0)
-                       t *= 1000000;
+                       t *= TIME_UNITS_PER_SEC;
                else if (strcasecmp(p, "ms") == 0 || strcasecmp(p, "msec")==0 ||
                         strcasecmp(p, "msecs") == 0)
-                       t *= 1000;
+                       t *= TIME_UNITS_PER_SEC/1000;
                else if (strcasecmp(p, "us") == 0 || strcasecmp(p, "usec")==0 ||
                         strcasecmp(p, "usecs") == 0)
-                       t *= 1;
+                       t *= TIME_UNITS_PER_SEC/1000000;
                else
                        return -1;
        }
@@ -241,10 +241,10 @@ void print_usecs(char *buf, int len, __u32 usec)
 {
        double tmp = usec;
 
-       if (tmp >= 1000000)
-               snprintf(buf, len, "%.1fs", tmp/1000000);
-       else if (tmp >= 1000)
-               snprintf(buf, len, "%.1fms", tmp/1000);
+       if (tmp >= TIME_UNITS_PER_SEC)
+               snprintf(buf, len, "%.1fs", tmp/TIME_UNITS_PER_SEC);
+       else if (tmp >= TIME_UNITS_PER_SEC/1000)
+               snprintf(buf, len, "%.1fms", tmp/(TIME_UNITS_PER_SEC/1000));
        else
                snprintf(buf, len, "%uus", usec);
 }