c++ - 通过 sleep 控制吞吐量

Question

我有这段代码，关键是我想使用 UDP 套接字接收不超过 600Kbits/s 的数据，我使用我们接收的持续时间和 sleep 命令实现了一个算法....

#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 时……

欢迎任何替代解决方案...

提前致谢..

Answer 1

最好不要休眠 - 只需在超过阈值时读取并丢弃数据，然后在准备好后(间隔到期后)继续处理数据。