2011-09-27 9 views
5

Esistono microsupporti di riferimento pubblicati che confrontano le collezioni mutabili e immutabili Scala con le altre e le raccolte in java.util.concurrent, in ambienti con più thread ? Sono particolarmente interessato ai casi in cui i lettori superano di gran lunga gli scrittori, ad esempio la memorizzazione nella cache di HashMaps nel codice lato server.Micro benchmark per il confronto di collezioni mutabili e immutabili Scala con java.util.concurrent * collezioni

I micro-benchmark delle collezioni Clojure sarebbero anche accettabili, in quanto i loro algoritmi sono simili a quelli utilizzati nelle collezioni persistenti di Scala 2.8.

Scriverò da solo se non ce ne sono già state fatte, ma scrivere buoni micro-benchmark non è banale.

+0

Penso che sia estremamente improbabile ottenere un benchmark ragionevole che paragoni collezioni mutevoli e immutabili, perché il design dell'applicazione stessa è diverso. –

+0

@Daniel: al momento disponiamo di un codice server Java che contiene HashMaps che vengono letti circa 1.000.000 di volte per ogni scrittura. Il codice usa 'synchronized', ma i lettori pagano una penalità per tutte quelle letture contese anche se i dati sono effettivamente immutabili. Ho pensato che potrei essere in grado di utilizzare le collezioni persistenti da functionaljava e bloccare solo quando si sostituisce la vecchia raccolta con la nuova raccolta "copiata" contenente il nuovo elemento. – Ralph

+0

Sembra un'aspettativa ragionevole e illustra il problema con i benchmark. Se testate questo tipo di carico, state influenzando l'immutabilità. Nota che, usando mappe immutabili, devi _replace_ la mappa ogni volta che aggiorni, il che significa che dovrai serializzare tutti gli aggiornamenti in qualche modo. La mappa stessa potrebbe essere indicata da un volatile, se non ti dispiace leggere le scritte in ritardo. –

risposta

2

ci sono alcuni risultati che confrontano le mappe Java hash, mappe hash Scala, mappe Java concomitante hash, liste concomitante salto Java, array paralleli Java e collezioni parallele Scala qui (alla fine della relazione tecnica):

http://infoscience.epfl.ch/record/165523/files/techrep.pdf

C'è un confronto più dettagliato della skip list concorrenti e Java hash concomitante mappe qui (anche alla fine della parte principale del rapporto, prima che l'appendice):

http://infoscience.epfl.ch/record/166908/files/ctries-techreport.pdf

Questi micro benchmark sono focalizzati sulla verifica delle prestazioni di una singola operazione. Se avete intenzione di scrivere i propri parametri di riferimento, questo sarà probabilmente essere utile: di

http://buytaert.net/files/oopsla07-georges.pdf

+0

Molto bello! Grazie. – Ralph

+0

Puoi trovare il codice sorgente per alcuni dei punti di riferimento nel primo documento qui: http://lampsvn.epfl.ch/svn-repos/scala/scala/trunk/test/benchmarks/, ma sono alquanto non strutturati. Per il 2 °: https://github.com/axel22/Ctries, dai uno sguardo a src/bench. – axel22

+0

Ecco i benchmark dettagliati sulle operazioni di raccolta Scala: https://github.com/scalameter/scalameter/tree/master/src/test/scala/org/scalameter/collections – axel22

0

Perché non provare a utilizzare java.util.concurrent.ConcurrentHashMap? in questo modo non devi sincronizzarti e il tuo milione di letture sarà molto più veloce (oltre a quello in scrittura).

+1

Credo che sia un errore. Se si legge un valore (mutabile) da HashMap, si aggiorna tale valore, quindi si tenta di reinserire, è comunque necessario sincronizzare l'operazione. Non sono sicuro che tu possa farlo con 'replace'. – Ralph

+0

Un'altra opzione potrebbe essere l'uso di STM di Clojure (è possibile utilizzarlo da Java). Anche se non sono sicuro di come lo useresti con una HashMap ... – Chochos