3

有哪些方法可以尝试在循环内限制send/函数。sendto()我正在为我的网络创建一个端口扫描仪，我尝试了两种方法，但它们似乎只在本地工作（当我在我的家用机器上测试它们时它们工作，但是当我尝试在另一台机器上测试它们时它不想创建适当的油门）。

方法一

我最初是/proc/net/dev在“发送的字节数”属性中解析和读取的，并以此为基础。这在本地有效（睡眠延迟正在调整以调整带宽流），但是当我在另一台服务器上尝试它时，/proc/net/dev它似乎也没有正确调整数据。我dstat在一台本地扫描的机器上运行，它正在快速输出大量数据。

方法二

然后，我尝试跟踪我发送的总字节数，并将其添加到total_sent我的带宽线程将读取并计算睡眠计时器的变量中。这也适用于我的本地机器，但是当我在服务器上尝试它时，它说每次我的带宽线程检查total_sent使我的带宽线程将睡眠减少到 0 时它只发送 1-2 个数据包，但即使在 0 时total_sent变量确实由于睡眠时间减少而不会增加，而是保持不变。

总的来说，我想要一种方法来监视 Linux 计算机的带宽并计算我可以在每个/套接字调用usleep()之前或之后传递的睡眠时间，以限制带宽。sendsendto()

编辑：我忘了提到的其他一些事情是我确实有一个速度测试功能来计算机器的上传速度，并且我有 2 个线程。1个线程根据带宽使用情况调整全局睡眠计时器，线程2将数据包发送到远程机器上的端口以测试它们是否打开并对其进行指纹识别（现在我只是使用带有a的udp数据包sendto()来测试这一切） .

如何使用. send_sendto()usleep()

编辑：这是我的带宽监控线程的代码。不要担心结构的东西，这只是我将数据传递给线程的方式。

void *bandwidthmonitor_cmd(void *param)
{
  int i = 0;
  double prevbytes = 0, elapsedbytes = 0, byteusage = 0, maxthrottle = 0;

  //recreating my param struct i passed to the thread
  command_struct bandwidth = *((command_struct *)param);
  free(param);

  //set SLEEP (global variable) to a base time in case it was edited and not reset
  SLEEP = 5000;

  //find the maximum throttle speed in kb/s (takes the global var UPLOAD_SPEED
  //which is in kb/s and times it by how much bandwidth % you want to use
  //and devides by 100 to find the maximum in kb/s
  //ex: UPLOAD_SPEED = 60, throttle = 90, maxthrottle = 54
  maxthrottle = (UPLOAD_SPEED * bandwidth.throttle) / 100;
  printf("max throttle: %.1f\n", maxthrottle);

  while(1)
  {
      //find out how many bytes elapsed since last polling of the thread
      elapsedbytes = TOTAL_BYTES_SEND - prevbytes;
      printf("elapsedbytes: %.1f\n", elapsedbytes);

      //set prevbytes to our current bytes so we can have results next loop
      prevbytes = TOTAL_BYTES_SEND;

      //convert our bytes to kb/s
      byteusage = 8 * (elapsedbytes / 1024);

      //throttle control to make it adjust sleep 20 times every 30~ 
      //iterations of the loop
      if(i & 0x40)
      {
           //adjust SLEEP by 1.1 gain
           SLEEP += (maxthrottle - byteusage) * -1.1;//;


           if(SLEEP < 0){
               SLEEP = 0;
           }
           printf("sleep:%.1f\n\n", SLEEP);
      }

      //sleep the thread for a short bit then start the process over
      usleep(25000);
      //increment variable i for our iteration throttling
      i++;
  }

}

我的发送线程只是一个循环发送 udp 数据包进行测试的简单sendto()例程。is my ,是一个 64 字节的字符数组，用“A”填充，并且is 。while(1)socksockfdbuffsinmy sockaddr_in

  while(1)
  {
    TOTAL_BYTES_SEND += 64;

    sendto(sock, buff, strlen(buff), 0, (struct sockaddr *) &sin, sizeof(sin))


    usleep(SLEEP);
  }

我知道我的套接字功能可以工作，因为我可以在dstat本地机器和远程机器上看到使用情况。此带宽代码适用于我的本地系统（所有变量都应更改）但在服务器上我尝试对经过的字节进行测试并没有更改（每次线程迭代始终为 64/128）并导致SLEEP限制为 0理论上应该使机器更快地发送数据包，但即使SLEEP等于 0 elapsedbytes 仍然是 64/128。我还在sendto()if 语句中对函数进行了编码，检查返回 -1 的函数并通过printf-ing 错误代码来提醒我，但在我所做的测试中没有一个。

4

2 回答 2

4

似乎这可以通过计算发送线程中的节流睡眠时间来最直接地解决。我不确定我是否看到另一个线程来完成这项工作的好处。

这是执行此操作的一种方法：

选择一个时间窗口，您将在其中测量您的发送速率。根据您的目标带宽，这将为您提供该时间段的最大字节数。然后，您可以检查是否在每次 sendto() 之后发送了那么多字节。如果您确实超过了字节阈值，则睡眠直到窗口结束以执行限制。

这是一些未经测试的代码，展示了这个想法。抱歉，clock_gettime 和 struct timespec 增加了一些复杂性。谷歌有一些很好的代码片段，用于使用 struct timespec 进行更完整的比较、加法和减法。

#define MAX_BYTES_PER_SECOND (128L * 1024L)
#define TIME_WINDOW_MS 50L
#define MAX_BYTES_PER_WINDOW ((MAX_BYTES_PER_SECOND * TIME_WINDOW_MS) / 1000L)

#include <time.h>
#include <stdlib.h>

int foo(void) {
  struct timespec window_start_time;

  size_t bytes_sent_in_window = 0;
  clock_gettime(CLOCK_REALTIME, &window_start_time);

  while (1) {
    size_t bytes_sent = sendto(sock, buff, strlen(buff), 0, (struct sockaddr *) &sin, sizeof(sin));
    if (bytes_sent < 0) {
      // error handling
    } else {
      bytes_sent_in_window += bytes_sent;

      if (bytes_sent_in_window >= MAX_BYTES_PER_WINDOW) {
        struct timespec now;
        struct timespec thresh;

        // Calculate the end of the window
        thresh.tv_sec = window_start_time.tv_sec;
        thresh.tv_nsec = window_start_time.tv_nsec;
        thresh.tv_nsec += TIME_WINDOW_MS * 1000000;
        if (thresh.tv_nsec > 1000000000L) {
          thresh.tv_sec += 1;
          thresh.tv_nsec -= 1000000000L;
        }

        // get the current time
        clock_gettime(CLOCK_REALTIME, &now);

        // if we have not gotten to the end of the window yet
        if (now.tv_sec < thresh.tv_sec ||
            (now.tv_sec == thresh.tv_sec && now.tv_nsec < thresh.tv_nsec)) {

          struct timespec remaining;

          // calculate the time remaining in the window
          //  - See google for more complete timespec subtract algorithm
          remaining.tv_sec = thresh.tv_sec - now.tv_sec;
          if (thresh.tv_nsec >= now.tv_nsec) {
            remaining.tv_nsec = thresh.tv_nsec - now.tv_nsec;
          } else {
            remaining.tv_nsec = 1000000000L + thresh.tv_nsec - now.tv_nsec;
            remaining.tv_sec -= 1;
          }

          // Sleep to end of window
          nanosleep(&remaining, NULL);
        }

        // Reset counters and timestamp for next window
        bytes_sent_in_window = 0;
        clock_gettime(CLOCK_REALTIME, &window_start_time);
      }
    }
  }
}
于 2012-11-26T05:38:40.630 回答
1

如果您想在应用程序级别执行此操作，您可以使用诸如涓流之类的实用程序来限制或调整应用程序可用的套接字传输速率。

例如，

trickle -s -d 50 -w 100 firefox

将从firefox50KB/s 的最大下载速率和 100KB 的峰值检测窗口开始。更改这些值可能会产生适合您的应用程序测试的东西。

于 2012-11-26T14:52:01.750 回答