tracing: add parser for nicbm log

trace/Makefile

 CXXFLAGS := -O3 -Wall -Wextra -g -Wno-unused-parameter -fpermissive
 LDLIBS := -lboost_iostreams
 
-process: process.o sym_map.o log_parser.o gem5.o
+process: process.o sym_map.o log_parser.o gem5.o nicbm.o
 process: CC=$(CXX)
 
 clean:

trace/events.h

@@ -141,3 +141,116 @@ class EHostMmioC : public event {
         out << ts << ": H.MMIOC id=" << id << std::endl;
     }
 };
+
+class e_nic_msix : public event {
+  public:
+    uint16_t vec;
+
+    e_nic_msix(uint64_t ts_, uint16_t vec_)
+        : event(ts_), vec(vec_)
+    {
+    }
+
+    virtual void dump(std::ostream &out)
+    {
+        out << ts << ": N.MSIX " << vec << std::endl;
+    }
+};
+
+class e_nic_dma_i : public event {
+  public:
+    uint64_t id;
+    uint64_t addr;
+    uint64_t size;
+
+    e_nic_dma_i(uint64_t ts_, uint64_t id_, uint64_t addr_, uint64_t size_)
+        : event(ts_), id(id_), addr(addr_), size(size_)
+    {
+    }
+
+    virtual void dump(std::ostream &out)
+    {
+        out << ts << ": N.DMAI id=" << id << " addr=" << addr << " size=" <<
+            size << std::endl;
+    }
+};
+
+class e_nic_dma_c : public event {
+  public:
+    uint64_t id;
+
+    e_nic_dma_c(uint64_t ts_, uint64_t id_)
+        : event(ts_), id(id_)    {
+    }
+
+    virtual void dump(std::ostream &out)
+    {
+        out << ts << ": N.DMAC id=" << id << std::endl;
+    }
+};
+
+class e_nic_mmio_r : public event {
+  public:
+    uint64_t addr;
+    uint64_t size;
+    uint64_t val;
+
+    e_nic_mmio_r(uint64_t ts_, uint64_t addr_, uint64_t size_, uint64_t val_)
+        : event(ts_), addr(addr_), size(size_), val(val_)
+    {
+    }
+
+    virtual void dump(std::ostream &out)
+    {
+        out << ts << ": N.MMIOR addr=" << addr << " size=" << size << " val=" <<
+            val << std::endl;
+    }
+};
+
+class e_nic_mmio_w : public event {
+  public:
+    uint64_t addr;
+    uint64_t size;
+    uint64_t val;
+
+    e_nic_mmio_w(uint64_t ts_, uint64_t addr_, uint64_t size_, uint64_t val_)
+        : event(ts_), addr(addr_), size(size_), val(val_)
+    {
+    }
+
+    virtual void dump(std::ostream &out)
+    {
+        out << ts << ": N.MMIOW addr=" << addr << " size=" << size << " val=" <<
+            val << std::endl;
+    }
+};
+
+class e_nic_tx : public event {
+  public:
+    uint16_t len;
+
+    e_nic_tx(uint64_t ts_, uint16_t len_)
+        : event(ts_), len(len_)
+    {
+    }
+
+    virtual void dump(std::ostream &out)
+    {
+        out << ts << ": N.TX " << len << std::endl;
+    }
+};
+
+class e_nic_rx : public event {
+  public:
+    uint16_t len;
+
+    e_nic_rx(uint64_t ts_, uint16_t len_)
+        : event(ts_), len(len_)
+    {
+    }
+
+    virtual void dump(std::ostream &out)
+    {
+        out << ts << ": N.RX " << len << std::endl;
+    }
+};

trace/nicbm.cpp

+#include <iostream>
+
+#include "events.h"
+#include "parser.h"
+#include "process.h"
+
+namespace bio = boost::iostreams;
+
+nicbm_parser::~nicbm_parser()
+{
+}
+
+void nicbm_parser::process_line(char *line, size_t line_len)
+{
+    parser p(line, line_len, 0);
+
+    uint64_t ts;
+    if (!p.consume_dec(ts))
+        return;
+
+    if (!p.consume_str(" nicbm: "))
+        return;
+
+    uint64_t id, addr, len, val;
+    if (p.consume_str("read(off=0x")) {
+        if (p.consume_hex(addr) &&
+            p.consume_str(", len=") &&
+            p.consume_dec(len) &&
+            p.consume_str(", val=0x") &&
+            p.consume_hex(val))
+        {
+            cur_event = new e_nic_mmio_r(ts, addr, len, val);
+        }
+    } else if (p.consume_str("write(off=0x")) {
+        if (p.consume_hex(addr) &&
+            p.consume_str(", len=") &&
+            p.consume_dec(len) &&
+            p.consume_str(", val=0x") &&
+            p.consume_hex(val))
+        {
+            cur_event = new e_nic_mmio_w(ts, addr, len, val);
+        }
+    } else if (p.consume_str("issuing dma op 0x")) {
+        if (p.consume_hex(id) &&
+            p.consume_str(" addr ") &&
+            p.consume_hex(addr) &&
+            p.consume_str(" len ") &&
+            p.consume_hex(len))
+        {
+            cur_event = new e_nic_dma_i(ts, id, addr, len);
+        }
+    } else if (p.consume_str("completed dma read op 0x")  ||
+            p.consume_str("completed dma write op 0x"))
+    {
+        if (p.consume_hex(id) &&
+            p.consume_str(" addr ") &&
+            p.consume_hex(addr) &&
+            p.consume_str(" len ") &&
+            p.consume_hex(len))
+        {
+            cur_event = new e_nic_dma_c(ts, id);
+        }
+    } else if (p.consume_str("issue MSI-X interrupt vec ")) {
+        if (p.consume_dec(id)) {
+            cur_event = new e_nic_msix(ts, id);
+        }
+    } else if (p.consume_str("eth tx: len ")) {
+        if (p.consume_dec(len)) {
+            cur_event = new e_nic_tx(ts, len);
+        }
+    } else if (p.consume_str("eth rx: port 0 len ")) {
+        if (p.consume_dec(len)) {
+            cur_event = new e_nic_rx(ts, len);
+        }
+    }/* else {
+        std::cerr.write(line, line_len);
+        std::cerr << std::endl;
+    }*/
+}

trace/process.cpp

@@ -29,7 +29,9 @@ int main(int argc, char *argv[])
     std::cerr << "map loaded" << std::endl;
 
     gem5_parser client(syms);
-    gem5_parser server(syms);
+    //gem5_parser server(syms);
+    //nicbm_parser client;
+    nicbm_parser server;
     client.open(argv[1]);
     server.open(argv[2]);
 

trace/process.h

@@ -69,3 +69,12 @@ class gem5_parser : public log_parser {
     gem5_parser(sym_map &syms_);
     virtual ~gem5_parser();
 };
+
+class nicbm_parser : public log_parser {
+  protected:
+    virtual void process_line(char *line, size_t len);
+
+  public:
+    virtual ~nicbm_parser();
+
+};