c++ - 大小为 1mega 的大数组导致 CPU 高？

Question

我有一个多线程服务器应用程序。该应用程序从套接字接收数据，然后处理这些数据，如解包、添加到数据队列等，功能如下。这个函数被频繁调用。有一个select语句，如果发现有数据就会调用这个函数接收):

         //the main function used to receive 
         //file data from clients
         void service(void){
              while(1){
                   ....
                   struct timeval timeout;
                   timeout.tv_sec = 3;

                   ...
                   ret = select(maxFd+1, &read_set, NULL, NULL, &timeout);
                   if (ret > 0){
                       //get socket from SocketsMap
                       //if fd in SocketsMap and its being set
                       //then receive data from the socket
                       receive_data(fd);
                   }
              }
         } 

         void receive_data(int fd){
              const int ONE_MEGA = 1024 * 1024;

              //char *buffer = new char[ONE_MEGA]; consumes much less CPU
              char buffer[ONE_MEGA]; // cause high CPU 
              int readn = recv(fd, buffer, ONE_MEGA, 0);

              //handle the data
         }

我发现上面的代码消耗了太多的 CPU——通常是 80% 到 90%，但是如果我从堆中创建缓冲区而不是 CPU，则只有 14%。为什么？

[更新]
添加了更多代码

[更新2]
最奇怪的是我还写了一个简单的数据接收服务器和客户端。服务器只是从套接字接收数据然后丢弃它。两种类型的空间分配工作几乎相同，CPU 使用率没有太大差异。在出现问题的多线程服务器应用程序中，我什至将进程堆栈大小重置为30M，使用数组仍然导致问题，但是从堆分配解决了它。我不知道为什么。

关于“sizeof(buffer)”，感谢您指出这一点，但我 100% 确定这不是问题所在，因为在我的应用程序中我不使用 sizeof(buffer)，而是使用 ONE_MEGA (1024* 1024)代替。

顺便说一句，还有一件事要提，但我不确定它是否有用。 将数组替换为较小的数组，例如“char buffer[1024]; 也会显着降低 cpu 使用率。

[更新3]
所有套接字都处于非阻塞模式。

Answer 1

我刚刚写了这个:

#include <iostream>
#include <cstdio>

using namespace std;

static __inline__ unsigned long long rdtsc(void)
{
    unsigned hi, lo;
    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
}

const int M = 1024*1024;

void bigstack()
{
    FILE *f = fopen("test.txt", "r");
    unsigned long long time;
    char buffer[M];

    time = rdtsc();
    fread(buffer, M, 1, f);
    time = rdtsc() - time;
    fclose(f);
    cout << "bs: Time = " << time / 1000 << endl;
}


void bigheap()
{
    FILE *f = fopen("test.txt", "r");
    unsigned long long time;
    char *buffer = new char[M];

    time = rdtsc();
    fread(buffer, M, 1, f);
    time = rdtsc() - time;
    delete [] buffer;
    fclose(f);
    cout << "bh: Time = " << time / 1000 << endl;
}



int main()
{
    for(int i = 0; i < 10; i++)
    {
    bigstack();
    bigheap();
    }
}

输出是这样的:

bs: Time = 8434
bh: Time = 7242
bs: Time = 1094
bh: Time = 2060
bs: Time = 842
bh: Time = 830
bs: Time = 785
bh: Time = 781
bs: Time = 782
bh: Time = 804
bs: Time = 782
bh: Time = 778
bs: Time = 792
bh: Time = 809
bs: Time = 785
bh: Time = 786
bs: Time = 782
bh: Time = 829
bs: Time = 786
bh: Time = 781

换句话说，从堆的栈中分配完全没有区别。开始时的少量“缓慢”与“预热缓存”有关。

而且我相当确信您的代码在两者之间表现不同的原因是其他原因 - 也许 simonc 所说:sizeof buffer 是问题所在？