Qual è il modo più efficiente in termini di risorse per contare quanti file ci sono in una directory?

CentOS 5.9

L'altro giorno ho riscontrato un problema in cui una directory conteneva molti file. Per contarlo, ho corsols -l /foo/foo2/ | wc -l

Si scopre che c'erano oltre 1 milione di file in una singola directory (lunga storia - la causa principale si sta risolvendo).

La mia domanda è: c'è un modo più veloce per fare il conteggio? Quale sarebbe il modo più efficiente per ottenere il conteggio?

Risposta breve:

\ls -afq | wc -l

(Ciò include .e .., quindi, sottrarre 2.)

Quando si elencano i file in una directory, potrebbero accadere tre cose comuni:

1. Enumerazione dei nomi dei file nella directory. Questo è inevitabile: non c'è modo di contare i file in una directory senza elencarli.
2. Ordinamento dei nomi dei file. I caratteri jolly Shell e il lscomando lo fanno.
3. Chiamata statper recuperare metadati su ciascuna voce della directory, ad esempio se si tratta di una directory.

# 3 è di gran lunga il più costoso, perché richiede il caricamento di un inode per ciascun file. In confronto, tutti i nomi di file necessari per il numero 1 sono memorizzati in modo compatto in pochi blocchi. # 2 spreca un po 'di tempo della CPU ma spesso non è un problema.

Se non ci sono newline nei nomi dei file, un semplice ls -A | wc -lti dice quanti file ci sono nella directory. Attenzione che se si dispone di un alias per ls, ciò può attivare una chiamata a stat(ad esempio ls --coloro è ls -Fnecessario conoscere il tipo di file, che richiede una chiamata a stat), quindi dalla riga di comando, chiamare command ls -A | wc -lo \ls -A | wc -lper evitare un alias.

Se ci sono newline nel nome del file, se le newline sono elencate o meno dipende dalla variante Unix. I coreutils GNU e BusyBox vengono visualizzati ?per impostazione predefinita per una nuova riga, quindi sono sicuri.

Chiama ls -fper elencare le voci senza ordinarle (# 2). Questo si accende automaticamente -a(almeno sui sistemi moderni). L' -fopzione è in POSIX ma con stato opzionale; la maggior parte delle implementazioni lo supportano, ma non BusyBox. L'opzione -qsostituisce i caratteri non stampabili incluse le nuove righe con ?; è POSIX ma non è supportato da BusyBox, quindi omettilo se hai bisogno del supporto BusyBox a spese di un numero eccessivo di file il cui nome contiene un carattere di nuova riga.

Se la directory non ha sottodirectory, la maggior parte delle versioni findnon chiamerà le statsue voci (ottimizzazione delle directory foglia: una directory che ha un numero di collegamenti pari a 2 non può avere sottodirectory, quindi findnon è necessario cercare i metadati delle voci a meno che un condizione come lo -typerichiede). Quindi find . | wc -lè un modo portatile e veloce per contare i file in una directory a condizione che la directory non abbia sottodirectory e che nessun nome di file contenga una nuova riga.

Se la directory non ha sottodirectory ma i nomi dei file possono contenere newline, prova una di queste (la seconda dovrebbe essere più veloce se supportata, ma potrebbe non esserlo in modo evidente).

find -print0 | tr -dc \\0 | wc -c
find -printf a | wc -c

D'altra parte, non usare findse la directory ha delle sottodirectory: persino find . -maxdepth 1chiamate statsu ogni voce (almeno con GNU find e BusyBox find). Eviti l'ordinamento (n. 2) ma paghi il prezzo di una ricerca inode (n. 3) che uccide le prestazioni.

Nella shell senza strumenti esterni, è possibile eseguire contare i file nella directory corrente con set -- *; echo $#. Questo manca i file punto (file il cui nome inizia con .) e riporta 1 anziché 0 in una directory vuota. Questo è il modo più veloce per contare i file in piccole directory perché non richiede l'avvio di un programma esterno, ma (tranne in zsh) fa perdere tempo per directory più grandi a causa della fase di ordinamento (# 2).

• In bash, questo è un modo affidabile per contare i file nella directory corrente:

  shopt -s dotglob nullglob
  a=(*)
  echo ${#a[@]}
  

• In ksh93, questo è un modo affidabile per contare i file nella directory corrente:

  FIGNORE='@(.|..)'
  a=(~(N)*)
  echo ${#a[@]}
  

• In zsh, questo è un modo affidabile per contare i file nella directory corrente:

  a=(*(DNoN))
  echo $#a
  

  Se avete il mark_dirsset di opzione, assicurarsi di spegnerlo: a=(*(DNoN^M)).

• In qualsiasi shell POSIX, questo è un modo affidabile per contare i file nella directory corrente:

  total=0
  set -- *
  if [ $# -ne 1 ] || [ -e "$1" ] || [ -L "$1" ]; then total=$((total+$#)); fi
  set -- .[!.]*
  if [ $# -ne 1 ] || [ -e "$1" ] || [ -L "$1" ]; then total=$((total+$#)); fi
  set -- ..?*
  if [ $# -ne 1 ] || [ -e "$1" ] || [ -L "$1" ]; then total=$((total+$#)); fi
  echo "$total"
  

Tutti questi metodi ordinano i nomi dei file, tranne quello zsh.

find /foo/foo2/ -maxdepth 1 | wc -l

È considerevolmente più veloce sulla mia macchina ma la .directory locale viene aggiunta al conteggio.

ls -1Uprima che la pipe dovrebbe spendere un po 'meno risorse, poiché non tenta di ordinare le voci del file, le legge semplicemente mentre vengono ordinate nella cartella su disco. Produce anche meno output, il che significa un po 'meno lavoro per wc.

È inoltre possibile utilizzare ls -fche è più o meno una scorciatoia per ls -1aU.

Non so se esiste un modo efficiente in termini di risorse per farlo tramite un comando senza piping.

Un altro punto di confronto. Pur non essendo un shell oneliner, questo programma C non fa nulla di superfluo. Si noti che i file nascosti vengono ignorati per corrispondere all'output di ls|wc -l( ls -l|wc -lè disattivato di uno a causa dei blocchi totali nella prima riga di output).

#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <error.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    int file_count = 0;
    DIR * dirp;
    struct dirent * entry;

    if (argc < 2)
        error(EXIT_FAILURE, 0, "missing argument");

    if(!(dirp = opendir(argv[1])))
        error(EXIT_FAILURE, errno, "could not open '%s'", argv[1]);

    while ((entry = readdir(dirp)) != NULL) {
        if (entry->d_name[0] == '.') { /* ignore hidden files */
            continue;
        }
        file_count++;
    }
    closedir(dirp);

    printf("%d\n", file_count);
}

Potresti provare perl -e 'opendir($dh,".");$i=0;while(readdir $dh){$i++};print "$i\n";'

Sarebbe interessante confrontare i tempi con il tuo tubo shell.

Da questa risposta , posso pensare a questa come una possibile soluzione.

/*
 * List directories using getdents() because ls, find and Python libraries
 * use readdir() which is slower (but uses getdents() underneath.
 *
 * Compile with 
 * ]$ gcc  getdents.c -o getdents
 */
#define _GNU_SOURCE
#include <dirent.h>     /* Defines DT_* constants */
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/syscall.h>

#define handle_error(msg) \
       do { perror(msg); exit(EXIT_FAILURE); } while (0)

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

#define BUF_SIZE 1024*1024*5

int
main(int argc, char *argv[])
{
   int fd, nread;
   char buf[BUF_SIZE];
   struct linux_dirent *d;
   int bpos;
   char d_type;

   fd = open(argc > 1 ? argv[1] : ".", O_RDONLY | O_DIRECTORY);
   if (fd == -1)
       handle_error("open");

   for ( ; ; ) {
       nread = syscall(SYS_getdents, fd, buf, BUF_SIZE);
       if (nread == -1)
           handle_error("getdents");

       if (nread == 0)
           break;

       for (bpos = 0; bpos < nread;) {
           d = (struct linux_dirent *) (buf + bpos);
           d_type = *(buf + bpos + d->d_reclen - 1);
           if( d->d_ino != 0 && d_type == DT_REG ) {
              printf("%s\n", (char *)d->d_name );
           }
           bpos += d->d_reclen;
       }
   }

   exit(EXIT_SUCCESS);
}

Copia il programma C sopra nella directory in cui devono essere elencati i file. Quindi eseguire questi comandi:

gcc getdents.c -o getdents
./getdents | wc -l

Una soluzione solo bash, che non richiede alcun programma esterno, ma non so quanto sia efficiente:

list=(*)
echo "${#list[@]}"

Probabilmente il modo più efficiente in termini di risorse non implicherebbe invocazioni di processi esterni. Quindi scommetterei su ...

cglb() ( c=0 ; set --
    tglb() { [ -e "$2" ] || [ -L "$2" ] &&
       c=$(($c+$#-1))
    }
    for glb in '.?*' \*
    do  tglb $1 ${glb##.*} ${glb#\*}
        set -- ..
    done
    echo $c
)

Dopo aver risolto il problema dalla risposta di @Joel, dove è stato aggiunto .come file:

find /foo/foo2 -maxdepth 1 | tail -n +2 | wc -l

tailrimuove semplicemente la prima riga, il che significa che .non viene più conteggiato.

os.listdir () in python può fare il lavoro per te. Fornisce una matrice del contenuto della directory, escluso lo speciale "." e '..' file. Inoltre, non è necessario preoccuparsi di file con caratteri speciali come '\ n' nel nome.

python -c 'import os;print len(os.listdir("."))'

di seguito è riportato il tempo impiegato dal comando python sopra rispetto al comando 'ls -Af'.

~ / test $ time ls -Af | wc -l
399.144

0m0.300 reali
utente 0m0.104s
sys 0m0.240s
~ / test $ time python -c 'import os; print len ​​(os.listdir ("."))'
399.142

0m0.249s reali
utente 0m0.064s
sys 0m0.180s

ls -1 | wc -lmi viene subito in mente. Che ls -1Usia più veloce di quanto ls -1sia puramente accademico, la differenza dovrebbe essere trascurabile ma per directory molto grandi.

Per escludere le sottodirectory dal conteggio, ecco una variazione sulla risposta accettata da Gilles:

echo $(( $( \ls -afq target | wc -l ) - $( \ls -od target | cut -f2 -d' ') ))

L' $(( ))espansione aritmetica esterna sottrae l'output della seconda $( )subshell dalla prima $( ). Il primo $( )è esattamente Gilles 'dall'alto. Il secondo $( )genera il conteggio delle directory che "collegano" alla destinazione. Questo deriva da ls -od(sostituire ls -ldse lo si desidera), dove la colonna che elenca il conteggio dei collegamenti reali ha questo significato speciale per le directory. Il conteggio "link" comprende ., ..e tutte le sottodirectory.

Non ho testato le prestazioni, ma sembrerebbe simile. Aggiunge una stat della directory di destinazione e un certo sovraccarico per la subshell e la pipe aggiunte.

Penserei che l'eco * sia più efficiente di qualsiasi comando 'ls':

echo * | wc -w