throughput control via Sleep

Hi everyone,

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..

Tags: C++, Threads, Sockets