0

Windows と Linux 間の通信に関するデモを書いています。

性能はギガビットネットワーク環境下でわずか40MB/s

パフォーマンスをアップグレードする方法はありますか?そして、なぜこんなに遅いのかわかりません。


クライアントとしての Windows のコード

#include "stdafx.h"


#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdlib.h>
#include <stdio.h>


// Need to link with Ws2_32.lib, Mswsock.lib, and Advapi32.lib
#pragma comment (lib, "Ws2_32.lib")
#pragma comment (lib, "Mswsock.lib")
#pragma comment (lib, "AdvApi32.lib")


#define DEFAULT_BUFLEN 65536
#define DEFAULT_PORT "27015"

int tcpnodelay(int sock) {
    int yes=1;
    return setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,(char*)&yes,sizeof(int));
}

int __cdecl main(int argc, char **argv) 
{
    WSADATA wsaData;
    SOCKET ConnectSocket = INVALID_SOCKET;
    struct addrinfo *result = NULL,
                    *ptr = NULL,
                    hints;
    char sendbuf[DEFAULT_BUFLEN];
    char recvbuf[32];
    unsigned long no;
    unsigned long iResult;
    unsigned long sent;
    int recvbuflen = 32;
    int recv_len, n;
    unsigned long recv_no;

    // Validate the parameters
    if (argc != 2) {
        printf("usage: %s server-name\n", argv[0]);
        return 1;
    }

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed with error: %d\n", iResult);
        return 1;
    }

    ZeroMemory( &hints, sizeof(hints) );
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    // Resolve the server address and port
    iResult = getaddrinfo(argv[1], DEFAULT_PORT, &hints, &result);
    if ( iResult != 0 ) {
        printf("getaddrinfo failed with error: %d\n", iResult);
        WSACleanup();
        return 1;
    }

    // Attempt to connect to an address until one succeeds
    for(ptr=result; ptr != NULL ;ptr=ptr->ai_next) {

        // Create a SOCKET for connecting to server
        ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, 
            ptr->ai_protocol);
        if (ConnectSocket == INVALID_SOCKET) {
            printf("socket failed with error: %ld\n", WSAGetLastError());
            WSACleanup();
            return 1;
        }

        // Connect to server.
        iResult = connect( ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
        if (iResult == SOCKET_ERROR) {
            closesocket(ConnectSocket);
            ConnectSocket = INVALID_SOCKET;
            continue;
        }
        break;
    }

    freeaddrinfo(result);

    if (ConnectSocket == INVALID_SOCKET) {
        printf("Unable to connect to server!\n");
        WSACleanup();
        return 1;
    }

    if (tcpnodelay(ConnectSocket)<0) {
        printf("Can't set TCP_NODELAY!\n");
    }

    recv_len = sizeof(no);
    printf("recv_len: %d\n", recv_len);

    // Send an initial buffer
    memset(sendbuf, 0, DEFAULT_BUFLEN);
    for (no=0; no<1024*1024; no++) {
        sent = 0;
        while (sent < DEFAULT_BUFLEN) {
            iResult = send(ConnectSocket, sendbuf+sent, DEFAULT_BUFLEN-sent, 0);

            if (iResult == SOCKET_ERROR) {
                printf("send failed with error: %d\n", WSAGetLastError());
                closesocket(ConnectSocket);
                WSACleanup();
                return 1;
            }

            sent += iResult;
        }


        n = recv(ConnectSocket, (char *)(&recv_no), recv_len, 0);
        if (recv_len!=n || recv_no!=no) {
            printf("recv len: %d, recv no %ld", n, recv_no);
            exit(1);
        }

    }


    printf("Bytes Sent: %ld\n", iResult);

    // shutdown the connection since no more data will be sent
    iResult = shutdown(ConnectSocket, SD_SEND);
    if (iResult == SOCKET_ERROR) {
        printf("shutdown failed with error: %d\n", WSAGetLastError());
        closesocket(ConnectSocket);
        WSACleanup();
        return 1;
    }

    // cleanup
    closesocket(ConnectSocket);
    WSACleanup();

    return 0;
}

サーバーとしてのLinuxのコード

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <netinet/in.h>

int main( int argc, char *argv[] )
{
  int sockfd, newsockfd, portno, clilen;
  char buffer[65536];
  unsigned int no;
  unsigned long read_size;
  struct sockaddr_in serv_addr, cli_addr;
  int  n;
  int send_len;

  /* First call to socket() function */
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd < 0) 
  {
    perror("ERROR opening socket");
    exit(1);
  }
  /* Initialize socket structure */
  bzero((char *) &serv_addr, sizeof(serv_addr));
  portno = 27015;
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_addr.s_addr = INADDR_ANY;
  serv_addr.sin_port = htons(portno);

  /* Now bind the host address using bind() call.*/
  if (bind(sockfd, (struct sockaddr *) &serv_addr,
           sizeof(serv_addr)) < 0)
  {
    perror("ERROR on binding");
    exit(1);
  }

  /* Now start listening for the clients, here process will
   * go in sleep mode and will wait for the incoming connection
   */
  listen(sockfd,5);
  clilen = sizeof(cli_addr);

  /* Accept actual connection from the client */
  newsockfd = accept(sockfd, (struct sockaddr *)&cli_addr, 
                     &clilen);
  if (newsockfd < 0) 
  {
    perror("ERROR on accept");
    exit(1);
  }

  send_len = sizeof(no);
  printf("send_len: %d\n", send_len);

  /* If connection is established then start communicating */
  bzero(buffer,65536);
  for (no=0; no<1024*1024; no++) {
    read_size = 0;
    while (read_size < 65536) {
      n = read( newsockfd,buffer+read_size,65536-read_size );
      if (n < 0)
      {
        perror("ERROR reading from socket");
        exit(1);
      }
      read_size += n;
    }


    n = write(newsockfd, &no, send_len);
    if (n < send_len) {
      printf("send len: %d\n", n);
      exit(1);
    }
  }
  printf("the message size: %d\n", n);

  /* Write a response to the client */
  n = write(newsockfd,"I got your message",18);
  if (n < 0)
  {
    perror("ERROR writing to socket");
    exit(1);
  }

  close(newsockfd);

  return 0; 
}
4

2 に答える 2

2

あなたはあなた自身の問題に答えました:

はい、バッファ全体を送信すると、パフォーマンスは 90MB/s になります。しかし、私の仕事では、64KB のデータごとに送信してフィードバックを受け取り、次の 64KB を送信する必要があります。

ギガビット イーサネットで 1 秒あたり約 81,200 のフルサイズ フレームをそれぞれ約 120MiB/s で送信できます (これには TCP と IP のヘッダーが含まれているため、実質的には多少少なく期待できます)。
TCP は、いくつかの「調整可能な」パラメータ (MTU、ウィンドウ サイズ) について最適ではないデフォルト値 (ギガビット LAN では最適ではありませんが、「一般的な」未知のネットワークでは安全です) から開始し、これらを適応的に調整します。それはすぐに起こりますが、すぐには起こりません。したがって、すべてのデータを一度に送信したときに表示される有効な 90MiB/秒は、まったく現実的です。

ここでの問題は、これは、常にワイヤをビジー状態に保つ場合に達成できる実用的な (そして多かれ少なかれ理論上の) 最大値であるということです。

サーバーの応答を待つのは正反対です。少なくとも応答が受信されて確認されるまで (特に Windows では)、(送信しているデータに関する限り) ワイヤを「アイドル状態」にします。デフォルトでは、ACK は 200 ミリ秒ごとに送信されるか、少なくとも 2 つがキューに入れられたときに送信されます (詳細については、Google TcpDelAckTicks を参照してください)。この「アイドル時間」はかなり短いですが、これは達成できる最大スループットに非常に深刻な影響を与えます。これは、他の分野で「パイプライン ストール」と呼ばれるものに相当します。

プロトコルで許可されている場合は、送信と返信を重複させるようにしてください。つまり、65kiB のブロックを少なくとも 2 つ (できれば 3 つ) 送信してから、サーバーから応答を受信します。このようにして、TCP スタックは、ワイヤをビジー状態に保ち、利用可能な帯域幅を利用するために送信できるデータを常に持っています。

于 2013-10-26T14:20:18.187 に答える