1 files changed, 296 insertions, 100 deletions
diff --git a/src/stateless/cp/trex_stateless_port.h b/src/stateless/cp/trex_stateless_port.h
index 428d5aee..4988b46a 100644
--- a/src/stateless/cp/trex_stateless_port.h
+++ b/src/stateless/cp/trex_stateless_port.h
@@ -22,87 +22,103 @@ limitations under the License.
 #define __TREX_STATELESS_PORT_H__
 
 #include <trex_stream.h>
-
-/**
- * bandwidth measurement class
+#include <trex_dp_port_events.h>
+#include <internal_api/trex_platform_api.h>
+
+class TrexStatelessCpToDpMsgBase;
+class TrexStreamsGraphObj;
+class TrexPortMultiplier;
+
+/** 
+ * TRex port owner can perform
+ * write commands
+ * while port is owned - others can
+ * do read only commands
  * 
  */
-class BWMeasure {
+class TrexPortOwner {
 public:
-    BWMeasure();
-    void reset(void);
-    double add(uint64_t size);
 
-private:
-    double calc_MBsec(uint32_t dtime_msec,
-                      uint64_t dbytes);
+    TrexPortOwner();
 
-public:
-   bool      m_start;
-   uint32_t  m_last_time_msec;
-   uint64_t  m_last_bytes;
-   double    m_last_result;
-};
+    /**
+     * is port free to acquire
+     */
+    bool is_free() {
+        return m_is_free;
+    }
 
-/**
- * TRex stateless port stats
- * 
- * @author imarom (24-Sep-15)
- */
-class TrexPortStats {
+    void release() {
+        m_is_free = true;
+        m_owner_name = "";
+        m_handler = "";
+    }
 
-public:
-    TrexPortStats() {
-        m_stats = {0};
+    bool is_owned_by(const std::string &user) {
+        return ( !m_is_free && (m_owner_name == user) );
+    }
+
+    void own(const std::string &owner_name) {
 
-        m_bw_tx_bps.reset();
-        m_bw_rx_bps.reset();
+        /* save user data */
+        m_owner_name = owner_name;
 
-        m_bw_tx_pps.reset();
-        m_bw_rx_pps.reset();
+        /* internal data */
+        m_handler = generate_handler();
+        m_is_free = false;
     }
 
-public:
+    bool verify(const std::string &handler) {
+        return ( (!m_is_free) && (m_handler == handler) );
+    }
 
-    BWMeasure m_bw_tx_bps;
-    BWMeasure m_bw_rx_bps;
-
-    BWMeasure m_bw_tx_pps;
-    BWMeasure m_bw_rx_pps;
-
-    struct {
-
-        double m_tx_bps;
-        double m_rx_bps;
-       
-        double m_tx_pps;
-        double m_rx_pps;
-       
-        uint64_t m_total_tx_pkts;
-        uint64_t m_total_rx_pkts;
-       
-        uint64_t m_total_tx_bytes;
-        uint64_t m_total_rx_bytes;
-       
-        uint64_t m_tx_rx_errors;
-    } m_stats;
+    const std::string &get_name() {
+        return (!m_is_free ? m_owner_name : g_unowned_name);
+    }
+
+    const std::string &get_handler() {
+        return (!m_is_free ? m_handler : g_unowned_handler);
+    }
+
+
+private:
+    std::string  generate_handler();
+
+    /* is this port owned by someone ? */
+    bool         m_is_free;
+
+    /* user provided info */
+    std::string  m_owner_name;
+
+    /* handler genereated internally */
+    std::string  m_handler;
+    
+
+    /* just references defaults... */
+    static const std::string g_unowned_name;
+    static const std::string g_unowned_handler;
 };
 
+
 /**
  * describes a stateless port
  * 
  * @author imarom (31-Aug-15)
  */
 class TrexStatelessPort {
+    friend class TrexDpPortEvent;
+
 public:
 
     /**
      * port state
      */
     enum port_state_e {
-        PORT_STATE_DOWN,
-        PORT_STATE_UP_IDLE,
-        PORT_STATE_TRANSMITTING
+        PORT_STATE_DOWN = 0x1,
+        PORT_STATE_IDLE = 0x2,
+        PORT_STATE_STREAMS = 0x4,
+        PORT_STATE_TX = 0x8,
+        PORT_STATE_PAUSE = 0x10,
     };
 
     /**
@@ -115,31 +131,66 @@ public:
         RC_ERR_FAILED_TO_COMPILE_STREAMS
     };
 
-    TrexStatelessPort(uint8_t port_id);
+  
+    TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api);
+    
+    /**
+     * acquire port
+     * throws TrexException in case of an error
+     */
+    void acquire(const std::string &user, bool force = false);
+
+    /**
+     * release the port from the current user
+     * throws TrexException in case of an error
+     */
+    void release(void);
+
+    /**
+     * validate the state of the port before start 
+     * it will return a stream graph 
+     * containing information about the streams 
+     * configured on this port 
+     *  
+     * on error it throws TrexException
+     */
+    const TrexStreamsGraphObj *validate(void);
 
     /**
      * start traffic
-     * 
+     * throws TrexException in case of an error
      */
-    rc_e start_traffic(void);
+    void start_traffic(const TrexPortMultiplier &mul, double duration);
 
     /**
      * stop traffic
-     * 
+     * throws TrexException in case of an error
      */
     void stop_traffic(void);
 
     /**
-     * access the stream table
+     * pause traffic
+     * throws TrexException in case of an error
+     */
+    void pause_traffic(void);
+
+    /**
+     * resume traffic
+     * throws TrexException in case of an error
+     */
+    void resume_traffic(void);
+
+    /**
+     * update current traffic on port
      * 
      */
-    TrexStreamTable *get_stream_table();
+    void update_traffic(const TrexPortMultiplier &mul);
 
     /**
      * get the port state
      * 
      */
-    port_state_e get_state() {
+    port_state_e get_state() const {
         return m_port_state;
     }
 
@@ -147,7 +198,7 @@ public:
      * port state as string
      * 
      */
-    std::string get_state_as_string();
+    std::string get_state_as_string() const;
 
     /**
      * fill up properties of the port
@@ -157,74 +208,219 @@ public:
      * @param driver 
      * @param speed 
      */
-    void get_properties(std::string &driver, std::string &speed);
+    void get_properties(std::string &driver, TrexPlatformApi::driver_speed_e &speed);
+
+
 
     /**
-    * query for ownership
-    * 
-    */
-    const std::string &get_owner() {
-        return m_owner;
+     * encode stats as JSON
+     */
+    void encode_stats(Json::Value &port);
+
+    uint8_t get_port_id() {
+        return m_port_id;
     }
 
     /**
-     * owner handler 
-     * for the connection 
+     * delegators
      * 
      */
-    const std::string &get_owner_handler() {
-        return m_owner_handler;
+
+    void add_stream(TrexStream *stream) {
+        verify_state(PORT_STATE_IDLE | PORT_STATE_STREAMS);
+
+        m_stream_table.add_stream(stream);
+        delete_streams_graph();
+
+        change_state(PORT_STATE_STREAMS);
     }
 
-    bool is_free_to_aquire() {
-        return (m_owner == "none");
+    void remove_stream(TrexStream *stream) {
+        verify_state(PORT_STATE_STREAMS);
+
+        m_stream_table.remove_stream(stream);
+        delete_streams_graph();
+
+        if (m_stream_table.size() == 0) {
+            change_state(PORT_STATE_IDLE);
+        }
     }
 
-    /**
-    * take ownership of the server array 
-    * this is static 
-    * ownership is total 
-    * 
-    */
-    void set_owner(const std::string &owner) {
-        m_owner = owner;
-        m_owner_handler = generate_handler();
+    void remove_and_delete_all_streams() {
+        verify_state(PORT_STATE_IDLE | PORT_STATE_STREAMS);
+
+        m_stream_table.remove_and_delete_all_streams();
+        delete_streams_graph();
+
+        change_state(PORT_STATE_IDLE);
     }
 
-    void clear_owner() {
-        m_owner = "none";
-        m_owner_handler = "";
+    TrexStream * get_stream_by_id(uint32_t stream_id) {
+        return m_stream_table.get_stream_by_id(stream_id);
     }
 
-    bool verify_owner_handler(const std::string &handler) {
+    void get_id_list(std::vector<uint32_t> &id_list) {
+        m_stream_table.get_id_list(id_list);
+    }
 
-        return ( (m_owner != "none") && (m_owner_handler == handler) );
+    void get_object_list(std::vector<TrexStream *> &object_list) {
+        m_stream_table.get_object_list(object_list);
+    }
 
+    TrexDpPortEvents & get_dp_events() {
+        return m_dp_events;
     }
 
+
     /**
-     * update the values of the stats
+     * returns the number of DP cores linked to this port
      * 
      */
-    void update_stats();
+    uint8_t get_dp_core_count() {
+        return m_cores_id_list.size();
+    }
 
-    const TrexPortStats & get_stats();
+    /**
+     * returns the traffic multiplier currently being used by the DP
+     * 
+     */
+    double get_multiplier() {
+        return (m_factor);
+    }
 
     /**
-     * encode stats as JSON
+     * get port speed in bits per second
+     * 
      */
-    void encode_stats(Json::Value &port);
+    uint64_t get_port_speed_bps() const;
+
+    TrexPortOwner & get_owner() {
+        return m_owner;
+    }
 
 private:
 
+
+    const std::vector<int> get_core_id_list () {
+        return m_cores_id_list;
+    }
+
+    bool verify_state(int state, bool should_throw = true) const;
+
+    void change_state(port_state_e new_state);
+
     std::string generate_handler();
 
-    TrexStreamTable  m_stream_table;
-    uint8_t          m_port_id;
-    port_state_e     m_port_state;
-    std::string      m_owner;
-    std::string      m_owner_handler;
-    TrexPortStats    m_stats;
+    /**
+     * send message to all cores using duplicate
+     * 
+     */
+    void send_message_to_all_dp(TrexStatelessCpToDpMsgBase *msg);
+
+    /**
+     * send message to specific DP core
+     * 
+     */
+    void send_message_to_dp(uint8_t core_id, TrexStatelessCpToDpMsgBase *msg);
+
+    /**
+     * triggered when event occurs
+     * 
+     */
+    void on_dp_event_occured(TrexDpPortEvent::event_e event_type);
+
+
+    /**
+     * calculate effective M per core
+     * 
+     */
+    double calculate_effective_factor(const TrexPortMultiplier &mul);
+
+  
+
+    /**
+     * generates a graph of streams graph
+     * 
+     */
+    void generate_streams_graph();
+
+    /**
+     * dispose of it
+     * 
+     * @author imarom (26-Nov-15)
+     */
+    void delete_streams_graph();
+
+
+    TrexStreamTable    m_stream_table;
+    uint8_t            m_port_id;
+    port_state_e       m_port_state;
+    std::string        m_driver_name;
+
+    TrexPlatformApi::driver_speed_e m_speed;
+
+    /* holds the DP cores associated with this port */
+    std::vector<int>   m_cores_id_list;
+
+    bool               m_last_all_streams_continues;
+    double             m_last_duration;
+    double             m_factor;
+
+    TrexDpPortEvents   m_dp_events;
+
+    /* holds a graph of streams rate*/
+    const TrexStreamsGraphObj  *m_graph_obj;
+
+    /* owner information */
+    TrexPortOwner       m_owner;
+};
+
+
+/**
+ * port multiplier object
+ * 
+ */
+class TrexPortMultiplier {
+public:
+
+
+    /**
+     * defines the type of multipler passed to start
+     */
+    enum mul_type_e {
+        MUL_FACTOR,
+        MUL_BPS,
+        MUL_PPS,
+        MUL_PERCENTAGE
+    };
+
+    /**
+     * multiplier can be absolute value 
+     * increment value or subtract value 
+     */
+    enum mul_op_e {
+        OP_ABS,
+        OP_ADD,
+        OP_SUB
+    };
+
+
+    TrexPortMultiplier(mul_type_e type, mul_op_e op, double value) {
+        m_type   = type;
+        m_op     = op;
+        m_value  = value;
+    }
+
+    TrexPortMultiplier(const std::string &type_str, const std::string &op_str, double value);
+
+
+public:
+    static const std::initializer_list<std::string> g_types;
+    static const std::initializer_list<std::string> g_ops;
+
+    mul_type_e  m_type;
+    mul_op_e    m_op;
+    double      m_value;
 };
 
 #endif /* __TREX_STATELESS_PORT_H__ */