Я пытаюсь найти лучший способ найти количество файлов в определенном каталоге, когда существует очень большое количество файлов (> 100 000).

Когда файлов столько, выполнение ls | wc -lзанимает довольно много времени. Я считаю, что это потому, что он возвращает имена всех файлов. Я пытаюсь занять как можно меньше дискового ввода-вывода.

Я экспериментировал с некоторыми сценариями оболочки и Perl безрезультатно. Любые идеи?

По умолчанию lsсортирует имена, что может занять некоторое время, если их много. Также не будет вывода, пока все имена не будут прочитаны и отсортированы. Используйте ls -fопцию, чтобы отключить сортировку.

ls -f | wc -l

Обратите внимание , что это также позволит -a, так ., ..и другие файлы , начинающиеся с .будут учитываться.

Самый быстрый способ - это специальная программа, например:

#include <stdio.h>
#include <dirent.h>

int main(int argc, char *argv[]) {
    DIR *dir;
    struct dirent *ent;
    long count = 0;

    dir = opendir(argv[1]);

    while((ent = readdir(dir)))
            ++count;

    closedir(dir);

    printf("%s contains %ld files\n", argv[1], count);

    return 0;
}

Из моего тестирования без учета кеширования я запускал каждый из них примерно по 50 раз в одном и том же каталоге, снова и снова, чтобы избежать перекоса данных на основе кеша, и я получил примерно следующие показатели производительности (в реальном времени):

ls -1  | wc - 0:01.67
ls -f1 | wc - 0:00.14
find   | wc - 0:00.22
dircnt | wc - 0:00.04

Последняя dircnt, это программа, скомпилированная из вышеуказанного источника.

РЕДАКТИРОВАТЬ 2016-09-26

По многочисленным просьбам я переписал эту программу, сделав ее рекурсивной, чтобы она переместилась в подкаталоги и продолжала отдельно подсчитывать файлы и каталоги.

Поскольку ясно, что некоторые люди хотят знать, как все это сделать, у меня есть много комментариев в коде, чтобы попытаться понять, что происходит. Я написал это и протестировал на 64-битном Linux, но он должен работать на любой POSIX-совместимой системе, включая Microsoft Windows. Сообщения об ошибках приветствуются; Я рад обновить это, если вы не можете заставить его работать на вашем AIX или OS / 400 или чем-то еще.

Как видите, это много сложнее, чем оригинал, и обязательно так: должна существовать по крайней мере одна функция для рекурсивного вызова, если вы не хотите, чтобы код стал очень сложным (например, управление стеком подкаталогов и обработка его в одном цикле). Поскольку мы должны проверять типы файлов, в игру вступают различия между различными ОС, стандартными библиотеками и т. Д., Поэтому я написал программу, которая пытается работать в любой системе, где она будет компилироваться.

Проверки ошибок очень мало, и сама countфункция на самом деле не сообщает об ошибках. Единственные вызовы, которые могут действительно потерпеть неудачу, это opendirи stat(если вам не повезло, и у вас есть система, в которой уже direntесть тип файла). Я не параноик по поводу проверки общей длины имен пути subdir, но теоретически система не должна разрешать любое имя пути длиннее, чем PATH_MAX. Если есть сомнения, я могу это исправить, но это просто дополнительный код, который нужно объяснить тому, кто учится писать C. Эта программа предназначена для того, чтобы быть примером того, как рекурсивно погружаться в подкаталоги.

#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/stat.h>

#if defined(WIN32) || defined(_WIN32) 
#define PATH_SEPARATOR '\\' 
#else
#define PATH_SEPARATOR '/' 
#endif

/* A custom structure to hold separate file and directory counts */
struct filecount {
  long dirs;
  long files;
};

/*
 * counts the number of files and directories in the specified directory.
 *
 * path - relative pathname of a directory whose files should be counted
 * counts - pointer to struct containing file/dir counts
 */
void count(char *path, struct filecount *counts) {
    DIR *dir;                /* dir structure we are reading */
    struct dirent *ent;      /* directory entry currently being processed */
    char subpath[PATH_MAX];  /* buffer for building complete subdir and file names */
    /* Some systems don't have dirent.d_type field; we'll have to use stat() instead */
#if !defined ( _DIRENT_HAVE_D_TYPE )
    struct stat statbuf;     /* buffer for stat() info */
#endif

/* fprintf(stderr, "Opening dir %s\n", path); */
    dir = opendir(path);

    /* opendir failed... file likely doesn't exist or isn't a directory */
    if(NULL == dir) {
        perror(path);
        return;
    }

    while((ent = readdir(dir))) {
      if (strlen(path) + 1 + strlen(ent->d_name) > PATH_MAX) {
          fprintf(stdout, "path too long (%ld) %s%c%s", (strlen(path) + 1 + strlen(ent->d_name)), path, PATH_SEPARATOR, ent->d_name);
          return;
      }

/* Use dirent.d_type if present, otherwise use stat() */
#if defined ( _DIRENT_HAVE_D_TYPE )
/* fprintf(stderr, "Using dirent.d_type\n"); */
      if(DT_DIR == ent->d_type) {
#else
/* fprintf(stderr, "Don't have dirent.d_type, falling back to using stat()\n"); */
      sprintf(subpath, "%s%c%s", path, PATH_SEPARATOR, ent->d_name);
      if(lstat(subpath, &statbuf)) {
          perror(subpath);
          return;
      }

      if(S_ISDIR(statbuf.st_mode)) {
#endif
          /* Skip "." and ".." directory entries... they are not "real" directories */
          if(0 == strcmp("..", ent->d_name) || 0 == strcmp(".", ent->d_name)) {
/*              fprintf(stderr, "This is %s, skipping\n", ent->d_name); */
          } else {
              sprintf(subpath, "%s%c%s", path, PATH_SEPARATOR, ent->d_name);
              counts->dirs++;
              count(subpath, counts);
          }
      } else {
          counts->files++;
      }
    }

/* fprintf(stderr, "Closing dir %s\n", path); */
    closedir(dir);
}

int main(int argc, char *argv[]) {
    struct filecount counts;
    counts.files = 0;
    counts.dirs = 0;
    count(argv[1], &counts);

    /* If we found nothing, this is probably an error which has already been printed */
    if(0 < counts.files || 0 < counts.dirs) {
        printf("%s contains %ld files and %ld directories\n", argv[1], counts.files, counts.dirs);
    }

    return 0;
}

РЕДАКТИРОВАТЬ 2017-01-17

Я включил два изменения, предложенные @FlyingCodeMonkey:

1. Используйте lstatвместо stat. Это изменит поведение программы, если у вас есть каталоги с символическими ссылками в каталоге, который вы сканируете. Предыдущее поведение состояло в том, что (связанный) подкаталог будет иметь свое количество файлов, добавленное к общему количеству; новое поведение заключается в том, что связанный каталог будет учитываться как один файл, а его содержимое не будет учитываться.
2. Если путь к файлу слишком длинный, выдается сообщение об ошибке и программа останавливается.

РЕДАКТИРОВАТЬ 2017-06-29

Если повезет, это будет последняя редакция этого ответа :)

Я скопировал этот код в репозиторий GitHub, чтобы немного упростить получение кода (вместо копирования / вставки вы можете просто загрузить исходный код ), плюс он позволяет любому предложить модификацию, отправив извлечение -запрос от GitHub.

Исходный код доступен по лицензии Apache License 2.0. Патчи ^* добро пожаловать!

• «патч» - это то, что старые люди, такие как я, называют «запросом на получение ответа»

Вы пытались найти? Например:

find . -name "*.ext" | wc -l

find, ls и perl протестированы на 40000 файлов: одинаковая скорость (хотя я не пробовал очищать кеш):

[user@server logs]$ time find . | wc -l
42917

real    0m0.054s
user    0m0.018s
sys     0m0.040s
[user@server logs]$ time /bin/ls -f | wc -l
42918

real    0m0.059s
user    0m0.027s
sys     0m0.037s

и с perl opendir / readdir одновременно:

[user@server logs]$ time perl -e 'opendir D, "."; @files = readdir D; closedir D; print scalar(@files)."\n"'
42918

real    0m0.057s
user    0m0.024s
sys     0m0.033s

примечание: я использовал / bin / ls -f, чтобы обойти опцию псевдонима, которая может немного замедлиться, и -f, чтобы избежать упорядочения файлов. ls без -f в два раза медленнее, чем find / perl, за исключением того, что ls используется с -f, похоже, это то же самое время:

[user@server logs]$ time /bin/ls . | wc -l
42916

real    0m0.109s
user    0m0.070s
sys     0m0.044s

Я также хотел бы иметь некоторый сценарий для запроса файловой системы напрямую без всей ненужной информации.

тесты, основанные на ответе Питера ван дер Хейдена, Гленна Джекмана и mark4o.

Томас

Вы можете изменить вывод в соответствии с вашими требованиями, но вот одна строчка из bash, которую я написал для рекурсивного подсчета и представления количества файлов в серии каталогов с числовыми именами.

dir=/tmp/count_these/ ; for i in $(ls -1 ${dir} | sort -n) ; { echo "$i => $(find ${dir}${i} -type f | wc -l),"; }

Это выглядит рекурсивно для всех файлов (не каталогов) в данном каталоге и возвращает результаты в хэш-подобном формате. Простые настройки команды find могут сделать файлы, которые вы хотите подсчитывать, более конкретными и т. Д.

Результаты примерно такие:

1 => 38,
65 => 95052,
66 => 12823,
67 => 10572,
69 => 67275,
70 => 8105,
71 => 42052,
72 => 1184,

Удивительно для меня, но простая находка очень похожа на ls -f

> time ls -f my_dir | wc -l
17626

real    0m0.015s
user    0m0.011s
sys     0m0.009s

против

> time find my_dir -maxdepth 1 | wc -l
17625

real    0m0.014s
user    0m0.008s
sys     0m0.010s

Конечно, значения в третьем десятичном знаке немного сдвигаются при каждом выполнении любого из них, поэтому они в основном идентичны. Обратите внимание, однако, что это findвозвращает одну дополнительную единицу, потому что она считает сам фактический каталог (и, как упоминалось ранее, ls -fвозвращает две дополнительные единицы, поскольку она также учитывает. И ..).

Просто добавляю это для полноты картины. Правильный ответ, конечно, уже был опубликован кем-то другим, но вы также можете получить количество файлов и каталогов с помощью древовидной программы.

Запустите команду, tree | tail -n 1чтобы получить последнюю строку, в которой будет что-то вроде «763 каталога, 9290 файлов». При этом файлы и папки подсчитываются рекурсивно, за исключением скрытых файлов, которые можно добавить с помощью флага -a. Для справки, на моем компьютере понадобилось 4,8 секунды, чтобы дерево посчитало весь мой домашний каталог, который был 24777 каталогов, 238680 файлов. find -type f | wc -lзанял 5,3 секунды, на полсекунды дольше, так что я думаю, что дерево довольно конкурентоспособно по скорости.

Если у вас нет вложенных папок, дерево - это быстрый и простой способ подсчета файлов.

Кроме того, и просто для удовольствия, вы можете использовать, tree | grep '^├'чтобы показывать только файлы / папки в текущем каталоге - это в основном намного более медленная версия ls.

Fast Linux File Count

Самый быстрый счетчик файлов Linux, который я знаю,

locate -c -r '/home'

Там нет нет необходимости вызывать Grep! Но, как уже упоминалось, у вас должна быть свежая база данных (ежедневно обновляемая заданием cron или вручную sudo updatedb).

От человека найти

-c, --count
    Instead  of  writing  file  names on standard output, write the number of matching
    entries only.

Кроме того, вы должны знать, что он также считает каталоги файлами!

Кстати: если вам нужен обзор ваших файлов и каталогов в вашей системе, введите

locate -S

Выводит количество каталогов, файлов и т. Д.

Пишу здесь, поскольку у меня недостаточно репутационных баллов, чтобы комментировать ответ, но мне разрешено оставлять свой собственный ответ, что не имеет смысла. Тем не мение...

Что касается ответа Кристофера Шульца , я предлагаю изменить stat на lstat и, возможно, добавить проверку границ, чтобы избежать переполнения буфера:

if (strlen(path) + strlen(PATH_SEPARATOR) + strlen(ent->d_name) > PATH_MAX) {
    fprintf(stdout, "path too long (%ld) %s%c%s", (strlen(path) + strlen(PATH_SEPARATOR) + strlen(ent->d_name)), path, PATH_SEPARATOR, ent->d_name);
    return;
}

Предложение использовать lstat - избегать использования символических ссылок, которые могут привести к циклам, если каталог содержит символическую ссылку на родительский каталог.

Вы могли бы попробовать , если используется opendir()и readdir()в Perlбыстрее. Пример этой функции можно найти здесь

Этот ответ здесь быстрее, чем почти все остальное на этой странице для очень больших, очень вложенных каталогов:

https://serverfault.com/a/691372/84703

locate -r '.' | grep -c "^$PWD"

Я пришел сюда, когда пытался сосчитать файлы в наборе данных ~ 10K папок с ~ 10K файлами в каждой. Проблема многих подходов заключается в том, что они неявно оценивают файлы размером 100 млн., Что занимает много времени.

Я взял на себя смелость расширить подход Кристофера-Шульца, чтобы он поддерживал передачу каталогов через args (его рекурсивный подход также использует stat).

Поместите в файл следующее dircnt_args.c:

#include <stdio.h>
#include <dirent.h>

int main(int argc, char *argv[]) {
    DIR *dir;
    struct dirent *ent;
    long count;
    long countsum = 0;
    int i;

    for(i=1; i < argc; i++) {
        dir = opendir(argv[i]);
        count = 0;
        while((ent = readdir(dir)))
            ++count;

        closedir(dir);

        printf("%s contains %ld files\n", argv[i], count);
        countsum += count;
    }
    printf("sum: %ld\n", countsum);

    return 0;
}

После gcc -o dircnt_args dircnt_args.cвы можете вызвать его так:

dircnt_args /your/dirs/*

На 100M файлах в 10K папках описанное выше выполняется довольно быстро (~ 5 минут для первого запуска, отслеживание в кэше: ~ 23 с).

Единственный подход , который закончил менее чем через час был Ls с примерно 1 мин на кэш: ls -f /your/dirs/* | wc -l. Счетчик сбился на пару символов новой строки в каталоге ...

Помимо ожидаемого, ни одна из моих попыток не findвернулась в течение часа: - /

Самый быстрый способ в linux (вопрос помечен как linux) - использовать прямой системный вызов. Вот небольшая программа, которая считает файлы (только без каталогов) в каталоге. Вы можете считать миллионы файлов, и это примерно в 2,5 раза быстрее, чем "ls -f", и примерно в 1,3-1,5 раза быстрее, чем ответ Кристофера Шульца.

#define _GNU_SOURCE
#include <dirent.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/syscall.h>

#define BUF_SIZE 4096

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

int countDir(char *dir) {


    int fd, nread, bpos, numFiles = 0;
    char d_type, buf[BUF_SIZE];
    struct linux_dirent *dirEntry;

    fd = open(dir, O_RDONLY | O_DIRECTORY);
    if (fd == -1) {
        puts("open directory error");
        exit(3);
    }
    while (1) {
        nread = syscall(SYS_getdents, fd, buf, BUF_SIZE);
        if (nread == -1) {
            puts("getdents error");
            exit(1);
        }
        if (nread == 0) {
            break;
        }

        for (bpos = 0; bpos < nread;) {
            dirEntry = (struct linux_dirent *) (buf + bpos);
            d_type = *(buf + bpos + dirEntry->d_reclen - 1);
            if (d_type == DT_REG) {
                // Increase counter
                numFiles++;
            }
            bpos += dirEntry->d_reclen;
        }
    }
    close(fd);

    return numFiles;
}

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

    if (argc != 2) {
        puts("Pass directory as parameter");
        return 2;
    }
    printf("Number of files in %s: %d\n", argv[1], countDir(argv[1]));
    return 0;
}

PS: Это не рекурсивно, но вы можете изменить его для этого.

lsтратит больше времени на сортировку имен файлов, использование -fдля отключения сортировки сэкономит время:

ls -f | wc -l

или вы можете использовать find:

find . -type f | wc -l

Я понял, что не использовать обработку памяти, когда у вас есть огромное количество данных, быстрее, чем "конвейерная обработка" команд. Я сохранил результат в файл и проанализировал его.

ls -1 /path/to/dir > count.txt && cat count.txt | wc -l

Вместо ls / find следует использовать "getdent".

Вот одна очень хорошая статья, в которой описан подход гетедентов.

http://be-n.com/spw/you-can-list-a-million-files-in-a-directory-but-not-with-ls.html

Вот выдержка:

ls и практически любой другой способ перечисления каталога (включая python os.listdir, find.) полагаются на libc readdir (). Однако readdir () считывает только 32 КБ записей каталога за раз, что означает, что если у вас много файлов в одном каталоге (то есть, 500 М записей каталога), это займет безумно много времени, чтобы прочитать все записи каталога. , особенно на медленном диске. Для каталогов, содержащих большое количество файлов, вам нужно копать глубже, чем инструменты, которые полагаются на readdir (). Вам нужно будет использовать системный вызов getdent () напрямую, а не вспомогательные методы из libc.

Мы можем найти код C для вывода списка файлов с помощью getdent () отсюда :

Вам нужно будет сделать две модификации, чтобы быстро вывести список всех файлов в каталоге.

Во-первых, увеличьте размер буфера с X примерно до 5 мегабайт.

#define BUF_SIZE 1024*1024*5

Затем измените основной цикл, где он печатает информацию о каждом файле в каталоге, чтобы пропустить записи с inode == 0. Я сделал это, добавив

if (dp->d_ino != 0) printf(...);

В моем случае я действительно заботился только об именах файлов в каталоге, поэтому я также переписал оператор printf (), чтобы печатать только имя файла.

if(d->d_ino) printf("%sn ", (char *) d->d_name);

Скомпилируйте его (ему не нужны внешние библиотеки, поэтому это очень просто сделать)

gcc listdir.c -o listdir

Теперь просто беги

./listdir [directory with insane number of files]

Я предпочитаю следующую команду, чтобы отслеживать изменения количества файлов в каталоге.

watch -d -n 0.01 'ls | wc -l'

Команда будет держать окно открытым, чтобы отслеживать количество файлов в каталоге с частотой обновления 0,1 с.

Первые 10 директоров с наибольшим количеством файлов.

dir=/ ; for i in $(ls -1 ${dir} | sort -n) ; { echo "$(find ${dir}${i} \
    -type f | wc -l) => $i,"; } | sort -nr | head -10