expose variables for number of global events per simulated second,

millisecond, microsecond, etc. so that the user can explicitly
convert between system ticks and time and know what sorts of
expensive operations are being used for that conversion.

arch/alpha/alpha_tru64_process.cc:
arch/alpha/pseudo_inst.cc:
dev/etherdump.cc:
dev/etherlink.cc:
dev/ns_gige.cc:
dev/sinic.cc:
dev/tsunami_io.cc:
dev/uart.cc:
sim/stat_control.cc:
sim/syscall_emul.hh:
    Use the new variables for getting the event clock
dev/etherdump.hh:
    delete variables that are no longer needed.

--HG--
extra : convert_revision : d95fc7d44909443e1b7952a24ef822ef051c7cf2

dev/etherdump.cc

@@ -74,9 +74,6 @@ void
 EtherDump::init()
 {
     curtime = time(NULL);
-    s_freq = ticksPerSecond;
-    us_freq = ticksPerSecond / ULL(1000000);
-
     struct pcap_file_header hdr;
     hdr.magic = TCPDUMP_MAGIC;
     hdr.version_major = PCAP_VERSION_MAJOR;
@@ -108,8 +105,8 @@ void
 EtherDump::dumpPacket(PacketPtr &packet)
 {
     pcap_pkthdr pkthdr;
-    pkthdr.seconds = curtime + (curTick / s_freq);
-    pkthdr.microseconds = (curTick / us_freq) % ULL(1000000);
+    pkthdr.seconds = curtime + (curTick / Clock::Int::s);
+    pkthdr.microseconds = (curTick / Clock::Int::us) % ULL(1000000);
     pkthdr.caplen = std::min(packet->length, maxlen);
     pkthdr.len = packet->length;
     stream.write(reinterpret_cast<char *>(&pkthdr), sizeof(pkthdr));

dev/etherdump.hh

@@ -49,8 +49,6 @@ class EtherDump : public SimObject
     void init();
 
     Tick curtime;
-    Tick s_freq;
-    Tick us_freq;
 
   public:
     EtherDump(const std::string &name, const std::string &file, int max);

dev/etherlink.cc

@@ -52,7 +52,7 @@ EtherLink::EtherLink(const string &name, EtherInt *peer0, EtherInt *peer1,
     : SimObject(name)
 {
     double rate = ((double)ticksPerSecond * 8.0) / (double)speed;
-    Tick delay = US2Ticks(dly);
+    Tick delay = dly * Clock::Int::us;
 
     link[0] = new Link(name + ".link0", this, 0, rate, delay, dump);
     link[1] = new Link(name + ".link1", this, 1, rate, delay, dump);

dev/ns_gige.cc

@@ -138,7 +138,7 @@ NSGigE::NSGigE(Params *p)
     }
 
 
-    intrDelay = US2Ticks(p->intr_delay);
+    intrDelay = p->intr_delay * Clock::Int::us;
     dmaReadDelay = p->dma_read_delay;
     dmaWriteDelay = p->dma_write_delay;
     dmaReadFactor = p->dma_read_factor;

dev/sinic.cc

@@ -79,7 +79,7 @@ const char *TxStateStrings[] =
 //
 Base::Base(Params *p)
     : PciDev(p), rxEnable(false), txEnable(false),
-      intrDelay(US2Ticks(p->intr_delay)),
+      intrDelay(p->intr_delay * Clock::Int::us),
       intrTick(0), cpuIntrEnable(false), cpuPendingIntr(false), intrEvent(0),
       interface(NULL)
 {

dev/tsunami_io.cc

@@ -95,6 +95,13 @@ TsunamiIO::RTCEvent::unserialize(Checkpoint *cp, const std::string &section)
 TsunamiIO::ClockEvent::ClockEvent()
     : Event(&mainEventQueue)
 {
+    /* This is the PIT Tick Rate. A constant for the 8254 timer. The
+     * Tsunami platform has one of these cycle counters on the Cypress
+     * South Bridge and it is used by linux for estimating the cycle
+     * frequency of the machine it is running on. --Ali
+     */
+    interval = (Tick)(Clock::Float::s / 1193180.0);
+
     DPRINTF(Tsunami, "Clock Event Initilizing\n");
     mode = 0;
 }
@@ -113,9 +120,7 @@ void
 TsunamiIO::ClockEvent::Program(int count)
 {
     DPRINTF(Tsunami, "Timer set to curTick + %d\n", count);
-    // should be count * (cpufreq/pitfreq)
-    interval = count * ticksPerSecond/1193180UL;
-    schedule(curTick + interval);
+    schedule(curTick + count * interval);
     status = 0;
 }
 

dev/uart.cc

@@ -73,17 +73,28 @@ Uart::IntrEvent::process()
 
 }
 
+/* The linux serial driver (8250.c about line 1182) loops reading from
+ * the device until the device reports it has no more data to
+ * read. After a maximum of 255 iterations the code prints "serial8250
+ * too much work for irq X," and breaks out of the loop. Since the
+ * simulated system is so much slower than the actual system, if a
+ * user is typing on the keyboard it is very easy for them to provide
+ * input at a fast enough rate to not allow the loop to exit and thus
+ * the error to be printed. This magic number provides a delay between
+ * the time the UART receives a character to send to the simulated
+ * system and the time it actually notifies the system it has a
+ * character to send to alleviate this problem. --Ali
+ */
 void
 Uart::IntrEvent::scheduleIntr()
 {
+    static const Tick interval = (Tick)((Clock::Float::s / 2e9) * 450);
     DPRINTF(Uart, "Scheduling IER interrupt for %#x, at cycle %lld\n", intrBit,
-            curTick + (ticksPerSecond/2000) * 350);
+            curTick + interval);
     if (!scheduled())
-        /* @todo Make this cleaner, will be much easier with
-         *       nanosecond time everywhere. Hint hint  Nate. */
-        schedule(curTick + (ticksPerSecond/2000000000) * 450);
+        schedule(curTick + interval);
     else
-        reschedule(curTick + (ticksPerSecond/2000000000) * 450);
+        reschedule(curTick + interval);
 }
 
 Uart::Uart(const string &name, SimConsole *c, MemoryController *mmu, Addr a,