通过睡眠控制吞吐量 [英] throughput control via Sleep

问题描述

大家好，

我有这段代码，关键是我想使用UDP套接字接收不超过600Kbits/s，我使用接收的持续时间和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;
}

问题是它接收到消息，但是会不时阻止接收过程...我想这会导致数据丢失，尤其是当我使用UDP时...

任何替代解决方案都是welcolme ...

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

推荐答案

如果缓冲区太小，只会使用recvfrom丢失数据.
您可以通过使用MSG_PEEK参数调用recvfrom来检查所需的缓冲区大小而无需从队列中删除任何数据来避免缓冲区过小(您可以阅读如何执行此操作

You''ll only lose data with recvfrom if your buffer is too small.
You can avoid having a too small buffer by calling recvfrom with MSG_PEEK argument to check the required buffer size without removing any data from the queue (you can read how to do this here[^]).

这篇关于通过睡眠控制吞吐量的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！