Início / unix / Perguntas / 784690
Accepted
Ole Tange
Asked: 2024-10-08 05:18:04 +0800 CST

Limitar velocidade de E/S de arquivo

  • 772

Estou procurando um comando semelhante ao ioniceand trickleand pv -Land tc-, mas que coloque limites de E/S em arquivos.

ioniceolha para dispositivos de bloco na máquina local. Quero que isso funcione para E/S de arquivo em geral. Se não funcionar para encfs montados em NFS, é inútil para mim.

tricklemolda a E/S da rede - não a E/S do sistema de arquivos. Então, se meu programa acessa um arquivo no encfs, ele não terá nenhuma pista se ele está montado em cima do NFS ou de um diretório local.

tcé semelhante a trickle: Ele molda a E/S da rede - não a E/S do sistema de arquivos.

pv -Lsó funciona em pipes. Preciso que funcione em todos os arquivos que o programa abre. Pense no Firefox: ele abre arquivos para leitura e escrita em vários threads.

Eu quero isso:

thecommand --read 5M --write 1M firefox

limitar firefoxa leitura de arquivos a 5 MB/s e a gravação a 1 MB/s.

firefoxé apenas um exemplo: quero que funcione para qualquer programa que abra arquivos diferentes para leitura e escrita.

Quero que a limitação funcione não importa se firefoxo acesso é a um arquivo local ou a um arquivo em NFS/tmpfs/encfs/SSHFS/RandomFS.

Não tem problema se ele só funcionar em programas vinculados dinamicamente (ou seja, não tem problema se ele fizer alguma mágica LD_PRELOAD).

Existe uma fera dessas?

nfs

4 respostas

  1. Best Answer

    Solução ruim:

    #define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <time.h>
#include <errno.h>

#define LIMIT_MB_PER_SEC 1
#define LIMIT_BYTES_PER_SEC (LIMIT_MB_PER_SEC * 1024 * 1024)

ssize_t (*real_read)(int fd, void *buf, size_t count) = NULL;
ssize_t (*real_write)(int fd, const void *buf, size_t count) = NULL;

static size_t bytes_transferred = 0;
static struct timespec start_time;

void init() {
    real_read = dlsym(RTLD_NEXT, "read");
    real_write = dlsym(RTLD_NEXT, "write");
    clock_gettime(CLOCK_MONOTONIC, &start_time);
}

void sleep_if_needed(size_t bytes) {
    struct timespec current_time;
    clock_gettime(CLOCK_MONOTONIC, &current_time);

    size_t elapsed_sec = current_time.tv_sec - start_time.tv_sec;
    size_t elapsed_nsec = current_time.tv_nsec - start_time.tv_nsec;

    double elapsed_time = elapsed_sec + elapsed_nsec / 1e9;

    if (elapsed_time >= 1.0) {
        // Reset for next second
        start_time = current_time;
        bytes_transferred = 0;
    }

    bytes_transferred += bytes;

    if (bytes_transferred > LIMIT_BYTES_PER_SEC) {
        double excess_time = (bytes_transferred - LIMIT_BYTES_PER_SEC) / (double)LIMIT_BYTES_PER_SEC;
        usleep((useconds_t)(excess_time * 1e6));  // Sleep to limit speed
    }
}

ssize_t read(int fd, void *buf, size_t count) {
    if (!real_read) init();

    ssize_t result = real_read(fd, buf, count);
    if (result > 0) {
        sleep_if_needed(result);
    }
    return result;
}

ssize_t write(int fd, const void *buf, size_t count) {
    if (!real_write) init();

    ssize_t result = real_write(fd, buf, count);
    if (result > 0) {
        sleep_if_needed(result);
    }
    return result;
}

    Correr:

    gcc -fPIC -shared -o limitrate.so -ldl limitrate.c
LD_PRELOAD=./limitrate.so time wc /tmp/test10M

    Grande desvantagem: não aceita opções de velocidade, mas pode ser base para outra resposta.

    Embora seja uma solução ruim, a funcionalidade principal praticamente faz a coisa certa: funciona em todos os arquivos interceptando reade write. Não importa se os arquivos estão armazenados localmente ou em um sistema de arquivos de rede. Não requer nenhuma configuração especializada que exija acesso root.

    Editar:

    Agora transformado em uma pequena ferramenta de linha de comando: https://git.data.coop/tange/tangetools/src/branch/master/iothrottle

    • 5

  2. Não estou em condições de escrever uma resposta legal com um exemplo, mas cgroupsposso fazer isso por você; systemd-runé seu amigo quando se executa algo em um escopo com recursos limitados.

    • 4

  3. A documentação está um pouco desatualizada, mas configurar o controle de tráfego tcpode ser uma opção.

    https://lartc.org/howto/

    • 0

  4. trickleirá limitar a taxa do lado do modo de usuário. Geralmente muito eficaz

    • 0

relate perguntas