├── runscript
├── sender
    ├── cellsim-runner.sh
    ├── simulation-analysis
    │   ├── rate-estimate.py
    │   ├── extract-useful.py
    │   ├── gen-rate.py
    │   ├── plot.sh
    │   ├── compare-all-3.sh
    │   ├── plot.p
    │   ├── gen-schedule.py
    │   ├── calc-stats.py
    │   └── cmp.p
    ├── hist.hh
    ├── fairness-analysis
    │   ├── plot.p
    │   ├── process-traces.py
    │   └── pcap.sh
    ├── macaddr.hh
    ├── packetsocket.hh
    ├── cellsim-setup.sh
    ├── history.hh
    ├── payload.hh
    ├── rate-estimate.hh
    ├── hist.cc
    ├── tapsocket.hh
    ├── history.cc
    ├── trace-analysis
    │   ├── process-traces.sh
    │   └── prep-for-simulation.py
    ├── rate-estimate.cc
    ├── payload.cc
    ├── acker.hh
    ├── delay-servo.hh
    ├── Makefile
    ├── saturateservo.hh
    ├── macaddr.cc
    ├── socket.hh
    ├── select.cc
    ├── timestamp.h
    ├── fatal_assert.h
    ├── tapsocket.cc
    ├── acker.cc
    ├── controlled-delay.cc
    ├── packetsocket.cc
    ├── saturatr.cc
    ├── buffer-setpoint.cc
    ├── delay-servo.cc
    ├── socket.cc
    ├── saturateservo.cc
    ├── select.h
    ├── send1way.cc
    ├── cellsim-tap.cc
    └── cellsim.cc
├── runon
├── infer
    ├── mypoisson.hh
    ├── cellqueue.hh
    ├── cellqueue.cc
    ├── simpleevolve.cc
    ├── Makefile
    ├── receiver.hh
    ├── processforecaster.hh
    ├── receiver.cc
    ├── process.hh
    ├── infer.cc
    ├── sampledfunction.cc
    ├── sampledfunction.hh
    ├── vbrssp.cc
    ├── process.cc
    └── processforecaster.cc
└── donat


/runscript:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl -w
 2 | 
 3 | use strict;
 4 | 
 5 | my ( $device, $script ) = @ARGV;
 6 | 
 7 | open SCRIPT, $script or die;
 8 | 
 9 | while ( <SCRIPT> ) {
10 |   chomp;
11 |   system( './runon', $device, 'shell', $_ );
12 | }
13 | 


--------------------------------------------------------------------------------
/sender/cellsim-runner.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | nohup /home/ubuntu/multisend/sender/cellsim /home/ubuntu/verizon_lte_uplink_slice.ms /home/ubuntu/verizon_lte_downlink_slice.ms 00:00:00:00:00:02 0 LTE-eth0 LTE-eth1 >/tmp/cellsim-stdout 2>/tmp/cellsim-stderr &
4 | 


--------------------------------------------------------------------------------
/runon:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl -w
 2 | 
 3 | use strict;
 4 | 
 5 | my $ADB = 'adb';
 6 | 
 7 | my %devices = ( A => '0149A97C0F012017',
 8 | 		B => '014696C50601901F' );
 9 | 
10 | my ( $device, @command ) = @ARGV;
11 | 
12 | die unless exists $devices{ $device };
13 | 
14 | exec { $ADB } ( 'adb', '-s', $devices{ $device }, @command );
15 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/rate-estimate.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | fh=open(sys.argv[1])
 3 | acc=[0]*3700 # 1 hour of data
 4 | for line in fh.readlines() :
 5 |   time=int(float(line.split()[0]));
 6 |   acc[(time/1000)]=acc[(time/1000)]+8*1500; # ms to sec
 7 | 
 8 | for i in range(0,len(acc)) :
 9 |     print i,"\t",(acc[i]/1.0e6); # in mbps
10 | 


--------------------------------------------------------------------------------
/sender/hist.hh:
--------------------------------------------------------------------------------
 1 | #ifndef HIST_HH
 2 | #define HIST_HH
 3 | 
 4 | #include <vector>
 5 | 
 6 | class Histogram
 7 | {
 8 | private:
 9 |   std::vector<int> storage;
10 |   const int bin_width;
11 | 
12 | public:
13 |   Histogram( const int s_bin_width );
14 |   void record( const int sample );
15 |   void print( void ) const;
16 | };
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/infer/mypoisson.hh:
--------------------------------------------------------------------------------
 1 | #ifndef MYPOISSON_HH
 2 | #define MYPOISSON_HH
 3 | 
 4 | #include <boost/math/distributions/poisson.hpp>
 5 | 
 6 | double poissonpdf( const double rate, int counts )
 7 | {
 8 |   if ( rate == 0 ) {
 9 |     return 0;
10 |   } else {
11 |     return boost::math::pdf( boost::math::poisson( rate ), counts );
12 |   }
13 | }
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/sender/fairness-analysis/plot.p:
--------------------------------------------------------------------------------
 1 | set term png size 1920,1080
 2 | set output "fairness.png"
 3 | set xlabel "Time in seconds"
 4 | set ylabel "Rate in mbps"
 5 | set multiplot layout 2,1 title "Fairness with 2 sprout bt flows"
 6 | set title "uplink"
 7 | plot "uplink.60001.rate", "uplink.60002.rate"
 8 | set title "downlink"
 9 | plot "downlink.60001.rate", "downlink.60002.rate"
10 | 


--------------------------------------------------------------------------------
/sender/macaddr.hh:
--------------------------------------------------------------------------------
 1 | #ifndef MAC_ADDR_HH
 2 | #define MAC_ADDR_HH
 3 | 
 4 | #include <string>
 5 | 
 6 | class MACAddress
 7 | {
 8 | private:
 9 |   uint8_t octets[ 6 ];
10 | 
11 |   bool is_broadcast( void ) const;
12 | 
13 | public:
14 |   MACAddress( const std::string & s_addr );
15 |   bool matches( const MACAddress & other ) const;
16 | 
17 |   static std::string parse_human( const std::string & with_colons );
18 |   std::string pp( void ) const;
19 | };
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/infer/cellqueue.hh:
--------------------------------------------------------------------------------
 1 | #ifndef CELLQUEUE_HH
 2 | #define CELLQUEUE_HH
 3 | 
 4 | #include <queue>
 5 | 
 6 | class CellQueue
 7 | {
 8 | private:
 9 |   std::queue< double > _packets;
10 | 
11 |   int _opportunities, _deliveries;
12 | 
13 | public:
14 |   CellQueue() : _packets(), _opportunities( 0 ), _deliveries( 0 ) {}
15 | 
16 |   void send( const double time );
17 |   bool recv( const double time );
18 |   unsigned int size( void ) const { return _packets.size(); }
19 | };
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/sender/packetsocket.hh:
--------------------------------------------------------------------------------
 1 | #ifndef PACKETSOCKET_HH
 2 | #define PACKETSOCKET_HH
 3 | 
 4 | #include <string>
 5 | #include <vector>
 6 | #include "macaddr.hh"
 7 | 
 8 | class PacketSocket
 9 | {
10 | private:
11 |   int sock;
12 | 
13 |   int get_index( const std::string & name ) const;
14 | 
15 | public:
16 |   PacketSocket( const std::string & s_interface );
17 | 
18 |   std::vector< std::string > recv_raw( void );
19 |   void send_raw( const std::string & input );
20 |   int fd( void ) const { return sock; }
21 | };
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/sender/cellsim-setup.sh:
--------------------------------------------------------------------------------
 1 | #! /bin/bash
 2 | # cellsim setup
 3 | 
 4 | if [ $# -lt 2 ]; then
 5 |    echo "Usage : ./cellsim-setup.sh ingress egress"
 6 |    exit
 7 | fi ;
 8 | 
 9 | ingress=$1
10 | egress=$2
11 | 
12 | # put both interfaces in promisc mode.
13 | set -v
14 | set -x
15 | sudo ifconfig $ingress up promisc
16 | sudo ifconfig $egress up promisc
17 | 
18 | 
19 | # Disable segmentation offloading to NIC.
20 | 
21 | sudo ethtool --offload  $ingress gso off  tso off gro off
22 | sudo ethtool --offload  $egress gso off  tso off gro off
23 | 
24 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/extract-useful.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | fh=open(sys.argv[1]);
 3 | start=int(sys.argv[2]);
 4 | end=int(sys.argv[3]);
 5 | repeats=int(sys.argv[4]);
 6 | useful=[]
 7 | 
 8 | # 3G : 1000 secs to 1200 secs
 9 | # 4G : 200 to 415 seconds
10 | start=start*1000
11 | end=end*1000
12 | for line in  fh.readlines() :
13 |     ts= int(line)
14 |     if((ts>=start) and (ts<=end)) :
15 |         useful.append(ts-start)
16 | 
17 | for i in range(0,repeats) :
18 |     for j in range(0,len(useful)):
19 |        print useful[j]+i*(end-start)
20 | 
21 | 


--------------------------------------------------------------------------------
/sender/fairness-analysis/process-traces.py:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/python
 2 | import sys
 3 | fh=open(sys.argv[1],"r");
 4 | start_time=-1
 5 | rate_estimate=[0]*1000
 6 | for line in fh.readlines() :
 7 |   current_time=float(line.split()[0]);
 8 |   bytes_rx=int(line.split()[12].strip(":"));
 9 |   if ( start_time == -1 ) :
10 |     start_time = current_time
11 |   assert((current_time-start_time) <= 1000);
12 |   rate_estimate[int(round(current_time-start_time))] += bytes_rx*8
13 | 
14 | for i in range(0,len(rate_estimate)):
15 |   print i,"\t",rate_estimate[i];
16 | 
17 | 


--------------------------------------------------------------------------------
/infer/cellqueue.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | #include "cellqueue.hh"
 4 | 
 5 | void CellQueue::send( const double time )
 6 | {
 7 |   _packets.push( time );
 8 | }
 9 | 
10 | bool CellQueue::recv( const double time )
11 | {
12 |   _opportunities++;
13 | 
14 |   if ( _packets.empty() ) {
15 |     fprintf( stderr, "Underflow at time %f\n", time );
16 |     return false;
17 |   } else {
18 |     const double send_time = _packets.front();
19 |     _packets.pop();
20 |     _deliveries++;
21 |     fprintf( stderr, "%f : packet delivered after delay of %f\n",
22 | 	     time, time - send_time );
23 |     return true;
24 |   }
25 | }
26 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/gen-rate.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | numarg=len(sys.argv)
 3 | # even number because we want rate and duration pairs +1, for the argv[0]
 4 | assert ((numarg%2==1) and (numarg >=3)); 
 5 | i=1
 6 | rate=[]
 7 | time=[]
 8 | while (i<numarg) :
 9 |    rate.append(int(sys.argv[i]));
10 |    i=i+1;
11 |    time.append(int(sys.argv[i]));
12 |    i=i+1;
13 | assert(len(rate)==len(time));
14 | 
15 | t=0;
16 | ###for i in range (0,len(rate)) :
17 | ### for j in range(0,time[i]*1000) :  # 1 hour in milliseconds 
18 | ###   t=t+1
19 | ###   print t,"\t",(rate[i]/(8.0*1000))  # because we want the credit in bytes and not bits 
20 | ### 
21 | 


--------------------------------------------------------------------------------
/sender/history.hh:
--------------------------------------------------------------------------------
 1 | #ifndef HISTORY_HH
 2 | #define HISTORY_HH
 3 | 
 4 | #include "payload.hh"
 5 | 
 6 | #include <list>
 7 | 
 8 | class History
 9 | {
10 | private:
11 |   static const uint64_t reorder_window = 20 * 1000 * 1000; /* 20 ms */
12 | 
13 |   std::list< Payload > _outstanding;
14 |   unsigned int _num_outstanding;
15 |   unsigned int _num_lost;
16 | 
17 | public:
18 |   History();
19 |   void packet_sent( const Payload & p );
20 |   void packet_received( const Payload & p );
21 |   unsigned int num_outstanding( void ) const { return _num_outstanding; }
22 |   unsigned int num_lost( void ) const { return _num_lost; }
23 | };
24 | 
25 | #endif
26 | 


--------------------------------------------------------------------------------
/sender/payload.hh:
--------------------------------------------------------------------------------
 1 | #ifndef PAYLOAD_HH
 2 | #define PAYLOAD_HH
 3 | 
 4 | #include <string>
 5 | 
 6 | class Payload
 7 | {
 8 | public:
 9 |   uint32_t sequence_number;
10 |   uint64_t sent_timestamp, recv_timestamp;
11 |   int sender_id;
12 | 
13 |   const std::string str( const size_t len ) const;
14 |   bool operator==( const Payload & other ) const;
15 | };
16 | 
17 | class SatPayload
18 | {
19 | public:
20 |   int32_t sequence_number, ack_number;
21 |   uint64_t sent_timestamp, recv_timestamp;
22 |   int sender_id;
23 | 
24 |   const std::string str( const size_t len ) const;
25 |   bool operator==( const SatPayload & other ) const;
26 | };
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/plot.sh:
--------------------------------------------------------------------------------
 1 | #! /bin/bash
 2 | if [ $# -lt 1 ]; then
 3 |   echo "Usage : enter file name "
 4 |   exit;
 5 | fi
 6 | file=$1
 7 | export expt=`echo $file | cut -d '/' -f 3`
 8 | echo "Expt name is $expt"
 9 | rm *.cap *.delay
10 | grep downlink $file | grep "/" > downlink.cap
11 | grep uplink $file | grep "/" > uplink.cap
12 | grep downlink $file | grep "delivery" > downlink.delay
13 | grep uplink $file | grep "delivery" > uplink.delay
14 | export t_offset=0
15 | echo "Time offset is $t_offset"
16 | gnuplot -p plot.p
17 | mkdir $expt
18 | mv uplink-plot.png $expt/uplink-$expt.png
19 | mv downlink-plot.png $expt/downlink-$expt.png
20 | mv *.cap *.delay $expt
21 | cp $file $expt
22 | 


--------------------------------------------------------------------------------
/sender/rate-estimate.hh:
--------------------------------------------------------------------------------
 1 | #ifndef RATE_ESTIMATE_HH
 2 | #define RATE_ESTIMATE_HH
 3 | 
 4 | #include <queue>
 5 | 
 6 | #include "socket.hh"
 7 | #include "payload.hh"
 8 | 
 9 | class RateEstimate
10 | {
11 | private:
12 |   const double empty_rate_estimate; /* packets per second */
13 |   const unsigned int averaging_extent_ms;
14 |   std::queue< Payload > history;
15 | 
16 |   void housekeeping( void ); /* cull packets older than averaging_extent_ms */
17 | 
18 | public:
19 |   RateEstimate( const double s_empty_rate_estimate, const unsigned int s_averaging_extent_ms );
20 |   void add_packet( const Payload & p );
21 |   double get_rate( void ); /* rate in packets per second */
22 | };
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/infer/simpleevolve.cc:
--------------------------------------------------------------------------------
 1 | #include "process.hh"
 2 | #include "sampledfunction.hh"
 3 | 
 4 | #include <vector>
 5 | #include <stdio.h>
 6 | 
 7 | void print( const SampledFunction & in )
 8 | {
 9 |   in.for_each( [] ( const double midpoint, const double & value, const int index ) {
10 |       printf( "%f %f\n", midpoint, value );
11 |     } );
12 | 
13 |   printf( "\n\n" );
14 | }
15 | 
16 | int main( void )
17 | {
18 |   Process myprocess( 2000, .1, 1, 100 );
19 | 
20 |   myprocess.normalize();
21 |   myprocess.observe( 0.01, 5 );
22 |   myprocess.normalize();
23 |   print( myprocess.pmf() );
24 | 
25 |   for ( int amt = 0; amt < 1000; amt++ ) {
26 |     myprocess.evolve( 0.01 );
27 |     myprocess.normalize();
28 |     print( myprocess.pmf() );
29 |   }
30 | }
31 | 


--------------------------------------------------------------------------------
/sender/hist.cc:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | #include <algorithm>
 3 | #include <stdio.h>
 4 | 
 5 | #include "hist.hh"
 6 | 
 7 | Histogram::Histogram( const int s_bin_width )
 8 |   : storage(),
 9 |     bin_width( s_bin_width )
10 | {
11 | }
12 | 
13 | void Histogram::record( const int sample )
14 | {
15 |   /* use offset bins centered on bin_width * k */
16 |   int sample_transformed = (sample + (bin_width / 2)) / bin_width;
17 |   assert( sample_transformed >= 0 );
18 |   if ( (int)storage.size() <= sample_transformed ) {
19 |     storage.resize( sample_transformed + 1 );
20 |   }
21 |   storage.at( sample_transformed )++;
22 | }
23 | 
24 | void Histogram::print( void ) const
25 | {
26 |   for ( size_t i = 0; i < storage.size(); i++ ) {
27 |     printf( "%d %d\n", (int) i * bin_width, storage[ i ] );
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/compare-all-3.sh:
--------------------------------------------------------------------------------
 1 | #! /bin/bash
 2 | if [ $# -lt 3 ] ; then
 3 |     echo "Enter folders one each for skype sprout and cubic"
 4 |     exit
 5 | fi
 6 | skype=$1
 7 | sprout=$2
 8 | cubic=$3
 9 | set -v
10 | python calc-stats.py $skype/uplink.cap util
11 | python calc-stats.py $skype/uplink.delay delay
12 | python calc-stats.py $sprout/uplink.cap util
13 | python calc-stats.py $sprout/uplink.delay delay
14 | python calc-stats.py $cubic/uplink.cap util
15 | python calc-stats.py $cubic/uplink.delay delay
16 | 
17 | python calc-stats.py $skype/downlink.cap util
18 | python calc-stats.py $skype/downlink.delay delay
19 | python calc-stats.py $sprout/downlink.cap util
20 | python calc-stats.py $sprout/downlink.delay delay
21 | python calc-stats.py $cubic/downlink.cap util
22 | python calc-stats.py $cubic/downlink.delay delay
23 | 


--------------------------------------------------------------------------------
/infer/Makefile:
--------------------------------------------------------------------------------
 1 | source = infer.cc process.cc sampledfunction.cc processforecaster.cc vbrssp.cc cellqueue.cc receiver.cc
 2 | objects = process.o sampledfunction.o processforecaster.o cellqueue.o receiver.o
 3 | executables = infer vbrssp
 4 | 
 5 | CXX = g++
 6 | CXXFLAGS = -g -O3 -std=c++0x -ffast-math -pedantic -Werror -Wall -Wextra -Weffc++ -fno-default-inline -pipe -Wno-unused-parameter -D_FILE_OFFSET_BITS=64 -D_XOPEN_SOURCE=500 -D_GNU_SOURCE
 7 | LIBS = -lm -lrt
 8 | 
 9 | all: $(executables)
10 | 
11 | infer: infer.o $(objects)
12 | 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
13 | 
14 | vbrssp: vbrssp.o $(objects)
15 | 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
16 | 
17 | %.o: %.cc
18 | 	$(CXX) $(CXXFLAGS) -c -o $@ $<
19 | 
20 | -include depend
21 | 
22 | depend: $(source)
23 | 	$(CXX) $(INCLUDES) -MM $(source) > depend
24 | 
25 | .PHONY: clean
26 | clean:
27 | 	-rm -f $(executables) depend *.o *.rpo
28 | 


--------------------------------------------------------------------------------
/sender/tapsocket.hh:
--------------------------------------------------------------------------------
 1 | #ifndef TAP_DEVICE_HH
 2 | #define TAP_DEVICE_HH
 3 | 
 4 | #include<string.h>
 5 | #include<stdio.h>
 6 | #include<net/if.h>
 7 | #include<unistd.h>
 8 | #include<fcntl.h>
 9 | #include<linux/if_tun.h>
10 | #include<errno.h>
11 | #include<stdlib.h>
12 | #include<sys/ioctl.h>
13 | #include <string>
14 | #include <vector>
15 | #include "macaddr.hh"
16 | 
17 | class TapSocket
18 | {
19 | private:
20 |   int sock;
21 | 
22 |   const MACAddress _from_filter;
23 |   const MACAddress _to_filter;
24 | 
25 | public:
26 |   TapSocket( const std::string & s_interface,
27 | 		const std::string & s_from_filter,
28 | 		const std::string & s_to_filter );
29 | 
30 |   std::vector< std::string > recv_raw( void );
31 |   void send_raw( const std::string & input );
32 |   int fd( void ) const { return sock; }
33 |   int tun_alloc( const char *dev, int flags) const;
34 |   int setup_tap( const char* tap_name ) const;
35 | 
36 | };
37 | 
38 | #endif
39 | 


--------------------------------------------------------------------------------
/sender/fairness-analysis/pcap.sh:
--------------------------------------------------------------------------------
 1 | #! /bin/bash
 2 | # stuff going towards the server on the egress after going through the sim
 3 | tcpdump -r sprout-vs-sprout-eth0.pcap -tt -l -e  dst host 128.30.77.65 and dst port 60001 and udp > uplink.60001
 4 | tcpdump -r sprout-vs-sprout-eth0.pcap -tt -l -e  dst host 128.30.77.65 and dst port 60002 and udp > uplink.60002
 5 | # stuff going towards the client on the ingress after going through the sim
 6 | tcpdump -r sprout-vs-sprout-eth1.pcap -tt -l -e  src host 128.30.77.65 and src port 60001 and udp > downlink.60001
 7 | tcpdump -r sprout-vs-sprout-eth1.pcap -tt -l -e  src host 128.30.77.65 and src port 60002 and udp > downlink.60002
 8 | 
 9 | python process-traces.py uplink.60001 > uplink.60001.rate
10 | python process-traces.py uplink.60002 > uplink.60002.rate
11 | python process-traces.py downlink.60001 > downlink.60001.rate
12 | python process-traces.py downlink.60002 > downlink.60002.rate
13 | 
14 | gnuplot -p plot.p
15 | 


--------------------------------------------------------------------------------
/sender/history.cc:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | 
 3 | #include "history.hh"
 4 | 
 5 | History::History()
 6 |   : _outstanding(),
 7 |     _num_outstanding( 0 ),
 8 |     _num_lost( 0 )
 9 | {
10 | }
11 | 
12 | void History::packet_sent( const Payload & p )
13 | {
14 |   _outstanding.push_back( p );
15 |   _num_outstanding++;
16 | }
17 | 
18 | void History::packet_received( const Payload & p )
19 | {
20 |   _outstanding.remove_if( [&] ( const Payload & x ) { return x.sequence_number == p.sequence_number; } );
21 | 
22 |   unsigned int new_size = _outstanding.size();
23 |   assert( _num_outstanding - new_size == 1 );
24 |   _num_outstanding = new_size;
25 | 
26 |   const uint64_t purge_older = p.sent_timestamp - reorder_window;
27 | 
28 |   _outstanding.remove_if( [&] ( const Payload & x ) { return x.sent_timestamp < purge_older; } );
29 | 
30 |   new_size = _outstanding.size();
31 |   _num_lost += _num_outstanding - new_size;
32 | 
33 |   _num_outstanding = new_size;
34 | }
35 | 


--------------------------------------------------------------------------------
/sender/trace-analysis/process-traces.sh:
--------------------------------------------------------------------------------
 1 | #! /bin/bash
 2 | # determine the number of sessions to extract the trace for .
 3 | ls --format=single-column client-*-* | cut -f 2,3 -d "-" > sessions.list
 4 | server_logs=`ls --format=single-column server-*`
 5 | echo "Server logs are "$server_logs
 6 | server_time=`echo $server_logs | cut -f 2 -d "-"`
 7 | echo "Server time is "$server_time
 8 | for session in `cat sessions.list` ;
 9 | do 
10 |    session_name=`echo $session | cut -f 1 -d "-"`
11 |    session_id=`echo $session | cut -f 2 -d "-"`
12 |    echo "Session name is "$session_name;
13 |    echo "Session id is "$session_id;
14 | 
15 |    # get a tmp server file 
16 |    grep "senderid=$session_id" $server_logs > server-$session_name-$session_id
17 | 
18 |    # prepare the files for simulation
19 |    nice -n 19 python prep-for-simulation.py client-$session_name-$session_id $session_id ;
20 |    nice -n 19 python prep-for-simulation.py server-$session_name-$session_id $session_id ;
21 | 
22 |    # remove the tmp server file
23 |    rm server-$session_name-$session_id ;
24 |   
25 | done
26 | 


--------------------------------------------------------------------------------
/sender/rate-estimate.cc:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | 
 3 | #include "rate-estimate.hh"
 4 | 
 5 | RateEstimate::RateEstimate( const double s_empty_rate_estimate, const unsigned int s_averaging_extent_ms )
 6 |   : empty_rate_estimate( s_empty_rate_estimate),
 7 |     averaging_extent_ms( s_averaging_extent_ms ),
 8 |     history()
 9 | {
10 | }
11 | 
12 | void RateEstimate::add_packet( const Payload & p )
13 | {
14 |   history.push( p );
15 |   housekeeping();
16 | }
17 | 
18 | double RateEstimate::get_rate( void )
19 | {
20 |   housekeeping();
21 |   const int num_packets = history.size();
22 |   if ( num_packets <= 2 ) {
23 |     return empty_rate_estimate;
24 |   }
25 | 
26 |   return 1000.0 * (double) num_packets / (double) averaging_extent_ms;
27 | }
28 | 
29 | void RateEstimate::housekeeping( void )
30 | {
31 |   const uint64_t now = Socket::timestamp();
32 |   while ( !history.empty() ) {
33 |     Payload & front = history.front();
34 |     assert( now >= front.recv_timestamp );
35 |     if ( now - front.recv_timestamp > 1000000 * averaging_extent_ms ) {
36 |       history.pop();
37 |     } else {
38 |       return;
39 |     }
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/infer/receiver.hh:
--------------------------------------------------------------------------------
 1 | #include "process.hh"
 2 | #include "processforecaster.hh"
 3 | 
 4 | #ifndef RECEIVER_HH
 5 | #define RECEIVER_HH
 6 | 
 7 | class DeliveryForecast
 8 | {
 9 | public:
10 |   const double TICK_LENGTH;
11 |   const std::vector< int > counts;
12 | 
13 |   DeliveryForecast( const double s_TICK_LENGTH, const std::vector< int > s_counts )
14 |     : TICK_LENGTH( s_TICK_LENGTH ), counts( s_counts ) {}
15 | };
16 | 
17 | class Receiver
18 | {
19 | private:
20 |   static constexpr double MAX_ARRIVAL_RATE = 2000;
21 |   static constexpr double BROWNIAN_MOTION_RATE = 300;
22 |   static constexpr double OUTAGE_ESCAPE_RATE = 5;
23 |   static const int NUM_BINS = 64;
24 |   static constexpr double TICK_LENGTH = 0.02;
25 |   static const int MAX_ARRIVALS_PER_TICK = 30;
26 |   static const int NUM_TICKS = 10;
27 | 
28 |   Process _process;
29 | 
30 |   std::vector< ProcessForecastInterval > _forecastr;
31 | 
32 |   double _time;
33 | 
34 |   int _count_this_tick;
35 | 
36 | public:
37 | 
38 |   Receiver( const double s_time );
39 |   void advance_to( const double time );
40 |   void recv( void );
41 | 
42 |   DeliveryForecast forecast( void );
43 | };
44 | 
45 | #endif
46 | 


--------------------------------------------------------------------------------
/sender/payload.cc:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | 
 3 | #include "payload.hh"
 4 | 
 5 | const std::string Payload::str( const size_t len ) const
 6 | {
 7 |   assert( len >= sizeof( Payload ) );
 8 |   std::string padding( len - sizeof( Payload ), 0 );
 9 |   return std::string( (char*)this, sizeof( Payload ) ) + padding;
10 | }
11 | 
12 | bool Payload::operator==( const Payload & other ) const
13 | {
14 |   return (sequence_number == other.sequence_number
15 | 	  && sent_timestamp == other.sent_timestamp
16 | 	  && recv_timestamp == other.recv_timestamp
17 | 	  && sender_id == other.sender_id);
18 | }
19 | 
20 | const std::string SatPayload::str( const size_t len ) const
21 | {
22 |   assert( len >= sizeof( SatPayload ) );
23 |   std::string padding( len - sizeof( SatPayload ), 0 );
24 |   return std::string( (char*)this, sizeof( SatPayload ) ) + padding;
25 | }
26 | 
27 | bool SatPayload::operator==( const SatPayload & other ) const
28 | {
29 |   return (sequence_number == other.sequence_number
30 | 	  && ack_number == other.ack_number
31 | 	  && sent_timestamp == other.sent_timestamp
32 | 	  && recv_timestamp == other.recv_timestamp
33 | 	  && sender_id == other.sender_id);
34 | }
35 | 


--------------------------------------------------------------------------------
/sender/acker.hh:
--------------------------------------------------------------------------------
 1 | #ifndef ACKER_HH
 2 | #define ACKER_HH
 3 | #include <fstream>
 4 | #include "socket.hh"
 5 | 
 6 | class SaturateServo;
 7 | 
 8 | class Acker
 9 | {
10 | private:
11 |   const std::string _name;
12 |   FILE* _log_file;
13 | 
14 |   const Socket _listen;
15 |   const Socket _send;
16 |   Socket::Address _remote;
17 |   const bool _server;
18 |   const int _ack_id;
19 | 
20 |   SaturateServo *_saturatr;
21 | 
22 |   uint64_t _next_ping_time;
23 | 
24 |   static const int _ping_interval = 1000000000;
25 | 
26 |   int _foreign_id;
27 | 
28 | public:
29 |   Acker( const char * s_name,
30 |          FILE* log_file,
31 | 	 const Socket & s_listen,
32 | 	 const Socket & s_send,
33 | 	 const Socket::Address & s_remote,
34 | 	 const bool s_server,
35 | 	 const int s_ack_id );
36 |   void recv( void );
37 |   void tick( void );
38 | 
39 |   void set_remote( const Socket::Address & s_remote ) { _remote = s_remote; }
40 | 
41 |   void set_saturatr( SaturateServo * const s_saturatr ) { _saturatr = s_saturatr; }
42 | 
43 |   uint64_t wait_time( void ) const;
44 | 
45 |   Acker( const Acker & ) = delete;
46 |   const Acker & operator=( const Acker & ) = delete;
47 | };
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/sender/delay-servo.hh:
--------------------------------------------------------------------------------
 1 | #ifndef DELAY_SERVO_HH
 2 | #define DELAY_SERVO_HH
 3 | 
 4 | #include <string>
 5 | 
 6 | #include "socket.hh"
 7 | #include "rate-estimate.hh"
 8 | #include "history.hh"
 9 | 
10 | class DelayServo {
11 | private:
12 | 
13 |   const std::string _name;
14 | 
15 |   const Socket & _sender;
16 |   const Socket::Address & _target;
17 |   const Socket & _receiver;
18 | 
19 |   RateEstimate _rate_estimator;
20 | 
21 |   unsigned int _packets_sent, _packets_received;
22 | 
23 |   static const unsigned int PACKET_SIZE = 1400; /* bytes */
24 |   static constexpr double QUEUE_DURATION_TARGET = 1.0; /* seconds */
25 |   static constexpr double STEERING_TIME = 0.05; /* seconds */
26 |   static constexpr double MINIMUM_RATE = 5.0; /* packets per second */
27 | 
28 |   int _unique_id;
29 | 
30 |   uint64_t _next_transmission, _last_transmission;
31 | 
32 |   History _hist;
33 | 
34 | public:
35 | 
36 |   DelayServo( const std::string & s_name, const Socket & s_sender,
37 | 	      const Socket::Address & s_target, const Socket & s_receiver );
38 | 
39 |   void tick( void );
40 |   void recv( void );
41 | 
42 |   int wait_time_ns( void ) const;
43 |   int fd( void ) const { return _receiver.get_sock(); }
44 | };
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/plot.p:
--------------------------------------------------------------------------------
 1 | set term png size 1920,1080
 2 | set xlabel "Time in seconds"
 3 | set output "uplink-plot.png"
 4 | set xrange[0:*]
 5 | set multiplot layout 2,1 title "Uplink - `echo $expt` "
 6 | set ylabel "Rate in Mbps"
 7 | time_offset=`echo $t_offset`
 8 | set title "Uplink throughput"
 9 | set lmargin 15
10 | set style data lines
11 | plot  "./uplink.cap" u ($2-time_offset):($5*8/1.0e6) title "available", "./uplink.cap" u ($2-time_offset):($9*8/1.0e6) title "attempted to use"
12 | set ylabel "Delay in seconds"
13 | set lmargin 15
14 | 
15 | set style data dots
16 | set logscale y
17 | set title "Uplink delay"
18 | plot "./uplink.delay" u ($2-time_offset):($4/1.0e3) title "delay",0.15 title "150 ms"
19 | unset logscale y
20 | 
21 | unset multiplot
22 | set output "downlink-plot.png"
23 | set multiplot layout 2,1 title "Downlink - `echo $expt` "
24 | set ylabel "Rate in Mbps"
25 | set title "Downlink throughput"
26 | set lmargin 15
27 | set style data lines
28 | plot  "./downlink.cap" u ($2-time_offset):($5*8/1.0e6) title "available","./downlink.cap" u ($2-time_offset):($9*8/1.0e6) title "attempted to use"  
29 | set ylabel "Delay in seconds"
30 | 
31 | set style data dots
32 | set logscale y
33 | set title "Downlink delay"
34 | set lmargin 15
35 | plot "./downlink.delay" u ($2-time_offset):($4/1.0e3) title "delay",0.15 title "150 ms"
36 | unset logscale y
37 | 


--------------------------------------------------------------------------------
/infer/processforecaster.hh:
--------------------------------------------------------------------------------
 1 | #ifndef PROCESSFORECASTER_HH
 2 | #define PROCESSFORECASTER_HH
 3 | 
 4 | #include "process.hh"
 5 | 
 6 | #include <vector>
 7 | 
 8 | class ProcessForecastTick
 9 | {
10 | private:
11 |   std::vector< std::vector< double > > _count_probability;
12 | 
13 | public:
14 |   ProcessForecastTick( const double tick_time, const Process & example, const unsigned int upper_limit );
15 | 
16 |   double probability( unsigned int component, unsigned int count ) const { return _count_probability[ component ][ count ]; }
17 |   double probability( const Process & ensemble, unsigned int count ) const;
18 | 
19 |   static std::vector< Process > make_components( const Process & example );
20 | };
21 | 
22 | class ProcessForecastInterval
23 | {
24 | private:
25 |   std::vector< std::vector< double > > _count_probability;
26 | 
27 |   static std::vector< double > convolve( const std::vector< double > & old_count_probabilities,
28 | 					 const std::vector< double > & this_tick );
29 | 
30 | public:
31 |   ProcessForecastInterval( const double tick_time,
32 | 			   const Process & example,
33 | 			   const unsigned int tick_upper_limit,
34 | 			   const unsigned int num_ticks );
35 | 
36 |   double probability( const Process & ensemble, unsigned int count ) const;
37 | 
38 |   unsigned int lower_quantile( const Process & ensemble, const double x ) const;
39 | };
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/infer/receiver.cc:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | #include <stdio.h>
 3 | 
 4 | #include "receiver.hh"
 5 | 
 6 | Receiver::Receiver( const double s_time )
 7 |   : _process( MAX_ARRIVAL_RATE,
 8 | 	      BROWNIAN_MOTION_RATE,
 9 | 	      OUTAGE_ESCAPE_RATE,
10 | 	      NUM_BINS ),
11 |     _forecastr(),
12 |     _time( s_time ),
13 |     _count_this_tick( 0 )
14 | {
15 |   for ( int i = 0; i < NUM_TICKS; i++ ) {
16 |     ProcessForecastInterval one_forecast( TICK_LENGTH,
17 | 					  _process,
18 | 					  MAX_ARRIVALS_PER_TICK,
19 | 					  i + 1 );
20 |     _forecastr.push_back( one_forecast );
21 |   }
22 | }
23 | 
24 | void Receiver::advance_to( const double time )
25 | {
26 |   assert( time >= _time );
27 | 
28 |   while ( _time + TICK_LENGTH < time ) {
29 |     _process.evolve( TICK_LENGTH );
30 |     if ( _count_this_tick ) {
31 |       _process.observe( TICK_LENGTH, _count_this_tick );
32 |       _count_this_tick = 0;
33 |     }
34 |     _time += TICK_LENGTH;
35 |   }
36 | }
37 | 
38 | void Receiver::recv( void )
39 | {
40 |   _count_this_tick++;
41 | }
42 | 
43 | DeliveryForecast Receiver::forecast( void )
44 | {
45 |   std::vector< int > ret;
46 | 
47 |   _process.normalize();
48 | 
49 |   for ( auto it = _forecastr.begin(); it != _forecastr.end(); it++ ) {
50 |     ret.push_back( it->lower_quantile( _process, 0.05 ) );
51 |   }
52 | 
53 |   return DeliveryForecast( TICK_LENGTH, ret );
54 | }
55 | 


--------------------------------------------------------------------------------
/sender/trace-analysis/prep-for-simulation.py:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/python
 2 | import sys
 3 | if(len(sys.argv) < 3 ) : 
 4 |   print "Usage : prep-for-simulation.py <file-name> <session-number> "
 5 |   exit
 6 | file_name=sys.argv[1];
 7 | fh=open(file_name,"r");
 8 | session_number=int(sys.argv[2]);
 9 | 
10 | #parse file_name to determine client vs server log_pos-timestamp-sessionID
11 | log_details=file_name.split("-")
12 | log_pos=log_details[0];
13 | 
14 | if(log_pos=="client") :
15 |   log_session=int(log_details[2]);
16 |   if(session_number != log_session) :
17 |         print "Client log file session number doesn't match input session number ";
18 |         exit
19 |   else :
20 |     output_handle=open("downlink-"+str(session_number)+".pps","w");
21 | elif(log_pos=="server") :
22 |   output_handle=open("uplink-"+str(session_number)+".pps","w");
23 | 
24 | start_time=-1
25 | for line in fh.readlines() :
26 |    fields=line.split();
27 |    if(fields[0]=="OUTGOING") : 
28 |       # only INCOMING packets for simulation
29 |       continue ;
30 |    elif (fields[0]=="INCOMING") :
31 |       sender_id=int(fields[3].split("=")[1].strip(","))
32 |       if(sender_id==session_number) :
33 |         recv_time_ms=int(int(fields[6].split("=")[1].strip(","))/1.0e6)  
34 |         if(start_time==-1) :
35 |            start_time=recv_time_ms;
36 |         output_handle.write(str(recv_time_ms-start_time)+"\n");
37 | 


--------------------------------------------------------------------------------
/sender/Makefile:
--------------------------------------------------------------------------------
 1 | source = send1way.cc socket.cc buffer-setpoint.cc hist.cc controlled-delay.cc rate-estimate.cc payload.cc history.cc delay-servo.cc saturatr.cc acker.cc saturateservo.cc cellsim.cc cellsim-tap.cc select.cc packetsocket.cc tapsocket.cc macaddr.cc
 2 | objects = socket.o hist.o rate-estimate.o payload.o history.o delay-servo.o acker.o saturateservo.o select.o packetsocket.o tapsocket.o macaddr.cc
 3 | executables = send1way buffer-setpoint controlled-delay saturatr cellsim cellsim-tap
 4 | 
 5 | CXX = g++
 6 | CXXFLAGS = -g -O3 -std=c++0x -ffast-math -pedantic -Werror -Wall -Wextra -Weffc++ -fno-default-inline -pipe -D_FILE_OFFSET_BITS=64 -D_XOPEN_SOURCE=500 -D_GNU_SOURCE
 7 | LIBS = -lm -lrt
 8 | 
 9 | all: $(executables)
10 | 
11 | send1way: send1way.o $(objects)
12 | 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
13 | 
14 | buffer-setpoint: buffer-setpoint.o $(objects)
15 | 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
16 | 
17 | controlled-delay: controlled-delay.o $(objects)
18 | 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
19 | 
20 | saturatr: saturatr.o $(objects)
21 | 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
22 | 
23 | cellsim: cellsim.o $(objects)
24 | 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
25 | 
26 | cellsim-tap: cellsim-tap.o $(objects)
27 | 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
28 | 
29 | %.o: %.cc
30 | 	$(CXX) $(CXXFLAGS) -c -o $@ $<
31 | 
32 | -include depend
33 | 
34 | depend: $(source)
35 | 	$(CXX) $(INCLUDES) -MM $(source) > depend
36 | 
37 | .PHONY: clean
38 | clean:
39 | 	-rm -f $(executables) depend *.o *.rpo
40 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/gen-schedule.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | from math import exp
 3 | numarg=len(sys.argv)
 4 | # specify packets per second and time 
 5 | # even number because we want rate and duration pairs +1, for the argv[0]
 6 | ##########3assert ((numarg%2==1) and (numarg >=3)); 
 7 | ##########3i=1
 8 | ##########3rate=[]
 9 | ##########3time=[]
10 | ##########3while (i<numarg) :
11 | ##########3   rate.append(int(sys.argv[i]));
12 | ##########3   i=i+1;
13 | ##########3   time.append(int(sys.argv[i]));
14 | ##########3   i=i+1;
15 | ##########3assert(len(rate)==len(time));
16 | ##########3
17 | ##t=0;
18 | ##for i in range (0,len(rate)) :
19 | ## num_pkts=time[i]*rate[i];
20 | ## for pkt_id in range(0,num_pkts) :  # 1 hour in milliseconds 
21 | ##   t=t+(1000/float(rate[i]))
22 | ##   print int(round(t))
23 | 
24 | 
25 | # 1000 packets a second at the beginning to allow awesome video
26 | t=0
27 | #for i in range(0,400*1000) : # generate a packet every ms 
28 | #   t=t+1
29 | #   print int(round(t))
30 | #
31 | # gradually reduce , this is convex downward 
32 | #for i in range(0,400*1000) : # generate a packet every ms 
33 | #   t=t+1+float(i/100000.0)       # 40*1000 is 40 seconds. 
34 | #   print int(round(t))
35 | #
36 | 
37 | # concave downward  decrease
38 | def rate(x):
39 |   return ( 1 - 1.1/(exp(0.007*(1400-x)) + 1)) if (x>400) else 1 
40 | 
41 | for i in range (0,1600):
42 |     delta=1/rate(i)
43 |     t=i*1000
44 |     while (t< (i+1)*1000) :
45 |       print int(round(t))
46 |       t=t+delta;
47 | 


--------------------------------------------------------------------------------
/sender/saturateservo.hh:
--------------------------------------------------------------------------------
 1 | #ifndef SATURATESERVO_HH
 2 | #define SATURATESERVO_HH
 3 | 
 4 | #include <fstream>
 5 | #include "socket.hh"
 6 | 
 7 | class Acker;
 8 | 
 9 | class SaturateServo
10 | {
11 | private:
12 |   const std::string _name;
13 |   FILE* _log_file;
14 | 
15 |   const Socket _listen;
16 |   const Socket _send;
17 |   Socket::Address _remote;
18 | 
19 |   const bool _server;
20 |   const int _send_id;
21 | 
22 |   Acker *_acker;
23 | 
24 |   uint64_t _next_transmission_time;
25 | 
26 |   static const int _transmission_interval = 1000 * 1000 * 1000;
27 | 
28 |   int _foreign_id;
29 | 
30 |   int _packets_sent, _max_ack_id;
31 | 
32 |   int _window;
33 | 
34 |   static const int LOWER_WINDOW = 20;
35 |   static const int UPPER_WINDOW = 1500;
36 | 
37 |   static constexpr double LOWER_RTT = 0.75;
38 |   static constexpr double UPPER_RTT = 3.0;
39 | 
40 | public:
41 |   SaturateServo( const char * s_name,
42 |                  FILE* log_file,
43 | 		 const Socket & s_listen,
44 | 		 const Socket & s_send,
45 | 		 const Socket::Address & s_remote,
46 | 		 const bool s_server,
47 | 		 const int s_send_id );
48 | 
49 |   void recv( void );
50 | 
51 |   uint64_t wait_time( void ) const;
52 | 
53 |   void tick( void );
54 | 
55 |   void set_acker( Acker * const s_acker ) { _acker = s_acker; }
56 | 
57 |   void set_remote( const Socket::Address & s_remote ) { _remote = s_remote; }
58 | 
59 |   SaturateServo( const SaturateServo & ) = delete;
60 |   const SaturateServo & operator=( const SaturateServo & ) = delete;
61 | };
62 | 
63 | #endif
64 | 


--------------------------------------------------------------------------------
/infer/process.hh:
--------------------------------------------------------------------------------
 1 | #ifndef PROCESS_HPP
 2 | #define PROCESS_HPP
 3 | 
 4 | #include "sampledfunction.hh"
 5 | 
 6 | class Process
 7 | {
 8 | private:
 9 |   class GaussianCache {
10 |   private:
11 |     SampledFunction _cdf;
12 |     double _stddev;
13 | 
14 |   public:
15 |     GaussianCache( const double maximum_rate, const int bins );
16 |     void calculate( const double s_stddev );
17 |     double cdf( const double x ) const { return _cdf[ x ]; }
18 |   };
19 | 
20 |   SampledFunction _probability_mass_function;
21 |   GaussianCache _gaussian;
22 | 
23 |   const double _brownian_motion_rate; /* stddev of difference after one second */
24 |   const double _outage_escape_rate; /* arrivals per second */
25 | 
26 |   bool _normalized;
27 | 
28 | public:
29 |   Process( const double maximum_rate, const double s_brownian_motion_rate, const double s_outage_escape_rate, const int bins );
30 | 
31 |   /* apply brownian motion */
32 |   void evolve( const double time );
33 | 
34 |   /* update from new observation */
35 |   void observe( const double time, const int counts );
36 | 
37 |   /* make pmf sum to unity */
38 |   void normalize( void );
39 | 
40 |   const SampledFunction & pmf( void ) const { return _probability_mass_function; }
41 | 
42 |   double lower_quantile( const double x ) const { return _probability_mass_function.lower_quantile( x ); }
43 | 
44 |   /* set rate to known quantity */
45 |   void set_certain( const double rate );
46 | 
47 |   Process & operator=( const Process & other );
48 | 
49 |   /* count probabilities assuming no evolution */
50 |   double count_probability( const double time, const int counts );
51 | 
52 |   bool is_normalized( void ) const { return _normalized; }
53 | };
54 | 
55 | #endif
56 | 


--------------------------------------------------------------------------------
/sender/macaddr.cc:
--------------------------------------------------------------------------------
 1 | #include <sys/types.h>
 2 | #include <assert.h>
 3 | #include <string.h>
 4 | #include "macaddr.hh"
 5 | 
 6 | MACAddress::MACAddress( const std::string & s_addr )
 7 |   : octets()
 8 | {
 9 |   assert( s_addr.size() == 6 );
10 |   for ( int i = 0; i < 6; i++ ) {
11 |     octets[ i ] = s_addr[ i ];
12 |   }
13 | }
14 | 
15 | bool MACAddress::is_broadcast( void ) const
16 | {
17 |   for ( int i = 0; i < 6; i++ ) {
18 |     if ( octets[ i ] != 0xff ) {
19 |       return false;
20 |     }
21 |   }
22 |   return true;
23 | }
24 | 
25 | bool MACAddress::matches( const MACAddress & other ) const
26 | {
27 |   return ( is_broadcast() || other.is_broadcast() || (0 == memcmp( octets, other.octets, 6 )) );
28 | }
29 | 
30 | std::string MACAddress::parse_human( const std::string & with_colons )
31 | {
32 |   std::string ret( 6, 0 );
33 | 
34 |   unsigned int octets[ 6 ];
35 | 
36 |   if ( with_colons.empty() ) {
37 |     for ( int i = 0; i < 6; i++ ) {
38 |       octets[ i ] = 0xff;
39 |     }
40 |   } else {
41 |     int items_matched = sscanf( with_colons.c_str(),
42 | 				"%x:%x:%x:%x:%x:%x",
43 | 				&octets[ 0 ],
44 | 				&octets[ 1 ],
45 | 				&octets[ 2 ],
46 | 				&octets[ 3 ],
47 | 				&octets[ 4 ],
48 | 				&octets[ 5 ] );
49 |     assert( items_matched == 6 );
50 |   }
51 | 
52 |   for ( int i = 0; i < 6; i++ ) {
53 |     assert( octets[ i ] <= 255 );
54 |     ret[ i ] = octets[ i ];
55 |   }
56 | 
57 |   return ret;
58 | }
59 | 
60 | std::string MACAddress::pp( void ) const
61 | {
62 |   char tmp[ 64 ];
63 |   snprintf( tmp, 64, "%x:%x:%x:%x:%x:%x",
64 | 	    octets[ 0 ],
65 | 	    octets[ 1 ],
66 | 	    octets[ 2 ],
67 | 	    octets[ 3 ],
68 | 	    octets[ 4 ],
69 | 	    octets[ 5 ] );
70 |   return std::string( tmp );
71 | }
72 | 


--------------------------------------------------------------------------------
/sender/socket.hh:
--------------------------------------------------------------------------------
 1 | #ifndef SOCKET_HH
 2 | #define SOCKET_HH
 3 | 
 4 | #include <sys/socket.h>
 5 | #include <netinet/in.h>
 6 | #include <string>
 7 | #include <time.h>
 8 | #include <string.h>
 9 | 
10 | class Socket {
11 | public:
12 |   static uint64_t timestamp( void );
13 | 
14 |   class Address {
15 |   private:
16 |     struct sockaddr_in _sockaddr;
17 | 
18 |   public:
19 |     Address( std::string ip, uint16_t port );
20 |     Address( const struct sockaddr_in s_sockaddr ) : _sockaddr( s_sockaddr ) {}
21 | 
22 |     const struct sockaddr_in & sockaddr( void ) const { return _sockaddr; }
23 |     const std::string str( void ) const;
24 | 
25 |     std::string ip( void ) const;
26 | 
27 |     bool operator==( const Address & other ) const { return (0 == memcmp( &_sockaddr, &other._sockaddr, sizeof( _sockaddr ))); }
28 |   };
29 | 
30 |   class Packet {
31 |   public:
32 |     Address addr;
33 |     std::string payload;
34 |     uint64_t timestamp;
35 | 
36 |     Packet( const Address &s_addr, const std::string &s_payload )
37 |       : addr( s_addr ), payload( s_payload ), timestamp( 0 )
38 |     {}
39 | 
40 |     Packet( const Address &s_addr, const std::string &s_payload, const struct timespec &ts )
41 |       : addr( s_addr ), payload( s_payload ), timestamp( ts.tv_sec * 1000000000 + ts.tv_nsec )
42 |     {}
43 |   };
44 | 
45 | private:
46 |   int sock;
47 | 
48 | public:
49 |   Socket();
50 |   void bind( const Address & addr ) const;
51 |   void connect( const Address & addr ) const;
52 |   void send( const Packet & payload ) const;
53 |   void bind_to_device( const std::string & name ) const;
54 |   Packet recv( void ) const;
55 |   int get_sock( void ) const { return sock; }
56 | };
57 | 
58 | const Socket::Address UNKNOWN( "0.0.0.0", 0 );
59 | 
60 | #endif
61 | 


--------------------------------------------------------------------------------
/sender/select.cc:
--------------------------------------------------------------------------------
 1 | /*
 2 |     Mosh: the mobile shell
 3 |     Copyright 2012 Keith Winstein
 4 | 
 5 |     This program is free software: you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation, either version 3 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License
16 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 |     In addition, as a special exception, the copyright holders give
19 |     permission to link the code of portions of this program with the
20 |     OpenSSL library under certain conditions as described in each
21 |     individual source file, and distribute linked combinations including
22 |     the two.
23 | 
24 |     You must obey the GNU General Public License in all respects for all
25 |     of the code used other than OpenSSL. If you modify file(s) with this
26 |     exception, you may extend this exception to your version of the
27 |     file(s), but you are not obligated to do so. If you do not wish to do
28 |     so, delete this exception statement from your version. If you delete
29 |     this exception statement from all source files in the program, then
30 |     also delete it here.
31 | */
32 | 
33 | #include "select.h"
34 | 
35 | fd_set Select::dummy_fd_set;
36 | 
37 | sigset_t Select::dummy_sigset;
38 | 
39 | void Select::handle_signal( int signum )
40 | {
41 |   fatal_assert( signum >= 0 );
42 |   fatal_assert( signum <= MAX_SIGNAL_NUMBER );
43 | 
44 |   Select &sel = get_instance();
45 |   sel.got_signal[ signum ] = 1;
46 |   sel.got_any_signal = 1;
47 | }
48 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/calc-stats.py:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/python
 2 | import sys
 3 | import math
 4 | if (len(sys.argv) < 3) :
 5 |    print sys.argv[0]," file stat";
 6 |    exit(4)
 7 | 
 8 | stat=sys.argv[2];
 9 | file_name=open(sys.argv[1],"r")
10 | bytes_sent=0
11 | bytes_avail=0
12 | start_time=-1
13 | util_list=[]
14 | 
15 | def mean(samples) :
16 |    return float(sum(samples))/len(samples)
17 | def percentile(samples,number) :
18 |    samples.sort()
19 |    reqd_index=int(round(number*0.01*len(samples)))
20 |    assert(reqd_index <= len(samples))
21 |    return samples[reqd_index] 
22 | if(stat=="util"):
23 |   for line in file_name.readlines() :
24 |    records=line.split()
25 |    if ((records[3]=="/") and (records[7]=="%")) :
26 |      if (start_time == -1) :
27 |        start_time = int(float(records[1]));
28 |      time=int(float(records[1]));
29 |      if(time-start_time <= 60) :
30 |         continue ;
31 |         # ignore first 60 seconds
32 |      bytes_sent+=int(records[2]);
33 |      bytes_avail+=int(records[4]);
34 |      if ( (int(records[2]) !=0) and (int(records[4]) !=0) ) :
35 |         util_list.append(float(records[6]));
36 |   print "mean ",(100*float(bytes_sent))/float(bytes_avail),"% "," 25th percentile  ",percentile(util_list,25),"%", " 75th percentile ",percentile(util_list,75)," %"
37 | 
38 | sum_delay=0;
39 | count=0;
40 | delay_list=[]
41 | if(stat=="delay"):
42 |   for line in file_name.readlines() :
43 |    records=line.split()
44 |    if (records[2]=="delivery") :
45 |      if (start_time == -1) :
46 |        start_time = int(float(records[1]));
47 |      time=int(float(records[1]));
48 |      if(time-start_time <= 60) :
49 |         continue ;
50 |         # ignore first 60 seconds
51 |      sum_delay+=int(records[3]);
52 |      delay_list.append(int(records[3]));
53 |      count=count+1;
54 |   print "mean ", float(sum_delay)/float(count),"ms"," 25th percentile  ",percentile(delay_list,25)," ms ", " 75th percentile ",percentile(delay_list,75)," ms "
55 | 


--------------------------------------------------------------------------------
/sender/simulation-analysis/cmp.p:
--------------------------------------------------------------------------------
 1 | set term png size 1920,1080
 2 | set xlabel "Time in seconds"
 3 | set output "tpt.png"
 4 | set multiplot layout 2,1 title "Skype vs Cubic vs Sprout - throughput "
 5 | skype_offset=1347419342
 6 | cubic_offset=1347412742
 7 | sprout_offset=1347414100
 8 | set style data lines
 9 | set ylabel "Rate in Mbps"
10 | set title "uplink throughput"
11 | set lmargin 15
12 | plot "./`echo $skype`/uplink.cap" u ($2-skype_offset):($9*8/1.0e6) title "skype-uplink" , "./`echo $skype`/uplink.cap" u ($2-skype_offset):($5*8/1.0e6) title "available", "./`echo $cubic`/uplink.cap" u ($2- cubic_offset):($9*8/1.0e6) title"cubic-uplink" , "./`echo $sproutbt`/uplink.cap" u ($2- sprout_offset):($9*8/1.0e6) title"sproutbt-uplink"
13 | 
14 | 
15 | set title "downlink throughput"
16 | set lmargin 15
17 | plot "./`echo $skype`/downlink.cap" u ($2-skype_offset):($9*8/1.0e6) title "skype-downlink" , "./`echo $skype`/downlink.cap" u ($2-skype_offset):($5*8/1.0e6) title "available", "./`echo $cubic`/downlink.cap" u ($2- cubic_offset):($9*8/1.0e6) title"cubic-downlink", "./`echo $sproutbt`/downlink.cap" u ($2- sprout_offset):($9*8/1.0e6) title"sproutbt-downlink"
18 | 
19 | 
20 | unset multiplot
21 | set output "delay.png"
22 | set multiplot layout 2,1 title "Skype vs Cubuc vs Sprout - delay "
23 | set logscale y
24 | set style data dots
25 | set ylabel "Delay in seconds"
26 | set title "uplink delay"
27 | set lmargin 15
28 | plot "./`echo $skype`/uplink.delay" u ($2-skype_offset):($4/1.0e3) title "skype-uplink"  ,  "./`echo $cubic`/uplink.delay" u ($2- cubic_offset):($4/1.0e3) title"cubic-uplink"  , "./`echo $sproutbt`/uplink.delay" u ($2- sprout_offset):($4/1.0e3) title"sproutbt-uplink" 
29 | 
30 | 
31 | set title "downlink delay"
32 | set lmargin 15
33 | plot "./`echo $skype`/downlink.delay" u ($2-skype_offset):($4/1.0e3) title "skype-downlink"  , "./`echo $cubic`/downlink.delay" u ($2- cubic_offset):($4/1.0e3) title"cubic-downlink" , "./`echo $sproutbt`/downlink.delay" u ($2- sprout_offset):($4/1.0e3) title"sproutbt-downlink" 
34 | 
35 | 


--------------------------------------------------------------------------------
/sender/timestamp.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     Mosh: the mobile shell
 3 |     Copyright 2012 Keith Winstein
 4 | 
 5 |     This program is free software: you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation, either version 3 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License
16 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 |     In addition, as a special exception, the copyright holders give
19 |     permission to link the code of portions of this program with the
20 |     OpenSSL library under certain conditions as described in each
21 |     individual source file, and distribute linked combinations including
22 |     the two.
23 | 
24 |     You must obey the GNU General Public License in all respects for all
25 |     of the code used other than OpenSSL. If you modify file(s) with this
26 |     exception, you may extend this exception to your version of the
27 |     file(s), but you are not obligated to do so. If you do not wish to do
28 |     so, delete this exception statement from your version. If you delete
29 |     this exception statement from all source files in the program, then
30 |     also delete it here.
31 | */
32 | 
33 | #ifndef TIMESTAMP_HPP
34 | #define TIMESTAMP_HPP
35 | 
36 | #include <time.h>
37 | 
38 | uint64_t timestamp( void )
39 | {
40 |   struct timespec ts;
41 |   if ( clock_gettime( CLOCK_REALTIME, &ts ) < 0 ) {
42 |     perror( "clock_gettime" );
43 |     exit( 1 );
44 |   }
45 | 
46 |   uint64_t millis = ts.tv_nsec / 1000000;
47 |   millis += uint64_t( ts.tv_sec ) * 1000;
48 | 
49 |   return millis;
50 | }
51 | 
52 | #endif
53 | 


--------------------------------------------------------------------------------
/infer/infer.cc:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <stdio.h>
 3 | #include <iostream>
 4 | #include <assert.h>
 5 | 
 6 | #include "process.hh"
 7 | #include "processforecaster.hh"
 8 | 
 9 | using namespace std;
10 | 
11 | int main( void )
12 | {
13 |   Process myprocess( 2000, 300, 5, 64 );
14 | 
15 |   myprocess.normalize();
16 | 
17 |   const int predict_ticks = 10;
18 |   const int interval_ms = 10;
19 | 
20 |   ProcessForecastInterval forecastr( (double)interval_ms / 1000.0, myprocess, 30, predict_ticks );
21 | 
22 |   int current_chunk = -1, count = -1;
23 | 
24 |   int predicted_counts = 0;
25 |   int predict_end = 0;
26 |   int actual_counts = 0;
27 | 
28 |   fprintf( stderr, "Ready...\n" );
29 | 
30 |   int worse_than_predicted = 0, total_predictions = 0;
31 | 
32 |   while ( cin.good() ) {
33 |     int ms = 0;
34 |     cin >> ms;
35 | 
36 |     if ( current_chunk == -1 ) { /* need to initialize */
37 |       current_chunk = ms / interval_ms;
38 |       count = 0;
39 |     }
40 | 
41 |     if ( ms == 0 && current_chunk != 0 ) {
42 |       break;
43 |     }
44 | 
45 |     assert( ms / interval_ms >= current_chunk );
46 | 
47 |     while ( current_chunk < ms / interval_ms ) {
48 |       myprocess.evolve( (double)interval_ms / 1000.0 );
49 |       myprocess.observe( (double)interval_ms / 1000.0, count );
50 |       myprocess.normalize();
51 | 
52 |       if ( current_chunk >= predict_end ) {
53 | 	total_predictions++;
54 | 
55 | 	if ( actual_counts < predicted_counts - 1 ) {
56 | 	  worse_than_predicted++;
57 | 	}
58 | 
59 | 	printf( "%d actual = %d predicted = %d diff = %d\n",
60 | 		ms, actual_counts, predicted_counts, actual_counts - predicted_counts );
61 | 
62 | 	predict_end = current_chunk + predict_ticks;
63 | 	actual_counts = 0;
64 | 	predicted_counts = forecastr.lower_quantile( myprocess, 0.15 );
65 |       }
66 | 
67 |       current_chunk++;
68 |       count = 0;
69 |     }
70 | 
71 |     count++;
72 |     actual_counts++;
73 |   }
74 | 
75 |   fprintf( stderr, "Results: %d/%d (= %f %%) were worse than predicted.\n",
76 | 	   worse_than_predicted,
77 | 	   total_predictions,
78 | 	   100.0 * (double) worse_than_predicted / (double) total_predictions );
79 | }
80 | 


--------------------------------------------------------------------------------
/sender/fatal_assert.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |     Mosh: the mobile shell
 3 |     Copyright 2012 Keith Winstein
 4 | 
 5 |     This program is free software: you can redistribute it and/or modify
 6 |     it under the terms of the GNU General Public License as published by
 7 |     the Free Software Foundation, either version 3 of the License, or
 8 |     (at your option) any later version.
 9 | 
10 |     This program is distributed in the hope that it will be useful,
11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |     GNU General Public License for more details.
14 | 
15 |     You should have received a copy of the GNU General Public License
16 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 |     In addition, as a special exception, the copyright holders give
19 |     permission to link the code of portions of this program with the
20 |     OpenSSL library under certain conditions as described in each
21 |     individual source file, and distribute linked combinations including
22 |     the two.
23 | 
24 |     You must obey the GNU General Public License in all respects for all
25 |     of the code used other than OpenSSL. If you modify file(s) with this
26 |     exception, you may extend this exception to your version of the
27 |     file(s), but you are not obligated to do so. If you do not wish to do
28 |     so, delete this exception statement from your version. If you delete
29 |     this exception statement from all source files in the program, then
30 |     also delete it here.
31 | */
32 | 
33 | #ifndef FATAL_ASSERT_HPP
34 | #define FATAL_ASSERT_HPP
35 | 
36 | #include <stdio.h>
37 | #include <stdlib.h>
38 | 
39 | static void fatal_error( const char *expression, const char *file, int line, const char *function )
40 | {
41 |   fprintf( stderr, "Fatal assertion failure in function %s at %s:%d\nFailed test: %s\n",
42 |            function, file, line, expression );
43 |   abort();
44 | }
45 | 
46 | #define fatal_assert(expr)						\
47 |   ((expr)								\
48 |    ? (void)0								\
49 |    : fatal_error (#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__ ))
50 | 
51 | #endif
52 | 


--------------------------------------------------------------------------------
/infer/sampledfunction.cc:
--------------------------------------------------------------------------------
 1 | #include "sampledfunction.hh"
 2 | 
 3 | #include <assert.h>
 4 | 
 5 | SampledFunction::SampledFunction( const int num_samples,
 6 | 					   const double maximum_value,
 7 | 					   const double minimum_value )
 8 |   : _offset( minimum_value ),
 9 |     _bin_width( (maximum_value - minimum_value) / num_samples ),
10 |     _function( int((maximum_value - minimum_value) / _bin_width) + 1, 1.0 )
11 | {
12 | }
13 | 
14 | void SampledFunction::for_each( const std::function< void( const double midpoint,
15 | 							 double & value,
16 | 							 const unsigned int index ) > f )
17 | {
18 |   for ( unsigned int i = 0; i < _function.size(); i++ ) {
19 |     f( from_bin_mid( i ), _function[ i ], i );
20 |   }
21 | }
22 | 
23 | void SampledFunction::for_each( const std::function< void( const double midpoint,
24 | 							   const double & value,
25 | 							   const unsigned int index ) > f ) const
26 | {
27 |   for ( unsigned int i = 0; i < _function.size(); i++ ) {
28 |     f( from_bin_mid( i ), _function[ i ], i );
29 |   }
30 | }
31 | 
32 | void SampledFunction::for_range( const double min,
33 | 					  const double max,
34 | 					  const std::function< void( const double midpoint,
35 | 								     double & value,
36 | 								     const unsigned int index ) > f )
37 | {
38 |   const unsigned int limit_high = to_bin( sample_ceil( max ) );
39 |   for ( unsigned int i = to_bin( sample_floor( min ) ); i <= limit_high; i++ ) {
40 |     f( from_bin_mid( i ), _function[ i ], i );
41 |   }
42 | }
43 | 
44 | const SampledFunction & SampledFunction::operator=( const SampledFunction & other )
45 | {
46 |   assert( _offset == other._offset );
47 |   assert( _bin_width == other._bin_width );
48 |   _function = other._function;
49 | 
50 |   return *this;
51 | }
52 | 
53 | double SampledFunction::lower_quantile( const double x ) const
54 | {
55 |   double sum = 0.0;
56 | 
57 |   for ( unsigned int i = 0; i < _function.size(); i++ ) {
58 |     sum += _function[ i ];
59 |     //    fprintf( stderr, "%d sum=%f\n", i, sum );
60 |     if ( sum >= x ) {
61 |       if ( i == 0 ) { return 0; } else { return from_bin_floor( i ); }
62 |     }
63 |   }
64 |   return from_bin_floor( _function.size() - 1 );
65 | }
66 | 
67 | 


--------------------------------------------------------------------------------
/infer/sampledfunction.hh:
--------------------------------------------------------------------------------
 1 | #ifndef SAMPLEDFUNCTION_HH
 2 | #define SAMPLEDFUNCTION_HH
 3 | 
 4 | #include <vector>
 5 | #include <functional>
 6 | #include <limits.h>
 7 | 
 8 | class SampledFunction {
 9 | private:
10 |   const double _offset;
11 |   const double _bin_width;
12 |   std::vector< double > _function;
13 | 
14 |   unsigned int to_bin( double x ) const { int ret = (x - _offset) / _bin_width; if ( ret < 0 ) { return 0; } else if ( ret >= (int)_function.size() ) { return _function.size() - 1; } else { return ret; } }
15 | 
16 |   double from_bin_floor( unsigned int bin ) const { if ( bin <= 0 ) { return -INT_MAX; } else { return bin * _bin_width + _offset; } }
17 |   double from_bin_ceil( unsigned int bin ) const { if ( bin >= _function.size() - 1 ) { return INT_MAX; } else { return (bin + 1) * _bin_width + _offset; } }
18 |   double from_bin_mid( unsigned int bin ) const { return (bin + 0.5) * _bin_width + _offset; }
19 | 
20 | public:
21 |   SampledFunction( const int num_samples, const double maximum_value, const double minimum_value );
22 | 
23 |   unsigned int size( void ) const { return _function.size(); }
24 |   unsigned int index( const double x ) const { return to_bin( x ); }
25 |   double & operator[]( const double x ) { return _function[ to_bin( x ) ]; }
26 |   const double & operator[]( const double x ) const { return _function[ to_bin( x ) ]; }
27 | 
28 |   double sample_floor( double x ) const { return from_bin_floor( to_bin( x ) ); }
29 |   double sample_ceil( double x ) const { return from_bin_ceil( to_bin( x ) ); }
30 | 
31 |   void for_each( const std::function< void( const double midpoint,
32 | 					    double & value,
33 | 					    const unsigned int index ) > f );
34 |   void for_each( const std::function< void( const double midpoint,
35 | 					    const double & value,
36 | 					    const unsigned int index ) > f ) const;
37 |   void for_range( const double min, const double max,
38 | 		  const std::function< void( const double midpoint,
39 | 					     double & value,
40 | 					     const unsigned int index ) > f );
41 | 
42 |   const SampledFunction & operator=( const SampledFunction & other );
43 | 
44 |   double lower_quantile( const double x ) const;
45 | };
46 | 
47 | #endif
48 | 


--------------------------------------------------------------------------------
/sender/tapsocket.cc:
--------------------------------------------------------------------------------
 1 | #include "tapsocket.hh"
 2 | #include <assert.h>
 3 | 
 4 | using namespace std;
 5 | 
 6 | int TapSocket::setup_tap( const char* tap_name ) const
 7 | {
 8 |   int tap_fd = tun_alloc( tap_name, IFF_TAP | IFF_NO_PI );
 9 |   if ( tap_fd < 0 ) {
10 |     perror( "Allocating interface" );
11 |     exit( 1 );
12 |   }
13 |   return tap_fd;
14 | }
15 | 
16 | int TapSocket::tun_alloc(const char *dev, int flags) const
17 | {
18 |   struct ifreq ifr;
19 |   int fd;
20 |   int err;
21 |   std::string clone_dev = "/dev/net/tun";
22 |               
23 |   /* open the clone device */
24 |   if( (fd = open(clone_dev.c_str(), O_RDWR)) < 0 ) {
25 |     return fd;
26 |   }
27 | 
28 |   /* zero out struct ifr, of type "struct ifreq" */
29 |   memset(&ifr, 0, sizeof(ifr));
30 |   ifr.ifr_flags = flags;   /* IFF_TUN or IFF_TAP, optionally IFF_NO_PI */
31 |                     
32 |   /* if a device name is supplied, use it */
33 |   assert( dev != nullptr );
34 |   strncpy(ifr.ifr_name, dev, IFNAMSIZ);
35 |                     
36 |   /* try to create the device */
37 |   if( (err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0 ) {
38 |     close(fd);
39 |     return err;
40 |   }
41 |                         
42 |   /* return file descriptor to tap device */
43 |   return fd;
44 | }
45 | 
46 | 
47 | TapSocket::TapSocket( const std::string & s_interface,
48 | 			    const std::string & s_from_filter,
49 | 			    const std::string & s_to_filter )
50 |   : sock( setup_tap( s_interface.c_str() ) ),
51 |     _from_filter( MACAddress::parse_human( s_from_filter ) ),
52 |     _to_filter( MACAddress::parse_human( s_to_filter ) )
53 | {}
54 | 
55 | vector< string > TapSocket::recv_raw( void )
56 | {
57 |   vector< string > ret;
58 | 
59 |   char buffer[1600];
60 |   int nread = read( sock, (void*) buffer, sizeof(buffer) );
61 |   string packet( buffer, nread );
62 | 
63 |   if(nread < 0) {
64 |     perror("Reading from interface");
65 |     close(sock);
66 |     exit(1);
67 |   }
68 | 
69 |   assert( packet.size() > 12 );
70 | 
71 |   const MACAddress destination_address( packet.substr( 0, 6 ) );
72 |   const MACAddress source_address( packet.substr( 6, 6 ) );
73 | 
74 |   if (  _to_filter.matches( destination_address )
75 | 	&& _from_filter.matches( source_address ) ) {
76 |     ret.push_back( packet );
77 |   }
78 | 
79 |   return ret;
80 | }
81 | 
82 | void TapSocket::send_raw( const std::string & input )
83 | {
84 |   /* write into tap device */
85 |   ssize_t bytes_sent = write( sock, input.c_str(), input.size() );
86 |   if ( bytes_sent < 0 ) {
87 |     perror( "send" );
88 |     exit( 1 );
89 |   }
90 | }
91 | 


--------------------------------------------------------------------------------
/sender/acker.cc:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | 
 3 | #include "acker.hh"
 4 | #include "payload.hh"
 5 | #include "saturateservo.hh"
 6 | 
 7 | Acker::Acker( const char *s_name, FILE* log_file_handle, const Socket & s_listen, const Socket & s_send, const Socket::Address & s_remote, const bool s_server, const int s_ack_id )
 8 |   : _name( s_name ), 
 9 |     _log_file(log_file_handle),
10 |     _listen( s_listen ),
11 |     _send( s_send ),
12 |     _remote( s_remote ),
13 |     _server( s_server ),
14 |     _ack_id( s_ack_id ),
15 |     _saturatr( NULL ),
16 |     _next_ping_time( Socket::timestamp() ),
17 |     _foreign_id( -1 )
18 | {}
19 | 
20 | void Acker::recv( void )
21 | {
22 |   /* get the data packet */
23 |   Socket::Packet incoming( _listen.recv() );
24 |   SatPayload *contents = (SatPayload *) incoming.payload.data();
25 |   contents->recv_timestamp = incoming.timestamp;
26 | 
27 |   int64_t oneway_ns = contents->recv_timestamp - contents->sent_timestamp;
28 |   double oneway = oneway_ns / 1.e9;
29 | 
30 |   if ( _server ) {
31 |     if ( _saturatr ) {
32 |       if ( contents->sender_id > _foreign_id ) {
33 | 	_foreign_id = contents->sender_id;
34 | 	_saturatr->set_remote( incoming.addr );
35 |       }
36 |     }
37 | 
38 |     if ( _remote == UNKNOWN ) {
39 |       return;
40 |     }
41 |   }
42 | 
43 |   assert( !(_remote == UNKNOWN) );
44 | 
45 |   Socket::Address fb_destination( _remote );
46 | 
47 |   /* send ack */
48 |   SatPayload outgoing( *contents );
49 |   outgoing.sequence_number = -1;
50 |   outgoing.ack_number = contents->sequence_number;
51 |   _send.send( Socket::Packet( _remote, outgoing.str( sizeof( SatPayload ) ) ) );
52 | 
53 |    fprintf( _log_file,"%s DATA RECEIVED senderid=%d, seq=%d, send_time=%ld, recv_time=%ld, 1delay=%.4f \n",
54 |       _name.c_str(),  _server ? contents->sender_id : _ack_id, contents->sequence_number, contents->sent_timestamp, contents->recv_timestamp,oneway ); 
55 | }
56 | 
57 | void Acker::tick( void )
58 | {
59 |   if ( _server ) {
60 |     return;
61 |   }
62 | 
63 |   /* send NAT heartbeats */
64 |   if ( _remote == UNKNOWN ) {
65 |     _next_ping_time = Socket::timestamp() + _ping_interval;
66 |     return;
67 |   }
68 | 
69 |   if ( _next_ping_time < Socket::timestamp() ) {
70 |     SatPayload contents;
71 |     contents.sequence_number = -1;
72 |     contents.ack_number = -1;
73 |     contents.sent_timestamp = Socket::timestamp();
74 |     contents.recv_timestamp = 0;
75 |     contents.sender_id = _ack_id;
76 | 
77 |     _send.send( Socket::Packet( _remote, contents.str( sizeof( SatPayload ) ) ) );
78 | 
79 |     _next_ping_time = Socket::timestamp() + _ping_interval;
80 |   }
81 | }
82 | 
83 | uint64_t Acker::wait_time( void ) const
84 | {
85 |   if ( _server ) {
86 |     return 1000000000;
87 |   }
88 | 
89 |   int diff = _next_ping_time - Socket::timestamp();
90 |   if ( diff < 0 ) {
91 |     diff = 0;
92 |   }
93 | 
94 |   return diff;
95 | }
96 | 


--------------------------------------------------------------------------------
/infer/vbrssp.cc:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <stdio.h>
 3 | #include <iostream>
 4 | #include <assert.h>
 5 | 
 6 | #include "receiver.hh"
 7 | #include "cellqueue.hh"
 8 | 
 9 | using namespace std;
10 | 
11 | int main( void )
12 | {
13 |   Receiver *receiver = NULL;
14 |   CellQueue queue;
15 |   std::queue< DeliveryForecast > forecasts;
16 |   std::queue< unsigned int > received_packet_feedback;
17 | 
18 |   double time;
19 |   const double TICK_LENGTH = 0.02;
20 |   const unsigned int FEEDBACK_DELAY_TICKS = 2;
21 |   const unsigned int TARGET_DELAY_TICKS = 5;
22 | 
23 |   int packets_received = 0;
24 |   int packets_sent = 0;
25 | 
26 |   while ( 1 ) {
27 |     if ( !cin.good() ) {
28 |       exit( 0 );
29 |     }
30 | 
31 |     int ms = -1;
32 |     cin >> ms;
33 | 
34 |     double packet_time = (double) ms / 1000.0;
35 | 
36 |     if ( !receiver ) {
37 |       receiver = new Receiver( packet_time );
38 |       time = packet_time;
39 |       for ( unsigned int i = 0; i < FEEDBACK_DELAY_TICKS; i++ ) {
40 | 	forecasts.push( receiver->forecast() );
41 | 	received_packet_feedback.push( 0 );
42 |       }
43 |     }
44 | 
45 |     if ( packet_time < time ) {
46 |       if ( queue.recv( time ) ) {
47 | 	receiver->recv();
48 | 	packets_received++;
49 |       }
50 |     } else {
51 |       /* need to advance time */
52 |       while ( packet_time >= time ) {
53 | 	time += TICK_LENGTH;
54 | 	receiver->advance_to( time );
55 | 	DeliveryForecast forecast( forecasts.front() );
56 | 	forecasts.pop();
57 | 	forecasts.push( receiver->forecast() );
58 | 	assert( forecasts.size() == FEEDBACK_DELAY_TICKS );
59 | 	
60 | 	unsigned int delayed_packets_received( received_packet_feedback.front() );
61 | 	received_packet_feedback.pop();
62 | 	received_packet_feedback.push( packets_received );
63 | 	assert( received_packet_feedback.size() == FEEDBACK_DELAY_TICKS );
64 | 
65 | 	int current_queue_size_estimate = packets_sent - delayed_packets_received - forecast.counts[ FEEDBACK_DELAY_TICKS ];
66 | 
67 | 	if ( current_queue_size_estimate < 0 ) {
68 | 	  current_queue_size_estimate = 0;
69 | 	}
70 | 
71 | 	/* send packets */
72 | 	int cumulative_delivery_forecast = forecast.counts[ TARGET_DELAY_TICKS ];
73 | 
74 | 	int packets_to_send = cumulative_delivery_forecast - current_queue_size_estimate;
75 | 
76 | 	printf( "%f, sent = %d, dpr = %d, fc = %d, cur est = %d, cum dev forecast = %d\n",
77 | 		time, packets_sent, delayed_packets_received, forecast.counts[ FEEDBACK_DELAY_TICKS ], current_queue_size_estimate,
78 | 		cumulative_delivery_forecast );
79 | 
80 | 	if ( packets_to_send > 0 ) {
81 | 	  printf( "%f: sending %d packets\n",
82 | 		  time, packets_to_send );
83 | 	  for ( int i = 0; i < packets_to_send; i++ ) {
84 | 	    queue.send( time );
85 | 	    packets_sent++;
86 | 	  }
87 | 	}
88 |       }
89 |       
90 |       if ( queue.recv( time ) ) {
91 | 	receiver->recv();
92 | 	packets_received++;
93 |       }
94 |     }
95 |   }
96 | }
97 | 


--------------------------------------------------------------------------------
/sender/controlled-delay.cc:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <vector>
 3 | #include <poll.h>
 4 | #include <assert.h>
 5 | #include <sys/types.h>
 6 | #include <unistd.h>
 7 | 
 8 | #include "delay-servo.hh"
 9 | 
10 | using namespace std;
11 | 
12 | Socket::Address get_nat_addr( const Socket & sender, const Socket::Address & dest,
13 | 			      const Socket & receiver )
14 | {
15 |   char buf[ 10 ];
16 |   for ( int i = 0; i < 10; i++ ) {
17 |     buf[ i ] = rand() % 256;
18 |   }
19 |   
20 |   string to_send( buf, 10 );
21 | 
22 |   sender.send( Socket::Packet( dest, to_send ) );
23 |   Socket::Packet received( receiver.recv() );
24 | 
25 |   if ( received.payload != to_send ) {
26 |     fprintf( stderr, "Bad packet received while getting NAT addresses.\n" );
27 |     exit( 1 );
28 |   }
29 | 
30 |   return received.addr;
31 | }
32 | 
33 | double hread( uint64_t in )
34 | {
35 |   return (double) in / 1.e9;
36 | }
37 | 
38 | int main( void )
39 | {
40 |   /* Create and bind Ethernet socket */
41 |   Socket ethernet_socket;
42 |  #ifdef EMULATE
43 |   Socket::Address ethernet_address( "127.0.0.1", 9000 );
44 |   ethernet_socket.bind( ethernet_address );
45 |   ethernet_socket.bind_to_device( "lo" );
46 |  #else 
47 |   Socket::Address ethernet_address( "128.30.76.255", 9000 );
48 |   ethernet_socket.bind( ethernet_address );
49 |   ethernet_socket.bind_to_device( "eth0" );
50 |  #endif
51 | 
52 |   /* Create and bind LTE socket */
53 |   Socket lte_socket;
54 | 
55 |  #ifdef EMULATE
56 |   lte_socket.bind( Socket::Address( "127.0.0.1", 9001 ) );
57 |   lte_socket.bind_to_device( "lo" );
58 |  #else 
59 |   lte_socket.bind( Socket::Address( "10.100.1.1", 9001 ) );
60 |   lte_socket.bind_to_device( "usb0" );
61 |  #endif
62 | 
63 |   /* Figure out the NAT addresses of each of the three LTE sockets */
64 |   Socket::Address target( get_nat_addr( lte_socket, ethernet_address, ethernet_socket ) );
65 |   fprintf( stderr, "LTE = %s\n", target.str().c_str() );
66 | 
67 |   DelayServo downlink( "DOWN", ethernet_socket, target, lte_socket );
68 |   DelayServo uplink( "UP  ", lte_socket, ethernet_address, ethernet_socket );
69 | 
70 |   while ( 1 ) {
71 |     fflush( NULL );
72 | 
73 |     /* possibly send packet */
74 |     downlink.tick();
75 |     uplink.tick();
76 |     
77 |     /* wait for incoming packet OR expiry of timer */
78 |     struct pollfd poll_fds[ 2 ];
79 |     poll_fds[ 0 ].fd = downlink.fd();
80 |     poll_fds[ 0 ].events = POLLIN;
81 |     poll_fds[ 1 ].fd = uplink.fd();
82 |     poll_fds[ 1 ].events = POLLIN;
83 | 
84 |     struct timespec timeout;
85 |     uint64_t next_transmission_delay = std::min( uplink.wait_time_ns(), downlink.wait_time_ns() );
86 |     timeout.tv_sec = next_transmission_delay / 1000000000;
87 |     timeout.tv_nsec = next_transmission_delay % 1000000000;
88 |     ppoll( poll_fds, 2, &timeout, NULL );
89 | 
90 |     if ( poll_fds[ 0 ].revents & POLLIN ) {
91 |       downlink.recv();
92 |     }
93 | 
94 |     if ( poll_fds[ 1 ].revents & POLLIN ) {
95 |       uplink.recv();
96 |     }
97 |   }
98 | }
99 | 


--------------------------------------------------------------------------------
/donat:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl -w
 2 | 
 3 | use strict;
 4 | 
 5 | my @script = ( q[iptables -t nat -F],
 6 | 	       q[iptables -F],
 7 | 	       q[iptables -t nat -A POSTROUTING -o rmnet0 -j MASQUERADE],
 8 | 	       q[iptables -t nat -A POSTROUTING -o rmnet1 -j MASQUERADE],
 9 | 	       q[iptables -t nat -A POSTROUTING -o rmnet2 -j MASQUERADE],
10 | 	       q[iptables -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT -i rmnet0 -o rndis0],
11 | 	       q[iptables -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT -i rmnet1 -o rndis0],
12 | 	       q[iptables -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT -i rmnet2 -o rndis0],
13 | 	       q[iptables -A FORWARD -j ACCEPT -o rmnet0 -i rndis0],
14 | 	       q[iptables -A FORWARD -j ACCEPT -o rmnet1 -i rndis0],
15 | 	       q[iptables -A FORWARD -j ACCEPT -o rmnet2 -i rndis0],
16 | 	       q[ifconfig rndis0 10.100.DEVICENUM.2 netmask 255.255.255.0 up],
17 | 	       q[echo 1 > /proc/sys/net/ipv4/ip_forward] );
18 | 
19 | my @devs = ( 'x', 'usb0', 'usb1', 'usb2' );
20 | 
21 | system( "echo 0 | sudo tee /proc/sys/net/ipv4/conf/all/rp_filter" );
22 | system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/all/accept_local" );
23 | system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/all/log_martians" );
24 | system( "echo 0 | sudo tee /proc/sys/net/ipv4/conf/eth0/rp_filter" );
25 | system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/eth0/accept_local" );
26 | system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/eth0/log_martians" );
27 | system( "echo 0 | sudo tee /proc/sys/net/ipv4/conf/default/rp_filter" );
28 | system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/default/accept_local" );
29 | system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/default/log_martians" );
30 | 
31 | for my $device ( qw[A B] ) {
32 |   my ( $num ) = $device =~ tr{ABC}{123}r;
33 |   my $dev = $devs[ $num ];
34 | 
35 |   my $linemod = "setprop sys.usb.config rndis,adb";
36 |   $linemod =~ s{DEVICENUM}{$num}g;
37 |   my $str = qq{./runon $device shell su -c "$linemod"};
38 |   print "$str\n";
39 |   system( $str );
40 |   print "Sleeping 3 seconds for rndis change to take effect and adb to reboot \n";
41 |   system("sleep 3");
42 |   print ("Stop network manager to prevent autoconf \n");
43 |   system( "sudo service network-manager stop" );
44 |   for my $line ( @script ) {
45 |     my $linemod = $line;
46 |     $linemod =~ s{DEVICENUM}{$num}g;
47 |     my $str = qq{./runon $device shell su -c "$linemod"};
48 |     print "$str\n";
49 |     system( $str );
50 |   }
51 |   system( "sudo ifconfig $dev 10.100.$num.1 netmask 255.255.255.0" );
52 |   system( "sudo route del -net default gw 10.100.$num.2 metric 2" );
53 |   system( "sudo route add -net default gw 10.100.$num.2 metric 2" );
54 |   system( "echo 0 | sudo tee /proc/sys/net/ipv4/conf/$dev/rp_filter" );
55 |   system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/$dev/accept_local" );
56 |   system( "ping -c3 10.100.$num.2" );
57 |   system( "ping -c3 -I$dev 8.8.8.8" );
58 | }
59 | 
60 | # A: 8a:71:5f:ef:c7:5e
61 | # B: 0a:8d:31:bb:7c:96
62 | # C: 6a:f6:8e:83:a7:7e
63 | 


--------------------------------------------------------------------------------
/sender/packetsocket.cc:
--------------------------------------------------------------------------------
  1 | #include <sys/socket.h>
  2 | #include <netpacket/packet.h>
  3 | #include <net/ethernet.h>
  4 | #include <sys/ioctl.h>
  5 | #include <net/if.h>
  6 | #include <sys/types.h>
  7 | #include <string.h>
  8 | #include <arpa/inet.h>
  9 | #include <assert.h>
 10 | 
 11 | #include "packetsocket.hh"
 12 | 
 13 | using namespace std;
 14 | 
 15 | int PacketSocket::get_index( const std::string & name ) const
 16 | {
 17 |   /* Find index number from name */
 18 |   struct ifreq ifr;
 19 | 
 20 |   strncpy( ifr.ifr_name, name.c_str(), IFNAMSIZ );
 21 |   if ( ioctl( sock, SIOCGIFINDEX, &ifr ) < 0 ) {
 22 |     perror( "ioctl" );
 23 |     exit( 1 );
 24 |   }
 25 | 
 26 |   fprintf( stderr, "# Interface %s has index %d\n", name.c_str(), ifr.ifr_ifindex );
 27 |   
 28 |   return ifr.ifr_ifindex;
 29 | }
 30 | 
 31 | PacketSocket::PacketSocket( const std::string & s_interface )
 32 |   : sock( socket( AF_PACKET, SOCK_RAW, htons( ETH_P_ALL ) ) )
 33 | {
 34 |   /* create packet socket */
 35 | 
 36 |   if ( sock < 0 ) {
 37 |     perror( "socket" );
 38 |     exit( 1 );
 39 |   }
 40 | 
 41 |   /* Get interface index */
 42 |   int index = get_index( s_interface );
 43 | 
 44 |   /* Bind packet socket to interface */
 45 |   struct sockaddr_ll sll;
 46 |   sll.sll_family = AF_PACKET;
 47 |   sll.sll_protocol = htons( ETH_P_ALL );
 48 |   sll.sll_ifindex = index;
 49 | 
 50 |   if ( bind( sock, (struct sockaddr *)&sll, sizeof( sll ) ) < 0 ) {
 51 |     perror( "bind" );
 52 |     exit( 1 );
 53 |   }
 54 | 
 55 |   /* Set to promiscuous mode */
 56 |   struct packet_mreq pmr;
 57 |   pmr.mr_ifindex = index;
 58 |   pmr.mr_type = PACKET_MR_PROMISC;
 59 | 
 60 |   if ( setsockopt( sock, SOL_SOCKET, PACKET_ADD_MEMBERSHIP, &pmr, sizeof( pmr ) ) < 0 ) {
 61 |     perror( "setsockopt promisc" );
 62 |     exit( 1 );
 63 |   }
 64 | }
 65 | 
 66 | vector< string > PacketSocket::recv_raw( void )
 67 | {
 68 |   vector< string > ret;
 69 | 
 70 |   const int BUFFER_SIZE = 2048;
 71 | 
 72 |   char buf[ BUFFER_SIZE ];
 73 | 
 74 |   sockaddr_ll source_address;
 75 |   socklen_t source_address_len = sizeof( source_address );
 76 | 
 77 |   ssize_t bytes_read = recvfrom( sock, buf, BUFFER_SIZE, MSG_TRUNC,
 78 | 				 reinterpret_cast<sockaddr *>( &source_address ),
 79 | 				 &source_address_len );
 80 |   if ( bytes_read < 0 ) {
 81 |     perror( "recvfrom" );
 82 |     exit( 1 );
 83 |   } else if ( bytes_read > BUFFER_SIZE ) {
 84 |     fprintf( stderr, "Received size (%ld) too long (> %d)!\n",
 85 | 	     bytes_read, BUFFER_SIZE );
 86 |     exit( 1 );
 87 |   }
 88 | 
 89 |   if ( source_address_len != 18 ) {
 90 |     fprintf( stderr, "address length = %d\n",
 91 | 	     source_address_len );
 92 |     perror( "recvfrom (unexpected address length)" );
 93 |     exit( 1 );
 94 |   }
 95 | 
 96 |   if ( source_address.sll_pkttype != PACKET_OUTGOING ) {
 97 |     ret.emplace_back( buf, bytes_read );
 98 |   }
 99 | 
100 |   return ret;
101 | }
102 | 
103 | void PacketSocket::send_raw( const std::string & input )
104 | {
105 |   ssize_t bytes_sent = send( sock, input.data(), input.size(), 0 );
106 |   if ( bytes_sent < 0 ) {
107 |     perror( "send" );
108 |     exit( 1 );
109 |   }
110 | }
111 | 
112 | 
113 | 


--------------------------------------------------------------------------------
/sender/saturatr.cc:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <vector>
  3 | #include <poll.h>
  4 | #include <assert.h>
  5 | #include <sys/types.h>
  6 | #include <unistd.h>
  7 | 
  8 | #include "acker.hh"
  9 | #include "saturateservo.hh"
 10 | 
 11 | using namespace std;
 12 | 
 13 | int main( int argc, char *argv[] )
 14 | {
 15 |   if ( argc != 1 && argc != 6 ) {
 16 |     fprintf( stderr, "Usage: %s [RELIABLE_IP RELIABLE_DEV TEST_IP TEST_DEV SERVER_IP]\n",
 17 | 	     argv[ 0 ]);
 18 |     exit( 1 );
 19 |   }
 20 | 
 21 |   Socket data_socket, feedback_socket;
 22 |   bool server;
 23 | 
 24 |   int sender_id = getpid();
 25 | 
 26 |   Socket::Address remote_data_address( UNKNOWN ), remote_feedback_address( UNKNOWN );
 27 | 
 28 |   uint64_t ts=Socket::timestamp();
 29 |   if ( argc == 1 ) { /* server */
 30 |     server = true;
 31 |     data_socket.bind( Socket::Address( "0.0.0.0", 9001 ) );
 32 |     feedback_socket.bind( Socket::Address( "0.0.0.0", 9002 ) );
 33 |   } else { /* client */
 34 |     server = false;
 35 |     
 36 |     const char *reliable_ip = argv[ 1 ];
 37 |     const char *reliable_dev = argv[ 2 ];
 38 | 
 39 |     const char *test_ip = argv[ 3 ];
 40 |     const char *test_dev = argv[ 4 ];
 41 | 
 42 |     const char *server_ip = argv[ 5 ];
 43 | 
 44 |     sender_id = ( (int)(ts/1e9) );
 45 | 
 46 |     data_socket.bind( Socket::Address( test_ip, 9003 ) );
 47 |     data_socket.bind_to_device( test_dev );
 48 |     remote_data_address = Socket::Address( server_ip, 9001 );
 49 | 
 50 |     feedback_socket.bind( Socket::Address( reliable_ip, 9004 ) );
 51 |     feedback_socket.bind_to_device( reliable_dev );
 52 |     remote_feedback_address = Socket::Address( server_ip, 9002 );
 53 |   }
 54 | 
 55 |   FILE* log_file;
 56 |   char log_file_name[50];
 57 |   sprintf(log_file_name,"%s-%d-%d",server ? "server" : "client",(int)(ts/1e9),sender_id);
 58 |   log_file=fopen(log_file_name,"w");
 59 | 
 60 |   SaturateServo saturatr( "OUTGOING", log_file, feedback_socket, data_socket, remote_data_address, server, sender_id );
 61 |   Acker acker( "INCOMING", log_file, data_socket, feedback_socket, remote_feedback_address, server, sender_id );
 62 | 
 63 |   saturatr.set_acker( &acker );
 64 |   acker.set_saturatr( &saturatr );
 65 | 
 66 |   while ( 1 ) {
 67 |     fflush( NULL );
 68 | 
 69 |     /* possibly send packet */
 70 |     saturatr.tick();
 71 |     acker.tick();
 72 |     
 73 |     /* wait for incoming packet OR expiry of timer */
 74 |     struct pollfd poll_fds[ 2 ];
 75 |     poll_fds[ 0 ].fd = data_socket.get_sock();
 76 |     poll_fds[ 0 ].events = POLLIN;
 77 |     poll_fds[ 1 ].fd = feedback_socket.get_sock();
 78 |     poll_fds[ 1 ].events = POLLIN;
 79 | 
 80 |     struct timespec timeout;
 81 |     uint64_t next_transmission_delay = std::min( saturatr.wait_time(), acker.wait_time() );
 82 | 
 83 |     if ( next_transmission_delay == 0 ) {
 84 |       fprintf( stderr, "ZERO %ld %ld\n", saturatr.wait_time(), acker.wait_time() );
 85 |     }
 86 | 
 87 |     timeout.tv_sec = next_transmission_delay / 1000000000;
 88 |     timeout.tv_nsec = next_transmission_delay % 1000000000;
 89 |     ppoll( poll_fds, 2, &timeout, NULL );
 90 | 
 91 |     if ( poll_fds[ 0 ].revents & POLLIN ) {
 92 |       acker.recv();
 93 |     }
 94 | 
 95 |     if ( poll_fds[ 1 ].revents & POLLIN ) {
 96 |       saturatr.recv();
 97 |     }
 98 |   }
 99 | }
100 | 


--------------------------------------------------------------------------------
/sender/buffer-setpoint.cc:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <vector>
  3 | #include <poll.h>
  4 | #include <assert.h>
  5 | #include <unistd.h>
  6 | 
  7 | #include "socket.hh"
  8 | #include "hist.hh"
  9 | 
 10 | using namespace std;
 11 | 
 12 | Socket::Address get_nat_addr( const Socket & sender, const Socket::Address & dest,
 13 | 			      const Socket & receiver )
 14 | {
 15 |   char buf[ 10 ];
 16 |   for ( int i = 0; i < 10; i++ ) {
 17 |     buf[ i ] = rand() % 256;
 18 |   }
 19 |   
 20 |   string to_send( buf, 10 );
 21 | 
 22 |   sender.send( Socket::Packet( dest, to_send ) );
 23 |   Socket::Packet received( receiver.recv() );
 24 | 
 25 |   if ( received.payload != to_send ) {
 26 |     fprintf( stderr, "Bad packet received while getting NAT addresses.\n" );
 27 |     exit( 1 );
 28 |   }
 29 | 
 30 |   return received.addr;
 31 | }
 32 | 
 33 | double hread( uint64_t in )
 34 | {
 35 |   return (double) in / 1.e9;
 36 | }
 37 | 
 38 | int main( void )
 39 | {
 40 |   /* Create and bind Ethernet socket */
 41 |   Socket ethernet_socket;
 42 |   Socket::Address ethernet_address( "128.30.76.255", 9000 );
 43 |   ethernet_socket.bind( ethernet_address );
 44 |   ethernet_socket.bind_to_device( "eth0" );
 45 | 
 46 |   /* Create and bind LTE socket */
 47 |   Socket lte_socket;
 48 | 
 49 |   lte_socket.bind( Socket::Address( "10.100.1.1", 9001 ) );
 50 |   lte_socket.bind_to_device( "usb0" );
 51 | 
 52 |   /* Figure out the NAT addresses of each of the three LTE sockets */
 53 |   Socket::Address target( get_nat_addr( lte_socket, ethernet_address, ethernet_socket ) );
 54 |   fprintf( stderr, "LTE = %s\n", target.str().c_str() );
 55 | 
 56 |   /* Send packets and timestamps */
 57 |   const int MAX_PACKETS_EN_ROUTE = 4800, PACKET_SIZE = 400;
 58 |   int packets_en_route = 0;
 59 |   int packets_sent = 0, packets_received = 0;
 60 | 
 61 |   const int PACKETS_TO_SEND = 100000;
 62 | 
 63 |   struct pdata {
 64 |     uint64_t seq, ts;
 65 |     int pid;
 66 |   };
 67 | 
 68 |   assert( sizeof( struct pdata ) <= (size_t) PACKET_SIZE );
 69 | 
 70 |   pid_t mypid = getpid();
 71 | 
 72 |   uint64_t last_ts = 0;
 73 | 
 74 |   Histogram interarrival_hist( 1000 * 100 ); /* 100 us */
 75 | 
 76 |   while ( packets_received < PACKETS_TO_SEND ) {
 77 |     while ( packets_en_route < MAX_PACKETS_EN_ROUTE ) {
 78 |       struct pdata outgoing;
 79 |       outgoing.seq = packets_sent++;
 80 |       outgoing.ts = Socket::timestamp();
 81 |       outgoing.pid = mypid;
 82 |       Socket::Packet pack( target, string( (char *) &outgoing, PACKET_SIZE ) );
 83 |       ethernet_socket.send( pack );
 84 |       packets_en_route++;
 85 |     }
 86 | 
 87 |     /* Receive packet */
 88 |     Socket::Packet pack( lte_socket.recv() );
 89 |     struct pdata *contents = (struct pdata *) pack.payload.data();
 90 |     if ( contents->pid == mypid ) {
 91 |       //      uint64_t e2e_delay = pack.timestamp - contents->ts;
 92 |       uint64_t inter_delay = 0;
 93 | 
 94 |       if ( last_ts > 0 ) {
 95 | 	inter_delay = pack.timestamp - last_ts;
 96 | 	interarrival_hist.record( inter_delay );
 97 |       }
 98 | 
 99 |       if ( last_ts / 1000000000 != pack.timestamp / 1000000000 ) {
100 | 	fprintf( stderr, "Status: %d packets sent, %d received (%.2f%%)\n", packets_sent,
101 | 		 packets_received,
102 | 		 (double) packets_received * 100.0 / (double) packets_sent );	
103 |       }
104 | 
105 |       last_ts = pack.timestamp;
106 | 
107 |       packets_en_route--;
108 |       packets_received++;
109 |     }
110 |   }
111 | 
112 |   interarrival_hist.print();
113 | }
114 | 


--------------------------------------------------------------------------------
/sender/delay-servo.cc:
--------------------------------------------------------------------------------
 1 | #include <sys/types.h>
 2 | #include <unistd.h>
 3 | #include <stdlib.h>
 4 | #include <assert.h>
 5 | 
 6 | #include "delay-servo.hh"
 7 | 
 8 | DelayServo::DelayServo( const std::string & s_name, const Socket & s_sender,
 9 | 			const Socket::Address & s_target, const Socket & s_receiver )
10 |   : _name( s_name ), 
11 |     _sender( s_sender ),
12 |     _target( s_target ),
13 |     _receiver( s_receiver ),
14 |     _rate_estimator( 50.0, 1000 ),
15 |     _packets_sent( 0 ),
16 |     _packets_received( 0 ),
17 |     _unique_id( (int) getpid() ^ rand() ),
18 |     _next_transmission( Socket::timestamp() ),
19 |     _last_transmission( _next_transmission ),
20 |     _hist()
21 | {
22 | }
23 | 
24 | int DelayServo::wait_time_ns( void ) const
25 | {
26 |   return _next_transmission - Socket::timestamp();
27 | }
28 | 
29 | void DelayServo::recv( void )
30 | {
31 |   Socket::Packet incoming( _receiver.recv() );
32 |   Payload *contents = (Payload *) incoming.payload.data();
33 |   contents->recv_timestamp = incoming.timestamp;
34 | 
35 |   if ( contents->sender_id == _unique_id ) {
36 |     _rate_estimator.add_packet( *contents );
37 |     _hist.packet_received( *contents );
38 |     _packets_received++;
39 |     double loss_rate = (double) _hist.num_lost() / (double) _packets_sent;
40 |     printf( "%s seq = %d delay = %f recvrate = %f queueest = %f outstanding = %d Mbps = %f lost = %.5f%% arrivemilli = %ld\n",
41 | 	    _name.c_str(),
42 | 	    contents->sequence_number,
43 | 	    (double) (contents->recv_timestamp - contents->sent_timestamp) / 1.0e9,
44 | 	    _rate_estimator.get_rate(),
45 | 	    (double) _hist.num_outstanding() / _rate_estimator.get_rate(),
46 | 	    _hist.num_outstanding(),
47 | 	    _rate_estimator.get_rate() * PACKET_SIZE * 8.0 / 1.0e6,
48 | 	    loss_rate * 100,
49 | 	    contents->recv_timestamp / 1000000 );
50 |   }
51 | }
52 | 
53 | void DelayServo::tick( void )
54 | {
55 |   uint64_t now = Socket::timestamp();
56 | 
57 |   /* schedule next packet transmission */
58 | 
59 |   /* Q: When will queue hit our target? */
60 |   /* Step 1: Estimate queue size in ms */
61 | 
62 |   double queue_duration_estimate = (double) _hist.num_outstanding() / _rate_estimator.get_rate(); /* in seconds */
63 | 
64 |   /* Step 2: At what rate, will queue duration hit the target exactly STEERING_TIME seconds in the future? */
65 | 
66 |   /* We want to account for this much difference over the next STEERING_TIME seconds */
67 |   double queue_duration_difference = QUEUE_DURATION_TARGET - queue_duration_estimate;
68 | 
69 |   double outgoing_packets_needed = queue_duration_difference * _rate_estimator.get_rate() + STEERING_TIME * _rate_estimator.get_rate();
70 |   double outgoing_packet_rate = std::max( MINIMUM_RATE,
71 | 					  outgoing_packets_needed / STEERING_TIME ); /* packets per second */
72 | 
73 |   uint64_t interpacket_delay = 1.e9 / outgoing_packet_rate;
74 | 
75 |   assert( outgoing_packet_rate > 0 );
76 | 
77 |   _next_transmission = _last_transmission + interpacket_delay;
78 | 
79 |   if ( _next_transmission <= now ) {
80 |     /* Send packet */
81 |     Payload outgoing;
82 |     outgoing.sequence_number = _packets_sent++;
83 |     outgoing.sent_timestamp = Socket::timestamp();
84 |     outgoing.sender_id = _unique_id;
85 |     _sender.send( Socket::Packet( _target, outgoing.str( PACKET_SIZE ) ) );
86 |     _hist.packet_sent( outgoing );
87 |     _last_transmission = outgoing.sent_timestamp;
88 |   }
89 | 
90 |   /* schedule next transmission */
91 |   _next_transmission = _last_transmission + interpacket_delay;
92 | }
93 | 


--------------------------------------------------------------------------------
/sender/socket.cc:
--------------------------------------------------------------------------------
  1 | #include <sys/socket.h>
  2 | #include <netinet/in.h>
  3 | #include <arpa/inet.h>
  4 | #include <sys/types.h>
  5 | #include <stdio.h>
  6 | #include <assert.h>
  7 | 
  8 | #include "socket.hh"
  9 | 
 10 | using namespace std;
 11 | 
 12 | Socket::Address::Address( string ip, uint16_t port )
 13 |   : _sockaddr()
 14 | {
 15 |   _sockaddr.sin_family = AF_INET;
 16 |   _sockaddr.sin_port = htons( port );
 17 | 
 18 |   if ( inet_aton( ip.c_str(), &_sockaddr.sin_addr ) == 0 ) {
 19 |     fprintf( stderr, "Invalid IP address (%s)\n", ip.c_str() );
 20 |     exit( 1 );
 21 |   }
 22 | }
 23 | 
 24 | std::string Socket::Address::ip( void ) const
 25 | {
 26 |   char tmp[ 64 ];
 27 |   snprintf( tmp, 64, "%s", inet_ntoa( _sockaddr.sin_addr ) );
 28 |   return string( tmp );
 29 | }
 30 | 
 31 | const string Socket::Address::str( void ) const
 32 | {
 33 |   char tmp[ 64 ];
 34 |   snprintf( tmp, 64, "%s:%d", inet_ntoa( _sockaddr.sin_addr ), ntohs( _sockaddr.sin_port ) );
 35 |   return string( tmp );
 36 | }
 37 | 
 38 | Socket::Socket()
 39 |   : sock( socket( AF_INET, SOCK_DGRAM, 0 ) )
 40 | {
 41 |   if ( sock < 0 ) {
 42 |     perror( "socket" );
 43 |     exit( 1 );
 44 |   }
 45 | 
 46 |   /* Ask for timestamps */
 47 |   int ts_opt = 1;
 48 |   if ( setsockopt( sock, SOL_SOCKET, SO_TIMESTAMPNS, &ts_opt, sizeof( ts_opt ) )
 49 |        < 0 ) {
 50 |     perror( "setsockopt" );
 51 |     exit( 1 );
 52 |   }
 53 | }
 54 | 
 55 | void Socket::connect( const Socket::Address & addr ) const
 56 | {
 57 |   if ( ::connect( sock, (sockaddr *)&addr.sockaddr(), sizeof( addr.sockaddr() ) ) < 0 ) {
 58 |     fprintf( stderr, "Error connecting to %s\n", addr.str().c_str() );
 59 |     perror( "bind" );
 60 |     exit( 1 );
 61 |   }
 62 | }
 63 | 
 64 | void Socket::bind( const Socket::Address & addr ) const
 65 | {
 66 |   if ( ::bind( sock, (sockaddr *)&addr.sockaddr(), sizeof( addr.sockaddr() ) ) < 0 ) {
 67 |     fprintf( stderr, "Error binding to %s\n", addr.str().c_str() );
 68 |     perror( "bind" );
 69 |     exit( 1 );
 70 |   }
 71 | }
 72 | 
 73 | void Socket::send( const Socket::Packet & packet ) const
 74 | {
 75 |   ssize_t bytes_sent = sendto( sock, packet.payload.data(), packet.payload.size(), 0,
 76 | 			       (sockaddr *)&packet.addr.sockaddr(), sizeof( packet.addr.sockaddr() ) );
 77 |   if ( bytes_sent != static_cast<ssize_t>( packet.payload.size() ) ) {
 78 |     perror( "sendto" );
 79 |   }
 80 | }
 81 | 
 82 | void Socket::bind_to_device( const std::string & name ) const
 83 | {
 84 |   if ( setsockopt( sock, SOL_SOCKET, SO_BINDTODEVICE, name.c_str(), name.size() ) < 0 ) {
 85 |     fprintf( stderr, "Error binding to %s\n", name.c_str() );
 86 |     perror( "setsockopt SO_BINDTODEVICE" );
 87 |     exit( 1 );
 88 |   }
 89 | }
 90 | 
 91 | Socket::Packet Socket::recv( void ) const
 92 | {
 93 |   /* data structure to receive timestamp, source address, and payload */
 94 |   struct sockaddr_in remote_addr;
 95 |   struct msghdr header;
 96 |   struct iovec msg_iovec;
 97 | 
 98 |   const int BUF_SIZE = 2048;
 99 | 
100 |   char msg_payload[ BUF_SIZE ];
101 |   char msg_control[ BUF_SIZE ];
102 |   header.msg_name = &remote_addr;
103 |   header.msg_namelen = sizeof( remote_addr );
104 |   msg_iovec.iov_base = msg_payload;
105 |   msg_iovec.iov_len = BUF_SIZE;
106 |   header.msg_iov = &msg_iovec;
107 |   header.msg_iovlen = 1;
108 |   header.msg_control = msg_control;
109 |   header.msg_controllen = BUF_SIZE;
110 |   header.msg_flags = 0;
111 | 
112 |   ssize_t received_len = recvmsg( sock, &header, 0 );
113 |   if ( received_len < 0 ) {
114 |     perror( "recvmsg" );
115 |     exit( 1 );
116 |   }
117 | 
118 |   if ( received_len > BUF_SIZE ) {
119 |     fprintf( stderr, "Received oversize datagram (size %d) and limit is %d\n",
120 | 	     static_cast<int>( received_len ), BUF_SIZE );
121 |     exit( 1 );
122 |   }
123 | 
124 |   /* verify presence of timestamp */
125 |   struct cmsghdr *ts_hdr = CMSG_FIRSTHDR( &header );
126 |   assert( ts_hdr );
127 |   assert( ts_hdr->cmsg_level == SOL_SOCKET );
128 |   assert( ts_hdr->cmsg_type == SO_TIMESTAMPNS );
129 | 
130 |   return Socket::Packet( Socket::Address( remote_addr ),
131 | 			 string( msg_payload, received_len ),
132 | 			 *(struct timespec *)CMSG_DATA( ts_hdr ) );
133 | }
134 | 
135 | uint64_t Socket::timestamp( void )
136 | {
137 |   struct timespec ts;
138 | 
139 |   if ( clock_gettime( CLOCK_REALTIME, &ts ) < 0 ) {
140 |     perror( "clock_gettime" );
141 |     exit( 1 );
142 |   }
143 | 
144 |   uint64_t ret = ts.tv_sec * 1000000000 + ts.tv_nsec;
145 |   return ret;
146 | }
147 | 


--------------------------------------------------------------------------------
/infer/process.cc:
--------------------------------------------------------------------------------
  1 | #include <assert.h>
  2 | #include <algorithm>
  3 | #include <boost/math/distributions/normal.hpp>
  4 | 
  5 | #include "process.hh"
  6 | #include "mypoisson.hh"
  7 | 
  8 | using namespace boost::math;
  9 | 
 10 | Process::Process( const double maximum_rate, const double s_brownian_motion_rate, const double s_outage_escape_rate, const int bins )
 11 |   : _probability_mass_function( bins, maximum_rate, 0 ),
 12 |     _gaussian( maximum_rate, bins * 2 ),
 13 |     _brownian_motion_rate( s_brownian_motion_rate ),
 14 |     _outage_escape_rate( s_outage_escape_rate ),
 15 |     _normalized( false )
 16 | {
 17 |   normalize();
 18 | }
 19 | 
 20 | void Process::observe( const double time, const int counts )
 21 | {
 22 |   _normalized = false;
 23 | 
 24 |   /* multiply by likelihood function */
 25 |   _probability_mass_function.for_each( [&]
 26 | 				       ( const double midpoint, double & value, const unsigned int index )
 27 | 				       {
 28 | 					 value *= poissonpdf( midpoint * time, counts );
 29 | 				       } );
 30 | }
 31 | 
 32 | void Process::normalize( void )
 33 | {
 34 |   if ( _normalized ) {
 35 |     return;
 36 |   }
 37 | 
 38 |   double sum( 0 );
 39 | 
 40 |   /* find the total */
 41 |   _probability_mass_function.for_each( [&sum]
 42 | 				       ( const double, const double & value, const unsigned int index )
 43 | 				       {
 44 | 					 sum += value;
 45 | 				       } );
 46 | 
 47 |   /* normalize */
 48 |   _probability_mass_function.for_each( [&sum]
 49 | 				       ( const double, double & value, const unsigned int index )
 50 | 				       {
 51 | 					 value /= sum;
 52 | 				       } );
 53 | 
 54 |   _normalized = true;
 55 | }
 56 | 
 57 | void Process::evolve( const double time )
 58 | {
 59 |   _normalized = false;
 60 | 
 61 |   /* initialize brownian motion */
 62 |   double stddev = _brownian_motion_rate * sqrt( time );
 63 |   _gaussian.calculate( stddev );
 64 | 
 65 |   /* initialize new pmf */
 66 |   SampledFunction new_pmf( _probability_mass_function );
 67 |   new_pmf.for_each( [] ( const double, double & value, const unsigned int index ) { value = 0; } );
 68 | 
 69 |   const double zero_escape_probability = 1 - poissonpdf( time * _outage_escape_rate, 0 );
 70 | 
 71 |   _probability_mass_function.for_each( [&]
 72 | 				       ( const double old_rate, const double & old_prob, const unsigned int old_index )
 73 | 				       {
 74 | 					 new_pmf.for_range( old_rate - 5 * stddev,
 75 | 							    old_rate + 5 * stddev,
 76 | 							    [&]
 77 | 							    ( const double new_rate, double & new_prob, const unsigned int new_index )
 78 | 							    {
 79 | 							      double zfactor = 1.0;
 80 | 							      
 81 | 							      if ( old_index == 0 ) {
 82 | 								zfactor = ( new_index != 0 ) ? zero_escape_probability : (1 - zero_escape_probability);
 83 | 							      }
 84 | 							      
 85 | 							      new_prob += zfactor * old_prob
 86 | 								* ( _gaussian.cdf( new_pmf.sample_ceil( new_rate ) - old_rate )
 87 | 								    - _gaussian.cdf( new_pmf.sample_floor( new_rate ) - old_rate ) );
 88 | 							    } );
 89 | 				       } );
 90 |   
 91 |   _probability_mass_function = new_pmf;
 92 | }
 93 | 
 94 | Process::GaussianCache::GaussianCache( const double maximum_rate, const int bins )
 95 |   : _cdf( bins, maximum_rate, -maximum_rate ),
 96 |     _stddev( -1 )
 97 | {}
 98 | 
 99 | void Process::GaussianCache::calculate( const double s_stddev )
100 | {
101 |   if ( s_stddev == _stddev ) {
102 |     return;
103 |   }
104 | 
105 |   _stddev = s_stddev;
106 |   normal diffdist( 0, _stddev );
107 | 
108 |   _cdf.for_each( [&] ( const double x, double & value, const unsigned int index ) { value = boost::math::cdf( diffdist, x ); } );
109 | }
110 | 
111 | void Process::set_certain( const double rate )
112 | {
113 |   _normalized = false;
114 | 
115 |   unsigned int index_to_hit = _probability_mass_function.index( rate );
116 | 
117 |   _probability_mass_function.for_each( [&] ( const double midpoint,
118 | 					     double & value,
119 | 					     const unsigned int index )
120 | 				       {
121 | 					 if ( index == index_to_hit ) {
122 | 					   value = 1.0;
123 | 					 } else {
124 | 					   value = 0.0;
125 | 					 }
126 | 				       } );
127 | 
128 |   normalize();
129 | 
130 |   assert( _probability_mass_function[ rate ] == 1.0 );
131 | }
132 | 
133 | Process & Process::operator=( const Process & other )
134 | {
135 |   _probability_mass_function = other._probability_mass_function;
136 |   _gaussian = other._gaussian;
137 |   _normalized = other._normalized;
138 |   *( const_cast< double * >( &_brownian_motion_rate ) ) = other._brownian_motion_rate;
139 | 
140 |   return *this;
141 | }
142 | 
143 | double Process::count_probability( const double time, const int counts )
144 | {
145 |   double ret = 0.0;
146 | 
147 |   _probability_mass_function.for_each( [&] ( const double rate,
148 | 					     const double & rate_probability,
149 | 					     const unsigned int index )
150 | 				       {
151 | 					 ret += rate_probability * poissonpdf( rate * time, counts );
152 | 				       } );
153 | 
154 |   return ret;
155 | }
156 | 


--------------------------------------------------------------------------------
/sender/saturateservo.cc:
--------------------------------------------------------------------------------
  1 | #include <assert.h>
  2 | 
  3 | #include "saturateservo.hh"
  4 | #include "socket.hh"
  5 | #include "payload.hh"
  6 | #include "acker.hh"
  7 | 
  8 | SaturateServo::SaturateServo( const char * s_name,
  9 |                               FILE* log_file,
 10 | 			      const Socket & s_listen,
 11 | 			      const Socket & s_send,
 12 | 			      const Socket::Address & s_remote,
 13 | 			      const bool s_server,
 14 | 			      const int s_send_id )
 15 |   : _name( s_name ),
 16 |     _log_file(log_file),
 17 |     _listen( s_listen ),
 18 |     _send( s_send ),
 19 |     _remote( s_remote ),
 20 |     _server( s_server ),
 21 |     _send_id( s_send_id ),
 22 |     _acker( NULL ),
 23 |     _next_transmission_time( Socket::timestamp() ),
 24 |     _foreign_id( -1 ),
 25 |     _packets_sent( 0 ),
 26 |     _max_ack_id( -1 ),
 27 |     _window( LOWER_WINDOW )
 28 | {}
 29 | 
 30 | void SaturateServo::recv( void )
 31 | {
 32 |   /* get the ack packet */
 33 |   Socket::Packet incoming( _listen.recv() );
 34 |   SatPayload *contents = (SatPayload *) incoming.payload.data();
 35 |   contents->recv_timestamp = incoming.timestamp;
 36 | 
 37 |   if ( contents->sequence_number != -1 ) {
 38 |     /* not an ack */
 39 |     printf( "MARTIAN!\n" );
 40 |     return;
 41 |   }
 42 | 
 43 |   /* possibly roam */
 44 |   if ( _server ) {
 45 |     if ( _acker ) {
 46 |       if ( (contents->sender_id > _foreign_id) && (contents->ack_number == -1) ) {
 47 | 	_foreign_id = contents->sender_id;
 48 | 	_acker->set_remote( incoming.addr );
 49 |       }
 50 |     }
 51 |   }
 52 | 
 53 |   /* process the ack */
 54 |   if ( contents->sender_id != _send_id ) {
 55 |     /* not from us */
 56 |     return;
 57 |   } else {
 58 |     if ( contents->ack_number > _max_ack_id ) {
 59 |       _max_ack_id = contents->ack_number;
 60 |     }
 61 | 
 62 |     /*    printf( "%s pid=%d ACK RECEIVED senderid=%d seq=%d, send_time=%ld, recv_time=%ld\n",
 63 | 	  _name.c_str(), getpid(), contents->sender_id, contents->sequence_number, contents->sent_timestamp, contents->recv_timestamp ); */
 64 | 
 65 |     int64_t rtt_ns = contents->recv_timestamp - contents->sent_timestamp;
 66 |     double rtt = rtt_ns / 1.e9;
 67 | 
 68 |     fprintf( _log_file, "%s ACK RECEIVED senderid=%d, seq=%d, send_time=%ld,  recv_time=%ld, rtt=%.4f, %d => ",
 69 |        _name.c_str(),_server ? _foreign_id : contents->sender_id , contents->ack_number, contents->sent_timestamp, contents->recv_timestamp, (double)rtt,  _window );
 70 |     /* increase-decrease rules */
 71 | 
 72 |     if ( (rtt < LOWER_RTT) && (_window < UPPER_WINDOW) ) {
 73 |       _window++;
 74 |     }
 75 | 
 76 |     if ( (rtt > UPPER_RTT) && (_window > LOWER_WINDOW + 10) ) {
 77 |       _window -= 20;
 78 |     }
 79 | 
 80 |     fprintf( _log_file, "%d\n", _window );
 81 |   }
 82 | }
 83 | 
 84 | uint64_t SaturateServo::wait_time( void ) const
 85 | {
 86 |   int num_outstanding = _packets_sent - _max_ack_id - 1;
 87 | 
 88 |   if ( _remote == UNKNOWN ) {
 89 |     return 1000000000;
 90 |   }
 91 | 
 92 |   if ( num_outstanding < _window ) {
 93 |     return 0;
 94 |   } else {
 95 |     int diff = _next_transmission_time - Socket::timestamp();
 96 |     if ( diff < 0 ) {
 97 |       diff = 0;
 98 |     }
 99 |     return diff;
100 |   }
101 | }
102 | 
103 | void SaturateServo::tick( void )
104 | {
105 |   if ( _remote == UNKNOWN ) {
106 |     return;
107 |   }
108 | 
109 |   int num_outstanding = _packets_sent - _max_ack_id - 1;
110 | 
111 |   if ( num_outstanding < _window ) {
112 |     /* send more packets */
113 |     int amount_to_send = _window - num_outstanding;
114 |     for ( int i = 0; i < amount_to_send; i++ ) {
115 |       SatPayload outgoing;
116 |       outgoing.sequence_number = _packets_sent;
117 |       outgoing.ack_number = -1;
118 |       outgoing.sent_timestamp = Socket::timestamp();
119 |       outgoing.recv_timestamp = 0;
120 |       outgoing.sender_id = _send_id;
121 | 
122 |       _send.send( Socket::Packet( _remote, outgoing.str( 1400 ) ) );
123 | 
124 |       /*
125 |       printf( "%s pid=%d DATA SENT %d senderid=%d seq=%d, send_time=%ld, recv_time=%ld\n",
126 |       _name.c_str(), getpid(), amount_to_send, outgoing.sender_id, outgoing.sequence_number, outgoing.sent_timestamp, outgoing.recv_timestamp ); */
127 | 
128 |       _packets_sent++;
129 |     }
130 | 
131 |     _next_transmission_time = Socket::timestamp() + _transmission_interval;
132 |   }
133 | 
134 |   if ( _next_transmission_time < Socket::timestamp() ) {
135 |     SatPayload outgoing;
136 |     outgoing.sequence_number = _packets_sent;
137 |     outgoing.ack_number = -1;
138 |     outgoing.sent_timestamp = Socket::timestamp();
139 |     outgoing.recv_timestamp = 0;
140 |     outgoing.sender_id = _send_id;
141 | 
142 |     _send.send( Socket::Packet( _remote, outgoing.str( 1400 ) ) );
143 | 
144 |     /*
145 |     printf( "%s pid=%d DATA SENT senderid=%d seq=%d, send_time=%ld, recv_time=%ld\n",
146 |     _name.c_str(), getpid(), outgoing.sender_id, outgoing.sequence_number, outgoing.sent_timestamp, outgoing.recv_timestamp ); */
147 | 
148 |     _packets_sent++;
149 | 
150 |     _next_transmission_time = Socket::timestamp() + _transmission_interval;
151 |   }
152 | }
153 | 


--------------------------------------------------------------------------------
/infer/processforecaster.cc:
--------------------------------------------------------------------------------
  1 | #include <assert.h>
  2 | #include <stdio.h>
  3 | 
  4 | #include "processforecaster.hh"
  5 | 
  6 | std::vector< Process > ProcessForecastTick::make_components( const Process & example )
  7 | {
  8 |   std::vector< Process > components;
  9 | 
 10 |   example.pmf().for_each( [&] ( const double midpoint, const double & value, unsigned int index )
 11 | 			  {
 12 | 			    Process component( example );
 13 | 			    component.set_certain( midpoint );
 14 | 			    assert( components.size() == index );
 15 | 			    assert( example.pmf().index( midpoint ) == index );
 16 | 			    components.push_back( component );
 17 | 			  } );
 18 |   return components;
 19 | }
 20 | 
 21 | ProcessForecastTick::ProcessForecastTick( const double tick_time,
 22 | 					  const Process & example,
 23 | 					  const unsigned int upper_limit )
 24 |   : _count_probability()
 25 | {
 26 |   /* step 1: make the component processes */
 27 |   std::vector< Process > components( make_components( example ) );
 28 | 
 29 |   /* step 2: for each process component, find the distribution of arrivals */
 30 |   for ( auto it = components.begin(); it != components.end(); it++ ) {
 31 |     std::vector< double > this_count_probability;
 32 |     double total = 0.0;
 33 |     for ( unsigned int i = 0; i < upper_limit; i++ ) {
 34 |       const double prob = it->count_probability( tick_time, i );
 35 |       this_count_probability.push_back( prob );
 36 |       total += prob;
 37 |     }
 38 |     assert( total < 1.0 + (1e-10) );
 39 |     this_count_probability.push_back( 1.0 - total );
 40 | 
 41 |     /* append to cache */
 42 |     _count_probability.push_back( this_count_probability );
 43 |   }
 44 | }
 45 | 
 46 | double ProcessForecastTick::probability( const Process & ensemble, unsigned int count ) const
 47 | {
 48 |   assert( ensemble.is_normalized() );
 49 |   assert( ensemble.pmf().size() == _count_probability.size() );
 50 |   assert( _count_probability.size() > 0 );
 51 | 
 52 |   assert( count < _count_probability[ 0 ].size() );
 53 | 
 54 |   double ret = 0.0;
 55 | 
 56 |   ensemble.pmf().for_each( [&] ( const double midpoint, const double & value, unsigned int index )
 57 | 			   {
 58 | 			     ret += value * _count_probability[ index ][ count ];
 59 | 			   } );
 60 | 
 61 |   assert( ret <= 1.0 );
 62 | 
 63 |   return ret;
 64 | }
 65 | 
 66 | std::vector< double > ProcessForecastInterval::convolve( const std::vector< double > & old_count_probabilities,
 67 | 							 const std::vector< double > & this_tick )
 68 | {
 69 |   std::vector< double > ret( old_count_probabilities.size() + this_tick.size() - 1 );
 70 | 
 71 |   for ( unsigned int old_count = 0; old_count < old_count_probabilities.size(); old_count++ ) {
 72 |     for ( unsigned int new_count = 0; new_count < this_tick.size(); new_count++ ) {
 73 |       ret[ old_count + new_count ] += old_count_probabilities[ old_count ] * this_tick[ new_count ];
 74 |     }
 75 |   }
 76 | 
 77 |   return ret;
 78 | }
 79 | 
 80 | ProcessForecastInterval::ProcessForecastInterval( const double tick_time,
 81 | 						  const Process & example,
 82 | 						  const unsigned int tick_upper_limit,
 83 | 						  const unsigned int num_ticks )
 84 |   : _count_probability()
 85 | {
 86 |   /* step 1: make the component processes */
 87 |   std::vector< Process > components( ProcessForecastTick::make_components( example ) );
 88 |  
 89 |   /* step 2: make the tick forecast */
 90 |   ProcessForecastTick tick_forecast( tick_time, example, tick_upper_limit );
 91 | 
 92 |   /* step 3: for each component, integrate and evolve forward */
 93 |   for ( auto it = components.begin(); it != components.end(); it++ ) {
 94 |     std::vector< double > this_component_count_probability( 1, 1.0 );
 95 |     for ( unsigned int tick = 0; tick < num_ticks; tick++ ) {
 96 |       /* collect tick forecast */
 97 |       std::vector< double > this_tick;
 98 |       for ( unsigned int i = 0; i < tick_upper_limit; i++ ) {
 99 | 	it->normalize();
100 | 	this_tick.push_back( tick_forecast.probability( *it, i ) );
101 |       }
102 | 
103 |       /* add to previous forecast */
104 |       this_component_count_probability = convolve( this_component_count_probability,
105 | 						   this_tick );
106 | 
107 |       /* evolve forward */
108 |       it->evolve( tick_time );
109 |     }
110 | 
111 |     _count_probability.push_back( this_component_count_probability );
112 |   }
113 | }
114 | 
115 | /* exact same routine as for ProcessForecastTick! */
116 | double ProcessForecastInterval::probability( const Process & ensemble, unsigned int count ) const
117 | {
118 |   assert( ensemble.is_normalized() );
119 |   assert( ensemble.pmf().size() == _count_probability.size() );
120 |   assert( _count_probability.size() > 0 );
121 | 
122 |   assert( count < _count_probability[ 0 ].size() );
123 | 
124 |   double ret = 0.0;
125 | 
126 |   ensemble.pmf().for_each( [&] ( const double midpoint, const double & value, unsigned int index )
127 | 			   {
128 | 			     ret += value * _count_probability[ index ][ count ];
129 | 			   } );
130 | 
131 |   assert( ret <= 1.0 );
132 | 
133 |   return ret;
134 | }
135 | 
136 | unsigned int ProcessForecastInterval::lower_quantile( const Process & ensemble, const double x ) const
137 | {
138 |   double sum = 0.0;
139 | 
140 |   for ( unsigned int i = 0; i < _count_probability[ 0 ].size(); i++ ) {
141 |     sum += probability( ensemble, i );
142 | 
143 |     if ( sum >= x ) {
144 |       return i;
145 |     }
146 |   }
147 | 
148 |   return _count_probability[ 0 ].size() + 1;
149 | }
150 | 


--------------------------------------------------------------------------------
/sender/select.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |     Mosh: the mobile shell
  3 |     Copyright 2012 Keith Winstein
  4 | 
  5 |     This program is free software: you can redistribute it and/or modify
  6 |     it under the terms of the GNU General Public License as published by
  7 |     the Free Software Foundation, either version 3 of the License, or
  8 |     (at your option) any later version.
  9 | 
 10 |     This program is distributed in the hope that it will be useful,
 11 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |     GNU General Public License for more details.
 14 | 
 15 |     You should have received a copy of the GNU General Public License
 16 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 |     In addition, as a special exception, the copyright holders give
 19 |     permission to link the code of portions of this program with the
 20 |     OpenSSL library under certain conditions as described in each
 21 |     individual source file, and distribute linked combinations including
 22 |     the two.
 23 | 
 24 |     You must obey the GNU General Public License in all respects for all
 25 |     of the code used other than OpenSSL. If you modify file(s) with this
 26 |     exception, you may extend this exception to your version of the
 27 |     file(s), but you are not obligated to do so. If you do not wish to do
 28 |     so, delete this exception statement from your version. If you delete
 29 |     this exception statement from all source files in the program, then
 30 |     also delete it here.
 31 | */
 32 | 
 33 | #ifndef SELECT_HPP
 34 | #define SELECT_HPP
 35 | 
 36 | #include <string.h>
 37 | #include <errno.h>
 38 | #include <signal.h>
 39 | #include <sys/select.h>
 40 | 
 41 | #include "fatal_assert.h"
 42 | 
 43 | /* Convenience wrapper for pselect(2).
 44 | 
 45 |    Any signals blocked by calling sigprocmask() outside this code will still be
 46 |    received during Select::select().  So don't do that. */
 47 | 
 48 | class Select {
 49 | public:
 50 |   static Select &get_instance( void ) {
 51 |     /* COFU may or may not be thread-safe, depending on compiler */
 52 |     static Select instance;
 53 |     return instance;
 54 |   }
 55 | 
 56 | private:
 57 |   Select()
 58 |     : max_fd( -1 )
 59 |     , got_any_signal( 0 )
 60 | 
 61 |     /* These initializations are not used; they are just
 62 |        here to appease -Weffc++. */
 63 |     , all_fds( dummy_fd_set )
 64 |     , read_fds( dummy_fd_set )
 65 |     , error_fds( dummy_fd_set )
 66 |     , empty_sigset( dummy_sigset )
 67 |   {
 68 |     FD_ZERO( &all_fds );
 69 |     FD_ZERO( &read_fds );
 70 |     FD_ZERO( &error_fds );
 71 | 
 72 |     clear_got_signal();
 73 |     fatal_assert( 0 == sigemptyset( &empty_sigset ) );
 74 |   }
 75 | 
 76 |   void clear_got_signal( void )
 77 |   {
 78 |     memset( got_signal, 0, sizeof( got_signal ) );
 79 |   }
 80 | 
 81 |   /* not implemented */
 82 |   Select( const Select & );
 83 |   Select &operator=( const Select & );
 84 | 
 85 | public:
 86 |   void add_fd( int fd )
 87 |   {
 88 |     if ( fd > max_fd ) {
 89 |       max_fd = fd;
 90 |     }
 91 |     FD_SET( fd, &all_fds );
 92 |   }
 93 | 
 94 |   void add_signal( int signum )
 95 |   {
 96 |     fatal_assert( signum >= 0 );
 97 |     fatal_assert( signum <= MAX_SIGNAL_NUMBER );
 98 | 
 99 |     /* Block the signal so we don't get it outside of pselect(). */
100 |     sigset_t to_block;
101 |     fatal_assert( 0 == sigemptyset( &to_block ) );
102 |     fatal_assert( 0 == sigaddset( &to_block, signum ) );
103 |     fatal_assert( 0 == sigprocmask( SIG_BLOCK, &to_block, NULL ) );
104 | 
105 |     /* Register a handler, which will only be called when pselect()
106 |        is interrupted by a (possibly queued) signal. */
107 |     struct sigaction sa;
108 |     sa.sa_flags = 0;
109 |     sa.sa_handler = &handle_signal;
110 |     fatal_assert( 0 == sigfillset( &sa.sa_mask ) );
111 |     fatal_assert( 0 == sigaction( signum, &sa, NULL ) );
112 |   }
113 | 
114 |   int select( int timeout )
115 |   {
116 |     memcpy( &read_fds,  &all_fds, sizeof( read_fds  ) );
117 |     memcpy( &error_fds, &all_fds, sizeof( error_fds ) );
118 |     clear_got_signal();
119 |     got_any_signal = 0;
120 | 
121 |     struct timespec ts;
122 |     struct timespec *tsp = NULL;
123 | 
124 |     if ( timeout >= 0 ) {
125 |       // timeout in milliseconds
126 |       ts.tv_sec  = timeout / 1000;
127 |       ts.tv_nsec = 1000000 * (long( timeout ) % 1000);
128 |       tsp = &ts;
129 |     }
130 |     // negative timeout means wait forever
131 | 
132 |     int ret = ::pselect( max_fd + 1, &read_fds, NULL, &error_fds, tsp, &empty_sigset );
133 | 
134 |     if ( ( ret == -1 ) && ( errno == EINTR ) ) {
135 |       /* The user should process events as usual. */
136 |       FD_ZERO( &read_fds );
137 |       FD_ZERO( &error_fds );
138 |       ret = 0;
139 |     }
140 | 
141 |     return ret;
142 |   }
143 | 
144 |   bool read( int fd )
145 | #if FD_ISSET_IS_CONST
146 |     const
147 | #endif
148 |   {
149 |     return FD_ISSET( fd, &read_fds );
150 |   }
151 | 
152 |   bool error( int fd )
153 | #if FD_ISSET_IS_CONST
154 |     const
155 | #endif
156 |   {
157 |     return FD_ISSET( fd, &error_fds );
158 |   }
159 | 
160 |   bool signal( int signum ) const
161 |   {
162 |     fatal_assert( signum >= 0 );
163 |     fatal_assert( signum <= MAX_SIGNAL_NUMBER );
164 |     return got_signal[ signum ];
165 |   }
166 | 
167 |   bool any_signal( void ) const
168 |   {
169 |     return got_any_signal;
170 |   }
171 | 
172 | private:
173 |   static const int MAX_SIGNAL_NUMBER = 64;
174 | 
175 |   static void handle_signal( int signum );
176 | 
177 |   int max_fd;
178 | 
179 |   /* We assume writes to these ints are atomic, though we also try to mask out
180 |      concurrent signal handlers. */
181 |   int got_any_signal;
182 |   int got_signal[ MAX_SIGNAL_NUMBER + 1 ];
183 | 
184 |   fd_set all_fds, read_fds, error_fds;
185 | 
186 |   sigset_t empty_sigset;
187 | 
188 |   static fd_set dummy_fd_set;
189 |   static sigset_t dummy_sigset;
190 | };
191 | 
192 | #endif
193 | 


--------------------------------------------------------------------------------
/sender/send1way.cc:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <vector>
  3 | #include <poll.h>
  4 | #include <assert.h>
  5 | 
  6 | #include "socket.hh"
  7 | 
  8 | using namespace std;
  9 | 
 10 | Socket::Address get_nat_addr( const Socket & sender, const Socket::Address & dest,
 11 | 			      const Socket & receiver )
 12 | {
 13 |   char buf[ 10 ];
 14 |   for ( int i = 0; i < 10; i++ ) {
 15 |     buf[ i ] = rand() % 256;
 16 |   }
 17 |   
 18 |   string to_send( buf, 10 );
 19 | 
 20 |   sender.send( Socket::Packet( dest, to_send ) );
 21 |   Socket::Packet received( receiver.recv() );
 22 | 
 23 |   if ( received.payload != to_send ) {
 24 |     fprintf( stderr, "Bad packet received while getting NAT addresses.\n" );
 25 |     exit( 1 );
 26 |   }
 27 | 
 28 |   return received.addr;
 29 | }
 30 | 
 31 | int main( void )
 32 | {
 33 |   /* Create and bind Ethernet socket */
 34 |   Socket ethernet_socket;
 35 |   Socket::Address ethernet_address( "128.30.76.255", 9000 );
 36 |   ethernet_socket.bind( ethernet_address );
 37 |   ethernet_socket.bind_to_device( "eth0" );
 38 | 
 39 |   /* Create and bind three LTE sockets */
 40 |   vector<Socket> lte_socket;
 41 | 
 42 |   for ( int i = 0; i < 3; i++ ) {
 43 |     lte_socket.push_back( Socket() );
 44 |   }
 45 | 
 46 |   lte_socket[ 0 ].bind( Socket::Address( "10.100.1.1", 9001 ) );
 47 |   lte_socket[ 0 ].bind_to_device( "usb0" );
 48 |   lte_socket[ 1 ].bind( Socket::Address( "10.100.2.1", 9002 ) );
 49 |   lte_socket[ 1 ].bind_to_device( "usb1" );
 50 |   lte_socket[ 2 ].bind( Socket::Address( "10.100.3.1", 9003 ) );
 51 |   lte_socket[ 2 ].bind_to_device( "usb2" );
 52 | 
 53 |   /* Figure out the NAT addresses of each of the three LTE sockets */
 54 |   vector<Socket::Address> target;
 55 |   
 56 |   for ( int i = 0; i < 3; i++ ) {
 57 |     target.push_back( get_nat_addr( lte_socket[ i ], ethernet_address, ethernet_socket ) );
 58 |     fprintf( stderr, "LTE %d = %s\n", i, target.back().str().c_str() );
 59 |   }
 60 | 
 61 |   /* Make dummy address */
 62 |   Socket::Address dummy_address( "220.181.111.147", 9004 );
 63 | 
 64 |   /* Send and get timestamps */
 65 |   const uint64_t NUM_PACKETS = 1400000;
 66 | 
 67 |   struct pollfd pollfds[ 3 ];
 68 |   for ( int i = 0; i < 3; i++ ) {
 69 |     pollfds[ i ].fd = lte_socket[ i ].get_sock();
 70 |     pollfds[ i ].events = POLLIN;
 71 |   }
 72 | 
 73 |   const int MAX_OUTSTANDING = 1000;
 74 |   vector<int> num_outstanding( 3 );
 75 | 
 76 |   struct packetstat {
 77 |     uint64_t sent_time;
 78 |     int dest;
 79 |     bool received;
 80 |   };
 81 | 
 82 |   vector<struct packetstat> packetstats( NUM_PACKETS );
 83 |   uint64_t next_unacked = 0;
 84 | 
 85 |   uint64_t packets_sent = 0;
 86 | 
 87 |   uint64_t base_time = Socket::timestamp();
 88 | 
 89 |   const uint64_t TIMEOUT = 500 * 1000 * 1000; /* 1 second */
 90 | 
 91 |   uint64_t last_time = base_time;
 92 | 
 93 |   vector<int> last_sec_count( 3 );
 94 | 
 95 |   int numextra = 0;
 96 | 
 97 |   while ( packets_sent < NUM_PACKETS ) {
 98 |     uint64_t the_time = Socket::timestamp();
 99 | 
100 |     if ( (the_time / 100000000) != (last_time / 100000000) ) {
101 |       if ( (the_time / 20000000000) != (last_time / 20000000000) ) {
102 | 	numextra = (numextra + 1) % 3;
103 | 	fprintf( stderr, "%ld FLIP %d\n", (the_time - base_time) / 10000000, numextra );
104 |       }
105 | 
106 |       last_time = the_time;
107 |       printf( "%ld %d %d %d\n", (the_time - base_time) / 100000000, last_sec_count[ 0 ], last_sec_count[ 1 ], last_sec_count[ 2 ] );
108 |       fflush( NULL );
109 |       for ( int i = 0; i < 3; i++ ) {
110 | 	last_sec_count[ i ] = 0;
111 | 	char *seq_encoded = (char *)&packets_sent;
112 | 	ethernet_socket.send( Socket::Packet( target[ i ], string( seq_encoded, 51 ) ) );
113 | 	packetstats[ packets_sent ].sent_time = Socket::timestamp();
114 | 	packetstats[ packets_sent ].dest = i;
115 | 	packets_sent++;
116 | 	num_outstanding[ i ]++;
117 |       }
118 |     }
119 | 
120 |     /* update next_unacked */
121 |     while ( packetstats[ next_unacked ].received ) {
122 |       next_unacked++;
123 |       /* possible timeout */
124 |       if ( !packetstats[ next_unacked ].received ) {
125 | 	if ( the_time - packetstats[ next_unacked ].sent_time > TIMEOUT ) {
126 | 	  fprintf( stderr, "Timeout on %ld (sent to %d)\n", next_unacked, packetstats[ next_unacked ].dest );
127 | 	  packetstats[ next_unacked ].received = true;
128 | 	  num_outstanding[ packetstats[ next_unacked ].dest ]--;
129 | 	}
130 |       }
131 |     }
132 | 
133 |     /* send packet if any receivers can be replenished */
134 |     for ( int i = 0; i < 1 + numextra; i++ ) {
135 |       if ( num_outstanding[ i ] < MAX_OUTSTANDING ) {
136 | 	int packets_to_send = MAX_OUTSTANDING - num_outstanding[ i ];
137 | 	for ( int pnum = 0; pnum < packets_to_send; pnum++ ) {
138 | 	  char *seq_encoded = (char *)&packets_sent;
139 | 	  ethernet_socket.send( Socket::Packet( target[ i ], string( seq_encoded, 51 ) ) );
140 | 	  packetstats[ packets_sent ].sent_time = Socket::timestamp();
141 | 	  packetstats[ packets_sent ].dest = i;
142 | 	  packets_sent++;
143 | 	  num_outstanding[ i ]++;
144 | 
145 | 	  if ( i == 0 ) {
146 | 	    if ( numextra < 2 ) {
147 | 	      ethernet_socket.send( Socket::Packet( dummy_address, string( seq_encoded, 51 ) ) );
148 | 	    }
149 | 	    if ( numextra < 1 ) {
150 | 	      ethernet_socket.send( Socket::Packet( dummy_address, string( seq_encoded, 51 ) ) );
151 | 	    }
152 | 	  }
153 | 	}
154 |       }
155 |     }
156 | 
157 |     /* now, poll */
158 |     if ( poll( pollfds, 3, -1 ) <= 0 ) {
159 |       perror( "poll" );
160 |       exit( 1 );
161 |     }
162 |     
163 |     for ( int i = 0; i < 3; i++ ) {
164 |       if ( pollfds[ i ].revents & POLLERR ) {
165 | 	fprintf( stderr, "Error on LTE %d\n", i );
166 | 	exit( 1 );
167 |       }
168 | 
169 |       if ( pollfds[ i ].revents & POLLIN ) {
170 | 	Socket::Packet rec = lte_socket[ i ].recv();
171 | 	//	assert ( rec.payload.size() == sizeof( packets_sent ) );
172 | 	uint64_t seq = *(uint64_t *)rec.payload.data();
173 | 	last_sec_count[ i ]++;
174 | 	assert( packetstats[ seq ].dest == i );
175 | 	if ( !packetstats[ seq ].received ) {
176 | 	  packetstats[ seq ].received = true;
177 | 	  num_outstanding[ i ]--;
178 | 	} else {
179 | 	  fprintf( stderr, "Packet %ld arrived after timeout!\n", seq );
180 | 	}
181 | 
182 | 	/*
183 | 	double sent_ts = double(packetstats[ seq ].sent_time - base_time) / 1000000.0;
184 | 	double recv_ts = double(rec.timestamp - base_time) / 1000000.0;
185 | 	*/
186 | 	//	printf( "%d %ld %.8f %.8f delay=%.8f %d oldest-queued=%ld\n", i, seq, sent_ts, recv_ts, recv_ts - sent_ts, num_outstanding[ i ], packets_sent - next_unacked );
187 |       }
188 |     }
189 |   }
190 | }
191 | 


--------------------------------------------------------------------------------
/sender/cellsim-tap.cc:
--------------------------------------------------------------------------------
  1 | #include <unistd.h>
  2 | #include <string>
  3 | #include <assert.h>
  4 | #include <list>
  5 | #include <stdio.h>
  6 | #include <queue>
  7 | #include <limits.h>
  8 | 
  9 | #include "select.h"
 10 | #include "timestamp.h"
 11 | #include "tapsocket.hh"
 12 | 
 13 | using namespace std;
 14 | 
 15 | class DelayQueue
 16 | {
 17 | private:
 18 |   class DelayedPacket
 19 |   {
 20 |   public:
 21 |     uint64_t entry_time;
 22 |     uint64_t release_time;
 23 |     string contents;
 24 | 
 25 |     DelayedPacket( uint64_t s_e, uint64_t s_r, const string & s_c )
 26 |       : entry_time( s_e ), release_time( s_r ), contents( s_c ) {}
 27 |   };
 28 | 
 29 |   class PartialPacket
 30 |   {
 31 |   public:
 32 |     int bytes_earned;
 33 |     DelayedPacket packet;
 34 |     
 35 |     PartialPacket( int s_b_e, const DelayedPacket & s_packet ) : bytes_earned( s_b_e ), packet( s_packet ) {}
 36 |   };
 37 | 
 38 |   static const int SERVICE_PACKET_SIZE = 1500;
 39 | 
 40 |   uint64_t convert_timestamp( const uint64_t absolute_timestamp ) const { return absolute_timestamp - _base_timestamp; }
 41 | 
 42 |   const string _name;
 43 | 
 44 |   std::queue< DelayedPacket > _delay;
 45 |   std::queue< DelayedPacket > _pdp;
 46 |   std::queue< PartialPacket > _limbo;
 47 | 
 48 |   std::queue< uint64_t > _schedule;
 49 | 
 50 |   std::vector< string > _delivered;
 51 | 
 52 |   const uint64_t _ms_delay;
 53 |   const float _loss_rate;
 54 | 
 55 |   uint64_t _total_bytes;
 56 |   uint64_t _used_bytes;
 57 | 
 58 |   uint64_t _queued_bytes;
 59 |   uint64_t _bin_sec;
 60 | 
 61 |   uint64_t _base_timestamp;
 62 | 
 63 |   uint32_t _packets_added;
 64 |   uint32_t _packets_dropped;
 65 |   std::string _file_name;
 66 | 
 67 |   void tick( void );
 68 | 
 69 | 
 70 | public:
 71 |   DelayQueue( const string & s_name, const uint64_t s_ms_delay, const char *filename, const uint64_t base_timestamp, const float loss_rate );
 72 | 
 73 |   int wait_time( void );
 74 |   std::vector< string > read( void );
 75 |   void write( const string & packet );
 76 |   void schedule_from_file( const uint64_t base_timestamp );
 77 | };
 78 | 
 79 | DelayQueue::DelayQueue( const string & s_name, const uint64_t s_ms_delay, const char *filename, const uint64_t base_timestamp, const float loss_rate )
 80 |   : _name( s_name ),
 81 |     _delay(),
 82 |     _pdp(),
 83 |     _limbo(),
 84 |     _schedule(),
 85 |     _delivered(),
 86 |     _ms_delay( s_ms_delay ),
 87 |     _loss_rate(loss_rate),
 88 |     _total_bytes( 0 ),
 89 |     _used_bytes( 0 ),
 90 |     _queued_bytes( 0 ),
 91 |     _bin_sec( base_timestamp / 1000 ),
 92 |     _base_timestamp( base_timestamp ),
 93 |     _packets_added ( 0 ),
 94 |     _packets_dropped( 0 ),
 95 |     _file_name( filename )
 96 | {
 97 |   /* Read schedule from file */
 98 |   schedule_from_file( base_timestamp );
 99 | 
100 |   /* Initialize seed for probabilistic loss model */
101 |   srand(0);
102 |   fprintf( stderr, "Initialized %s queue with %d services.\n", filename, (int)_schedule.size() );
103 | }
104 | 
105 | void DelayQueue::schedule_from_file( const uint64_t base_timestamp ) 
106 | {
107 |   FILE *f = fopen( _file_name.c_str(), "r" );
108 |   if ( f == NULL ) {
109 |     perror( "fopen" );
110 |     exit( 1 );
111 |   }
112 | 
113 |   /* Only populate when the schedule is empty */
114 |   assert( _schedule.empty() );
115 | 
116 |   while ( 1 ) {
117 |     uint64_t ms;
118 |     int num_matched = fscanf( f, "%lu\n", &ms );
119 |     if ( num_matched != 1 ) {
120 |       break;
121 |     }
122 | 
123 |     ms += base_timestamp;
124 | 
125 |     if ( !_schedule.empty() ) {
126 |       assert( ms >= _schedule.back() );
127 |     }
128 | 
129 |     _schedule.push( ms );
130 |   }
131 |   fclose( f );
132 | }
133 | 
134 | int DelayQueue::wait_time( void )
135 | {
136 |   int delay_wait = INT_MAX, schedule_wait = INT_MAX;
137 | 
138 |   uint64_t now = timestamp();
139 | 
140 |   tick();
141 | 
142 |   if ( !_delay.empty() ) {
143 |     delay_wait = _delay.front().release_time - now;
144 |     if ( delay_wait < 0 ) {
145 |       delay_wait = 0;
146 |     }
147 |   }
148 | 
149 |   if ( !_schedule.empty() ) {
150 |     schedule_wait = _schedule.front() - now;
151 |     assert( schedule_wait >= 0 );
152 |   }
153 | 
154 |   return std::min( delay_wait, schedule_wait );
155 | }
156 | 
157 | std::vector< string > DelayQueue::read( void )
158 | {
159 |   tick();
160 | 
161 |   std::vector< string > ret( _delivered );
162 |   _delivered.clear();
163 | 
164 |   return ret;
165 | }
166 | 
167 | void DelayQueue::write( const string & packet )
168 | {
169 |   float r= rand()/(float)RAND_MAX;
170 |   _packets_added++;
171 |   if (r < _loss_rate) {
172 |    _packets_dropped++;
173 |    fprintf(stderr, "%s , Stochastic drop of packet, _packets_added so far %d , _packets_dropped %d , drop rate %f \n",
174 |                   _name.c_str(), _packets_added,_packets_dropped , (float)_packets_dropped/(float) _packets_added );
175 |   }
176 |   else {
177 |     uint64_t now( timestamp() );
178 |     DelayedPacket p( now, now + _ms_delay, packet );
179 |     _delay.push( p );
180 |     _queued_bytes=_queued_bytes+packet.size();
181 |   }
182 | }
183 | 
184 | void DelayQueue::tick( void )
185 | {
186 |   uint64_t now = timestamp();
187 | 
188 |   /* If the schedule is empty, repopulate it */
189 |   if ( _schedule.empty() ) {
190 |     schedule_from_file( now );
191 |   }
192 | 
193 |   /* move packets from end of delay to PDP */
194 |   while ( (!_delay.empty())
195 | 	  && (_delay.front().release_time <= now) ) {
196 |     _pdp.push( _delay.front() );
197 |     _delay.pop();
198 |   }
199 | 
200 |   /* execute packet delivery schedule */
201 |   while ( (!_schedule.empty())
202 | 	  && (_schedule.front() <= now) ) {
203 |     /* grab a PDO */
204 |     _schedule.pop();
205 |     int bytes_to_play_with = SERVICE_PACKET_SIZE;
206 | 
207 |     /* execute limbo queue first */
208 |     if ( !_limbo.empty() ) {
209 |       if ( _limbo.front().bytes_earned + bytes_to_play_with >= (int)_limbo.front().packet.contents.size() ) {
210 | 	/* deliver packet */
211 | 	_total_bytes += _limbo.front().packet.contents.size();
212 | 	_used_bytes += _limbo.front().packet.contents.size();
213 | 
214 | 	fprintf( stderr, "%s %f delivery %d\n", _name.c_str(), convert_timestamp( now ) / 1000.0, int(now - _limbo.front().packet.entry_time) );
215 | 
216 | 	_delivered.push_back( _limbo.front().packet.contents );
217 | 	bytes_to_play_with -= (_limbo.front().packet.contents.size() - _limbo.front().bytes_earned);
218 | 	assert( bytes_to_play_with >= 0 );
219 | 	_limbo.pop();
220 | 	assert( _limbo.empty() );
221 |       } else {
222 | 	_limbo.front().bytes_earned += bytes_to_play_with;
223 | 	bytes_to_play_with = 0;
224 | 	assert( _limbo.front().bytes_earned < (int)_limbo.front().packet.contents.size() );
225 |       }
226 |     }
227 |     
228 |     /* execute regular queue */
229 |     while ( bytes_to_play_with > 0 ) {
230 |       assert( _limbo.empty() );
231 | 
232 |       /* will this be an underflow? */
233 |       if ( _pdp.empty() ) {
234 | 	_total_bytes += bytes_to_play_with;
235 | 	bytes_to_play_with = 0;
236 | 	/* underflow */
237 | 	//	fprintf( stderr, "%s %f underflow!\n", _name.c_str(), now / 1000.0 );
238 |       } else {
239 | 	/* dequeue whole and/or partial packet */
240 | 	DelayedPacket packet = _pdp.front();
241 | 	_pdp.pop();
242 | 	if ( bytes_to_play_with >= (int)packet.contents.size() ) {
243 | 	  /* deliver whole packet */
244 | 	  _total_bytes += packet.contents.size();
245 | 	  _used_bytes += packet.contents.size();
246 | 
247 | 	  fprintf( stderr, "%s %f delivery %d\n", _name.c_str(), convert_timestamp( now ) / 1000.0, int(now - packet.entry_time) );
248 | 
249 | 	  _delivered.push_back( packet.contents );
250 | 	  bytes_to_play_with -= packet.contents.size();
251 | 	} else {
252 | 	  /* put packet in limbo */
253 | 	  assert( _limbo.empty() );
254 | 
255 | 	  assert( bytes_to_play_with < (int)packet.contents.size() );
256 | 
257 | 	  PartialPacket limbo_packet( bytes_to_play_with, packet );
258 | 	  
259 | 	  _limbo.push( limbo_packet );
260 | 	  bytes_to_play_with -= _limbo.front().bytes_earned;
261 | 	  assert( bytes_to_play_with == 0 );
262 | 	}
263 |       }
264 |     }
265 |   }
266 | 
267 |   while ( now / 1000 > _bin_sec ) {
268 |     fprintf( stderr, "%s %ld %ld / %ld = %.1f %% %ld \n", _name.c_str(), _bin_sec - (_base_timestamp / 1000), _used_bytes, _total_bytes, 100.0 * _used_bytes / (double) _total_bytes , _queued_bytes );
269 |     _total_bytes = 0;
270 |     _used_bytes = 0;
271 |     _queued_bytes = 0;
272 |     _bin_sec++;
273 |   }
274 | }
275 | 
276 | int main( int argc, char *argv[] )
277 | {
278 |   const char *up_filename, *down_filename, *client_mac;
279 |   float loss_rate;
280 | 
281 |   assert( argc == 7 );
282 | 
283 |   up_filename = argv[ 1 ];
284 |   down_filename = argv[ 2 ];
285 |   client_mac = argv[ 3 ];
286 |   loss_rate = atof(argv[ 4 ]);
287 | 
288 |   auto internet_side_interface = argv[ 5 ];
289 |   auto client_side_interface   = argv[ 6 ];
290 | 
291 |   TapSocket internet_side( internet_side_interface, string(), string( client_mac ) );
292 |   TapSocket client_side( client_side_interface, string( client_mac ), string() );
293 | 
294 |   /* Read in schedule */
295 |   uint64_t now = timestamp();
296 |   DelayQueue uplink( "uplink", 20, up_filename, now , loss_rate );
297 |   DelayQueue downlink( "downlink", 20, down_filename, now , loss_rate);
298 | 
299 |   Select &sel = Select::get_instance();
300 |   sel.add_fd( internet_side.fd() );
301 |   sel.add_fd( client_side.fd() );
302 | 
303 |   while ( 1 ) {
304 |     int wait_time = std::min( uplink.wait_time(), downlink.wait_time() );
305 |     int active_fds = sel.select( wait_time );
306 |     if ( active_fds < 0 ) {
307 |       perror( "select" );
308 |       exit( 1 );
309 |     }
310 | 
311 |     if ( sel.read( client_side.fd() ) ) {
312 |       std::vector< string > filtered_packets( client_side.recv_raw() );
313 |       for ( auto it = filtered_packets.begin(); it != filtered_packets.end(); it++ ) {
314 | 	uplink.write( *it );
315 |       }
316 |     }
317 | 
318 |     if ( sel.read( internet_side.fd() ) ) {
319 |       std::vector< string > filtered_packets( internet_side.recv_raw() );
320 |       for ( auto it = filtered_packets.begin(); it != filtered_packets.end(); it++ ) {
321 | 	downlink.write( *it );
322 |       }
323 |     }
324 | 
325 |     std::vector< string > uplink_packets( uplink.read() );
326 |     for ( auto it = uplink_packets.begin(); it != uplink_packets.end(); it++ ) {
327 |       internet_side.send_raw( *it );
328 |     }
329 | 
330 |     std::vector< string > downlink_packets( downlink.read() );
331 |     for ( auto it = downlink_packets.begin(); it != downlink_packets.end(); it++ ) {
332 |       client_side.send_raw( *it );
333 |     }
334 |   }
335 | }
336 | 


--------------------------------------------------------------------------------
/sender/cellsim.cc:
--------------------------------------------------------------------------------
  1 | #include <unistd.h>
  2 | #include <string>
  3 | #include <assert.h>
  4 | #include <list>
  5 | #include <stdio.h>
  6 | #include <queue>
  7 | #include <limits.h>
  8 | #include <signal.h>
  9 | 
 10 | #include "select.h"
 11 | #include "timestamp.h"
 12 | #include "packetsocket.hh"
 13 | 
 14 | using namespace std;
 15 | 
 16 | bool end_loop = false;
 17 | void sigfunc(int signum)
 18 | {
 19 |     signum += 0;
 20 |     end_loop = true;
 21 | }
 22 | 
 23 | 
 24 | class DelayQueue
 25 | {
 26 | private:
 27 |   class DelayedPacket
 28 |   {
 29 |   public:
 30 |     uint64_t entry_time;
 31 |     uint64_t release_time;
 32 |     string contents;
 33 | 
 34 |     DelayedPacket( uint64_t s_e, uint64_t s_r, const string & s_c )
 35 |       : entry_time( s_e ), release_time( s_r ), contents( s_c ) {}
 36 |   };
 37 | 
 38 |   class PartialPacket
 39 |   {
 40 |   public:
 41 |     int bytes_earned;
 42 |     DelayedPacket packet;
 43 |     
 44 |     PartialPacket( int s_b_e, const DelayedPacket & s_packet ) : bytes_earned( s_b_e ), packet( s_packet ) {}
 45 |   };
 46 | 
 47 |   static const int SERVICE_PACKET_SIZE = 1514;
 48 | 
 49 |   uint64_t convert_timestamp( const uint64_t absolute_timestamp ) const { return absolute_timestamp; }
 50 | 
 51 |   FILE * _output;
 52 |   const string _name;
 53 | 
 54 |   queue< DelayedPacket > _delay;
 55 |   queue< DelayedPacket > _pdp;
 56 |   queue< PartialPacket > _limbo;
 57 | 
 58 |   queue< uint64_t > _schedule;
 59 | 
 60 |   vector< string > _delivered;
 61 | 
 62 |   const uint64_t _ms_delay;
 63 |   const float _loss_rate;
 64 | 
 65 |   uint64_t _total_bytes;
 66 |   uint64_t _used_bytes;
 67 | 
 68 |   uint64_t _queued_bytes;
 69 |   uint64_t _bin_sec;
 70 | 
 71 |   uint64_t _base_timestamp;
 72 | 
 73 |   uint32_t _packets_added;
 74 |   uint32_t _packets_dropped;
 75 |   string _file_name;
 76 | 
 77 |   bool _printing;
 78 | 
 79 |   static const int queue_limit_in_packets = 256;
 80 | 
 81 |   void tick( void );
 82 | 
 83 |   /* forbid copies */
 84 |   DelayQueue( const DelayQueue & other ) = delete;
 85 |   DelayQueue & operator=( const DelayQueue & other ) = delete;
 86 |   
 87 | public:
 88 |   DelayQueue( FILE * s_output, const string & s_name, const uint64_t s_ms_delay, const string filename, const uint64_t base_timestamp, const float loss_rate, bool s_printing = false );
 89 | 
 90 |   int wait_time( void );
 91 |   vector< string > read( void );
 92 |   void write( const string & packet );
 93 |   void schedule_from_file( const uint64_t base_timestamp );
 94 | };
 95 | 
 96 | DelayQueue::DelayQueue( FILE * s_output, const string & s_name, const uint64_t s_ms_delay, const string filename, const uint64_t base_timestamp, const float loss_rate, bool s_printing )
 97 |   : _output( s_output ),
 98 |     _name( s_name ),
 99 |     _delay(),
100 |     _pdp(),
101 |     _limbo(),
102 |     _schedule(),
103 |     _delivered(),
104 |     _ms_delay( s_ms_delay ),
105 |     _loss_rate(loss_rate),
106 |     _total_bytes( 0 ),
107 |     _used_bytes( 0 ),
108 |     _queued_bytes( 0 ),
109 |     _bin_sec( base_timestamp / 1000 ),
110 |     _base_timestamp( base_timestamp ),
111 |     _packets_added ( 0 ),
112 |     _packets_dropped( 0 ),
113 |     _file_name( filename ),
114 |     _printing( s_printing )
115 | {
116 |   /* Read schedule from file */
117 |   schedule_from_file( base_timestamp );
118 | 
119 |   /* Initialize seed for probabilistic loss model */
120 |   srand(0);
121 |   fprintf( _output, "# Initialized %s queue with %d services.\n", filename.c_str(), (int)_schedule.size() );
122 |   fprintf( _output, "# Direction: %s\n", _name.c_str() );
123 |   fprintf( _output, "# base timestamp: %lu\n", base_timestamp );
124 | }
125 | 
126 | void DelayQueue::schedule_from_file( const uint64_t base_timestamp ) 
127 | {
128 |   FILE *f = fopen( _file_name.c_str(), "r" );
129 |   if ( f == NULL ) {
130 |     perror( "fopen" );
131 |     exit( 1 );
132 |   }
133 | 
134 |   /* Only populate when the schedule is empty */
135 |   assert( _schedule.empty() );
136 | 
137 |   while ( 1 ) {
138 |     uint64_t ms;
139 |     int num_matched = fscanf( f, "%lu\n", &ms );
140 |     if ( num_matched != 1 ) {
141 |       break;
142 |     }
143 | 
144 |     ms += base_timestamp;
145 | 
146 |     if ( !_schedule.empty() ) {
147 |       assert( ms >= _schedule.back() );
148 |     }
149 | 
150 |     _schedule.push( ms );
151 |   }
152 |   fclose( f );
153 | }
154 | 
155 | int DelayQueue::wait_time( void )
156 | {
157 |   int delay_wait = INT_MAX, schedule_wait = INT_MAX;
158 | 
159 |   uint64_t now = timestamp();
160 | 
161 |   tick();
162 | 
163 |   if ( !_delay.empty() ) {
164 |     delay_wait = _delay.front().release_time - now;
165 |     if ( delay_wait < 0 ) {
166 |       delay_wait = 0;
167 |     }
168 |   }
169 | 
170 |   if ( !_schedule.empty() ) {
171 |     schedule_wait = _schedule.front() - now;
172 |     assert( schedule_wait >= 0 );
173 |   }
174 | 
175 |   return min( delay_wait, schedule_wait );
176 | }
177 | 
178 | vector< string > DelayQueue::read( void )
179 | {
180 |   tick();
181 | 
182 |   vector< string > ret( _delivered );
183 |   _delivered.clear();
184 | 
185 |   return ret;
186 | }
187 | 
188 | void DelayQueue::write( const string & packet )
189 | {
190 |   float r= rand()/(float)RAND_MAX;
191 |   _packets_added++;
192 |   if (r < _loss_rate) {
193 |    _packets_dropped++;
194 |    fprintf(stderr, "# %s , Stochastic drop of packet, _packets_added so far %d , _packets_dropped %d , drop rate %f \n",
195 |                   _name.c_str(), _packets_added,_packets_dropped , (float)_packets_dropped/(float) _packets_added );
196 |   }
197 |   else {
198 |     uint64_t now( timestamp() );
199 | 
200 |     if ( _delay.size() >= queue_limit_in_packets ) {
201 |       fprintf( _output, "# %lu + %lu (dropped)\n",
202 | 	       convert_timestamp( now ),
203 | 	       packet.size() );
204 | 
205 |       return; /* drop the packet */
206 |     }
207 | 
208 |     DelayedPacket p( now, now + _ms_delay, packet );
209 |     _delay.push( p );
210 | 
211 |     fprintf( _output, "%lu + %lu\n",
212 | 	     convert_timestamp( now ),
213 | 	     packet.size() );
214 |     
215 |     _queued_bytes=_queued_bytes+packet.size();
216 |   }
217 | }
218 | 
219 | void DelayQueue::tick( void )
220 | {
221 |   uint64_t now = timestamp();
222 | 
223 |   /* If the schedule is empty, repopulate it */
224 |   if ( _schedule.empty() ) {
225 |     schedule_from_file( now );
226 |   }
227 | 
228 |   /* move packets from end of delay to PDP */
229 |   while ( (!_delay.empty())
230 | 	  && (_delay.front().release_time <= now) ) {
231 |     _pdp.push( _delay.front() );
232 |     _delay.pop();
233 |   }
234 | 
235 |   /* execute packet delivery schedule */
236 |   while ( (!_schedule.empty())
237 | 	  && (_schedule.front() <= now) ) {
238 |     /* grab a PDO */
239 |     const uint64_t pdo_time = _schedule.front();
240 |     _schedule.pop();
241 |     /* delivery opportunity */
242 |     fprintf( _output, "%lu # %d\n", convert_timestamp( pdo_time ), SERVICE_PACKET_SIZE );
243 | 
244 |     int bytes_to_play_with = SERVICE_PACKET_SIZE;
245 | 
246 |     /* execute limbo queue first */
247 |     if ( !_limbo.empty() ) {
248 |       if ( _limbo.front().bytes_earned + bytes_to_play_with >= (int)_limbo.front().packet.contents.size() ) {
249 | 	/* deliver packet */
250 | 	_total_bytes += _limbo.front().packet.contents.size();
251 | 	_used_bytes += _limbo.front().packet.contents.size();
252 | 
253 | 	/*
254 | 	if ( _printing ) {
255 | 	  printf( "%s %lu delivery %d %lu leftover\n", _name.c_str(), convert_timestamp( pdo_time ), int(pdo_time - _limbo.front().packet.entry_time), _limbo.front().packet.contents.size() );
256 | 	}
257 | 	*/
258 | 	/* new-style output (mahimahi-style) */
259 | 	fprintf( _output, "%lu - %lu %d\n",
260 | 		 convert_timestamp( pdo_time ),
261 | 		 _limbo.front().packet.contents.size(),
262 | 		 int(pdo_time - _limbo.front().packet.entry_time) );
263 | 
264 | 	_delivered.push_back( _limbo.front().packet.contents );
265 | 	bytes_to_play_with -= (_limbo.front().packet.contents.size() - _limbo.front().bytes_earned);
266 | 	assert( bytes_to_play_with >= 0 );
267 | 	_limbo.pop();
268 | 	assert( _limbo.empty() );
269 |       } else {
270 | 	_limbo.front().bytes_earned += bytes_to_play_with;
271 | 	bytes_to_play_with = 0;
272 | 	assert( _limbo.front().bytes_earned < (int)_limbo.front().packet.contents.size() );
273 |       }
274 |     }
275 |     
276 |     /* execute regular queue */
277 |     while ( bytes_to_play_with > 0 ) {
278 |       assert( _limbo.empty() );
279 | 
280 |       /* will this be an underflow? */
281 |       if ( _pdp.empty() ) {
282 | 	/* underflow */
283 | 	/*
284 | 	if ( _printing ) {
285 | 	  printf( "%s %lu underflow %d\n", _name.c_str(), convert_timestamp( pdo_time ), bytes_to_play_with );
286 | 	}
287 | 	*/
288 | 	_total_bytes += bytes_to_play_with;
289 | 	bytes_to_play_with = 0;
290 |       } else {
291 | 	/* dequeue whole and/or partial packet */
292 | 	DelayedPacket packet = _pdp.front();
293 | 	_pdp.pop();
294 | 	if ( bytes_to_play_with >= (int)packet.contents.size() ) {
295 | 	  /* deliver whole packet */
296 | 	  _total_bytes += packet.contents.size();
297 | 	  _used_bytes += packet.contents.size();
298 | 
299 | 	  /*
300 | 	  if ( _printing ) {
301 | 	    printf( "%s %lu delivery %d %lu\n", _name.c_str(), convert_timestamp( pdo_time ), int(pdo_time - packet.entry_time), packet.contents.size() );
302 | 	  }
303 | 	  */
304 | 
305 | 	  /* new-style output (mahimahi-style) */
306 | 	  fprintf( _output, "%lu - %lu %d\n",
307 | 		   convert_timestamp( pdo_time ),
308 | 		   packet.contents.size(),
309 | 		   int(pdo_time - packet.entry_time) );
310 | 	  
311 | 	  _delivered.push_back( packet.contents );
312 | 	  bytes_to_play_with -= packet.contents.size();
313 | 	} else {
314 | 	  /* put packet in limbo */
315 | 	  assert( _limbo.empty() );
316 | 
317 | 	  assert( bytes_to_play_with < (int)packet.contents.size() );
318 | 
319 | 	  PartialPacket limbo_packet( bytes_to_play_with, packet );
320 | 	  
321 | 	  _limbo.push( limbo_packet );
322 | 	  bytes_to_play_with -= _limbo.front().bytes_earned;
323 | 	  assert( bytes_to_play_with == 0 );
324 | 	}
325 |       }
326 |     }
327 |   }
328 | 
329 |   while ( now / 1000 > _bin_sec ) {
330 |     //    fprintf( stderr, "%s %ld %ld / %ld = %.1f %% %ld \n", _name.c_str(), _bin_sec - (_base_timestamp / 1000), _used_bytes, _total_bytes, 100.0 * _used_bytes / (double) _total_bytes , _queued_bytes );
331 |     _total_bytes = 0;
332 |     _used_bytes = 0;
333 |     _queued_bytes = 0;
334 |     _bin_sec++;
335 |   }
336 | }
337 | 
338 | int main( int argc, char *argv[] )
339 | {
340 |   assert( argc >= 6 );
341 | 
342 |   signal(SIGINT, sigfunc);
343 |   signal(SIGTERM, sigfunc);
344 |   signal(SIGHUP, sigfunc);
345 | 
346 |   const string up_filename = argv[ 1 ];
347 |   const string down_filename = argv[ 2 ];
348 |   const double loss_rate = atof( argv[ 3 ] );
349 | 
350 |   const string internet_side_interface = argv[ 4 ];
351 |   const string client_side_interface   = argv[ 5 ];
352 | 
353 |   PacketSocket internet_side( internet_side_interface );
354 |   PacketSocket client_side( client_side_interface );
355 |   FILE* up_output = stdout, *down_output = stderr;
356 |   if (argc >= 7)
357 |     up_output = fopen(argv[6], "w");
358 |   
359 |   if (argc >= 8)
360 |     down_output = fopen(argv[7], "w");
361 |   /* Read in schedule */
362 |   uint64_t now = timestamp();
363 |   DelayQueue uplink( up_output, "uplink", 20, up_filename, now , loss_rate );
364 |   DelayQueue downlink( down_output, "downlink", 20, down_filename, now , loss_rate, true );
365 | 
366 |   Select &sel = Select::get_instance();
367 |   sel.add_fd( internet_side.fd() );
368 |   sel.add_fd( client_side.fd() );
369 | 
370 |   while ( !end_loop ) {
371 |     int wait_time = min( uplink.wait_time(), downlink.wait_time() );
372 |     int active_fds = sel.select( wait_time );
373 |     if ( active_fds < 0 ) {
374 |       perror( "select" );
375 |       exit( 1 );
376 |     }
377 | 
378 |     if ( sel.read( client_side.fd() ) ) {
379 |       for ( const auto & it : client_side.recv_raw() ) {
380 | 	uplink.write( it );
381 |       }
382 |     }
383 | 
384 |     if ( sel.read( internet_side.fd() ) ) {
385 |       for ( const auto & it : internet_side.recv_raw() ) {
386 | 	downlink.write( it );
387 |       }
388 |     }
389 | 
390 |     for ( const auto & it : uplink.read() ) {
391 |       internet_side.send_raw( it );
392 |     }
393 | 
394 |     for ( const auto & it : downlink.read() ) {
395 |       client_side.send_raw( it );
396 |     }
397 |   }
398 | 
399 |   fclose(up_output);
400 |   fclose(down_output);
401 |   exit(0);
402 | 
403 | }
404 | 


--------------------------------------------------------------------------------