Se i processi sempre e solo leggere i dati, ma non modificano, allora credo che è possibile inserire i dati di ingresso in un unico file di grandi dimensioni e di avere ogni processo aperto e leggere da quel file. Ogni processo avrà il proprio indicatore di posizione del file che può spostarsi ovunque nel file per leggere i dati di cui ha bisogno. Ho testato due processi MATLAB leggendo simultaneamente da un file circa un milione di volte ciascuno e tutto sembrava funzionare correttamente. Ho usato solo i comandi di I/O di file di base (elencati sotto). Sembra si potrebbe anche farlo usando MEMMAPFILE, come Mr Fooz menzionato nella sua risposta (e SCFrench in un commento), a patto di avere la versione di MATLAB R2008a o più recente.
Ecco alcuni dei file I/O comanda che si dovrà probabilmente usare per questo:
FOPEN: Ogni processo chiamerà FOPEN e restituire un identificatore di file userà in tutte le chiamate successive. È possibile aprire un file in entrambe le binario o testo modalità:
fid = fopen('data.dat','r'); % Binary mode
fid = fopen('data.txt','rt'); % Text mode
FREAD: In modalità binaria, FREAD leggerà i dati dal file:
A = fread(fid,20,'double'); % Reads 20 double-precision values
FSCANF: nel testo modalità, FSCANF leggerà e formatterà i dati dal file:
A = fscanf(fid,'%d',4); % Reads 4 integer values
FGETL/FGETS: In modalità testo, questi leggeranno intere righe dal file.
FTELL: Questo vi dirà l'indicatore di posizione del file corrente in byte dall'inizio del file:
ftell(fid)
ans =
8 % The position indicator is 8 bytes from the file beginning
FSEEK: Questo imposterà l'indicatore di posizione del file nella posizione desiderata nel file:
fseek(fid,0,-1); % Moves the position indicator to the file beginning
FCLOSE: Ogni processo dovrà chiudere il suo accesso al file (è facile dimenticare di fare questo):
fclose(fid);
Questa soluzione sarà probabilmente richiederà che il file di input ha un formato ben strutturato che è facile da attraversare (vale a dire solo una grande matrice). Se ha molti campi di lunghezza variabile, leggere i dati dalla posizione corretta nel file potrebbe diventare molto complicato.
Se i processi devono anche modificare i dati, questo potrebbe diventare ancora più difficile. In generale, non si desidera che un file/posizione di memoria venga scritto contemporaneamente da più processi o scritto da un processo mentre un altro sta leggendo dalla stessa posizione, poiché può verificarsi un comportamento indesiderato. In tal caso, si dovrebbe limitare l'accesso al file in modo tale che solo un processo alla volta funzioni su di esso. Altri processi dovrebbero aspettare fino a quando il primo è fatto.Una versione di esempio di codice che ogni processo dovrebbe funzionare in questo caso è:
processDone = false;
while ~processDone,
if file_is_free(), % A function to check that other processes are not
% accessing the file
fid = fopen(fileName,'r+'); % Open the file
perform_process(fid); % The computation this process has to do
fclose(fid); % Close the file
processDone = true;
end
end
meccanismi di sincronizzazione come questi ("locks") possono talvolta avere un elevato sovraccarico che riduce l'efficienza parallelo complessiva del codice.
miei dati personali possono essere grandi, ma è statico, cioè, la funzione non cambiarlo. Si. La lettura di un file potrebbe effettivamente funzionare. – AnnaR