Add ability to slightly perturb latency of ethernet/memory

base/random.cc:
    Change normal random function to Xrand48 so we have one source of
    randomness for everything.
base/random.hh:
    Add uniform distribution ability to random functions
dev/etherlink.cc:
dev/etherlink.hh:
    Add ability to slightly perturb latency of ethernet

--HG--
extra : convert_revision : f7f856761fd525c233ae2a6d993b1fd702b488f7

2 files changed, 49 insertions, 4 deletions

diff --git a/base/random.cc b/base/random.cc
index a6d9da6c1..babe93db5 100644
--- a/base/random.cc
+++ b/base/random.cc
@@ -31,6 +31,7 @@
 
 #include "sim/param.hh"
 #include "base/random.hh"
+#include "base/trace.hh"
 
 using namespace std;
 
@@ -52,15 +53,33 @@ seed(&paramContext, "seed", "seed to random number generator", 1);
 void
 RandomContext::checkParams()
 {
-    ::srandom(seed);
+    ::srand48(seed);
 }
 
 long
 getLong()
 {
-    return random();
+    return mrand48();
 }
 
+int64_t
+getUniform(int64_t maxmin)
+{
+    double r;
+    r = (drand48() - 0.500) * 2 * maxmin;
+    DPRINTFN("getUniform %f\n", r);
+    return (int64_t)round(r);
+}
+
+uint64_t
+getUniformPos(uint64_t max)
+{
+    double r;
+    r = drand48() * 2 * max;
+    return (uint64_t)round(r);
+}
+
+
 // idea for generating a double from erand48
 double
 getDouble()
@@ -70,8 +89,8 @@ getDouble()
         uint16_t _short[4];
     };
 
-    _long[0] = random();
-    _long[1] = random();
+    _long[0] = mrand48();
+    _long[1] = mrand48();
 
     return ldexp((double) _short[0], -48) +
         ldexp((double) _short[1], -32) +
diff --git a/base/random.hh b/base/random.hh
index b4d20a274..eac91a53c 100644
--- a/base/random.hh
+++ b/base/random.hh
@@ -33,6 +33,8 @@
 
 long getLong();
 double getDouble();
+uint64_t getUniformPos(uint64_t max);
+int64_t getUniform(int64_t max);
 
 template <typename T>
 struct Random;
@@ -41,48 +43,72 @@ template<> struct Random<int8_t>
 {
     static int8_t get()
     { return getLong() & (int8_t)-1; }
+
+    static int8_t uniform(int8_t maxmin)
+    { return getUniform(maxmin); }
 };
 
 template<> struct Random<uint8_t>
 {
     static uint8_t get()
     { return getLong() & (uint8_t)-1; }
+
+    static uint8_t uniform(uint8_t max)
+    { return getUniformPos(max); }
 };
 
 template<> struct Random<int16_t>
 {
     static int16_t get()
     { return getLong() & (int16_t)-1; }
+
+    static int16_t uniform(int16_t maxmin)
+    { return getUniform(maxmin); }
 };
 
 template<> struct Random<uint16_t>
 {
     static uint16_t get()
     { return getLong() & (uint16_t)-1; }
+
+    static uint16_t uniform(uint16_t max)
+    { return getUniformPos(max); }
 };
 
 template<> struct Random<int32_t>
 {
     static int32_t get()
     { return (int32_t)getLong(); }
+
+    static int32_t uniform(int32_t maxmin)
+    { return getUniform(maxmin); }
 };
 
 template<> struct Random<uint32_t>
 {
     static uint32_t get()
     { return (uint32_t)getLong(); }
+
+    static uint32_t uniform(uint32_t max)
+    { return getUniformPos(max); }
 };
 
 template<> struct Random<int64_t>
 {
     static int64_t get()
     { return (int64_t)getLong() << 32 || (uint64_t)getLong(); }
+
+    static int64_t uniform(int64_t maxmin)
+    { return getUniform(maxmin); }
 };
 
 template<> struct Random<uint64_t>
 {
     static uint64_t get()
     { return (uint64_t)getLong() << 32 || (uint64_t)getLong(); }
+
+    static uint64_t uniform(uint64_t max)
+    { return getUniformPos(max); }
 };
 
 template<> struct Random<float>