Linguaggio di programmazione con supporto di concorrenza nativo per grafici di grandi dimensioni?

Penso che Scala con Akka sia una buona scelta.

Scala ha un'eccellente libreria di collezioni, con collezioni immutabili (una buona scelta per la concorrenza) e raccolte parallele (non la stessa cosa della concorrenza, ma potrebbe comunque essere d'aiuto). Intendiamoci, ha anche collezioni mutevoli se ne hai bisogno.

Nel wiki di strumenti e librerie Vedo un riferimento a uno Menthor , che dovrebbe eseguire l'elaborazione grafica parallela e simultanea. È ospitato sulla pagina EPFL di Heather Miller, e Heather è uno dei committer di Scala.

C'è anche Graph for Scala , una raccolta di grafici che sembra essere abbastanza utilizzata. Potresti collaborare a questo progetto, magari estendendolo alle tue esigenze.

E, naturalmente, JVM ha Neo4J, un database grafico. Se devi risolvere problemi di grafici distribuiti, forse hai solo bisogno di Neo4J. E, poi, c'è Twitter FlockDB, che si rivolge praticamente allo stesso spazio. Entrambi hanno belle librerie per Scala.

E, infine, arriviamo ad Akka. Akka fornisce supporto per il modello di concorrenza dell'attore, che è piuttosto buono. Ma non finisce qui! Ha agenti Clojure-like (che non sono come agenti DAI), Software Transactional Memory e molte altre funzionalità.

Quindi, nel complesso, penso che Scala sia un'ottima scelta.

Ci sono diversi linguaggi di programmazione simultanei .

Personalmente, ti consiglio di consultare Erlang . Non ne so molto, ma quando studiavo la programmazione concorrente, sembrava saltar fuori un bel po ', quindi sospetto che ci sia una comunità decente per questo.

Inoltre, sembra che ci siano un paio di moduli Python ( greenlet e gevent ) che potrebbe aiutarti, se vuoi andare in quella direzione.

Quando si tratta di concorrenza, è fondamentale evitare lo stato condiviso. Alcuni paradigmi e linguaggi si prestano naturalmente alla programmazione concorrente per questo:

• il paradigma che passa il messaggio , un concetto centrale in Smalltalk e (AFAIK) Objective-C; l'idea è che gli elementi costitutivi del tuo programma comunicano attraverso i messaggi, che naturalmente gestisce lo stato condiviso in modo concorrente
• programmazione funzionale in generale evita lo stato; specialmente quando la purezza è applicabile (dopotutto, una funzione pura non può avere uno stato condiviso). Le lingue da esaminare in questo contesto sono abbondanti; quelli più popolari includono diversi dialetti LISP (Common Lisp, Clojure, Scheme), la famiglia ML (ML, F #, Haskell) ed Erlang. Haskell è particolarmente interessante perché si basa su una valutazione lenta e impone la completa purezza (ovvero, non è possibile scrivere funzioni non pure in Haskell). Haskell, essendo progettato come linguaggio compilato, può anche essere molto performante, il più vicino possibile a C, come si può probabilmente ottenere con un linguaggio di così alto livello.

Sulla piattaforma Windows F # è una buona scelta se ti piace .NET

F # è il più vicino a un linguaggio di programmazione funzionale di tutte le lingue di Microsoft. Linguaggi di programmazione funzionale (come Haskell e ML ) incoraggiando per loro natura uno stile di programmazione (espressioni idiomatiche) che il compilatore può facilmente tradurre in codice che può utilizzare più core / CPU.

Per un esempio di come i pattern di progettazione Async e Paralell incoraggiano questo, vedi: link

Forse un esempio specifico sarebbe utile. Questo codice calcolerà i primi 40 numeri Fibonacci contemporaneamente:

let rec fib x = if x <= 2 then 1 else fib(x-1) + fib(x-2)

let fibs =

    Async.Parallel [ for i in 0..40 -> async { return fib(i) } ]

    |> Async.RunSynchronously

Questo esempio è preso da qui .

Il modello di concorrenza principale di D è basato su messaggio che passa con una condivisione estremamente limitata ed esplicita di dati mutabili attraverso i thread. Questo modello può essere utilizzato tramite std.concurrency . Ciò che rende questo interessante è che è fatto nel contesto di un linguaggio di sistemi in stile C che consente una programmazione tradizionale e imperativa nelle parti del codice che non si occupano di concorrenza.

Poiché D è un linguaggio di sistema, l'isolamento garantisce che le proprietà std.concurrency siano applicate in parte dal modulo std.concurrency. Il linguaggio fornisce i meccanismi per far rispettare queste garanzie, come il supporto per l'immutabilità transitiva e il qualificatore shared . (I dati immutabili possono essere liberamente passati tra i thread std.concurrency.) Il modulo std.concurrency fornisce comunque le politiche per forzare l'isolamento. Altri moduli relativi al threading come std.parallelism e core.thread non impone l'isolamento.

Se ti interessa principalmente il parallelismo multicore come mezzo per aumentare le prestazioni, dovresti usare il modulo std.parallelism. Se sei più interessato alla concorrenza come parte inerente del problema ( concorrenza e parallelismo non sono la stessa cosa anche se sono correlati ), quindi std.concurrency potrebbe adattarsi meglio alle tue esigenze. Inoltre, std.concurrency verrà esteso per funzionare su reti, anche se attualmente funziona solo con thread su una singola macchina.

Credo che tu possa scegliere qualsiasi linguaggio funzionale come Haskell, Scala, Clojure ed Erlang. Supponiamo che conosca le basi di fp e che sto pianificando di fare lo stesso, che cosa farei, cercare qualche buona implementazione open source, diciamo, ho scelto scala e akka, vorrei vedere un po 'di codice, capire il fattibilità e gettare un disegno di base nella mia testa, ottenere una vista di 10k piedi delle cose.

Penso che scala / akka sia una grande opzione dal momento che la sua collezione di librerie è ricca e Akka si occupa abbastanza bene della concorrenza. La cosa più importante è che ha una buona documentazione e una buona comunità.