--- /dev/null
+/*
+ Hanoh Haim
+ Cisco Systems, Inc.
+*/
+
+/*
+Copyright (c) 2015-2015 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.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "bp_sim.h"
+#include <common/gtest.h>
+#include <common/basic_utils.h>
+
+
+#define EXPECT_EQ_UINT32(a,b) EXPECT_EQ((uint32_t)(a),(uint32_t)(b))
+
+// one stream info with const packet , no VM
+class CTRexDpStatelessVM {
+
+};
+
+//- add dump function
+// - check one object
+// create frame work
+
+class CTRexDpStreamModeContinues{
+public:
+ void set_pps(double pps){
+ m_pps=pps;
+ }
+ double get_pps(){
+ return (m_pps);
+ }
+
+ void dump(FILE *fd);
+private:
+ double m_pps;
+};
+
+
+void CTRexDpStreamModeContinues::dump(FILE *fd){
+ fprintf (fd," pps : %f \n",m_pps);
+}
+
+
+class CTRexDpStreamModeSingleBurst{
+public:
+ void set_pps(double pps){
+ m_pps=pps;
+ }
+ double get_pps(){
+ return (m_pps);
+ }
+
+ void set_total_packets(uint64_t total_packets){
+ m_total_packets =total_packets;
+ }
+
+ uint64_t get_total_packets(){
+ return (m_total_packets);
+ }
+
+ void dump(FILE *fd);
+
+private:
+ double m_pps;
+ uint64_t m_total_packets;
+};
+
+
+void CTRexDpStreamModeSingleBurst::dump(FILE *fd){
+ fprintf (fd," pps : %f \n",m_pps);
+ fprintf (fd," total_packets : %llu \n",m_total_packets);
+}
+
+
+class CTRexDpStreamModeMultiBurst{
+public:
+ void set_pps(double pps){
+ m_pps=pps;
+ }
+ double get_pps(){
+ return (m_pps);
+ }
+
+ void set_pkts_per_burst(uint64_t pkts_per_burst){
+ m_pkts_per_burst =pkts_per_burst;
+ }
+
+ uint64_t get_pkts_per_burst(){
+ return (m_pkts_per_burst);
+ }
+
+ void set_ibg(double ibg){
+ m_ibg = ibg;
+ }
+
+ double get_ibg(){
+ return ( m_ibg );
+ }
+
+ void set_number_of_bursts(uint32_t number_of_bursts){
+ m_number_of_bursts = number_of_bursts;
+ }
+
+ uint32_t get_number_of_bursts(){
+ return (m_number_of_bursts);
+ }
+
+ void dump(FILE *fd);
+
+private:
+ double m_pps;
+ double m_ibg; // inter burst gap
+ uint64_t m_pkts_per_burst;
+ uint32_t m_number_of_bursts;
+};
+
+void CTRexDpStreamModeMultiBurst::dump(FILE *fd){
+ fprintf (fd," pps : %f \n",m_pps);
+ fprintf (fd," total_packets : %llu \n",m_pkts_per_burst);
+ fprintf (fd," ibg : %f \n",m_ibg);
+ fprintf (fd," num_of_bursts : %llu \n",m_number_of_bursts);
+}
+
+
+
+class CTRexDpStreamMode {
+public:
+ enum MODES {
+ moCONTINUES = 0x0,
+ moSINGLE_BURST = 0x1,
+ moMULTI_BURST = 0x2
+ } ;
+ typedef uint8_t MODE_TYPE_t;
+
+ void reset();
+
+ void set_mode(MODE_TYPE_t mode ){
+ m_type = mode;
+ }
+
+ MODE_TYPE_t get_mode(){
+ return (m_type);
+ }
+
+
+ CTRexDpStreamModeContinues & cont(void){
+ return (m_data.m_cont);
+ }
+ CTRexDpStreamModeSingleBurst & single_burst(void){
+ return (m_data.m_signle_burst);
+ }
+
+ CTRexDpStreamModeMultiBurst & multi_burst(void){
+ return (m_data.m_multi_burst);
+ }
+
+ void dump(FILE *fd);
+
+private:
+ uint8_t m_type;
+ union Data {
+ CTRexDpStreamModeContinues m_cont;
+ CTRexDpStreamModeSingleBurst m_signle_burst;
+ CTRexDpStreamModeMultiBurst m_multi_burst;
+ } m_data;
+};
+
+
+void CTRexDpStreamMode::reset(){
+ m_type =CTRexDpStreamMode::moCONTINUES;
+ memset(&m_data,0,sizeof(m_data));
+}
+
+void CTRexDpStreamMode::dump(FILE *fd){
+ const char * table[3] = {"CONTINUES","SINGLE_BURST","MULTI_BURST"};
+
+ fprintf(fd," mode : %s \n", (char*)table[m_type]);
+ switch (m_type) {
+ case CTRexDpStreamMode::moCONTINUES :
+ cont().dump(fd);
+ break;
+ case CTRexDpStreamMode::moSINGLE_BURST :
+ single_burst().dump(fd);
+ break;
+ case CTRexDpStreamMode::moMULTI_BURST :
+ multi_burst().dump(fd);
+ break;
+ default:
+ fprintf(fd," ERROR type if not valid %d \n",m_type);
+ break;
+ }
+}
+
+
+
+
+class CTRexDpStatelessStream {
+
+public:
+ enum FLAGS_0{
+ _ENABLE = 0,
+ _SELF_START = 1,
+ _VM_ENABLE =2,
+ _END_STREAM =-1
+ };
+
+ CTRexDpStatelessStream(){
+ reset();
+ }
+
+ void reset(){
+ m_packet =0;
+ m_vm=0;
+ m_flags=0;
+ m_isg_sec=0.0;
+ m_next_stream = CTRexDpStatelessStream::_END_STREAM ; // END
+ m_mode.reset();
+ }
+
+ void set_enable(bool enable){
+ btSetMaskBit32(m_flags,_ENABLE,_ENABLE,enable?1:0);
+ }
+
+ bool get_enabled(){
+ return (btGetMaskBit32(m_flags,_ENABLE,_ENABLE)?true:false);
+ }
+
+ void set_self_start(bool enable){
+ btSetMaskBit32(m_flags,_SELF_START,_SELF_START,enable?1:0);
+ }
+
+ bool get_self_start(bool enable){
+ return (btGetMaskBit32(m_flags,_SELF_START,_SELF_START)?true:false);
+ }
+
+
+ /* if we don't have VM we could just replicate the mbuf and allocate it once */
+ void set_vm_enable(bool enable){
+ btSetMaskBit32(m_flags,_VM_ENABLE,_VM_ENABLE,enable?1:0);
+ }
+
+ bool get_vm_enabled(bool enable){
+ return (btGetMaskBit32(m_flags,_VM_ENABLE,_VM_ENABLE)?true:false);
+ }
+
+ void set_inter_stream_gap(double isg_sec){
+ m_isg_sec =isg_sec;
+ }
+
+ double get_inter_stream_gap(){
+ return (m_isg_sec);
+ }
+
+ CTRexDpStreamMode & get_mode();
+
+
+ // CTRexDpStatelessStream::_END_STREAM for END
+ void set_next_stream(int32_t next_stream){
+ m_next_stream =next_stream;
+ }
+
+ int32_t get_next_stream(void){
+ return ( m_next_stream );
+ }
+
+ void dump(FILE *fd);
+
+private:
+ char * m_packet;
+ CTRexDpStatelessVM * m_vm;
+ uint32_t m_flags;
+ double m_isg_sec; // in second
+ CTRexDpStreamMode m_mode;
+ int32_t m_next_stream; // next stream id
+};
+
+//- list of streams info with const packet , no VM
+// - object that include the stream /scheduler/ packet allocation / need to create an object for one thread that works for test
+// generate pcap file and compare it
+
+
+void CTRexDpStatelessStream::dump(FILE *fd){
+
+ fprintf(fd," enabled : %d \n",get_enabled()?1:0);
+ fprintf(fd," self_start : %d \n",get_self_start()?1:0);
+ fprintf(fd," vm : %d \n",get_vm_enabled()?1:0);
+ fprintf(" isg : %f \n",m_isg_sec);
+ m_mode.dump(fd);
+ if (m_next_stream == CTRexDpStatelessStream::_END_STREAM ) {
+ fprintf(fd," action : End of Stream \n");
+ }else{
+ fprintf(" next : %d \n",m_next_stream);
+ }
+}
+
+
+
+class CTRexStatelessBasic {
+
+public:
+ CTRexStatelessBasic(){
+ m_threads=1;
+ }
+
+ bool init(void){
+ return (true);
+ }
+
+public:
+ bool m_threads;
+};
+
+
+/* stateless basic */
+class dp_sl_basic : public testing::Test {
+ protected:
+ virtual void SetUp() {
+ }
+ virtual void TearDown() {
+ }
+public:
+};
+
+
+TEST_F(dp_sl_basic, test1) {
+ CTRexDpStatelessStream s1;
+ s1.set_enable(true);
+ s1.set_self_start(true);
+ s1.set_inter_stream_gap(0.77);
+ s1.get_mode().set_mode(CTRexDpStreamMode::moCONTINUES);
+ s1.get_mode().cont().set_pps(100.2);
+ s1.dump(stdout);
+}
+
+
+
+
+
Code Review / trex.git / commitdiff