throughput control via Sleep - c++

Question

I have this code, the point is that I want to receive no more than 600Kbits/s using a UDP socket, I implemented an algorithm using duration during which we receive and the sleep command....
#if defined (WIN32)
#include <winsock2.h>
typedef int socklen_t;
#elif defined (linux)
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define closesocket(s) close(s)
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
#endif
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define RCVBUFSIZE 4
#define PORT 4444
#define ECHOMAX 255
int main(void)
{
#if defined (WIN32)
WSADATA WSAData;
int erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
#else
int erreur = 0;
#endif
int recvMsgSize;
char echoBuffer[RCVBUFSIZE];
//unsigned int echoStringLen;
//int bytesRcvd, totalBytesRcvd; //bytes received in a single recv()
SOCKET sock;
SOCKADDR_IN sin;
SOCKADDR_IN SenderAddr;
int SenderAddrSize = sizeof(SenderAddr);
if(!erreur)
{
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
sin.sin_addr.s_addr = inet_addr("127.0.0.1");
sin.sin_family = AF_INET;
sin.sin_port = htons(4444);
memset(&sin.sin_zero, '\0', sizeof(sin.sin_zero));
bind(sock, (SOCKADDR*)&sin, sizeof(sin));
//totalBytesRcvd = 0;
printf("Received: ");
int speed_limit= 614400; //600Kbits/s
int one_second=1000;
int elapsed; //elapsed time
int transmit=0; // how much i receive during 'elapsed'
int expected_receive; //what I'm excpected to receive
int transmit_delta; //diference
int time_sleep; //how much to sleep
clock_t start_time= clock();
for(;;)
{
if((recvMsgSize=recvfrom(sock, echoBuffer,1024, 0, (SOCKADDR *)&SenderAddr, &SenderAddrSize)) > 0)
{
transmit+=recvMsgSize;
clock_t tempo= clock();
elapsed=(tempo-start_time)/CLOCKS_PER_SEC;
// Check moment speed every five second, you can choose any value
if(elapsed>5)
{
start_time= tempo;
expected_receive=speed_limit*elapsed/8;
transmit_delta=expected_receive-transmit;
if(transmit_delta>0)
{
time_sleep=8*transmit_delta*one_second/speed_limit;
Sleep(time_sleep);
}
transmit=0;
}
echoBuffer[recvMsgSize]='\0';
printf(echoBuffer);
}
}
printf("\n");
getchar() ;
closesocket(sock);
#if defined (WIN32)
WSACleanup();
#endif
}
return EXIT_SUCCESS;
}
the problem is that it receive the message but it blocks the receiving process from time to time...which I guess will cause loss of data especially when I'm using UDP...
any alternative solution is welcolme...
thanks in advance..

Answer 1

Better not to sleep - just read and discard data while you are over the threshold, then resume processing it once you are ready to do so (after interval expires).

Answer 2

If the data is arriving over UDP, there is no way to reduce the throughput at the receiving end. You'd have to tell the sending computer to send less data. The receiver's only choice is the receive the UDP packets, or let them get dropped, and do something with them, or not.
If you use TCP, then the TCP protocol includes a built-in way to do what you want (called "source quench") ... the TCP protocol layer of the receiver will send a message to the sender telling the sender to slow down if the receiver is having problems keeping up. (and you can influence whether "the receiver is having problems keeping up" by reading the data slower than usual, if you want).

Answer 3

If you use non-blocking sockets with select() you can just ignore the data until you're ready to read it. Not reading data will cause the TCP connection to "slow down". However, this way you do not have exact control about the amount of data received. It's just an approximation. All techniques I know of that limit bandwidth in a more accurate way are implemented on the sender side.