moyen le plus rapide de faire la somme des tailles de fichier par propriétaire dans un répertoire

Analyse de la sortie de ls - mauvaise idée.

Pourquoi ne pas utiliser find à la place?

• démarrer dans le répertoire $ {dir}
  • limite à ce niveau de répertoire ( -maxdepth 1 )
  • limite aux fichiers ( -type f )
  • imprimer une ligne avec le nom d'utilisateur et la taille du fichier en octets ( -printf "% u% s \ n" )
• exécuter les résultats via un filtre Perl
  • diviser chaque ligne ( -a )
  • ajouter à un hachage sous clé (champ 0) la taille (champ 1)
  • à la fin ( END {...} ) affiche le contenu du hachage, trié par clé, c'est-à-dire par nom d'utilisateur

$ perl dummy.pl .
1000 263618544

Une solution utilisant Perl:

#!/usr/bin/perl
use strict;
use warnings;
use autodie;

use File::Spec;

my %users;
foreach my $dir (@ARGV) {
    opendir(my $dh, $dir);

    # files in this directory
    while (my $entry = readdir($dh)) {
        my $file = File::Spec->catfile($dir, $entry);

        # only files
        if (-f $file) {
            my($uid, $size) = (stat($file))[4, 7];
            $users{$uid} += $size
        }
    }

    closedir($dh);
}

print "$_ $users{$_}\n" foreach (sort keys %users);

exit 0;

Exécution du test:

$ find ${dir} -maxdepth 1 -type f -printf "%u %s\n" | \
     perl -ane '$s{$F[0]} += $F[1]; END { print "$_ $s{$_}\n" foreach (sort keys %s); }'
stefanb 263305714

Je ne sais pas pourquoi la question est balisée en perl lorsque awk est utilisé.

Voici une version simple de Perl:

#!/usr/bin/perl

chdir($ARGV[0]) or die("Usage: $0 dir\n");

map {
    if ( ! m/^[.][.]?$/o ) {
        ($s,$u) = (stat)[7,4];
        $h{$u} += $s;
    }
} glob ".* *";

map {
    $s = $h{$_};
    $u = !( $s      >>10) ? ""
       : !(($s>>=10)>>10) ? "k"
       : !(($s>>=10)>>10) ? "M"
       : !(($s>>=10)>>10) ? "G"
       :   ($s>>=10)      ? "T"
       :                    undef
       ;
    printf "%-8s %12d\t%s\n", $s.$u, $h{$_}, getpwuid($_)//$_;
} keys %h;

• glob obtient notre liste de fichiers
• m // rejette . et ..
• stat la taille et l'uid
• accumuler des tailles dans %h
• calculer l'unité par décalage de bits ( >> 10 est une division entière par 1024)
• mapper l'uid au nom d'utilisateur ( // fournit une solution de secours)
• résultats d'impression (non triés)
• REMARQUE: contrairement à certaines autres réponses, ce code ne se répète pas dans les sous-répertoires

Pour exclure les liens symboliques, les sous-répertoires, etc., changez le if en tests -X appropriés. (par exemple. (-f $ _) , (! -d $ _ et! -l $ _) , etc.). Voir documentation perl sur l'optimisation du gestionnaire de fichiers _ pour la mise en cache résultats statistiques.

Un autre perl, qui affiche les tailles totales triées par utilisateur:

#!/usr/bin/perl
use warnings;
use strict;
use autodie;
use feature qw/say/;
use File::Spec;
use Fcntl qw/:mode/;

my $dir = shift;
my %users;

opendir(my $d, $dir);
while (my $file = readdir $d) {
  my $filename = File::Spec->catfile($dir, $file);
  my ($mode, $uid, $size) = (stat $filename)[2, 4, 7];
  $users{$uid} += $size if S_ISREG($mode);
}
closedir $d;

my @sizes = sort { $a->[0] cmp $b->[0] }
  map { [ getpwuid($_) // $_, $users{$_} ] } keys %users;
local $, = "\t";
say @$_ for @sizes;

Ai-je vu un awk dans l'op? En voici un dans GNU awk utilisant filefuncs a> extension:

$ time awk -v path=../million_files -f bar.awk

real    0m5.057s
user    0m4.000s
sys     0m1.056s

$ time awk -v path=100kfiles -f bar.awk
root 4
james 342439926

real    0m1.289s
user    0m0.852s
sys     0m0.440s

$ ls -l
total 3623
drwxr-xr-x 2 james james  3690496 Mar 21 21:32 100kfiles/
-rw-r--r-- 1 root  root         4 Mar 21 18:52 bar
-rw-r--r-- 1 james james      424 Mar 21 21:33 bar.awk
-rw-r--r-- 1 james james      546 Mar 21 21:19 bar.awk~
-rw-r--r-- 1 james james      315 Mar 21 19:14 foo.awk
-rw-r--r-- 1 james james      125 Mar 21 18:53 foo.awk~
$ awk -v path=. -f bar.awk
root 4
james 1410

$ cat bar.awk
@load "filefuncs"
BEGIN {
    FS=":"                                     # passwd field sep
    passwd="/etc/passwd"                       # get usernames from passwd
    while ((getline < passwd)>0)
        users[$3]=$1
    close(passwd)                              # close passwd

    if(path="")                                # set path with -v path=...
        path="."                               # default path is cwd
    pathlist[1]=path                           # path from the command line
                                               # you could have several paths
    fts(pathlist,FTS_PHYSICAL,filedata)        # dont mind links (vs. FTS_LOGICAL)
    for(p in filedata)                         # p for paths
        for(f in filedata[p])                  # f for files
            if(filedata[p][f]["stat"]["type"]=="file")      # mind files only
                size[filedata[p][f]["stat"]["uid"]]+=filedata[p][f]["stat"]["size"]
    for(i in size)
        print (users[i]?users[i]:i),size[i]    # print username if found else uid
    exit
}

Obtenez une liste, additionnez les tailles et triez-la par propriétaire (avec Perl)

use warnings;
use strict;
use feature 'say';    
use File::Find;
use Getopt::Long;

my %rept;    
sub get_sizes {
    return if not -f; 
    my ($owner_id, $size) = (stat)[4,7] 
        or do { warn "Trouble stat for: $_"; return };
    $rept{$owner_id} += $size 
}

my ($dir, $recurse) = ('.', '');
GetOptions('recursive|r!' => \$recurse, 'directory|d=s' => \$dir)
    or die "Usage: $0 [--recursive] [--directory dirname]\n";

($recurse) 
    ? find( { wanted => \&get_sizes }, $dir )
    : find( { wanted => \&get_sizes, 
              preprocess => sub { return grep { -f } @_ } }, $dir );

say (getpwuid($_)//$_, " => $rept{$_} bytes") for keys %rept;

Je n'ai pas pu la comparer, et ça vaudrait la peine de l'essayer une approche où le répertoire est itéré sur, par opposition à glob -ed (alors que j'ai trouvé glob beaucoup plus rapide dans un problème lié ).

Je m'attends à de bons temps d'exécution par rapport à ls , qui ralentit considérablement comme une liste de fichiers dans un seul répertoire devient longue. Cela est dû au système, donc Perl sera également affecté, mais pour autant que je me souvienne, il le gère beaucoup mieux. Cependant, j'ai vu un ralentissement dramatique seulement une fois que les entrées atteignent environ un demi-million, pas quelques milliers, donc je ne sais pas pourquoi cela fonctionne lentement sur votre système.

Si cela doit être récursif dans les répertoires qu'il trouve, utilisez File :: Find . Par exemple

perl -MFile::Find -wE'
    $dir = shift // "."; 
    find( sub { 
        return if not -f;
        ($owner_id, $size) = (stat)[4,7] 
            or do { warn "Trouble stat for: $_"; return }; 
        $rept{$owner_id} += $size 
    }, $dir ); 
    say (getpwuid($_)//$_, "$_ => $rept{$_} bytes") for keys %rept
'

Cela scanne un répertoire avec 2,4 Go, principalement de petits fichiers sur une hiérarchie de sous-répertoires, en un peu plus de 2 secondes. Le du -sh a pris environ 5 secondes (la première fois).

Il est raisonnable de réunir ces deux dans un seul script

perl -wE'
    chdir (shift // "."); 
    for (glob ".* *") { 
        next if not -f;
        ($owner_id, $size) = (stat)[4,7]
            or do { warn "Trouble stat for: $_"; next };
        $rept{$owner_id} += $size 
    } 
    say (getpwuid($_)//$_, " => $rept{$_} bytes") for sort keys %rept
'

Je trouve que cela fonctionne à peu près de la même manière que le code à un répertoire ci-dessus, lorsqu'il est exécuté de manière non récursive (par défaut tel quel).

Notez que L'interface File :: Find :: Rule présente de nombreuses commodités mais est plus lent dans certains cas d'utilisation importants, ce qui compte clairement ici. (Cette analyse devrait être refaite car elle a quelques années.)