Come evitare scontri nell'elaborazione distribuita quando si esegue il polling del lavoro?

1

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.

    
posta Kelvin Wayne 22.07.2018 - 23:00
fonte

2 risposte

0

Usa un numero mod hash di server. Controlla se è uguale al tuo id del server. Guarda solo le altre partizioni quando non c'è lavoro per il tuo. Otterrai delle collisioni ma solo quando avrai finito il lavoro.

    
risposta data 23.07.2018 - 02:26
fonte
0

Ho raggiunto questo tipo di carico di lavoro distribuito utilizzando JMS in questo modo:

  1. Il programma primario legge i dati di origine e compone i singoli "messaggi" di lavoro e li inserisce in una coda JMS
  2. I server di lavoro leggono i messaggi dalla coda (possono essere inclusi nella gestione delle transazioni, se necessario) uno alla volta finché la coda non è vuota.

Nessuna necessità di partizionare il lavoro, dal momento che qualsiasi unità di lavoro può essere gestita da qualsiasi server ... basta comporre le unità di lavoro con la granularità desiderata e lasciare che il server JMS gestisca la distribuzione sui server dei lavoratori.

Nota: la "J" in JMS sta per Java, ma in realtà ci sono client JMS per molte lingue.

    
risposta data 23.07.2018 - 04:16
fonte

Leggi altre domande sui tag