Initial commit of code written so far

Author: venkatarun95

VERSION-INFO

@@ -0,0 +1,17 @@
+Implements remy, kernel cc (cubic on linux), UDT's TCP aimd implementation and PCC (slightly doubtful and buggy) on a poisson on-off traffic model (currently configures for 5s mean).
+
+For remy and aimd congestion control, it is not a reliable transport. Kernel's and UDT's tcp implementations are naturally reliable. This could cause bias in readings.
+
+It sends it on a real network. It prints command line usage except for cctype, which is assumed to be 'remy' by default (other options are 'kernel', 'tcp' and 'pcc').
+
+Further, the signal type (with loss signal-without slow_rewma, without slow-rewma and aith slow_rewma-without loss signal) are controlled by which memory-xx.hh/memory-xx.cc are included (xx can be 'default,' 'with-loss-signal' and 'without-slow-rewma') are included and also by the appropriate protobufs-xx folder. This are controlled in the options in compile.sh. According to that appropriate binaries (remy, rat-runner, scoring-example) are generated. Binaries generated with these three configurations are already present.
+
+Receivers:
+ - The receivers for various types of congestion control algorithms are as follows
+   - 'remy', 'tcp' - receiver (simply echoes back the first few bytes (ie. the header) if the received UDP packet)
+   - 'kernel' - 'iperf -s' (which is required on both ends, for measuring RTT, use 'tcpdump' followed by 'tcptrace -lr'
+   - 'pcc' - pcc-receiver
+
+Can be run either on a real network or on mahi-mahi. When running on mahi-mahi, note that the receiver's address is the address of the interface on the outside part of the os (do an ifconfig on a fresh terminal). Everything except the kernel version (which uses iperf) runs over UDP, last time I could not send udp between two GENI nodes, although it should be possible to do so.
+
+PS: sockperf can also be used, just uncomment the apropriate line and comment the iperf line in kernelTCP.hh

ccc.hh

@@ -0,0 +1,39 @@
+#ifndef CCC_HH
+#define CCC_HH
+
+#include<iostream>
+
+class CCC
+{
+public:
+  CCC() : 
+  _intersend_time( 0 ),
+  _the_window( 2 ),
+  _timeout( 0.002 ) {}
+
+  virtual ~CCC() {}
+public:
+  virtual void init() {}
+  virtual void close() {}
+  virtual void onACK( int ack __attribute((unused)) ) {std::cout<<"Hello!";}
+  //virtual void onLoss(const int* losslist, const int& size) {}   virtual void onTimeout() {}
+  virtual void onPktSent( int seq_num __attribute((unused)) ) { }
+  virtual void onTimeout() {}
+  //virtual void onPktReceived(const CPacket* pkt) {}
+  //virtual void processCustomMsg(const CPacket& pkt) {}
+
+  double get_the_window(){ return _the_window; }
+  double get_intersend_time(){ return _intersend_time; }
+  double get_timeout(){ return _timeout; }
+
+protected:
+  void setRTO(const int& usRTO){ _timeout = usRTO/1000.0;}
+
+  double _intersend_time;
+  double _the_window;
+
+private:
+  double _timeout;
+}; 
+
+#endif

compile.sh

@@ -0,0 +1,41 @@
+clear
+clear
+echo Compiling...
+
+OPTIONS="-I./protobufs-default -DREMYTYPE_DEFAULT -I./udt"
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT random.o -MD -MP -c -o random.o random.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT memory.o -MD -MP -c -o memory.o memory.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT memoryrange.o -MD -MP -c -o memoryrange.o memoryrange.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT rat.o -MD -MP -c -o rat.o rat.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT whisker.o -MD -MP -c -o whisker.o whisker.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT whiskertree.o -MD -MP -c -o whiskertree.o whiskertree.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT udp-socket.o -MD -MP -c -o udp-socket.o udp-socket.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT traffic-generator.o -MD -MP -c -o traffic-generator.o traffic-generator.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT ctcp.o -MD -MP -c -o ctcp.o ctcp.cc
+
+#g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT remycc.o -MD -MP -c -o remycc.o remycc.cc
+
+g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread                                  -Werror -fno-default-inline -pg -O2 -MT pcc-tcp.o -MD -MP -c -o pcc-tcp.o pcc-tcp.cc
+
+g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT sender.o -MD -MP -c -o sender.o sender.cc
+
+g++ -DHAVE_CONFIG_H -I. $OPTIONS -std=c++11 -pthread -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2 -MT receiver.o -MD -MP -c -o receiver.o receiver.cc
+
+
+
+echo Linking sender...
+g++ -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2   -o sender udp-socket.o ctcp.o pcc-tcp.o traffic-generator.o memoryrange.o memory.o rat.o whisker.o whiskertree.o random.o remycc.o sender.o ./protobufs-default/libremyprotos.a -ljemalloc -lm -pthread -lprotobuf -lpthread -ljemalloc -ludt #-static-libstdc++
+#g++ -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2   -o sender random.o udp-socket.o ctcp.o traffic-generator.o remycc.o sender.o ./protobufs/libremyprotos.a -ljemalloc -lm -pthread -lprotobuf -lpthread   -ljemalloc
+
+echo Linking receiver...
+#g++ -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2   -o receiver udp-socket.o ctcp.o memory.o memoryrange.o rat.o whisker.o whiskertree.o random.o receiver.o ./protobufs/libremyprotos.a -ljemalloc -lm -pthread -lprotobuf -lpthread   -ljemalloc
+g++ -pedantic -Wall -Wextra -Weffc++ -Werror -fno-default-inline -pg -O2   -o receiver random.o udp-socket.o ctcp.o receiver.o -ljemalloc -lm -pthread -lprotobuf -lpthread   -ljemalloc

configs.hh

@@ -0,0 +1 @@
+#define SCALE_SEND_RECEIVE_EWMA

congctrls.hh

@@ -0,0 +1,109 @@
+#include "ccc.hh"
+
+class DefaultCC: public CCC
+{
+public:
+   DefaultCC() : 
+      m_issthresh( 83333 ),
+      m_bSlowStart( true ),
+      m_iDupACKCount( 0 ),
+      m_iLastACK( 0 )
+      {}
+
+   void init()
+   {
+      m_issthresh = true;
+      m_bSlowStart = 83333;
+
+      _intersend_time = 0.0;
+      _the_window = 2.0;
+
+      //setACKInterval(2);
+      setRTO(1000000);
+   }
+
+   virtual void onACK(const int& ack)
+   {
+      if (ack == m_iLastACK)
+      {
+         if (3 == ++ m_iDupACKCount)
+            DupACKAction();
+         else if (m_iDupACKCount > 3)
+            _the_window += 1.0;
+         else
+            ACKAction();
+      }
+      else
+      {
+         if (m_iDupACKCount >= 3)
+            _the_window = m_issthresh;
+
+         m_iLastACK = ack;
+         m_iDupACKCount = 1;
+
+         ACKAction();
+      }
+   }
+
+   virtual void onTimeout()
+   {
+      //m_issthresh = getPerfInfo()->pktFlightSize / 2;
+      m_issthresh = _the_window / 2;
+      if (m_issthresh < 2)
+         m_issthresh = 2;
+
+      m_bSlowStart = true;
+      _the_window = 2.0;
+   }
+
+protected:
+   virtual void ACKAction()
+   {
+      if (m_bSlowStart)
+      {
+         _the_window += 1.0;
+
+         if (_the_window >= m_issthresh)
+            m_bSlowStart = false;
+      }
+      else
+         _the_window += 1.0/_the_window;
+   }
+
+   virtual void DupACKAction()
+   {
+      m_bSlowStart = false;
+
+      //m_issthresh = getPerfInfo()->pktFlightSize / 2;
+      m_issthresh = _the_window / 2;
+      if (m_issthresh < 2)
+         m_issthresh = 2;
+
+      _the_window = m_issthresh + 3;
+   }
+
+protected:
+   int m_issthresh;
+   bool m_bSlowStart;
+
+   int m_iDupACKCount;
+   int m_iLastACK;
+};
+
+
+class CUDPBlast: public CCC
+{
+public:
+   CUDPBlast()
+   {
+      _intersend_time = 1000000;
+      _the_window = 83333.0;
+   }
+
+public:
+   void setRate(double mbps)
+   {
+      //_intersend_time = (m_iMSS * 8.0) / mbps;
+      _intersend_time = (1500 * 8.0) / mbps;
+   }
+};

ctcp.cc

@@ -0,0 +1,118 @@
+/*#include <string.h>
+#include <stdio.h>
+
+#include "ctcp.hh"
+
+using namespace std;
+
+double current_timestamp( chrono::high_resolution_clock::time_point &start_time_point ){
+	using namespace chrono;
+	high_resolution_clock::time_point cur_time_point = high_resolution_clock::now();
+	return duration_cast<duration<double>>(cur_time_point - start_time_point).count()*1000; //convert to milliseconds, because that is the scale on which the rats have been trained
+}
+
+template<class T>
+void CTCP<T>::send_data ( double duration, int flow_id, int src_id ){
+	TCPHeader header, ack_header;
+
+	char buf[packet_size];
+	memset(buf, '-', sizeof(char)*packet_size);
+	buf[packet_size-1] = '\0';
+
+	chrono::high_resolution_clock::time_point start_time_point = chrono::high_resolution_clock::now();
+	_last_send_time = 0.0;
+	double cur_time = 0;
+	int transmitted_bytes = 0;
+
+	int seq_num = 0;
+	_last_send_time = 0.0;
+	_largest_ack = -1;
+	_packets_sent = 0;
+
+	double delay_sum = 0;
+	int num_packets_transmitted = 0;
+
+	congctrl.init();
+
+	while ( cur_time < duration ){
+		cur_time = current_timestamp( start_time_point );
+		assert( _packets_sent >= _largest_ack + 1 );
+		while( ( (_packets_sent < _largest_ack + 1 + congctrl.get_the_window()) 
+			and (_last_send_time + congctrl.get_intersend_time() <= cur_time) ) 
+			and cur_time < duration ){
+			
+			header.seq_num = seq_num;
+			header.flow_id = flow_id;
+			header.src_id = src_id;
+			header.sender_timestamp = cur_time;
+
+			memcpy(buf, &header, sizeof(TCPHeader));
+			congctrl.onPktSent( seq_num );
+			socket.senddata( buf, packet_size, NULL );
+
+			cur_time = current_timestamp( start_time_point );
+			_packets_sent++;
+			_last_send_time = cur_time;
+			seq_num += 1;
+
+			cout<<"sent"<<congctrl.get_the_window()<<" ";
+		}
+
+		cur_time = current_timestamp( start_time_point );
+		double timeout = _last_send_time + congctrl.get_timeout(); // everything in milliseconds
+		if( congctrl.get_the_window() > 0 )
+			timeout = min( timeout, _last_send_time + congctrl.get_intersend_time() - cur_time );
+
+		sockaddr_in other_addr;
+		if( socket.receivedata( buf, packet_size, timeout, other_addr ) == 0 ) {
+			cur_time = current_timestamp( start_time_point );
+			if( cur_time > _last_send_time + congctrl.get_timeout() )
+				congctrl.onTimeout();
+			continue;
+		}
+
+		memcpy(&ack_header, buf, sizeof(TCPHeader));
+		ack_header.seq_num ++; //because the receiver doesn't do that for us yet
+
+		if ( ack_header.src_id != src_id || ack_header.flow_id != flow_id ){
+			if( ack_header.src_id != src_id ){
+				std::cerr<<"Received incorrect ack for src "<<ack_header.src_id<<" to "<<src_id<<endl;
+			}
+			continue;
+		}
+		
+		_largest_ack = max(_largest_ack, ack_header.seq_num);
+		congctrl.onACK(seq_num);
+		cout<<"acked";
+
+		// Track statistics
+		cur_time = current_timestamp( start_time_point );
+		delay_sum += cur_time - ack_header.sender_timestamp;
+		this->tot_delay += cur_time - ack_header.sender_timestamp;
+
+		transmitted_bytes += data_size;
+		this->tot_bytes_transmitted += data_size;
+
+		num_packets_transmitted += 1;
+		this->tot_packets_transmitted += 1;
+	}
+
+	congctrl.close();
+
+	cur_time = current_timestamp( start_time_point );
+	this->tot_time_transmitted += cur_time;
+
+	double throughput = transmitted_bytes/( cur_time / 1000.0 );
+	double delay = (delay_sum / 1000) / num_packets_transmitted;
+
+	std::cout<<"\n\nData Successfully Transmitted\n\tThroughput: "<<throughput<<" bytes/sec\n\tAverage Delay: "<<delay<<" sec/packet\n";
+
+	double avg_throughput = tot_bytes_transmitted / ( tot_time_transmitted / 1000.0);
+	double avg_delay = (tot_delay / 1000) / tot_packets_transmitted;
+	std::cout<<"\n\tAvg. Throughput: "<<avg_throughput<<" bytes/sec\n\tAverage Delay: "<<avg_delay<<" sec/packet\n";
+}
+
+template<class T>
+void CTCP<T>::listen_for_data ( ){
+
+}*/