Je voulais produire un fichier aléatoire de 1 Go, alors j'ai utilisé la commande suivante.
dd if=/dev/urandom of=output bs=1G count=1
Mais chaque fois que je lance cette commande, je reçois un fichier de 32 Mo:
<11:58:40>$ dd if=/dev/urandom of=output bs=1G count=1
0+1 records in
0+1 records out
33554431 bytes (34 MB, 32 MiB) copied, 0,288321 s, 116 MB/s
Qu'est-ce qui ne va pas?
MODIFIER:
Merci à de bonnes réponses dans ce sujet, je suis venu avec une solution qui lit 32 morceaux de 32 Mo de large qui fait 1 Go:
dd if=/dev/urandom of=output bs=32M count=32
Une autre solution a été donnée qui lit 1 Go directement dans la mémoire, puis écrit sur le disque. Cette solution nécessite beaucoup de mémoire, elle n’est donc pas recommandée:
dd if=/dev/urandom of=output bs=1G count=1 iflag=fullblock
script
dd
random-number-generator
Trismégistos
la source
la source
dd
. Je utiliseraishead
,cat
oursync
à sa place presque toujours. Et votre question si l’une des raisons pour lesquelles les alternatives sont généralement plus sûres.head
ne peut pas effectuer cette tâche sans l'-c
option qui n'est pas dans POSIX . Je ne connais aucune versioncat
qui puisse résoudre ce problème.rsync
est un utilitaire complètement non standard. Ce n'est ni ici ni là; En parcourant sa page de manuel, je ne vois pas non plus comment résoudre ce problème./dev/urandom
n'est pas non plus dans POSIX ...Réponses:
bs
, la taille du tampon, signifie la taille d’un seul appel read () effectué par dd.(Par exemple, à la fois
bs=1M count=1
etbs=1k count=1k
se traduira par un 1 fichier MiB, mais la première version fera en une seule étape, alors que le second fera en 1024 petits morceaux.)Les fichiers normaux peuvent être lus à presque toutes les tailles de mémoire tampon (à condition que la mémoire tampon puisse tenir dans la RAM), mais les périphériques et les fichiers "virtuels" fonctionnent souvent très près des appels individuels et ont une restriction arbitraire quant à la quantité de données qu’ils produiront. read () appelle.
Pour
/dev/urandom
, cette limite est définie dans urandom_read () dans drivers / char / random.c :Cela signifie que chaque fois que la fonction est appelée, elle serre la taille demandée à 33554431 octets.
Par défaut, contrairement à la plupart des autres outils, dd ne réessayera pas après avoir reçu moins de données que demandé - vous obtenez le 32 Mo et c'est tout. (Pour le faire réessayer automatiquement, comme dans la réponse de Kamil, vous devrez spécifier
iflag=fullblock
.)Notez également que "la taille d'un seul read ()" signifie que l'intégralité de la mémoire tampon doit tenir simultanément dans la mémoire. Par conséquent, les tailles de bloc massives correspondent également à l'utilisation massive de la mémoire par dd .
Et tout cela est inutile, car vous n'obtiendrez généralement aucune performance lorsque vous dépassez environ 16 à 32 blocs MiB - les appels système ne sont pas la partie la plus lente ici, mais le générateur de nombres aléatoires.
Donc, pour plus de simplicité, utilisez simplement
head -c 1G /dev/urandom > output
.la source
iflag=fullblock
s'agit d'une extension GNU de l'dd
utilitaire POSIX . Comme la question ne spécifie pas Linux, je pense que l’utilisation d’extensions spécifiques à Linux devrait probablement être explicitement mentionnée, de manière à ne pas confondre les lecteurs futurs essayant de résoudre un problème similaire sur un système autre que Linux.dd
sur ma machine, avec des tailles de blocs de 1k à 512M. En lisant sur un SSD Intel 750, des performances optimales (environ 1 300 Mo / s) ont été atteintes avec des blocs de 2 Mo, ce qui correspond approximativement à vos résultats. De plus grandes tailles de bloc n'a pas aidé ni empêché. La lecture de/dev/zero
, performance optimale (près de 20 Go / s) était à 64 Ko et 128 Ko blocs; des blocs plus petits et plus grands ont diminué les performances, ce qui correspond approximativement à mon commentaire précédent. En bout de ligne: référence pour votre situation actuelle. Et bien sûr, aucun de nous n'a comparé/dev/random
: Pdd
soit plus rapide. Un résumé rapide a montré que l’head
utilisation de lectures de 8 Ko et de deux écritures de 4 Ko était intéressante (GNU coreutils 8.26 sur Debian 9.6 / Linux 4.8).head
les vitesses sont en effet quelque part entredd bs=4k
etdd bs=8k
.head
les vitesses sont en baisse ~ 40% par rapport àdd if=/dev/zero bs=64k
et en baisse ~ 25% par rapport àdd if=/dev/nvme0n1 bs=2M
. Les lectures de/dev/zero
sont bien sûr plus limitées en ressources CPU, mais pour le SSD I / O, la lecture joue également un rôle. C'est une différence plus grande que ce à quoi je m'attendais.dd
peut lire moins queibs
(note:bs
spécifie les deuxibs
etobs
), à moins que neiflag=fullblock
soit spécifié.0+1 records in
indique que0
des blocs complets et1
un bloc partiel ont été lus. Cependant, tout blocage total ou partiel augmente le compteur.Je ne connais pas le mécanisme exact qui permet deEdit: cette réponse simultanée explique le mécanisme qui permet dedd
lire un bloc moins important que1G
dans ce cas particulier. J'imagine que tout bloc est lu dans la mémoire avant son écriture, la gestion de la mémoire peut donc interférer (mais ce n'est qu'une supposition).dd
lire un bloc qui est inférieur1G
à ce qui est dans ce cas particulierQuoi qu'il en soit, je ne recommande pas une telle taille
bs
. Je voudrais utiliserbs=1M count=1024
. La chose la plus importante est: sansiflag=fullblock
aucune tentative de lecture peut lire moinsibs
( à moins queibs=1
, je pense, cela est tout à fait inefficace si).Donc, si vous avez besoin de lire une quantité exacte de données, utilisez
iflag=fullblock
. Noteiflag
n’est pas requis par POSIX, vousdd
ne pouvez pas le supporter. Selon cette réponse,ibs=1
c'est probablement le seul moyen POSIX de lire un nombre exact d'octets. Bien sûr, si vous changez,ibs
vous devrez recalculer lecount
. Dans votre cas, baisseribs
à32M
ou moins résoudra probablement le problème, même sansiflag=fullblock
.Dans mon Kubuntu, je corrigerais votre commande comme ceci:
la source