File di grandi dimensioni e hashing - preoccupazione

Question

Sto cercando di hash di un file riga (16 MB) per riga con il seguente codice prestazioni:

def hash(data, protocol) do 
    :crypto.hash(protocol, data) 
    |> Base.encode16() 
end 

File.stream!(path) 
|> Stream.map(&hash(&1, :md5) <> "h") 
|> Enum.to_list() 
|> hd() 
|> IO.puts() 

Secondo time comando, questo richiede tra i 10 ei 12 secondi, che sembra essere un numero enorme per, me visto che con il seguente codice Python:

import md5 

with open('a', 'r') as f: 
    content = f.readlines() 
    l = [] 
    for _, val in enumerate(content): 
     m = md5.new() 
     m.update(val) 
     l.append(m.hexdigest() + "h") 

    print l[0] 

piste (sempre secondo time) in circa 2,3 secondi.

Dove dovrei stardare per migliorare le prestazioni del mio codice Elixir? Ho cercato di dividere il flusso iniziale in 10 pezzi, e fuoco un'attività asincrona per ciascuno di essi:

File.stream!(path) 
|> Stream.chunk(chunk_size) # with chunk_size being (nb_of_lines_in_file/10) 
|> Enum.map(fn chunk -> Task.async(fn -> Enum.map(chunk, &hash(&1, :md5) <> "h") end) end) 
|> Enum.flat_map(&Task.await/1) 
|> hd() 
|> IO.puts() 

ma i rendimenti pari o peggiori risultati, circa 11+ secondi per eseguire, perché?

Answer 1

Una cosa da tenere in considerazione è che l'utilizzo del tempo per registrare le prestazioni del codice Elixir prende sempre in considerazione lo l'ora di avvio della macchina virtuale BEAM. In base all'applicazione , potrebbe essere o non avere senso includerla in qualsiasi benchmark di confronto in altre lingue. Se vuoi solo aumentare le prestazioni del codice Elixir, è meglio usare uno strumento di benchmarking come Benchfella o anche solo: timer.tc da erlang.

https://hex.pm/packages/benchfella

La mia ipotesi è che i problemi di prestazioni sono tutti gli I/O correlato. File.stream! non è particolarmente efficiente per l'elaborazione di righe di file di grandi dimensioni.

Ho scritto un post sul blog su un problema simile di hashing dell'intero file.

http://www.cursingthedarkness.com/2015/06/micro-benchmarking-in-elixir-using.html

E c'è un discorso scorrevole di fare l'elaborazione basata linea veloce qui.

http://bbense.github.io/beatwc/

Penso che se si slurp l'intero file in si otterrà una migliore performance. Non esiterei affatto a usare solo

File.stream!(path) |> Enum.map(fn(line) -> hash(line, :md5) <> "h" end) 

per un file 16mb. L'uso di un flusso in una pipeline traduce quasi sempre la velocità per l'utilizzo della memoria. Poiché i dati sono immutabili in Elixir, le liste di grandi dimensioni in genere hanno un sovraccarico inferiore rispetto a quanto inizialmente previsto.

Il codice basato su attività non sarà di grande aiuto poiché sospetto che la maggior parte del tempo di venga speso per il chunk delle linee in queste due linee.

File.stream!(path) 
|> Stream.chunk(chunk_size) # with chunk_size being (nb_of_lines_in_file/10) 

Questo sarà molto lento. Un altro esempio di codice che potresti trovare utile. https://github.com/dimroc/etl-language-comparison/tree/master/elixir

Ci sono molti trucchi che è possibile utilizzare per ottenere un'elaborazione veloce dei file in elisir. Spesso puoi migliorare la velocità dalla versione originale di File.stream! di più ordini di grandezza.