Un lavoro di big data è suddiviso in X partizioni. Le partizioni sono memorizzate in un database. Lo stato di ogni partizione viene anche memorizzato nel database e utilizzato per garantire che ogni partizione venga elaborata una sola volta da un singolo server.
Ho server X, ognuno con un id univoco (int), ognuno dei quali esegue il polling del database per le partizioni Y successive (pre-read e buffer, quindi loop ed elabora le partizioni pre-read, continua fino a quando non ci sono più partizioni rimangono).
Riesco a vedere nel registro che ottengo molti conflitti, ad esempio più server che tentano di elaborare la stessa partizione e che falliscono, quando provano ad assumere la proprietà (dato che è già stato utilizzato da un altro server)
Tutti questi errori sono perdite di tempo, viaggi di andata e ritorno sulla rete e potenza di calcolo.
Sto cercando idee su come suddividere le partizioni tra i server durante la lettura delle partizioni.
Ogni partizione ha i seguenti attributi:
- Id - string [13]
- Sequenza - lunga (contatore incrementale)
- Crea ora - timestamp
Qualche idea su come implementare al meglio un algoritmo di lettura non contrastante?
Ricorda:
- Il numero di partizioni è sconosciuto
- Il numero di server è noto, ma potrebbe aumentare / diminuire
- Posso modificare / aggiungere attributi alla partizione se possono aiutare a minimizzare le interferenze
- X La partizione non dovrebbe avere affinità con il server Y, qualsiasi server dovrebbe essere in grado di elaborare qualsiasi partizione
La mia idea: Ho giocato con l'idea di usare l'id del server per bilanciare la loro lettura, ad esempio il server 1 legge 0-1000 record, il server 2 legge 1001-2000 record e così via, tuttavia si verificano troppi problemi, potrebbero non esserci partizioni abbastanza da dividere su server X, oppure i server possono essere avviati in momenti diversi leggendo le stesse partizioni anche con un offset in base al loro id server.