hacer salida estándar con velocidad específica

Question

Para una prueba de carga de mi aplicación (en Linux), estoy buscando una herramienta que muestre datos en stdout a una velocidad específica (como 100 bytes/s), para que pueda canalizar la salida a netcat que lo envía a mi aplicación. Alguna opción para dd sería ideal, pero no encontré nada hasta ahora. Realmente no importa qué tipo de datos se imprimen (los bytes NUL son correctos). ¿Algún consejo?

Answer 1

creo que esto es lo que realmente quiere: Pipe Viewer

El uso de <fast input> | pv -qL <rate>[k|m|g|t] | <rate-limited output> limitará la tubería a la tasa solicitada.

Answer 2

Si está bien con obtener todos los cientos de bytes a la vez, puede hacer un ciclo con sleep y echo en el shell como primer intento al menos.

Answer 3

Bueno, ahora estoy usando nuttcp para hacer pruebas de carga "reales" en su lugar. Parece tener una sobrecarga bastante baja, por lo que el sistema de prueba no está demasiado alterado.

Answer 4

Escribí un programa rápido que toma un argumento, cuántos caracteres A imprimir en salida estándar por segundo (argumento negativo significa que no hay límite de velocidad). ¡Espero que esto ayude! :-) (En GNU libc, necesitará vincular su programa con -lrt.)

Editar: revisado para imprimir punto por defecto, a menos que se especifique un segundo argumento, en cuyo caso se utiliza el primer carácter de ese. (Y eso significa que, si se desea imprimir el carácter NUL, basta con especificar una cadena vacía como el segundo argumento :-).)

#include <math.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
#include <unistd.h> 

int 
sleeptill(const struct timespec *when) 
{ 
    struct timespec now, diff; 

    clock_gettime(CLOCK_REALTIME, &now); 
    diff.tv_sec = when->tv_sec - now.tv_sec; 
    diff.tv_nsec = when->tv_nsec - now.tv_nsec; 
    while (diff.tv_nsec < 0) { 
     diff.tv_nsec += 1000000000; 
     --diff.tv_sec; 
    } 
    if (diff.tv_sec < 0) 
     return 0; 
    return nanosleep(&diff, 0); 
} 

int 
main(int argc, char **argv) 
{ 
    double rate = 0.0; 
    char *endp; 
    struct timespec start; 
    double offset; 

    if (argc >= 2) { 
     rate = strtod(argv[1], &endp); 
     if (endp == argv[1] || *endp) 
      rate = 0.0; 
     else 
      rate = 1/rate; 

     if (!argv[2]) 
      argv[2] = "."; 
    } 

    if (!rate) { 
     fprintf(stderr, "usage: %s rate [char]\n", argv[0]); 
     return 1; 
    } 

    clock_gettime(CLOCK_REALTIME, &start); 
    offset = start.tv_nsec/1000000000.0; 

    while (1) { 
     struct timespec till = start; 
     double frac; 
     double whole; 

     frac = modf(offset += rate, &whole); 
     till.tv_sec += whole; 
     till.tv_nsec = frac * 1000000000.0; 
     sleeptill(&till); 
     write(STDOUT_FILENO, argv[2], 1); 
    } 
}