minor update

hw/unit_tests/generic_queue/main.cpp

@@ -1,14 +1,22 @@
-#include <cstdlib>
-#include <iostream>
-#include <stdlib.h>
-#include <vector>
-#include <chrono>
 #include "vl_simulator.h"
 #include "VVX_fifo_queue.h"
-#include "VVX_fifo_queue__Syms.h"
+#include <iostream>
 
-static const uint32_t MAX_TICKS  = 10000000;
+#define MAX_TICKS 20
-static const uint32_t NUM_ITERATIONS = 20000;
+
+#define CHECK(x)                                  \
+   do {                                           \
+     if (x)                                       \
+       break;                                     \
+     std::cout << "FAILED: " << #x << std::endl;  \
+	   std::abort();			                          \
+   } while (false)
+
+uint64_t ticks = 0;
+
+double sc_time_stamp() { 
+  return ticks;
+}
 
 using Device = VVX_fifo_queue;
 
@@ -18,41 +26,68 @@ int main(int argc, char **argv) {
 
   vl_simulator<Device> sim;
 
-  auto start_time = std::chrono::system_clock::now();
+  // run test
-
+  ticks = sim.reset(0);
-  // run simulation
+  while (ticks < MAX_TICKS) {
-  unit64_t ticks = sim.reset(0);
+    switch (ticks) {
-  
+    case 0:
-  for (;;) {
+      // initial values
-    //sim->io_in_valid = (in_sample < num_iterations * FFT_SIZE);
+      sim->pop  = 0;
-    //sim->io_out_ready = (out_sample < num_iterations * FFT_SIZE);
+      sim->push = 0;
-
+      ticks = sim.step(ticks, 2);
-    // enqueue data
+      break;
-    //if (sim->io_in_valid && sim->io_in_ready) {
+    case 2:
-      //std::cout << "t" << std::dec << ticks << std::hex << " input: re=" << re << ", im=" << im << std::endl;
+      // Verify outputs    
-      //sim->io_in_data = sample;
+      CHECK(sim->full == 0x0);
-    //}
+      CHECK(sim->empty == 0x1);
-
+      // push 0xa
-    // dequeue data
+      sim->pop     = 0;
-    //if (sim->io_out_valid && sim->io_out_ready) {
+      sim->push    = 1;
-      //std::cout << "t" << std::dec << ticks << std::hex << " output: re=" << re << ", im=" << im << std::endl;
+      sim->data_in = 0xa;
-      //test_outputs[out_sample++] = sample;
+      break;
-    //}
+    case 4:
-
+      // verify outputs    
-    // check for completion
+      CHECK(sim->data_out == 0xa);
-    
+      CHECK(sim->full == 0x0);
+      CHECK(sim->empty == 0x0);
+      // push 0xb
+      sim->pop     = 0;
+      sim->push    = 1;
+      sim->data_in = 0xb;
+      break;
+    case 6:
+      // verify outputs    
+      CHECK(sim->data_out == 0xa);
+      CHECK(sim->full == 0x1);
+      CHECK(sim->empty == 0x0);
+      // pop
+      sim->pop  = 1;
+      sim->push = 0;
+      break;
+    case 8:
+      // verify outputs    
+      CHECK(sim->data_out == 0xb);
+      CHECK(sim->full == 0x0);
+      CHECK(sim->empty == 0x0);
+      // pop
+      sim->pop  = 1;
+      sim->push = 0;
+      break;
+    case 10:
+      // verify outputs    
+      CHECK(sim->full == 0x0);
+      CHECK(sim->empty == 0x1);
+      sim->pop  = 0;
+      sim->push = 0;
+      break;
+    }
 
     // advance clock
     ticks = sim.step(ticks, 2);
   }
 
-  auto end_time = std::chrono::system_clock::now();
+  std::cout << "PASSED!" << std::endl;
-  auto latency = end_time - start_time;
+  std::cout << "Simulation time: " << std::dec << ticks/2 << " cycles" << std::endl;
-  std::cout << "Average elapsed time = "
-            << std::chrono::duration<double, std::milli>(latency).count()
-            << " ms" << std::endl;
-
-  std::cout << "Simulation run time: " << std::dec << ticks/2 << " cycles" << std::endl;
 
   return 0;
 }