merge doc

12 files changed, 259 insertions, 152 deletions

diff --git a/src/dpdk22/drivers/net/i40e/i40e_ethdev.c b/src/dpdk22/drivers/net/i40e/i40e_ethdev.c
index 510a98cd..dff4ec3c 100644
--- a/src/dpdk22/drivers/net/i40e/i40e_ethdev.c
+++ b/src/dpdk22/drivers/net/i40e/i40e_ethdev.c
@@ -2101,6 +2101,8 @@ i40e_trex_get_speed(struct rte_eth_dev *dev)
 
 //TREX_PATCH
 // fill stats array with fdir rules match count statistics
+// Notice that we read statistics from start to start + len, but we fill the stats are
+//  starting from 0 with len values
 void
 i40e_trex_fdir_stats_get(struct rte_eth_dev *dev, uint32_t *stats, uint32_t start, uint32_t len)
 {
diff --git a/src/flow_stat.cpp b/src/flow_stat.cpp
index ef32284b..de081ffe 100644
--- a/src/flow_stat.cpp
+++ b/src/flow_stat.cpp
@@ -23,7 +23,7 @@
 #include <iostream>
 #include <assert.h>
 #include <os_time.h>
-#include <internal_api/trex_platform_api.h>
+#include "internal_api/trex_platform_api.h"
 #include "trex_stateless.h"
 #include "trex_stream.h"
 #include "flow_stat_parser.h"
@@ -61,9 +61,14 @@ CFlowStatUserIdInfo::CFlowStatUserIdInfo(uint8_t proto) {
     m_proto = proto;
     m_ref_count = 1;
     m_trans_ref_count = 0;
+    m_was_sent = false;
+    for (int i = 0; i < TREX_MAX_PORTS; i++) {
+        m_rx_changed[i] = false;
+        m_tx_changed[i] = false;
+    }
 }
 
-std::ostream& operator<<(std::ostream& os, const class CFlowStatUserIdInfo& cf) {
+std::ostream& operator<<(std::ostream& os, const CFlowStatUserIdInfo& cf) {
     os << "hw_id:" << cf.m_hw_id << " proto:" << (uint16_t) cf.m_proto << " ref("
        << (uint16_t) cf.m_ref_count << "," << (uint16_t) cf.m_trans_ref_count << ")";
     os << " rx count (";
@@ -138,7 +143,7 @@ std::ostream& operator<<(std::ostream& os, const CFlowStatUserIdMap& cf) {
 }
 
 uint16_t CFlowStatUserIdMap::get_hw_id(uint32_t user_id) {
-    class CFlowStatUserIdInfo *cf = find_user_id(user_id);
+    CFlowStatUserIdInfo *cf = find_user_id(user_id);
 
     if (cf == NULL) {
         return FREE_HW_ID;
@@ -147,7 +152,7 @@ uint16_t CFlowStatUserIdMap::get_hw_id(uint32_t user_id) {
     }
 }
 
-class CFlowStatUserIdInfo *
+CFlowStatUserIdInfo *
 CFlowStatUserIdMap::find_user_id(uint32_t user_id) {
     flow_stat_user_id_map_it_t it = m_map.find(user_id);
 
@@ -158,17 +163,17 @@ CFlowStatUserIdMap::find_user_id(uint32_t user_id) {
     }
 }
 
-class CFlowStatUserIdInfo *
+CFlowStatUserIdInfo *
 CFlowStatUserIdMap::add_user_id(uint32_t user_id, uint8_t proto) {
 #ifdef __DEBUG_FUNC_ENTRY__
     std::cout << __METHOD_NAME__ << " user id:" << user_id << " proto:" << (uint16_t)proto
               << std::endl;
 #endif
 
-    class CFlowStatUserIdInfo *new_id = new CFlowStatUserIdInfo(proto);
+    CFlowStatUserIdInfo *new_id = new CFlowStatUserIdInfo(proto);
     if (new_id != NULL) {
         std::pair<flow_stat_user_id_map_it_t, bool> ret;
-        ret = m_map.insert(std::pair<uint32_t, class CFlowStatUserIdInfo *>(user_id, new_id));
+        ret = m_map.insert(std::pair<uint32_t, CFlowStatUserIdInfo *>(user_id, new_id));
         if (ret.second == false) {
             printf("%s Error: Trying to add user id %d which already exist\n", __func__, user_id);
             delete new_id;
@@ -186,7 +191,7 @@ int CFlowStatUserIdMap::add_stream(uint32_t user_id, uint8_t proto) {
               << std::endl;
 #endif
 
-    class CFlowStatUserIdInfo *c_user_id;
+    CFlowStatUserIdInfo *c_user_id;
 
     c_user_id = find_user_id(user_id);
     if (! c_user_id) {
@@ -204,7 +209,7 @@ int CFlowStatUserIdMap::del_stream(uint32_t user_id) {
     std::cout << __METHOD_NAME__ << " user id:" << user_id << std::endl;
 #endif
 
-    class CFlowStatUserIdInfo *c_user_id;
+    CFlowStatUserIdInfo *c_user_id;
 
     c_user_id = find_user_id(user_id);
     if (! c_user_id) {
@@ -225,7 +230,7 @@ int CFlowStatUserIdMap::start_stream(uint32_t user_id, uint16_t hw_id) {
     std::cout << __METHOD_NAME__ << " user id:" << user_id << " hw_id:" << hw_id << std::endl;
 #endif
 
-    class CFlowStatUserIdInfo *c_user_id;
+    CFlowStatUserIdInfo *c_user_id;
 
     c_user_id = find_user_id(user_id);
     if (! c_user_id) {
@@ -235,7 +240,7 @@ int CFlowStatUserIdMap::start_stream(uint32_t user_id, uint16_t hw_id) {
     }
 
     if (c_user_id->is_hw_id()) {
-        fprintf(stderr, "%s Error: Trying to associate hw id %d to user_id %d but it is already associate to %ld\n"
+        fprintf(stderr, "%s Error: Trying to associate hw id %d to user_id %d but it is already associate to %u\n"
                 , __func__, hw_id, user_id, c_user_id->get_hw_id());
         return -1;
     }
@@ -250,7 +255,7 @@ int CFlowStatUserIdMap::start_stream(uint32_t user_id) {
     std::cout << __METHOD_NAME__ << " user id:" << user_id << std::endl;
 #endif
 
-    class CFlowStatUserIdInfo *c_user_id;
+    CFlowStatUserIdInfo *c_user_id;
 
     c_user_id = find_user_id(user_id);
     if (! c_user_id) {
@@ -271,7 +276,7 @@ int CFlowStatUserIdMap::stop_stream(uint32_t user_id) {
     std::cout << __METHOD_NAME__ << " user id:" << user_id << std::endl;
 #endif
 
-    class CFlowStatUserIdInfo *c_user_id;
+    CFlowStatUserIdInfo *c_user_id;
 
     c_user_id = find_user_id(user_id);
     if (! c_user_id) {
@@ -284,7 +289,7 @@ int CFlowStatUserIdMap::stop_stream(uint32_t user_id) {
 }
 
 bool CFlowStatUserIdMap::is_started(uint32_t user_id) {
-    class CFlowStatUserIdInfo *c_user_id;
+    CFlowStatUserIdInfo *c_user_id;
 
     c_user_id = find_user_id(user_id);
     if (! c_user_id) {
@@ -295,7 +300,7 @@ bool CFlowStatUserIdMap::is_started(uint32_t user_id) {
 }
 
 uint8_t CFlowStatUserIdMap::l4_proto(uint32_t user_id) {
-    class CFlowStatUserIdInfo *c_user_id;
+    CFlowStatUserIdInfo *c_user_id;
 
     c_user_id = find_user_id(user_id);
     if (! c_user_id) {
@@ -310,7 +315,7 @@ uint16_t CFlowStatUserIdMap::unmap(uint32_t user_id) {
     std::cout << __METHOD_NAME__ << " user id:" << user_id << std::endl;
 #endif
 
-    class CFlowStatUserIdInfo *c_user_id;
+    CFlowStatUserIdInfo *c_user_id;
 
     c_user_id = find_user_id(user_id);
     if (! c_user_id) {
@@ -583,15 +588,21 @@ int CFlowStatRuleMgr::stop_stream(const TrexStream * stream) {
             return -1;
         } else {
             // update counters, and reset before unmapping
-            class CFlowStatUserIdInfo *p_user_id = m_user_id_map.find_user_id(m_hw_id_map.get_user_id(hw_id));
+            CFlowStatUserIdInfo *p_user_id = m_user_id_map.find_user_id(m_hw_id_map.get_user_id(hw_id));
             assert(p_user_id != NULL);
             uint64_t rx_counter;
             tx_per_flow_t tx_counter;
             for (uint8_t port = 0; port < m_num_ports; port++) {
                 m_api->del_rx_flow_stat_rule(port, FLOW_STAT_RULE_TYPE_IPV4_ID, proto, hw_id);
                 m_api->get_flow_stats(port, &rx_counter, (void *)&tx_counter, hw_id, hw_id, true);
-                p_user_id->set_rx_counter(port, rx_counter);
-                p_user_id->set_tx_counter(port, tx_counter);
+                if (p_user_id->get_rx_counter(port) != rx_counter) {
+                    p_user_id->set_rx_counter(port, rx_counter);
+                    p_user_id->set_need_to_send_rx(port);
+                }
+                if (p_user_id->get_tx_counter(port) != tx_counter) {
+                    p_user_id->set_tx_counter(port, tx_counter);
+                    p_user_id->set_need_to_send_tx(port);
+                }
             }
             m_user_id_map.unmap(stream->m_rx_check.m_pg_id);
             m_hw_id_map.unmap(hw_id);
@@ -611,39 +622,58 @@ int CFlowStatRuleMgr::get_active_pgids(flow_stat_active_t &result) {
 }
 
 // return false if no counters changed since last run. true otherwise
-bool CFlowStatRuleMgr::dump_json(std::string & json) {
+bool CFlowStatRuleMgr::dump_json(std::string & json, bool baseline) {
     uint64_t rx_stats[MAX_FLOW_STATS];
     tx_per_flow_t tx_stats[MAX_FLOW_STATS];
     Json::FastWriter writer;
     Json::Value root;
 
-    if (m_user_id_map.is_empty()) {
-        return false;
-    }
     root["name"] = "flow_stats";
     root["type"] = 0;
+    
+    if (baseline) {
+        root["baseline"] = true;
+    }
+
     Json::Value &data_section = root["data"];
+    data_section["ts"]["value"] = Json::Value::UInt64(os_get_hr_tick_64());
+    data_section["ts"]["freq"] = Json::Value::UInt64(os_get_hr_freq());
+
+    if (m_user_id_map.is_empty()) {
+        if (baseline) {
+            json = writer.write(root);
+            return true;
+        } else
+            return false;
+    }
 
     // read hw counters, and update
-    data_section["timestamp"] = Json::Value::UInt64(os_get_hr_tick_64());
     for (uint8_t port = 0; port < m_num_ports; port++) {
         m_api->get_flow_stats(port, rx_stats, (void *)tx_stats, 0, m_max_hw_id, false);
         for (int i = 0; i <= m_max_hw_id; i++) {
             if (rx_stats[i] != 0) {
-                class CFlowStatUserIdInfo *p_user_id = m_user_id_map.find_user_id(m_hw_id_map.get_user_id(i));
+                CFlowStatUserIdInfo *p_user_id = m_user_id_map.find_user_id(m_hw_id_map.get_user_id(i));
                 if (likely(p_user_id != NULL)) {
-                    p_user_id->set_rx_counter(port, rx_stats[i]);
+                    if (p_user_id->get_rx_counter(port) != rx_stats[i]) {
+                        p_user_id->set_rx_counter(port, rx_stats[i]);
+                        p_user_id->set_need_to_send_rx(port);
+                    }
                 } else {
-                    std::cerr <<  __METHOD_NAME__ << i << ":Could not count " << rx_stats[i] << " rx packets, because no mapping was found" << std::endl;
+                    std::cerr <<  __METHOD_NAME__ << i << ":Could not count " << rx_stats[i] << " rx packets, on port "
+                              << (uint16_t)port << ", because no mapping was found." << std::endl;
                 }
             }
             if (tx_stats[i].get_pkts() != 0) {
                 tx_per_flow_t tx_pkts = tx_stats[i];
-                class CFlowStatUserIdInfo *p_user_id = m_user_id_map.find_user_id(m_hw_id_map.get_user_id(i));
+                CFlowStatUserIdInfo *p_user_id = m_user_id_map.find_user_id(m_hw_id_map.get_user_id(i));
                 if (likely(p_user_id != NULL)) {
-                    p_user_id->set_tx_counter(port, tx_pkts);
+                    if (p_user_id->get_tx_counter(port) != tx_pkts) {
+                        p_user_id->set_tx_counter(port, tx_pkts);
+                        p_user_id->set_need_to_send_tx(port);
+                    }
                 } else {
-                    std::cerr <<  __METHOD_NAME__ << i << ":Could not count tx " << tx_pkts << " because no mapping was found" << std::endl;
+                    std::cerr <<  __METHOD_NAME__ << i << ":Could not count " << tx_pkts <<  " tx packets on port "
+                              << (uint16_t)port << ", because no mapping was found." << std::endl;
                 }
             }
         }
@@ -656,13 +686,18 @@ bool CFlowStatRuleMgr::dump_json(std::string & json) {
         uint32_t user_id = it->first;
         std::string str_user_id = static_cast<std::ostringstream*>( &(std::ostringstream()
                                                                       << user_id) )->str();
+        if (! user_id_info->was_sent()) {
+            data_section[str_user_id]["first_time"] = true;
+            user_id_info->set_was_sent(true);
+        }
         for (uint8_t port = 0; port < m_num_ports; port++) {
             std::string str_port = static_cast<std::ostringstream*>( &(std::ostringstream() << int(port) ) )->str();
-
-            if (user_id_info->get_rx_counter(port) != 0) {
+            if (user_id_info->need_to_send_rx(port) || baseline) {
+                user_id_info->set_no_need_to_send_rx(port);
                 data_section[str_user_id]["rx_pkts"][str_port] = Json::Value::UInt64(user_id_info->get_rx_counter(port));
             }
-            if (user_id_info->get_tx_counter(port).get_pkts() != 0) {
+            if (user_id_info->need_to_send_tx(port) || baseline) {
+                user_id_info->set_no_need_to_send_tx(port);
                 data_section[str_user_id]["tx_pkts"][str_port] = Json::Value::UInt64(user_id_info->get_tx_counter(port).get_pkts());
                 data_section[str_user_id]["tx_bytes"][str_port] = Json::Value::UInt64(user_id_info->get_tx_counter(port).get_bytes());
             }
diff --git a/src/flow_stat.h b/src/flow_stat.h
index 6f7671fd..3e00a180 100644
--- a/src/flow_stat.h
+++ b/src/flow_stat.h
@@ -83,7 +83,13 @@ class tx_per_flow_t_ {
         return *this;
     }
 
-    friend std::ostream& operator<<(std::ostream& os, const class tx_per_flow_t_ &t) {
+    inline bool operator!= (const tx_per_flow_t_ &t_in) {
+        if ((m_bytes != t_in.m_bytes) || (m_pkts != t_in.m_pkts))
+            return true;
+        return false;
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, const tx_per_flow_t_ &t) {
         os  << "p:" << t.m_pkts << " b:" << t.m_bytes;
         return os;
     }
@@ -107,7 +113,7 @@ class CFlowStatUserIdInfo {
     void set_tx_counter(uint8_t port, tx_per_flow_t val) {m_tx_counter[port] = val;}
     tx_per_flow_t get_tx_counter(uint8_t port) {return m_tx_counter[port] + m_tx_counter_base[port];}
     void set_hw_id(uint16_t hw_id) {m_hw_id = hw_id;}
-    uint64_t get_hw_id() {return m_hw_id;}
+    uint16_t get_hw_id() {return m_hw_id;}
     void reset_hw_id();
     bool is_hw_id() {return (m_hw_id != UINT16_MAX);}
     uint64_t get_proto() {return m_proto;}
@@ -117,8 +123,18 @@ class CFlowStatUserIdInfo {
     void add_started_stream() {m_trans_ref_count++;}
     int stop_started_stream() {m_trans_ref_count--; return m_trans_ref_count;}
     bool is_started() {return (m_trans_ref_count != 0);}
+    bool need_to_send_rx(uint8_t port) {return m_rx_changed[port];}
+    bool need_to_send_tx(uint8_t port) {return m_tx_changed[port];}
+    void set_no_need_to_send_rx(uint8_t port) {m_rx_changed[port] = false;}
+    void set_no_need_to_send_tx(uint8_t port) {m_tx_changed[port] = false;}
+    void set_need_to_send_rx(uint8_t port) {m_rx_changed[port] = true;}
+    void set_need_to_send_tx(uint8_t port) {m_tx_changed[port] = true;}
+    bool was_sent() {return m_was_sent == true;}
+    void set_was_sent(bool val) {m_was_sent = val;}
 
  private:
+    bool m_rx_changed[TREX_MAX_PORTS]; // Which RX counters changed since we last published
+    bool m_tx_changed[TREX_MAX_PORTS]; // Which TX counters changed since we last published
     uint64_t m_rx_counter[TREX_MAX_PORTS]; // How many packets received with this user id since stream start
     // How many packets received with this user id, since stream creation, before stream start.
     uint64_t m_rx_counter_base[TREX_MAX_PORTS];
@@ -129,6 +145,7 @@ class CFlowStatUserIdInfo {
     uint8_t m_proto;      // protocol (UDP, TCP, other), associated with this user id.
     uint8_t m_ref_count;  // How many streams with this ref count exists
     uint8_t m_trans_ref_count;  // How many streams with this ref count currently transmit
+    bool m_was_sent; // Did we send this info to clients once?
 };
 
 typedef std::map<uint32_t, class CFlowStatUserIdInfo *> flow_stat_user_id_map_t;
@@ -140,8 +157,8 @@ class CFlowStatUserIdMap {
     friend std::ostream& operator<<(std::ostream& os, const CFlowStatUserIdMap& cf);
     bool is_empty() {return (m_map.empty() == true);};
     uint16_t get_hw_id(uint32_t user_id);
-    class CFlowStatUserIdInfo * find_user_id(uint32_t user_id);
-    class CFlowStatUserIdInfo * add_user_id(uint32_t user_id, uint8_t proto);
+    CFlowStatUserIdInfo * find_user_id(uint32_t user_id);
+    CFlowStatUserIdInfo * add_user_id(uint32_t user_id, uint8_t proto);
     int add_stream(uint32_t user_id, uint8_t proto);
     int del_stream(uint32_t user_id);
     int start_stream(uint32_t user_id, uint16_t hw_id);
@@ -185,15 +202,15 @@ class CFlowStatRuleMgr {
     int start_stream(TrexStream * stream, uint16_t &ret_hw_id);
     int stop_stream(const TrexStream * stream);
     int get_active_pgids(flow_stat_active_t &result);
-    bool dump_json(std::string & json);
+    bool dump_json(std::string & json, bool baseline);
 
  private:
     int compile_stream(const TrexStream * stream, Cxl710Parser &parser);
     int add_hw_rule(uint16_t hw_id, uint8_t proto);
 
  private:
-    class CFlowStatHwIdMap m_hw_id_map; // map hw ids to user ids
-    class CFlowStatUserIdMap m_user_id_map; // map user ids to hw ids
+    CFlowStatHwIdMap m_hw_id_map; // map hw ids to user ids
+    CFlowStatUserIdMap m_user_id_map; // map user ids to hw ids
     uint8_t m_num_ports; // How many ports are being used
     const TrexPlatformApi *m_api;
     int m_max_hw_id; // max hw id we ever used
diff --git a/src/internal_api/trex_platform_api.h b/src/internal_api/trex_platform_api.h
index b1cf2fb7..f8f76584 100644
--- a/src/internal_api/trex_platform_api.h
+++ b/src/internal_api/trex_platform_api.h
@@ -139,7 +139,7 @@ public:
 
     virtual void get_interface_info(uint8_t interface_id, intf_info_st &info) const = 0;
 
-    virtual void publish_async_data_now(uint32_t key) const = 0;
+    virtual void publish_async_data_now(uint32_t key, bool baseline) const = 0;
     virtual uint8_t get_dp_core_count() const = 0;
     virtual void get_interface_stat_info(uint8_t interface_id, uint16_t &num_counters, uint16_t &capabilities) const =0;
     virtual int get_flow_stats(uint8_t port_id, uint64_t *stats, void *tx_stats, int min, int max, bool reset) const = 0;
@@ -168,7 +168,7 @@ public:
 
     void get_interface_info(uint8_t interface_id, intf_info_st &info) const;
 
-    void publish_async_data_now(uint32_t key) const;
+    void publish_async_data_now(uint32_t key, bool baseline) const;
     uint8_t get_dp_core_count() const;
     void get_interface_stat_info(uint8_t interface_id, uint16_t &num_counters, uint16_t &capabilities) const;
     int get_flow_stats(uint8_t port_id, uint64_t *stats, void *tx_stats, int min, int max, bool reset) const;
@@ -214,7 +214,7 @@ public:
 
     virtual void get_interface_stats(uint8_t interface_id, TrexPlatformInterfaceStats &stats) const {
     }
-    virtual void get_interface_stat_info(uint8_t interface_id, uint16_t &num_counters, uint16_t &capabilities) const {num_counters=128; capabilities=0; }
+    virtual void get_interface_stat_info(uint8_t interface_id, uint16_t &num_counters, uint16_t &capabilities) const {num_counters=128; capabilities=TrexPlatformApi::IF_STAT_IPV4_ID; }
 
     virtual void port_id_to_cores(uint8_t port_id, std::vector<std::pair<uint8_t, uint8_t>> &cores_id_list) const {
         for (int i = 0; i < m_dp_core_count; i++) {
@@ -222,7 +222,7 @@ public:
         }
     }
 
-    virtual void publish_async_data_now(uint32_t key) const {
+    virtual void publish_async_data_now(uint32_t key, bool baseline) const {
 
     }
     virtual int get_flow_stats(uint8_t port_id, uint64_t *stats, void *tx_stats, int min, int max, bool reset) const {return 0;};
diff --git a/src/main_dpdk.cpp b/src/main_dpdk.cpp
index 0d40215a..1b750bbd 100644
--- a/src/main_dpdk.cpp
+++ b/src/main_dpdk.cpp
@@ -2307,7 +2307,7 @@ public:
 public:
     void Dump(FILE *fd,DumpFormat mode);
     void DumpAllPorts(FILE *fd);
-    void dump_json(std::string & json);
+    void dump_json(std::string & json, bool baseline);
 private:
     std::string get_field(std::string name,float &f);
     std::string get_field(std::string name,uint64_t &f);
@@ -2341,8 +2341,15 @@ std::string CGlobalStats::get_field_port(int port,std::string name,uint64_t &f){
 }
 
 
-void CGlobalStats::dump_json(std::string & json){
-    json="{\"name\":\"trex-global\",\"type\":0,\"data\":{";
+void CGlobalStats::dump_json(std::string & json, bool baseline){
+    /* refactor this to JSON */
+
+    json="{\"name\":\"trex-global\",\"type\":0,";
+    if (baseline) {
+        json += "\"baseline\": true,";
+    }
+
+    json +="\"data\":{";
 
 #define GET_FIELD(f) get_field(std::string(#f),f)
 #define GET_FIELD_PORT(p,f) get_field_port(p,std::string(#f),lp->f)
@@ -2631,7 +2638,7 @@ private:
 
 public:
 
-    void publish_async_data(bool sync_now);
+    void publish_async_data(bool sync_now, bool baseline = false);
     void publish_async_barrier(uint32_t key);
 
     void dump_stats(FILE *fd,
@@ -2640,7 +2647,7 @@ public:
     bool sanity_check();
     void update_stats(void);
     tx_per_flow_t get_flow_tx_stats(uint8_t port, uint16_t hw_id);
-    void clear_flow_tx_stats(uint8_t port, uint16_t index);
+    tx_per_flow_t clear_flow_tx_stats(uint8_t port, uint16_t index);
     void get_stats(CGlobalStats & stats);
     void dump_post_test_stats(FILE *fd);
     void dump_config(FILE *fd);
@@ -3307,8 +3314,32 @@ tx_per_flow_t CGlobalTRex::get_flow_tx_stats(uint8_t port, uint16_t index) {
     return m_stats.m_port[port].m_tx_per_flow[index] - m_stats.m_port[port].m_prev_tx_per_flow[index];
 }
 
-void CGlobalTRex::clear_flow_tx_stats(uint8_t port, uint16_t index) {
+// read stats. Return read value, and clear.
+tx_per_flow_t CGlobalTRex::clear_flow_tx_stats(uint8_t port, uint16_t index) {
+    uint8_t port0;
+    CFlowGenListPerThread * lpt;
+    tx_per_flow_t ret;
+
+    m_stats.m_port[port].m_tx_per_flow[index].clear();
+
+    for (int i=0; i < get_cores_tx(); i++) {
+        lpt = m_fl.m_threads_info[i];
+        port0 = lpt->getDualPortId() * 2;
+        if (port == port0) {
+            m_stats.m_port[port0].m_tx_per_flow[index] +=
+                lpt->m_node_gen.m_v_if->m_stats[0].m_tx_per_flow[index];
+        } else if (port == port0 + 1) {
+            m_stats.m_port[port0 + 1].m_tx_per_flow[index] +=
+                lpt->m_node_gen.m_v_if->m_stats[1].m_tx_per_flow[index];
+        }
+    }
+
+    ret = m_stats.m_port[port].m_tx_per_flow[index] - m_stats.m_port[port].m_prev_tx_per_flow[index];
+
+    // Since we return diff from prev, following "clears" the stats.
     m_stats.m_port[port].m_prev_tx_per_flow[index] = m_stats.m_port[port].m_tx_per_flow[index];
+
+    return ret;
 }
 
 void CGlobalTRex::get_stats(CGlobalStats & stats){
@@ -3532,7 +3563,7 @@ void CGlobalTRex::dump_stats(FILE *fd, CGlobalStats::DumpFormat format){
 }
 
 void
-CGlobalTRex::publish_async_data(bool sync_now) {
+CGlobalTRex::publish_async_data(bool sync_now, bool baseline) {
     std::string json;
 
     /* refactor to update, dump, and etc. */
@@ -3541,7 +3572,7 @@ CGlobalTRex::publish_async_data(bool sync_now) {
         get_stats(m_stats);
     }
 
-    m_stats.dump_json(json);
+    m_stats.dump_json(json, baseline);
     m_zmq_publisher.publish_json(json);
 
     /* generator json , all cores are the same just sample the first one */
@@ -3568,7 +3599,7 @@ CGlobalTRex::publish_async_data(bool sync_now) {
     m_zmq_publisher.publish_json(json);
 
     if (get_is_stateless()) {
-        if (m_trex_stateless->m_rx_flow_stat.dump_json(json))
+        if (m_trex_stateless->m_rx_flow_stat.dump_json(json, baseline))
             m_zmq_publisher.publish_json(json);
     }
 }
@@ -3930,10 +3961,9 @@ int CPhyEthIF::get_flow_stats(uint64_t *rx_stats, tx_per_flow_t *tx_stats, int m
                 rx_stats[i - min] = m_stats.m_rx_per_flow[i] + diff_stats[i];
             }
             if (tx_stats != NULL) {
-                tx_stats[i - min] = g_trex.get_flow_tx_stats(m_port_id, i);
+                tx_stats[i - min] = g_trex.clear_flow_tx_stats(m_port_id, i);
             }
             m_stats.m_rx_per_flow[i] = 0;
-            g_trex.clear_flow_tx_stats(m_port_id, i);
         } else {
             m_stats.m_rx_per_flow[i] += diff_stats[i];
             if (rx_stats != NULL) {
@@ -4911,6 +4941,10 @@ int CTRexExtendedDriverBase40G::configure_rx_filter_rules(CPhyEthIF * _if) {
 
 // instead of adding this to rte_ethdev.h
 extern "C" int rte_eth_fdir_stats_get(uint8_t port_id, uint32_t *stats, uint32_t start, uint32_t len);
+// get rx stats on _if, between min and max
+// prev_stats should be the previous values read from the hardware.
+//            Getting changed to be equal to current HW values.
+// stats return the diff between prev_stats and current hw values
 int CTRexExtendedDriverBase40G::get_rx_stats(CPhyEthIF * _if, uint32_t *stats, uint32_t *prev_stats, int min, int max) {
     uint32_t hw_stats[MAX_FLOW_STATS];
     uint32_t port_id = _if->get_port_id();
@@ -4920,13 +4954,13 @@ int CTRexExtendedDriverBase40G::get_rx_stats(CPhyEthIF * _if, uint32_t *stats, u
 
     rte_eth_fdir_stats_get(port_id, hw_stats, start, len);
     for (int i = loop_start; i <  loop_start + len; i++) {
-        if (hw_stats[i] >= prev_stats[i]) {
-            stats[i] = (uint64_t)(hw_stats[i] - prev_stats[i]);
+        if (hw_stats[i - min] >= prev_stats[i]) {
+            stats[i] = (uint64_t)(hw_stats[i - min] - prev_stats[i]);
         } else {
             // Wrap around
-            stats[i] = (uint64_t)((hw_stats[i] + ((uint64_t)1 << 32)) - prev_stats[i]);
+            stats[i] = (uint64_t)((hw_stats[i - min] + ((uint64_t)1 << 32)) - prev_stats[i]);
         }
-        prev_stats[i] = hw_stats[i];
+        prev_stats[i] = hw_stats[i - min];
     }
 
     return 0;
@@ -5190,8 +5224,8 @@ TrexDpdkPlatformApi::get_interface_info(uint8_t interface_id, intf_info_st &info
 }
 
 void
-TrexDpdkPlatformApi::publish_async_data_now(uint32_t key) const {
-    g_trex.publish_async_data(true);
+TrexDpdkPlatformApi::publish_async_data_now(uint32_t key, bool baseline) const {
+    g_trex.publish_async_data(true, baseline);
     g_trex.publish_async_barrier(key);
 }
 
diff --git a/src/platform_cfg.cpp b/src/platform_cfg.cpp
index ec67af64..a76cea2b 100755
--- a/src/platform_cfg.cpp
+++ b/src/platform_cfg.cpp
@@ -4,7 +4,7 @@
 */
 
 /*
-Copyright (c) 2015-2015 Cisco Systems, Inc.
+Copyright (c) 2015-2016 Cisco Systems, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,16 +19,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-#include "platform_cfg.h"
-#include <common/basic_utils.h> 
-#include <stdlib.h>
-#include <iostream>
 #include <fstream>
-
+#include <iostream>
+#include <stdlib.h>
+#include "common/basic_utils.h"
+#include "platform_cfg.h"
 
 void CPlatformMemoryYamlInfo::reset(){
        int i;
-       i=0; 
+       i=0;
        for (i=0; i<MBUF_SIZE; i++) {
            m_mbuf[i] = CONST_NB_MBUF_2_10G;
        }
@@ -49,39 +48,35 @@ void CPlatformMemoryYamlInfo::reset(){
        m_mbuf[MBUF_DP_FLOWS]     = (1024*1024/2);
        m_mbuf[MBUF_GLOBAL_FLOWS] =(10*1024/2);
 }
+
 const std::string names []={
                    "MBUF_64",
                    "MBUF_128",
                    "MBUF_256",
-                   "MBUF_512",       
-                   "MBUF_1024",      
-                   "MBUF_2048",    
-                   "MBUF_4096",    
-                   "MBUF_9K",    
-
-
+                   "MBUF_512",
+                   "MBUF_1024",
+                   "MBUF_2048",
+                   "MBUF_4096",
+                   "MBUF_9K",
 
                    "TRAFFIC_MBUF_64",
                    "TRAFFIC_MBUF_128",
                    "TRAFFIC_MBUF_256",
-                   "TRAFFIC_MBUF_512",       
-                   "TRAFFIC_MBUF_1024",      
-                   "TRAFFIC_MBUF_2048",      
-                   "TRAFFIC_MBUF_4096",    
-                   "TRAFFIC_MBUF_9K",    
+                   "TRAFFIC_MBUF_512",
+                   "TRAFFIC_MBUF_1024",
+                   "TRAFFIC_MBUF_2048",
+                   "TRAFFIC_MBUF_4096",
+                   "TRAFFIC_MBUF_9K",
 
-
-                   "MBUF_DP_FLOWS",  
+                   "MBUF_DP_FLOWS",
                    "MBUF_GLOBAL_FLOWS"
 
-    };
+};
 
 const std::string * get_mbuf_names(void){
   return names;
 }
 
-
-
 void CPlatformDualIfYamlInfo::Dump(FILE *fd){
     fprintf(fd,"    socket  : %d  \n",m_socket);
     int i;
@@ -92,8 +87,6 @@ void CPlatformDualIfYamlInfo::Dump(FILE *fd){
     fprintf(fd,"   ]  \n");
 }
 
-
-
 void CPlatformCoresYamlInfo::Dump(FILE *fd){
     if ( m_is_exists == false){
        fprintf(fd," no platform info \n");
@@ -121,10 +114,18 @@ void operator >> (const YAML::Node& node, CPlatformDualIfYamlInfo & plat_info) {
     }
 }
 
-
 void operator >> (const YAML::Node& node, CPlatformCoresYamlInfo & plat_info) {
      node["master_thread_id"] >> plat_info.m_master_thread;
-     node["latency_thread_id"] >> plat_info.m_rx_thread;
+     if (node.FindValue("rx_thread_id")) {
+         node["rx_thread_id"] >> plat_info.m_rx_thread;
+     } else {
+         // Obolete option.
+         if (node.FindValue("latency_thread_id")) {
+             node["latency_thread_id"] >> plat_info.m_rx_thread;
+         } else {
+             node["rx_thread_id"] >> plat_info.m_rx_thread; // do this to get the error message
+         }
+     }
 
      const YAML::Node& dual_info = node["dual_if"];
      for(unsigned i=0;i<dual_info.size();i++) {
@@ -134,19 +135,15 @@ void operator >> (const YAML::Node& node, CPlatformCoresYamlInfo & plat_info) {
      }
 }
 
-
 void CPlatformMemoryYamlInfo::Dump(FILE *fd){
-
     fprintf(fd," memory per 2x10G ports  \n");
     const std::string * names =get_mbuf_names();
 
-    int i=0; 
+    int i=0;
     for (i=0; i<MBUF_SIZE; i++) {
         fprintf(fd," %-40s  : %lu \n",names[i].c_str(), (ulong)m_mbuf[i]);
     }
 }
-             
-
 
 void CMacYamlInfo::copy_dest(char *p){
     assert(m_dest_base.size() == 6);
@@ -174,18 +171,14 @@ void CMacYamlInfo::Dump(FILE *fd){
         fprintf(fd,"ERROR in dest mac addr \n");
         return;
     }
-    fprintf (fd," src     : ");   
+    fprintf (fd," src     : ");
     dump_mac_vector( m_dest_base,fd);
-    fprintf (fd," dest    : ");   
+    fprintf (fd," dest    : ");
     dump_mac_vector( m_src_base,fd);
 
 }
 
-
-
-
 void operator >> (const YAML::Node& node, CMacYamlInfo & mac_info) {
-
     const YAML::Node& dmac = node["dest_mac"];
     for(unsigned i=0;i<dmac.size();i++) {
         uint32_t fi;
@@ -204,86 +197,83 @@ void operator >> (const YAML::Node& node, CMacYamlInfo & mac_info) {
 }
 
 void operator >> (const YAML::Node& node, CPlatformMemoryYamlInfo & plat_info) {
-
     if ( node.FindValue("mbuf_64") ){
-        node["mbuf_64"] >> plat_info.m_mbuf[MBUF_64];    
+        node["mbuf_64"] >> plat_info.m_mbuf[MBUF_64];
     }
 
     if ( node.FindValue("mbuf_128") ){
-        node["mbuf_128"] >> plat_info.m_mbuf[MBUF_128];    
+        node["mbuf_128"] >> plat_info.m_mbuf[MBUF_128];
     }
 
     if ( node.FindValue("mbuf_256") ){
-        node["mbuf_256"] >> plat_info.m_mbuf[MBUF_256];    
+        node["mbuf_256"] >> plat_info.m_mbuf[MBUF_256];
     }
 
     if ( node.FindValue("mbuf_512") ){
-        node["mbuf_512"] >> plat_info.m_mbuf[MBUF_512];        
+        node["mbuf_512"] >> plat_info.m_mbuf[MBUF_512];
     }
 
     if ( node.FindValue("mbuf_1024") ){
-        node["mbuf_1024"] >> plat_info.m_mbuf[MBUF_1024];         
+        node["mbuf_1024"] >> plat_info.m_mbuf[MBUF_1024];
     }
 
     if ( node.FindValue("mbuf_2048") ){
-        node["mbuf_2048"] >> plat_info.m_mbuf[MBUF_2048];      
+        node["mbuf_2048"] >> plat_info.m_mbuf[MBUF_2048];
     }
 
     if ( node.FindValue("mbuf_4096") ){
-        node["mbuf_4096"] >> plat_info.m_mbuf[MBUF_4096];      
+        node["mbuf_4096"] >> plat_info.m_mbuf[MBUF_4096];
     }
 
     if ( node.FindValue("mbuf_9k") ){
-        node["mbuf_9k"] >> plat_info.m_mbuf[MBUF_9k];      
+        node["mbuf_9k"] >> plat_info.m_mbuf[MBUF_9k];
     }
 
 
     if ( node.FindValue("traffic_mbuf_64") ){
-        node["traffic_mbuf_64"] >> plat_info.m_mbuf[TRAFFIC_MBUF_64];    
+        node["traffic_mbuf_64"] >> plat_info.m_mbuf[TRAFFIC_MBUF_64];
     }
 
     if ( node.FindValue("traffic_mbuf_128") ){
-        node["traffic_mbuf_128"] >> plat_info.m_mbuf[TRAFFIC_MBUF_128];    
+        node["traffic_mbuf_128"] >> plat_info.m_mbuf[TRAFFIC_MBUF_128];
     }
 
     if ( node.FindValue("traffic_mbuf_256") ){
-        node["traffic_mbuf_256"] >> plat_info.m_mbuf[TRAFFIC_MBUF_256];    
+        node["traffic_mbuf_256"] >> plat_info.m_mbuf[TRAFFIC_MBUF_256];
     }
 
     if ( node.FindValue("traffic_mbuf_512") ){
-        node["traffic_mbuf_512"] >> plat_info.m_mbuf[TRAFFIC_MBUF_512];        
+        node["traffic_mbuf_512"] >> plat_info.m_mbuf[TRAFFIC_MBUF_512];
     }
 
     if ( node.FindValue("traffic_mbuf_1024") ){
-        node["traffic_mbuf_1024"] >> plat_info.m_mbuf[TRAFFIC_MBUF_1024];         
+        node["traffic_mbuf_1024"] >> plat_info.m_mbuf[TRAFFIC_MBUF_1024];
     }
 
     if ( node.FindValue("traffic_mbuf_2048") ){
-        node["traffic_mbuf_2048"] >> plat_info.m_mbuf[TRAFFIC_MBUF_2048];      
+        node["traffic_mbuf_2048"] >> plat_info.m_mbuf[TRAFFIC_MBUF_2048];
     }
 
     if ( node.FindValue("traffic_mbuf_4096") ){
-        node["traffic_mbuf_4096"] >> plat_info.m_mbuf[TRAFFIC_MBUF_4096];      
+        node["traffic_mbuf_4096"] >> plat_info.m_mbuf[TRAFFIC_MBUF_4096];
     }
 
     if ( node.FindValue("traffic_mbuf_9k") ){
-        node["traffic_mbuf_9k"] >> plat_info.m_mbuf[TRAFFIC_MBUF_9k];      
+        node["traffic_mbuf_9k"] >> plat_info.m_mbuf[TRAFFIC_MBUF_9k];
     }
 
 
     if ( node.FindValue("dp_flows") ){
-        node["dp_flows"] >> plat_info.m_mbuf[MBUF_DP_FLOWS];      
+        node["dp_flows"] >> plat_info.m_mbuf[MBUF_DP_FLOWS];
     }
 
     if ( node.FindValue("global_flows") ){
-        node["global_flows"] >> plat_info.m_mbuf[MBUF_GLOBAL_FLOWS];      
+        node["global_flows"] >> plat_info.m_mbuf[MBUF_GLOBAL_FLOWS];
     }
 
 }
 
-
 void operator >> (const YAML::Node& node, CPlatformYamlInfo & plat_info) {
-
     if (node.FindValue("interface_mask")) {
         printf("WARNING interface_mask in not used any more !\n");
     }
@@ -299,7 +289,7 @@ void operator >> (const YAML::Node& node, CPlatformYamlInfo & plat_info) {
 
 
     if ( node.FindValue("port_limit") ){
-        node["port_limit"] >> plat_info.m_port_limit;    
+        node["port_limit"] >> plat_info.m_port_limit;
         plat_info.m_port_limit_exist=true;
     }
 
@@ -307,29 +297,29 @@ void operator >> (const YAML::Node& node, CPlatformYamlInfo & plat_info) {
     plat_info.m_enable_zmq_pub_exist = true;
 
     if ( node.FindValue("enable_zmq_pub") ){
-        node["enable_zmq_pub"] >> plat_info.m_enable_zmq_pub;    
+        node["enable_zmq_pub"] >> plat_info.m_enable_zmq_pub;
         plat_info.m_enable_zmq_pub_exist = true;
     }
 
     if ( node.FindValue("zmq_pub_port") ){
-        node["zmq_pub_port"] >> plat_info.m_zmq_pub_port;    
+        node["zmq_pub_port"] >> plat_info.m_zmq_pub_port;
         plat_info.m_enable_zmq_pub_exist = true;
     }
 
     if ( node.FindValue("prefix") ){
-        node["prefix"] >> plat_info.m_prefix;    
+        node["prefix"] >> plat_info.m_prefix;
     }
 
     if ( node.FindValue("limit_memory") ){
-        node["limit_memory"] >> plat_info.m_limit_memory;    
+        node["limit_memory"] >> plat_info.m_limit_memory;
     }
 
     if ( node.FindValue("c") ){
-        node["c"] >> plat_info.m_thread_per_dual_if;    
+        node["c"] >> plat_info.m_thread_per_dual_if;
     }
 
     if ( node.FindValue("telnet_port") ){
-        node["telnet_port"] >> plat_info.m_telnet_port;    
+        node["telnet_port"] >> plat_info.m_telnet_port;
         plat_info.m_telnet_exist=true;
     }
 
@@ -388,7 +378,6 @@ int CPlatformYamlInfo::load_from_yaml_file(std::string file_name){
     return (0);
 }
 
-
 std::string CPlatformYamlInfo::get_use_if_comma_seperated(){
     std::string s="";
     int i;
@@ -399,23 +388,21 @@ std::string CPlatformYamlInfo::get_use_if_comma_seperated(){
     return (s);
 }
 
-
 void CPlatformYamlInfo::Dump(FILE *fd){
     if ( m_info_exist ==false ){
         fprintf(fd," file info does not exist  \n");
         return;
     }
 
-
     if (m_port_limit_exist && (m_port_limit != 0xffffffff)) {
-    fprintf(fd," port limit     :  %d \n",m_port_limit);
+        fprintf(fd," port limit     :  %d \n",m_port_limit);
     }else{
-    fprintf(fd," port limit     :  not configured \n");
+        fprintf(fd," port limit     :  not configured \n");
     }
     fprintf(fd," port_bandwidth_gb    :  %lu \n", (ulong)m_port_bandwidth_gb);
-    
+
     if ( m_if_mask_exist && m_if_mask.size() ) {
-    fprintf(fd," if_mask        : ");
+        fprintf(fd," if_mask        : ");
         int i;
         for (i=0; i<(int)m_if_mask.size(); i++) {
             fprintf(fd," %s,",m_if_mask[i].c_str());
@@ -423,9 +410,9 @@ void CPlatformYamlInfo::Dump(FILE *fd){
         fprintf(fd,"\n");
 
     }else{
-    fprintf(fd," if_mask        : None \n");
+        fprintf(fd," if_mask        : None \n");
     }
-    
+
     if ( m_prefix.length() ){
         fprintf(fd," prefix              : %s \n",m_prefix.c_str());
     }
@@ -460,8 +447,3 @@ void CPlatformYamlInfo::Dump(FILE *fd){
     m_memory.Dump(fd);
     m_platform.Dump(fd);
 }
-
-
-
-
-
diff --git a/src/rpc-server/commands/trex_rpc_cmd_general.cpp b/src/rpc-server/commands/trex_rpc_cmd_general.cpp
index dcf74b50..f054c0ed 100644
--- a/src/rpc-server/commands/trex_rpc_cmd_general.cpp
+++ b/src/rpc-server/commands/trex_rpc_cmd_general.cpp
@@ -398,9 +398,10 @@ trex_rpc_cmd_rc_e
 TrexRpcPublishNow::_run(const Json::Value &params, Json::Value &result) {
     TrexStateless *main = get_stateless_obj();
 
-    uint32_t key = parse_uint32(params, "key", result);
+    uint32_t key  = parse_uint32(params, "key", result);
+    bool baseline = parse_bool(params, "baseline", result);
 
-    main->get_platform_api()->publish_async_data_now(key);
+    main->get_platform_api()->publish_async_data_now(key, baseline);
 
     result["result"] = Json::objectValue;
     return (TREX_RPC_CMD_OK);
diff --git a/src/rpc-server/commands/trex_rpc_cmds.h b/src/rpc-server/commands/trex_rpc_cmds.h
index 386ccc27..c4b01b85 100644
--- a/src/rpc-server/commands/trex_rpc_cmds.h
+++ b/src/rpc-server/commands/trex_rpc_cmds.h
@@ -57,7 +57,7 @@ TREX_RPC_CMD_DEFINE(TrexRpcCmdTestSub,    "test_sub", 2, false);
  * general cmds
  */
 TREX_RPC_CMD_DEFINE(TrexRpcCmdPing,       "ping",                 0, false);
-TREX_RPC_CMD_DEFINE(TrexRpcPublishNow,    "publish_now",          1, false);
+TREX_RPC_CMD_DEFINE(TrexRpcPublishNow,    "publish_now",          2, false);
 TREX_RPC_CMD_DEFINE(TrexRpcCmdGetCmds,    "get_supported_cmds",   0, false);
 TREX_RPC_CMD_DEFINE(TrexRpcCmdGetVersion, "get_version",          0, false);
 TREX_RPC_CMD_DEFINE(TrexRpcCmdGetActivePGIds, "get_active_pgids",0, false);
diff --git a/src/sim/trex_sim.h b/src/sim/trex_sim.h
index 59184b75..5aeeb226 100644
--- a/src/sim/trex_sim.h
+++ b/src/sim/trex_sim.h
@@ -149,7 +149,9 @@ private:
                      uint64_t &simulated_pkts,
                      uint64_t &written_pkts);
 
+    void cleanup();
     void flush_dp_to_cp_messages_core(int core_index);
+    void flush_cp_to_dp_messages_core(int core_index);
 
     void validate_response(const Json::Value &resp);
 
diff --git a/src/sim/trex_sim_stateless.cpp b/src/sim/trex_sim_stateless.cpp
index 87c61ae2..ffe377f4 100644
--- a/src/sim/trex_sim_stateless.cpp
+++ b/src/sim/trex_sim_stateless.cpp
@@ -347,6 +347,10 @@ SimStateless::run_dp(const std::string &out_filename) {
         }
     }
 
+    /* cleanup */
+    cleanup();
+
+
     std::cout << "\n\nSimulation summary:\n";
     std::cout << "-------------------\n\n";
     std::cout << "simulated " << simulated_pkts_cnt << " packets\n";
@@ -360,6 +364,18 @@ SimStateless::run_dp(const std::string &out_filename) {
     std::cout << "\n";
 }
 
+void
+SimStateless::cleanup() {
+
+    for (int port_id = 0; port_id < get_stateless_obj()->get_port_count(); port_id++) {
+        get_stateless_obj()->get_port_by_id(port_id)->stop_traffic();
+        get_stateless_obj()->get_port_by_id(port_id)->remove_and_delete_all_streams();
+    }
+    for (int i = 0; i < m_dp_core_count; i++) {
+        flush_cp_to_dp_messages_core(i);
+        flush_dp_to_cp_messages_core(i);
+    }
+}
 
 uint64_t 
 SimStateless::get_limit_per_core(int core_index) {
@@ -418,6 +434,23 @@ SimStateless::flush_dp_to_cp_messages_core(int core_index) {
     }
 }
 
+void
+SimStateless::flush_cp_to_dp_messages_core(int core_index) {
+
+    CNodeRing *ring = CMsgIns::Ins()->getCpDp()->getRingCpToDp(core_index);
+
+    while ( true ) {
+        CGenNode * node = NULL;
+        if (ring->Dequeue(node) != 0) {
+            break;
+        }
+        assert(node);
+
+        TrexStatelessCpToDpMsgBase * msg = (TrexStatelessCpToDpMsgBase *)node;
+        delete msg;
+    }
+}
+
 bool
 SimStateless::should_capture_core(int i) {
 
diff --git a/src/stateless/cp/trex_dp_port_events.cpp b/src/stateless/cp/trex_dp_port_events.cpp
index 8e098adf..1321a362 100644
--- a/src/stateless/cp/trex_dp_port_events.cpp
+++ b/src/stateless/cp/trex_dp_port_events.cpp
@@ -82,6 +82,12 @@ protected:
 
 void
 TrexDpPortEvents::barrier() {
+
+    /* simulator will be stuck here forever */
+    #ifdef TREX_SIM
+    return;
+    #endif
+     
     int barrier_id = create_event(new DPBarrier());
 
     TrexStatelessCpToDpMsgBase *barrier_msg = new TrexStatelessDpBarrier(m_port->m_port_id, barrier_id);
diff --git a/src/stateless/cp/trex_stateless_port.cpp b/src/stateless/cp/trex_stateless_port.cpp
index 7302e05d..5947aaf7 100644
--- a/src/stateless/cp/trex_stateless_port.cpp
+++ b/src/stateless/cp/trex_stateless_port.cpp
@@ -103,14 +103,9 @@ TrexStatelessPort::TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api
 }
 
 TrexStatelessPort::~TrexStatelessPort() {
-    if (m_graph_obj) {
-        delete m_graph_obj;
-    }
 
-    if (m_pending_async_stop_event != TrexDpPortEvents::INVALID_ID) {
-        m_dp_events.destroy_event(m_pending_async_stop_event);
-        m_pending_async_stop_event = TrexDpPortEvents::INVALID_ID;
-    }
+    stop_traffic();
+    remove_and_delete_all_streams();
 }
 
 /**