Come scrivere un software di benchmarking del disco?

Sto codificando un software di benchmark su disco (HDD / SSD). Ho alcune domande su come dovrebbe essere un benchmark (indipendentemente dal linguaggio di programmazione usato).

Questo è il mio pseudo codice per testare velocità di scrittura sequenziale :

total_size = 1GiB
block_size = 1MiB
random_byte_array[2**30] = an array of random bytes of total size 1GiB

my_file = open_new_file_for_binary_write()
start_stopwatch()

for i in range(total_size / block_size):
    my_file.write(random_byte_array, length=block_size, offset=i*block_size)

stop_stopwatch()
my_file.close()

result = total_size / stopwatch.elapsed_time_in_seconds()

Le mie domande su questo pseudo codice sono:

1. Dovrei scrivere in un file come sopra, dove continuo a scrivere senza allocare il file da solo, e lasciare che il sistema operativo assegni la dimensione necessaria mentre scrivo o dovrei creare un file di dimensioni 1GiB prima di iniziare a scrivere, quindi aprire quel file e scrivere in quel file pre-allocato?
2. Devo avviare il cronometro come sopra o devo includere i tempi di apertura / chiusura del file nel mio calcolo?

Questo è il mio pseudo codice per testare velocità di scrittura 4KiB casuale con 1 thread e 1 profondità di coda :

total_size = 1GiB
block_size = 4KiB
random_byte_array[2**30] = an array of random bytes of total size 1GiB

start_stopwatch()

for i in range(total_size / block_size):
    my_file = open_new_file_for_binary_write()
    my_file.write(random_byte_array, length=block_size, offset=i*block_size)
    my_file.close()

stop_stopwatch()

result = total_size / stopwatch.elapsed_time_in_seconds()

Le mie domande su questo pseudo codice sono:

3. Devo creare e scrivere in nuovi file come faccio sopra, o dovrei creare un file 1 GiB, quindi scrivere posizioni casuali di quel file in modo che io apro un file solo una volta invece di aprire / chiudere una nuova file "total_size / block_size" volte?

4. Devo includere i tempi di apertura / chiusura dei file come sopra o no?

E le mie domande su profondità della coda multipla :

5. Come implementiamo la scrittura con più profondità della coda? Lo facciamo con più thread? Ma alcuni programmi di benchmarking hanno test con 32 profondità di coda e solo 1 thread, come viene implementato? Come fanno a inviare più richieste di scrittura senza creare più thread?

6. Qual è la differenza tra l'utilizzo di più profondità di coda e più thread?

7. Quando eseguiamo il benchmarking con più profondità della coda o più thread, includiamo i tempi di apertura / chiusura dei file?

PS: sto usando C # per implementare il mio software, ma suppongo che le mie domande siano indipendenti dalla lingua.