이 문제의 주요 원인은 수백만 파일의 ext3 성능이지만이 문제의 실제 근본 원인은 다릅니다.

디렉토리를 나열해야 할 경우 파일 목록을 생성하는 디렉토리에서 readdir ()이 호출됩니다. readdir은 posix 호출이지만 여기서 사용되는 실제 Linux 시스템 호출은 ‘getdents’입니다. Getdents는 항목으로 버퍼를 채워서 디렉토리 항목을 나열합니다.

문제는 주로 readdir ()이 32Kb의 고정 버퍼 크기를 사용하여 파일을 가져 오는 것입니다. 디렉토리가 점점 커짐에 따라 (파일이 추가됨에 따라 크기가 커짐) ext3은 항목을 가져 오는 데 느리고 느리게되고 추가 readdir의 32Kb 버퍼 크기는 디렉토리에 항목의 일부를 포함하기에 충분합니다. 이로 인해 readdir이 반복해서 반복되어 값 비싼 시스템 호출을 반복해서 호출합니다.

예를 들어, 내부에 260 만 개가 넘는 파일로 만든 테스트 디렉토리에서 “ls -1 | wc-l”을 실행하면 많은 getdent 시스템 호출의 큰 strace 출력이 표시됩니다.

$ strace ls -1 | wc -l
brk(0x4949000)                          = 0x4949000
getdents(3, /* 1025 entries */, 32768)  = 32752
getdents(3, /* 1024 entries */, 32768)  = 32752
getdents(3, /* 1025 entries */, 32768)  = 32760
getdents(3, /* 1025 entries */, 32768)  = 32768
brk(0)                                  = 0x4949000
brk(0x496a000)                          = 0x496a000
getdents(3, /* 1024 entries */, 32768)  = 32752
getdents(3, /* 1026 entries */, 32768)  = 32760
...

또한이 디렉토리에 소요 된 시간은 상당했습니다.

$ time ls -1 | wc -l
2616044

real    0m20.609s
user    0m16.241s
sys 0m3.639s

이를보다 효율적인 프로세스로 만드는 방법은 훨씬 큰 버퍼로 수동으로 getdents를 호출하는 것입니다. 이것은 성능을 크게 향상시킵니다.

지금, 당신은 자신이 직접 그래서 인터페이스는 일반적으로 그것을 사용하는 존재하지 getdents 전화를 안하고 (볼 getdents에 대한 man 페이지를 확인!) 그러나 당신이 할 수 수동으로 전화하여 시스템 콜 호출 방법을보다 효율적으로.

이렇게하면 이러한 파일을 가져 오는 데 걸리는 시간이 크게 줄어 듭니다. 나는 이것을하는 프로그램을 썼다.

/* I can be compiled with the command "gcc -o dentls dentls.c" */

#define _GNU_SOURCE

#include <dirent.h>     /* Defines DT_* constants */
#include <err.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>

struct linux_dirent {
        long           d_ino;
        off_t          d_off;
        unsigned short d_reclen;
        char           d_name[256];
        char           d_type;
};

static int delete = 0;
char *path = NULL;

static void parse_config(
        int argc,
        char **argv)
{
    int option_idx = 0;
    static struct option loptions[] = {
      { "delete", no_argument, &delete, 1 },
      { "help", no_argument, NULL, 'h' },
      { 0, 0, 0, 0 }
    };

    while (1) {
        int c = getopt_long(argc, argv, "h", loptions, &option_idx);
        if (c < 0)
            break;

        switch(c) {
          case 0: {
              break;
          }

          case 'h': {
              printf("Usage: %s [--delete] DIRECTORY\n"
                     "List/Delete files in DIRECTORY.\n"
                     "Example %s --delete /var/spool/postfix/deferred\n",
                     argv[0], argv[0]);
              exit(0);
              break;
          }

          default:
          break;
        }
    }

    if (optind >= argc)
      errx(EXIT_FAILURE, "Must supply a valid directory\n");

    path = argv[optind];
}

int main(
    int argc,
    char** argv)
{

    parse_config(argc, argv);

    int totalfiles = 0;
    int dirfd = -1;
    int offset = 0;
    int bufcount = 0;
    void *buffer = NULL;
    char *d_type;
    struct linux_dirent *dent = NULL;
    struct stat dstat;

    /* Standard sanity checking stuff */
    if (access(path, R_OK) < 0)
        err(EXIT_FAILURE, "Could not access directory");

    if (lstat(path, &dstat) < 0)
        err(EXIT_FAILURE, "Unable to lstat path");

    if (!S_ISDIR(dstat.st_mode))
        errx(EXIT_FAILURE, "The path %s is not a directory.\n", path);

    /* Allocate a buffer of equal size to the directory to store dents */
    if ((buffer = calloc(dstat.st_size*3, 1)) == NULL)
        err(EXIT_FAILURE, "Buffer allocation failure");

    /* Open the directory */
    if ((dirfd = open(path, O_RDONLY)) < 0)
        err(EXIT_FAILURE, "Open error");

    /* Switch directories */
    fchdir(dirfd);

    if (delete) {
        printf("Deleting files in ");
        for (int i=5; i > 0; i--) {
            printf("%u. . . ", i);
            fflush(stdout);
            sleep(1);
        }
        printf("\n");
    }

    while (bufcount = syscall(SYS_getdents, dirfd, buffer, dstat.st_size*3)) {
        offset = 0;
        dent = buffer;
        while (offset < bufcount) {
            /* Don't print thisdir and parent dir */
            if (!((strcmp(".",dent->d_name) == 0) || (strcmp("..",dent->d_name) == 0))) {
                d_type = (char *)dent + dent->d_reclen-1;
                /* Only print files */
                if (*d_type == DT_REG) {
                    printf ("%s\n", dent->d_name);
                    if (delete) {
                        if (unlink(dent->d_name) < 0)
                            warn("Cannot delete file \"%s\"", dent->d_name);
                    }
                    totalfiles++;
                }
            }
            offset += dent->d_reclen;
            dent = buffer + offset;
        }
    }
    fprintf(stderr, "Total files: %d\n", totalfiles);
    close(dirfd);
    free(buffer);

    exit(0);
}

이것은 근본적인 근본적인 문제 (파일 시스템에서 성능이 떨어지는 파일 시스템의 많은 파일)와 싸우지 않습니다. 게시 된 많은 대안보다 훨씬 빠를 가능성이 큽니다.

예상대로 영향을받는 디렉토리를 제거하고 나중에 다시 만들어야합니다. 디렉토리는 크기가 커질뿐 디렉토리의 크기 때문에 파일이 몇 개 있어도 성능이 저하 될 수 있습니다.

편집 : 나는 이것을 꽤 정리했습니다. 런타임에 명령 행에서 삭제할 수있는 옵션을 추가하고 솔직히 되돌아 보면 문제가되는 트리 워크 항목을 제거했습니다. 또한 메모리 손상을 일으키는 것으로 나타났습니다.

이제 할 수 있습니다 dentls --delete /my/path

새로운 결과. 182 만 개의 파일이있는 디렉토리를 기반으로합니다.

## Ideal ls Uncached
$ time ls -u1 data >/dev/null

real    0m44.948s
user    0m1.737s
sys 0m22.000s

## Ideal ls Cached
$ time ls -u1 data >/dev/null

real    0m46.012s
user    0m1.746s
sys 0m21.805s


### dentls uncached
$ time ./dentls data >/dev/null
Total files: 1819292

real    0m1.608s
user    0m0.059s
sys 0m0.791s

## dentls cached
$ time ./dentls data >/dev/null
Total files: 1819292

real    0m0.771s
user    0m0.057s
sys 0m0.711s

이것이 여전히 잘 작동한다는 것에 놀랐습니다!

답변

rsync -a --delete ./emptyDirectoty/ ./hugeDirectory/

<?php
$dir = '/directory/in/question';
$dh = opendir($dir)) {
while (($file = readdir($dh)) !== false) {
    unlink($dir . '/' . $file);
}
closedir($dh);
?>

tune2fs -O ^has_journal <device>