Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Questo articolo fornisce istruzioni dettagliate per copiare manualmente i dati in un contenitore di archiviazione BLOB da usare con Cache HPC di Azure. Usa operazioni parallele multithread per ottimizzare la velocità di copia.
Per altre informazioni sullo spostamento dei dati nell'archivio BLOB per cache HPC di Azure, vedere Spostare i dati nell'archivio BLOB di Azure.
Esempio di copia semplice
È possibile creare manualmente una copia multithread in un client eseguendo più comandi di copia contemporaneamente in background su set predefiniti di file o percorsi.
Il comando Linux/UNIX cp include l'argomento -p per preservare la proprietà e i metadati mtime. L'aggiunta di questo argomento ai comandi seguenti è facoltativa. L'aggiunta dell'argomento aumenta il numero di chiamate al file system inviate dal client al file system di destinazione per la modifica dei metadati.
Questo semplice esempio copia due file in parallelo:
cp /mnt/source/file1 /mnt/destination1/ & cp /mnt/source/file2 /mnt/destination1/ &
Dopo aver eseguito questo comando, il jobs comando mostrerà che sono in esecuzione due thread.
Copiare dati con nomi di file prevedibili
Se i nomi dei file sono prevedibili, è possibile usare espressioni per creare thread di copia paralleli.
Ad esempio, se la directory contiene 1000 file numerati in sequenza da 0001 a 1000, è possibile usare le espressioni seguenti per creare 10 thread paralleli che ogni copia 100 file:
cp /mnt/source/file0* /mnt/destination1/ & \
cp /mnt/source/file1* /mnt/destination1/ & \
cp /mnt/source/file2* /mnt/destination1/ & \
cp /mnt/source/file3* /mnt/destination1/ & \
cp /mnt/source/file4* /mnt/destination1/ & \
cp /mnt/source/file5* /mnt/destination1/ & \
cp /mnt/source/file6* /mnt/destination1/ & \
cp /mnt/source/file7* /mnt/destination1/ & \
cp /mnt/source/file8* /mnt/destination1/ & \
cp /mnt/source/file9* /mnt/destination1/
Copiare dati con nomi di file non strutturati
Se la struttura di denominazione dei file non è prevedibile, è possibile raggruppare i file in base ai nomi di directory.
Questo esempio raccoglie intere directory da inviare ai comandi cp che vengono eseguiti come attività in background.
/root
|-/dir1
| |-/dir1a
| |-/dir1b
| |-/dir1c
|-/dir1c1
|-/dir1d
Dopo aver raccolto i file, è possibile eseguire comandi di copia parallela per copiare in modo ricorsivo le sottodirectory e tutto il relativo contenuto:
cp /mnt/source/* /mnt/destination/
mkdir -p /mnt/destination/dir1 && cp /mnt/source/dir1/* mnt/destination/dir1/ &
cp -R /mnt/source/dir1/dir1a /mnt/destination/dir1/ &
cp -R /mnt/source/dir1/dir1b /mnt/destination/dir1/ &
cp -R /mnt/source/dir1/dir1c /mnt/destination/dir1/ & # this command copies dir1c1 via recursion
cp -R /mnt/source/dir1/dir1d /mnt/destination/dir1/ &
Quando aggiungere punti di montaggio
Dopo aver eseguito un numero sufficiente di thread paralleli verso un singolo punto di assemblaggio del file system di destinazione, ci sarà un punto in cui l'aggiunta di più thread non offre una maggiore velocità effettiva. La velocità effettiva verrà misurata in file/secondi o byte al secondo, a seconda del tipo di dati. O peggio, il over-threading può talvolta causare una riduzione della velocità effettiva.
In questo caso, è possibile aggiungere punti di montaggio lato client ad altri indirizzi di montaggio di Cache HPC di Azure usando lo stesso percorso di montaggio del file system remoto:
10.1.0.100:/nfs on /mnt/sourcetype nfs (rw,vers=3,proto=tcp,addr=10.1.0.100)
10.1.1.101:/nfs on /mnt/destination1type nfs (rw,vers=3,proto=tcp,addr=10.1.1.101)
10.1.1.102:/nfs on /mnt/destination2type nfs (rw,vers=3,proto=tcp,addr=10.1.1.102)
10.1.1.103:/nfs on /mnt/destination3type nfs (rw,vers=3,proto=tcp,addr=10.1.1.103)
Aggiungendo punti di montaggio lato client, è possibile eseguire comandi di copia in parallelo verso i punti di montaggio aggiuntivi, ottenendo un ulteriore parallelismo.
Ad esempio, se i file sono molto grandi, è possibile definire i comandi di copia per usare percorsi di destinazione distinti, inviando più comandi in parallelo dal client che esegue la copia.
cp /mnt/source/file0* /mnt/destination1/ & \
cp /mnt/source/file1* /mnt/destination2/ & \
cp /mnt/source/file2* /mnt/destination3/ & \
cp /mnt/source/file3* /mnt/destination1/ & \
cp /mnt/source/file4* /mnt/destination2/ & \
cp /mnt/source/file5* /mnt/destination3/ & \
cp /mnt/source/file6* /mnt/destination1/ & \
cp /mnt/source/file7* /mnt/destination2/ & \
cp /mnt/source/file8* /mnt/destination3/ & \
Nell'esempio precedente, tutti e tre i punti di montaggio di destinazione sono destinati ai processi di copia dei file client.
Quando aggiungere clienti
Infine, quando sono state raggiunte le funzionalità del client, l'aggiunta di altri thread di copia o di punti di montaggio aggiuntivi non produrrà alcun aumento di file aggiuntivi/sec o byte/sec. In questo caso, è possibile distribuire un altro client con lo stesso set di punti di montaggio che eseguiranno i propri set di processi di copia file.
Esempio:
Client1: cp -R /mnt/source/dir1/dir1a /mnt/destination/dir1/ &
Client1: cp -R /mnt/source/dir2/dir2a /mnt/destination/dir2/ &
Client1: cp -R /mnt/source/dir3/dir3a /mnt/destination/dir3/ &
Client2: cp -R /mnt/source/dir1/dir1b /mnt/destination/dir1/ &
Client2: cp -R /mnt/source/dir2/dir2b /mnt/destination/dir2/ &
Client2: cp -R /mnt/source/dir3/dir3b /mnt/destination/dir3/ &
Client3: cp -R /mnt/source/dir1/dir1c /mnt/destination/dir1/ &
Client3: cp -R /mnt/source/dir2/dir2c /mnt/destination/dir2/ &
Client3: cp -R /mnt/source/dir3/dir3c /mnt/destination/dir3/ &
Client4: cp -R /mnt/source/dir1/dir1d /mnt/destination/dir1/ &
Client4: cp -R /mnt/source/dir2/dir2d /mnt/destination/dir2/ &
Client4: cp -R /mnt/source/dir3/dir3d /mnt/destination/dir3/ &
Creare manifesti di file
Dopo aver compreso gli approcci precedenti (più thread di copia per destinazione, più destinazioni per client, più client per ogni file system di origine accessibile dalla rete), prendere in considerazione questa raccomandazione: Compilare manifesti di file e quindi usarli con comandi di copia in più client.
Questo scenario usa il comando UNIX find per creare manifesti di file o directory:
user@build:/mnt/source > find . -mindepth 4 -maxdepth 4 -type d
./atj5b55c53be6-01/support/gsi/2018-07-22T21:12:06EDT
./atj5b55c53be6-01/support/pcap/2018-07-23T01:34:57UTC
./atj5b55c53be6-01/support/trace/rolling
./atj5b55c53be6-03/support/gsi/2018-07-22T21:12:06EDT
./atj5b55c53be6-03/support/pcap/2018-07-23T01:34:57UTC
./atj5b55c53be6-03/support/trace/rolling
./atj5b55c53be6-02/support/gsi/2018-07-22T21:12:06EDT
./atj5b55c53be6-02/support/pcap/2018-07-23T01:34:57UTC
./atj5b55c53be6-02/support/trace/rolling
Reindirizzare questo risultato a un file: find . -mindepth 4 -maxdepth 4 -type d > /tmp/foo
È quindi possibile scorrere il manifesto usando i comandi BASH per contare i file e determinare le dimensioni delle sottodirectory:
ben@xlcycl1:/sps/internal/atj5b5ab44b7f > for i in $(cat /tmp/foo); do echo " `find ${i} |wc -l` `du -sh ${i}`"; done
244 3.5M ./atj5b5ab44b7f-02/support/gsi/2018-07-18T00:07:03EDT
9 172K ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-18T05:01:00UTC
124 5.8M ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-19T01:01:01UTC
152 15M ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-20T01:01:00UTC
131 13M ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-20T21:59:41UTC_partial
789 6.2M ./atj5b5ab44b7f-02/support/gsi/2018-07-20T21:59:41UTC
134 12M ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-20T22:22:55UTC_hpccache_catchup
7 16K ./atj5b5ab44b7f-02/support/pcap/2018-07-18T17:12:19UTC
8 83K ./atj5b5ab44b7f-02/support/pcap/2018-07-18T17:17:17UTC
575 7.7M ./atj5b5ab44b7f-02/support/cores/armada_main.2000.1531980253.gsi
33 4.4G ./atj5b5ab44b7f-02/support/trace/rolling
281 6.6M ./atj5b5ab44b7f-01/support/gsi/2018-07-18T00:07:03EDT
15 182K ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-18T05:01:00UTC
244 17M ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-19T01:01:01UTC
299 31M ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-20T01:01:00UTC
256 29M ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-20T21:59:41UTC_partial
889 7.7M ./atj5b5ab44b7f-01/support/gsi/2018-07-20T21:59:41UTC
262 29M ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-20T22:22:55UTC_hpccache_catchup
11 248K ./atj5b5ab44b7f-01/support/pcap/2018-07-18T17:12:19UTC
11 88K ./atj5b5ab44b7f-01/support/pcap/2018-07-18T17:17:17UTC
645 11M ./atj5b5ab44b7f-01/support/cores/armada_main.2019.1531980253.gsi
33 4.0G ./atj5b5ab44b7f-01/support/trace/rolling
244 2.1M ./atj5b5ab44b7f-03/support/gsi/2018-07-18T00:07:03EDT
9 158K ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-18T05:01:00UTC
124 5.3M ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-19T01:01:01UTC
152 15M ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-20T01:01:00UTC
131 12M ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-20T21:59:41UTC_partial
789 8.4M ./atj5b5ab44b7f-03/support/gsi/2018-07-20T21:59:41UTC
134 14M ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-20T22:25:58UTC_hpccache_catchup
7 159K ./atj5b5ab44b7f-03/support/pcap/2018-07-18T17:12:19UTC
7 157K ./atj5b5ab44b7f-03/support/pcap/2018-07-18T17:17:17UTC
576 12M ./atj5b5ab44b7f-03/support/cores/armada_main.2013.1531980253.gsi
33 2.8G ./atj5b5ab44b7f-03/support/trace/rolling
Infine, è necessario creare i comandi di copia dei file effettivi nei client.
Se si dispone di quattro client, usare questo comando:
for i in 1 2 3 4 ; do sed -n ${i}~4p /tmp/foo > /tmp/client${i}; done
Se si dispone di cinque client, usare un codice simile al seguente:
for i in 1 2 3 4 5; do sed -n ${i}~5p /tmp/foo > /tmp/client${i}; done
E per sei... Estrapolare secondo necessità.
for i in 1 2 3 4 5 6; do sed -n ${i}~6p /tmp/foo > /tmp/client${i}; done
Si otterranno N file risultanti, uno per ognuno dei client N con i nomi dei percorsi delle directory di livello quattro ottenute come parte dell'output del find comando.
Usare ogni file per compilare il comando di copia:
for i in 1 2 3 4 5 6; do for j in $(cat /tmp/client${i}); do echo "cp -p -R /mnt/source/${j} /mnt/destination/${j}" >> /tmp/client${i}_copy_commands ; done; done
Questo genererà N file, ognuno con un comando di copia per riga, che può essere eseguito come script BASH sul client.
L'obiettivo è eseguire più thread di questi script contemporaneamente per ogni client in parallelo su più client.