Ho un sistema in cui una serie di operazioni deve essere eseguita ogni giorno. Ogni Operazione ha i seguenti metadati: Tipo , Entità e una Data (indipendente dalla data corrente). Legge qualcosa dal database, calcola le cose e salva i risultati nel database. Un'operazione è una combinazione di: [Entità, Tipo, Data]. Ho bisogno del massimo grado o parallelismo (o distribuzione) possibile.
Le operazioni con Entità diverse possono essere eseguite indipendentemente (l'ordine non ha importanza). Il tipo tuttavia (lascia 'dire che ci sono tipi T1, T2, T3) devono essere elaborati in ordine. La data (all'interno di un tipo) può essere eseguita indipendentemente (di nuovo l'ordine non ha importanza). Tutte le operazioni per una singola entità possono essere create (sono note) contemporaneamente (generate una volta al giorno, più entità in momenti diversi della giornata). La quantità di Tipi ed Entità è una costante conosciuta.
Quindi diciamo che esiste un insieme di operazioni:
#1 [E1, T1, D1], #2 [E1, T1, D2], (different dates)
#3 [E1, T2, D1], #4 [E1, T2, D1], (different type than the above)
#5 [E2, T1, D1] (different entity than those above)
Posso iniziare con # 1, # 2 e # 5 nello stesso tempo. Poi ho bisogno di aspettare il # 1 e il # 2 per finire (entrambi hanno T1 che è < di T2). Solo così posso iniziare (sempre in parallelo) # 3 e # 4.
Per parallelo o distribuito intendo distribuzione su più thread all'interno di una macchina e distribuzione su più macchine. Possono esserci molte operazioni con la stessa entità e tipo (date diverse), ma anche molti tipi e così via.
Quali sono le possibili (generali) architetture che mi consentono di fare quanto sopra?
Quello che ho ora :
Tutto viene inserito in un bus di servizio di Azure (ora è una singola coda). Un'operazione è un singolo messaggio. Ci sono molti servizi che consumano i messaggi e svolgono azioni. Non so come sincronizzare i messaggi con tipi diversi. Azure Service Bus (afaik) non mi permette di scegliere alcuni tipi di messaggi prima di altri. Mi dà solo il messaggio 'Prossimo disponibile'.
Possibile soluzione :
Utilizzo di code separate per diversi tipi di operazione. Quando i miei processori vogliono un messaggio, guardano la coda T1 (e prendono se c'è qualcosa), se è vuota guardano la coda T2 (di nuovo prendono se c'è qualcosa) e così via. In questo modo ho forzato il vincolo di tipo. Il problema numero 1 è che non so quando sono terminate le ultime operazioni (la coda vuota indica che il lavoro è iniziato, non finito). Il problema n. 2 è che devo aspettare che tutte le operazioni di tipo T1 finiscano (che ad esempio sono più ad uso di database) e tutte le T2 (potenzialmente ad alta intensità di CPU) vengono eseguite nello stesso momento sebbene possano essere parallelizzate per Entità diverse .