add razor trace

Author: SoonyangZhang

razor-ns3/model/razortrace.cc

@@ -0,0 +1,59 @@
+#include <unistd.h>
+#include <memory.h>
+#include "razortrace.h"
+#include "ns3/simulator.h"
+#include "ns3/log.h"
+namespace ns3{
+void RazorTraceReceiver::OpenTraceLossFile(std::string name){
+	char buf[FILENAME_MAX];
+	memset(buf,0,FILENAME_MAX);
+	std::string path = std::string (getcwd(buf, FILENAME_MAX)) + "/traces/"
+			+name+"_loss.txt";
+	m_lossSeq.open(path.c_str(), std::fstream::out);
+}
+void RazorTraceReceiver::CloseTraceLossFile(){
+	if(m_lossSeq.is_open()){
+		m_lossSeq.close();
+	}
+}
+void RazorTraceReceiver::OnLossSeq(uint32_t seq){
+	if(m_lossSeq.is_open()){
+		char line [256];
+		memset(line,0,256);
+		//double now=Simulator::Now().GetSeconds();
+		sprintf (line, "%d",seq);
+		m_lossSeq<<line<<std::endl;
+	}
+}
+void RazorTraceReceiver::Close(){
+	CloseTraceLossFile();
+}
+void RazorTraceSender::OpenTraceSentFile(std::string name){
+	char buf[FILENAME_MAX];
+	memset(buf,0,FILENAME_MAX);
+	std::string path = std::string (getcwd(buf, FILENAME_MAX)) + "/traces/"
+			+name+"_sent.txt";
+	m_sendSeq.open(path.c_str(), std::fstream::out);
+}
+void RazorTraceSender::CloseTraceSentFile(){
+	if(m_sendSeq.is_open()){
+		m_sendSeq.close();
+	}
+}
+void RazorTraceSender::OnSentSeq(uint32_t seq){
+	if(m_sendSeq.is_open()){
+		char line [256];
+		memset(line,0,256);
+		//double now=Simulator::Now().GetSeconds();
+		sprintf (line, "%d",seq);
+		m_sendSeq<<line<<std::endl;
+	}
+}
+void RazorTraceSender::Close(){
+	CloseTraceSentFile();
+}
+}
+
+
+
+

razor-ns3/model/razortrace.h

@@ -0,0 +1,34 @@
+#ifndef TRACE_RAZORTRACE_H_
+#define TRACE_RAZORTRACE_H_
+#include <iostream>
+#include <fstream>
+#include <string>
+namespace ns3{
+class RazorTraceReceiver{
+public:
+	RazorTraceReceiver(){}
+	~RazorTraceReceiver(){
+		Close();
+	}
+	void OpenTraceLossFile(std::string name);
+	void CloseTraceLossFile();
+	void OnLossSeq(uint32_t seq);
+private:
+	void Close();
+	std::fstream m_lossSeq;
+};
+class RazorTraceSender{
+public:
+	RazorTraceSender(){}
+	~RazorTraceSender(){
+		Close();
+	}
+	void OpenTraceSentFile(std::string name);
+	void CloseTraceSentFile();
+	void OnSentSeq(uint32_t seq);
+private:
+	void Close();
+	std::fstream m_sendSeq;
+};
+}
+#endif /* TRACE_RAZORTRACE_H_ */

razor-ns3/model/sim_endpoint.cc

@@ -382,6 +382,9 @@ void SimEndpoint::CalculateRtt(uint32_t keep_rtt)
 void SimEndpoint::SenderInit()
 {
 	m_sender=new SimSender();
+	if(!m_sentSeqCb.IsNull()){
+		m_sender->SetSentSeqTrace(m_sentSeqCb);
+	}
 	sim_header_t sHeader;
 	INIT_SIM_HEADER(sHeader,RazorProtoType::MIN_MSG_ID,m_uid);
 	m_sender->SetHeader(sHeader);
@@ -398,21 +401,24 @@ void SimEndpoint::ReceiverInit()
 	if(m_receiver==nullptr)
 	{
 		m_receiver=new SimReceiver();
+		if(!m_lossSeqCb.IsNull()){
+			m_receiver->SetLossSeqTrace(m_lossSeqCb);
+		}
 		sim_header_t sHeader;
 		INIT_SIM_HEADER(sHeader,RazorProtoType::MIN_MSG_ID,m_uid);
 		m_receiver->SetHeader(sHeader);
 		m_receiver->SetFeedBack(MakeCallback(&SimEndpoint::Send,this));
 	}
 }
-void SimEndpoint::ChangeRate(uint32_t bitrate)
+void SimEndpoint::ChangeRate(uint32_t kbps)
 {
-	uint32_t rate=bitrate*1000;
+	uint32_t rate=kbps*1000;
 	double now=Simulator::Now().GetSeconds();
 	NS_LOG_INFO(now<<" "<<m_bitRate/1000<<" "<<rate/1000);
 	m_bitRate=rate;
 	if(rate<=0)
 	{
-	NS_LOG_FUNCTION("fuck insane bitrate"<<bitrate<< "and set it to min");	
+	NS_LOG_FUNCTION("fuck insane bitrate"<<kbps<< "and set it to min");	
 	m_bitRate=SIM_MIN_BITRATE;
 	}
 

razor-ns3/model/sim_endpoint.h

@@ -49,6 +49,14 @@ class SimEndpoint:public Application
 			Callback<void,uint32_t>connectionFailed);
 	void SendPing(void);
 	void Send(Ptr<Packet> packet);
+	typedef Callback<void,uint32_t> LossSeqCallback;
+	void SetLossSeqTrace(LossSeqCallback cb){
+		m_lossSeqCb=cb;
+	}
+	typedef Callback<void,uint32_t> SentSeqCallback;
+	void SetSentSeqTrace(SentSeqCallback cb){
+		m_sentSeqCb=cb;
+	}
 private:
 	void Connect();
     virtual void StartApplication ();
@@ -66,7 +74,7 @@ class SimEndpoint:public Application
     	m_bitRate=bitrate;
     	m_frameRate=framerate;
     }
-    void ChangeRate(uint32_t bitrate);
+    void ChangeRate(uint32_t kbps);
     void SenderInit();
     void ReceiverInit();
     void GenerateFakeData();
@@ -102,6 +110,8 @@ class SimEndpoint:public Application
 
     SimSender *m_sender;
     SimReceiver *m_receiver;
+	LossSeqCallback m_lossSeqCb;
+	SentSeqCallback m_sentSeqCb;
 };
 }
 #endif /* SIM_ENDPOINT_H */

razor-ns3/model/sim_receiver.cc

@@ -6,6 +6,7 @@
 #include "ns3/packet.h"
 #include"ns3/log.h"
 #include "sim_constants.h"
+#include <string>
 namespace ns3
 {
 NS_LOG_COMPONENT_DEFINE("SimReceiver");
@@ -91,7 +92,7 @@ void SimReceiver::SetFeedBack(Callback<void,Ptr<Packet>>feedback)
 }
 void SimReceiver::SendFeedback(void*handler,const uint8_t* payload, int payload_size)
 {
-	NS_LOG_FUNCTION(Simulator::Now().GetMilliSeconds());
+	//NS_LOG_FUNCTION(Simulator::Now().GetMilliSeconds());
 	SimReceiver *obj=static_cast<SimReceiver*>(handler);
 	sim_header_t sHeader=obj->m_sHeader;
 	sHeader.mid=RazorProtoType::SIM_FEEDBACK;
@@ -105,15 +106,29 @@ void SimReceiver::SendFeedback(void*handler,const uint8_t* payload, int payload_
 	header.SetMessagePayload((void*)&feedback,sizeof(sim_feedback_t));
 	if(!obj->m_feedback.IsNull())
 	{
-		NS_LOG_INFO("send feedback");
+		//NS_LOG_INFO("send feedback");
 		Ptr<Packet> packet=Create<Packet>(0);
 		packet->AddHeader(header);
 		obj->m_feedback(packet);
 	}
 }
 void SimReceiver::RecvFakeData(sim_segment_t seg)
 {
-	NS_LOG_FUNCTION(Simulator::Now().GetMilliSeconds()<<"receive "<<seg.packet_id);
+	//NS_LOG_FUNCTION(Simulator::Now().GetMilliSeconds()<<"receive "<<seg.packet_id);
+	if(seg.packet_id!=m_base_seq+1){
+		uint32_t i=0;
+		uint32_t from=m_base_seq+1;
+		uint32_t to=seg.packet_id;		
+		for(i=from;i<to;i++){
+			if(!m_lossSeqCb.IsNull()){
+				m_lossSeqCb(i);
+			}
+		}		
+		}
+	m_base_seq=seg.packet_id;
+	/*if(!m_lossSeqCb.IsNull()){
+		m_lossSeqCb(seg.packet_id);
+	}*/
 	uint8_t  header_len=sizeof(sim_header_t)+sizeof(sim_segment_t);
 	if(m_cc!=NULL)
 	{
@@ -137,7 +152,7 @@ uint32_t SimReceiver::GetFakeData()
 }
 void SimReceiver::HeartBeat()
 {
-	NS_LOG_FUNCTION_NOARGS();
+	//NS_LOG_FUNCTION_NOARGS();
 	if(m_heartbeatEvent.IsExpired())
 	{
 		if(m_cc!=NULL)
@@ -156,7 +171,7 @@ void SimReceiver::StatsRecvRate()
 	if(m_statsRateEvent.IsExpired())
 	{
 		rate=m_statsDataLen*8/(m_rateStatsInterval*0.001);
-		NS_LOG_INFO("receive bitrate "<<rate);
+		//NS_LOG_INFO("receive bitrate "<<rate);
 		m_statsDataLen=0.0;
 		Time interval=MilliSeconds((uint64_t)m_rateStatsInterval);
 		m_statsRateEvent=Simulator::Schedule(interval,&SimReceiver::StatsRecvRate,this);

razor-ns3/model/sim_receiver.h

@@ -12,6 +12,7 @@
 #include "ns3/socket.h"
 #include "ns3/event-id.h"
 #include "ns3/simulator.h"
+#include "ns3/callback.h"
 #include<vector>
 namespace ns3
 {
@@ -44,6 +45,10 @@ class SimReceiver
 	void HeartBeat();
 	void StatsRecvRate();
 	void UpdateRtt(uint32_t rtt,uint32_t rtt_var);
+	typedef Callback<void,uint32_t> LossSeqCallback;
+	void SetLossSeqTrace(LossSeqCallback cb){
+		m_lossSeqCb=cb;
+	}
 private:
 	uint32_t GetIndex(uint32_t i);
 //the important part is not about video consuming,so ignore it
@@ -70,6 +75,8 @@ class SimReceiver
 	EventId m_statsRateEvent;
 	uint32_t m_rateStatsInterval;//in 100ms;
 	Callback<void,Ptr<Packet>> m_feedback;
+	uint32_t m_base_seq{0};
+	LossSeqCallback m_lossSeqCb;
 };
 }
 

razor-ns3/model/sim_sender.cc

@@ -4,21 +4,20 @@
 #include"ns3/log.h"
 #include"ns3/nstime.h"
 #include "ns3/packet.h"
+#include<string>
 namespace ns3
 {
 NS_LOG_COMPONENT_DEFINE("SimSender");
 SimSender::SimSender()
 {
-	m_frame_id=0;
-	m_packet_id=0;
 	m_transport_seq=0;
 	m_active=true;
 	m_first_ts=-1;
-	m_remb=0;//0 open receiver bandwidth estimate
+	m_remb=1;//0 open receiver bandwidth estimate
 	m_paceTime=5;
 	m_segmentSize=1000;
 	m_lossFraction=0;
-	m_paceQueueLen=300;
+	m_paceQueueLen=3000; //300;  change it
 	m_maxSplitPackets=1000;
 	m_cc=razor_sender_create((void*)this,&SimSender::ChangeBitRate,(void*)this,
 			&SimSender::PacePacketSend,m_paceQueueLen);
@@ -68,7 +67,7 @@ void SimSender::UpdateRtt(uint32_t rtt,uint32_t rtt_var)
 }
 void SimSender::ProcessFeedBack(sim_feedback_t feedback)
 {
-	NS_LOG_FUNCTION_NOARGS();
+	//NS_LOG_FUNCTION_NOARGS();
 	if(m_cc!=NULL)
 	{
 		m_cc->on_feedback(m_cc,feedback.feedback,feedback.feedback_size);
@@ -123,10 +122,9 @@ void SimSender::PutFakeData(uint8_t ftype,uint32_t size)
 	{
 		timestamp=(uint32_t)(now_ts-m_first_ts);
 	}
-	++m_frame_id;
 	for(i=0;i<total;i++)
 	{
-		seg.packet_id=++m_packet_id;
+		seg.packet_id=m_packet_id;
 		seg.fid=m_frame_id;
 		seg.ftype=ftype;
 		seg.index=i;
@@ -139,7 +137,9 @@ void SimSender::PutFakeData(uint8_t ftype,uint32_t size)
 		seg.data_size=splits[i];
 		m_cache.insert(std::make_pair(seg.packet_id,seg));
 		m_cc->add_packet(m_cc,seg.packet_id,0,seg.data_size+header_len);
+		m_packet_id++;
 	}
+	m_frame_id++;
 	//NS_LOG_INFO("splits packet "<<total);
 }
 void SimSender::SetSendSegmentCallback(Callback<void,Ptr<Packet>>sendPacket)
@@ -152,7 +152,7 @@ void SimSender::SetVideoBitChangeCallback(Callback<void,uint32_t> changeBitRate)
 }
 void SimSender::ChangeBitRate(void* trigger, uint32_t bitrate, uint8_t fraction_loss, uint32_t rtt)
 {
-	NS_LOG_FUNCTION(Simulator::Now().GetMilliSeconds());
+	double now=Simulator::Now().GetSeconds();
 	SimSender *obj=static_cast<SimSender*>(trigger);
 	uint32_t overhead_bitrate, per_packets_second, payload_bitrate, video_bitrate_kbps;
 	double loss;
@@ -168,20 +168,22 @@ void SimSender::ChangeBitRate(void* trigger, uint32_t bitrate, uint8_t fraction_
 	{
 		obj->m_lossFraction=(3*obj->m_lossFraction+fraction_loss)/4;
 	}
-	loss=obj->m_lossFraction/255.0;
+	loss=(double)obj->m_lossFraction/255.0;
 	if (loss > 0.5)
 		loss = 0.5;
 	video_bitrate_kbps = (uint32_t)((1.0 - loss) * payload_bitrate) / 1000;
-	NS_LOG_INFO("bitrate "<<bitrate<<"change bitrate "<<video_bitrate_kbps<<"kbps");
+	NS_LOG_INFO(std::to_string(now)<<" "<<video_bitrate_kbps<<" l "<<std::to_string(loss));
 	if(!obj->m_changeBitRate.IsNull())
 	{
-		obj->m_changeBitRate(video_bitrate_kbps);
+		//to prevent channel overuse 
+		uint32_t protect_rate=video_bitrate_kbps;
+		obj->m_changeBitRate(protect_rate);//video_bitrate_kbps
 	}
 
 }
 void SimSender::PacePacketSend(void* handler, uint32_t packet_id, int retrans, size_t size)
 {
-	NS_LOG_INFO(Simulator::Now().GetMilliSeconds()<<"packet send "<<packet_id<<"size "<<size);
+	//NS_LOG_INFO(Simulator::Now().GetMilliSeconds()<<"packet send "<<packet_id<<"size "<<size);
 	SimSender *obj=static_cast<SimSender*>(handler);
 	if(!obj->m_sendPacket.IsNull())
 	{
@@ -197,12 +199,15 @@ void SimSender::PacePacketSend(void* handler, uint32_t packet_id, int retrans, s
 		segment.send_ts=(uint16_t)(Simulator::Now().GetMilliSeconds()-obj->m_first_ts-segment.timestamp);
 		segment.transport_seq=++(obj->m_transport_seq);
 		obj->m_cache.erase(iter);
+		if(!obj->m_sentSeqCb.IsNull()){
+			obj->m_sentSeqCb(segment.packet_id);
+		}
 		uint8_t header_len=sizeof(sim_header_t)+sizeof(sim_segment_t);
 		if(obj->m_cc)
 		{
 			obj->m_cc->on_send(obj->m_cc,segment.transport_seq,header_len+segment.data_size);
 		}
-		NS_LOG_INFO("packet_id"<<packet_id<<"seq"<<segment.transport_seq);
+		//NS_LOG_INFO("packet_id"<<packet_id<<"seq"<<segment.transport_seq);
 		sim_header_t sHeader=obj->m_header;
 		sHeader.mid=RazorProtoType::SIM_SEG;
 		RazorHeader header;