L’algoritmo di memoria: parte 1

Come annunciato in precedenza nel paragrafo3.5.1, in questa fase bisogna riservare particolare attenzione allo spazio disco a disposizione. L’algoritmo destinato a tale obiettivo applica la logica seguente:

1. stima la quantità di memoria totale che verrà occupata dal processo; 2. verifica lo spazio disco a disposizione nel calcolatore;

3. calcola il massimo numero di righe, ovvero di file, che può essere ospitato nel disco fisso.

Tra i vari file che verranno di seguito prodotti, quelli che ingombrano maggior- mente il disco rigido sono quelli con estensione dat e fft; per questa ragione saranno

i soli ad esser presi in considerazione. Le due tipologie di file hanno egual peso (dopotutto l’uno rappresenta la trasformata di Fourier dell’altro), ma se l’fft è un file temporaneo che può essere tranquillamente rimosso, per il dat il discorso cambia: questo tipo di file è utile alla creazione dei grafici, che verrà svolta nel terzo script (papabili), ed è quindi preferibile evitarne la cancellazione.

La memoria M occupata da un file dat (o dall’intero file dell’osservazione) è ricavabile dalla seguente espressione

M = tsamp r nchan

b

8 byte, (B.4)

dove tsampè il numero di campionamenti temporali ed r un loro eventuale ricampiona-

mento (nel codiceB.15viene espresso dalla variabile$camp_downsampil rapporto tra i due

parametri), nchanil numero di canali e b quello di bit dedicato ad ogni campionamento.

Il numero di canali per il dat è sempre pari a 1, mentre per il file completo dipende dai parametri osservativi (es. 512, 1024). Il numero di campionamenti varierà in base alla durata dell’osservazione e alla frequenza di campionamento della serie temporale, invece r dipende dalla DM a cui si sta disperdendo (si veda il sotto-paragrafo 3.5.1). Inoltre, nei file di dati a disposizione per questo lavoro, i tsamp vengono espressi a

32bit (4 byte) nel dat e a 1 bit nel file originale, questo per renderlo più maneggevole e dalle dimensioni ridotte. Proviamo ad applicare l’espressione B.4in un esempio pratico: calcoliamo il peso di un singolo dat utilizzando i dati presenti in figura3.7. Dalle opzioni -numout e -downsamp della riga di comando leggiamo tsamp e r,

nchan = 1 e b = 32, quindi avremo all’incirca Mdat ' 0.5Gbyte.

A questo punto verifichiamo lo spazio libero sul disco fisso del calcolatore e calcoliamo il massimo numero di righe da poter eseguire, cioè qual è il massimo numero di file che possiamo generare fino alla saturazione della memoria (linee 45-46). Se non è possibile eseguire neanche una riga, lo script, dopo aver preso nota di ciò in

informazioni.txt, termina l’esecuzione; se c’è spazio a sufficienza tutte le righe vengono

eseguite, altrimenti solo parte di esse può essere lanciata e le restanti dovranno aspettare che venga fatto un po’ di spazio grazie all’eliminazione di alcuni dat. La quantità di righe da eseguire viene assegnata a $variabile, viceversa $controllo tornerà

utile nella seconda parte dell’algoritmo (§B.2.4), dove avverrà la rimozione dei file. Codice B.15: Problemi di memoria. . .



e s c a m o t a g e :

set c a m p _ d o w n s a m p = ‘cat $ w a y / p r e p . txt | awk - v p = $ i n i z i o ’ NR == p {p r i n t $7 } ’ ‘ 40 set p e s o _ r i g a = ‘e c h o $ c a m p _ d o w n s a m p $ d m s | awk ’{p r i n t f("%i ",4* $1 * $2 *10^ -6)

} ’ ‘

set p e s o _ C P U _ d a t = ‘e c h o $ c a m p _ d o w n s a m p $ C P U | awk ’{p r i n t f("%i ",4* $1 * $2 *10^ -6) } ’ ‘

if ( $ p e s o _ r i g a == 0) t h e n set p e s o _ r i g a = 1

e n d i f

45 set m e m o r i a = ‘ df | g r e p $ s c r a t c h | awk ’{p r i n t f("%i ",( $4 - $4 / 5 0 ) *10^ -3) } ’ ‘

set m a x _ r i g h e = ‘e c h o $ m e m o r i a $ p e s o _ C P U _ d a t $ p e s o _ r i g a | awk ’{p r i n t f("%i ",( $1 - $2 ) / $3 ) } ’ ‘

if ( $ m a x _ r i g h e == 0) t h e n

e c h o " In $nodo $ s c r a t c h memoria INSUFFICIENTE . Fermato a l l a r i g a $ i n i z i o

( e s c l u s a ) di $ f i n e . " > > $ w a y / i n f o r m a z i o n i . txt

ls *. inf * A C C E L * | x a r g s - i cp {} $ w a y / c a n d i d a t i 50 cd t e m p d a t

ls *. dat | x a r g s - n 1 - i mv {} ..

rm - r t e m p d a t e x i t 55 e l s e if ( $ m a x _ r i g h e >= $ r i g h e _ r i m ) t h e n set c o n t r o l l o = 0 @ v a r i a b i l e = $ r i g h e _ r i m e l s e if ( $ m a x _ r i g h e >= 1 && $ m a x _ r i g h e < $ r i g h e _ r i m ) t h e n set c o n t r o l l o = 1 60 @ v a r i a b i l e = $ m a x _ r i g h e e n d i f   B.2.2 De-dispersione

Le righe, che andranno a produrre i file dat, vengono lanciate all’interno di un grande ciclo while. In ogni ciclo, per non sovraccaricare eccessivamente la macchina, si è deciso di lanciare in parallelo una quantità di righe pari al massimo al numero di CPU del calcolatore, vale a dire non più di quattro.

Prima dell’esecuzione di una riga ci si assicura che non sia già presente nella cartella di lavoro nemmeno un file dat, tra quelli che stanno per essere creati dalla riga stessa, oppure che abbia una dimensione diversa da zero. Questo perché raramente, considerata la mole di dati e l’intenso lavorio, possono sopraggiungere errori di calcolo, che vanno ad incidere sulla corretta produzione dei file dat. Di ciò ci si renderà conto solamente alla fine dell’intera procedura di riduzione, che andrà dunque ripetuta. Il tipo di check utilizzato alla linea 73 (o 94) serve proprio ad evitare il ripetersi dell’intero processo, andando a rimediare soltanto agli errori di quelle poche righe di prepsubband. Sempre nelle due linee di codice appena citate compare un altro tipo di controllo: nel ciclo if si verifica l’esistenza di un file con estensione cand. Questo serve a discriminare i dat che non sono mai stati creati, da quelli che sono stati rimossi dall’algoritmo di memoria, per liberare spazio disco. I cand, come vedremo nel codice B.17, sono file che vengono generati dagli fft che, a loro volta, sono prodotti dai dat, cosicché se, per un qualsiasi motivo, ci son state complicazioni nella creazione dei dat non potremo avere neanche file cand3_.

Il ciclo while, prima di continuare col prossimo set di righe, attende il termine dell’esecuzione di tutte le$rrighe lanciate (linee 107-112), che andranno poi sottratte

al computo totale, rappresentato dal parametro$variabile (linea 113).

Codice B.16: Lancio delle righe e creazione dei file dat 

w h i l e ( $ v a r i a b i l e > 0)

set r = 0

if ( $ v a r i a b i l e >= $ C P U ) t h e n

65 w h i l e ( $r < $ C P U )

set D M s t e p = ‘cat $ w a y / p r e p . txt | awk - v i = $ i n i z i o ’ NR == i {

p r i n t $11 } ’ ‘

set l o w D M = ‘cat $ w a y / p r e p . txt | awk - v i = $ i n i z i o ’ NR == i {

p r i n t $9 } ’ ‘ set d = 0 w h i l e ( $d < $ d m s ) 70 set DM = ‘e c h o $ l o w D M $d $ D M s t e p | awk ’{p r i n t f("%.2 f ", $1 + $2 * $3 ) } ’ ‘ set d a t _ f i l e = $ r o o t \ _ D M $ D M . dat set c a n d _ f i l e = $ r o o t \ _ D M $ D M \ _ A C C E L _ $ z m a x . c a n d 3

In base a quanto detto i tre tipi di file sono l’uno figlio dell’altro. Il loro rapporto di “parentela” può essere dedotto leggendo il valore della DM che ognuno di loro possiede nella stringa del proprio nome (linee 71-72).

if ((! - f $ d a t _ f i l e || - z $ d a t _ f i l e ) && ! - f $ c a n d _ f i l e )

t h e n

set g o s u b b a n d = ‘cat $ w a y / p r e p . txt | awk - v p = $ i n i z i o ’ NR == p ’ ‘ 75 s l e e p 2 $ g o s u b b a n d & g o t o s a l t a e n d i f @ d ++ 80 end s a l t a : @ i n i z i o ++ @ r ++ end 85 e l s e if ( $ v a r i a b i l e < $ C P U ) t h e n w h i l e ( $r < $ v a r i a b i l e )

set D M s t e p = ‘cat $ w a y / p r e p . txt | awk - v i = $ i n i z i o ’ NR == i {

p r i n t $11 } ’ ‘

set l o w D M = ‘cat $ w a y / p r e p . txt | awk - v i = $ i n i z i o ’ NR == i {

p r i n t $9 } ’ ‘ set d = 0 90 w h i l e ( $d < $ d m s ) set DM = ‘e c h o $ l o w D M $d $ D M s t e p | awk ’{p r i n t f("%.2 f ", $1 + $2 * $3 ) } ’ ‘ set d a t _ f i l e = $ r o o t \ _ D M $ D M . dat set c a n d _ f i l e = $ r o o t \ _ D M $ D M \ _ A C C E L _ $ z m a x . c a n d if ((! - f $ d a t _ f i l e || - z $ d a t _ f i l e ) && ! - f $ c a n d _ f i l e ) t h e n

95 set g o s u b b a n d = ‘cat $ w a y / p r e p . txt | awk - v p = $ i n i z i o ’ NR == p ’ ‘ s l e e p 2 $ g o s u b b a n d & g o t o s a l t a 2 e n d i f 100 @ d ++ end s a l t a 2 : @ i n i z i o ++ @ r ++ 105 end e n d i f t e r m i n a t o p r e p : set s u b b a n d _ a t t i v i = ‘ps - fA | g r e p $ u s e r | g r e p p r e p s u b b a n d | g r e p - v g r e p | wc -l ‘ if ( $ s u b b a n d _ a t t i v i > 0) t h e n 110 s l e e p $ r i p g o t o t e r m i n a t o p r e p e n d i f @ v a r i a b i l e = $ v a r i a b i l e - $r end  

B.2.3 Ricerca dei candidati

Per prima cosa si contano i dat fin qui creati (linea 115). Ha quindi inizio un secondo grosso ciclo while, che si concluderà quando tutti i dat saranno spostati nella cartella tempdat.

Applichiamo sui dat il task realfft, visto nel §3.5.1, che crea i file con estensione fft. Anche qui vengono elaborati in contemporanea un numero di dat pari al massimo a quello delle CPU del calcolatore, purché non sia già presente nella cartella un file cand corrispondente. Una volta terminato quest’ultimo processo, si applica la lista delle RFI periodiche trovate a DM = 0 (§ 3.2.1). Giunta alla fine anche

quest’altra operazione, mediante il comando accelsearch, si passa alla ricerca di periodicità vera e propria. Questo tipo di ricerca produce una serie di file di testo (come ad esempio i cand incontrati in § B.2.2), che conservano i risultati e le informazioni dei candidati riscontrati dall’analisi. Gli fft, ormai inutili, possono essere eliminati, invece i dat impiegati vengono spostati momentaneamente nella cartella tempdat (linee 173-174).

Codice B.17: Ricerca dei candidati  115 set n u m _ d a t = ‘ls *. dat | wc -l ‘ w h i l e ( $ n u m _ d a t > 0) set j = 1 if ( $ n u m _ d a t >= $ C P U ) t h e n w h i l e ( $j <= $ C P U )

120 set g o f f t = ‘ls *. dat | awk - v p = $j ’ NR == p ’ ‘

set c a n d _ f i l e = ‘ls *. dat | awk - v p = $j ’ NR == p ’ | awk - F" . dat " ’{p r i n t $1"_ACCEL_’ $zmax ’ . cand"} ’ ‘

if (! - f $ c a n d _ f i l e ) t h e n s l e e p 2 r e a l f f t $ g o f f t & 125 e n d i f @ j ++ end e l s e if ( $ n u m _ d a t < $ C P U ) t h e n w h i l e ( $j <= $ n u m _ d a t )

130 set g o f f t = ‘ls *. dat | awk - v p = $j ’ NR == p ’ ‘

set c a n d _ f i l e = ‘ls *. dat | awk - v p = $j ’ NR == p ’ | awk - F" . dat " ’{p r i n t $1"_ACCEL_’ $zmax ’ . cand"} ’ ‘

if (! - f $ c a n d _ f i l e ) t h e n s l e e p 2 r e a l f f t $ g o f f t & 135 e n d i f @ j ++ end e n d i f t e r m i n a t o f f t : 140 set f f t _ a t t i v i = ‘ps - fA | g r e p $ u s e r | g r e p r e a l f f t | g r e p - v g r e p | wc -l ‘ if ( $ f f t _ a t t i v i > 0) t h e n s l e e p $ r i p g o t o t e r m i n a t o f f t e n d i f 145 @ j - - @ n u m _ d a t = $ n u m _ d a t - $j set k = 1 w h i l e ( $k <= $j ) set g o z a p b i r d s = ‘ls *. fft | awk - v p = $k ’ NR == p ’ ‘ 150 s l e e p 2 z a p b i r d s - zap - z a p f i l e $ w a y / $ r o o t . z a p l i s t - b a r y v $ t o p v e l $ g o z a p b i r d s & @ k ++ end t e r m i n a t o z a p : 155 set z a p _ a t t i v i = ‘ps - fA | g r e p $ u s e r | g r e p z a p b i r d s | g r e p - v g r e p | wc -l ‘ if ( $ z a p _ a t t i v i > 0) t h e n s l e e p $ r i p z a p g o t o t e r m i n a t o z a p e n d i f 160 set k = 1 w h i l e ( $k <= $j ) set g o a c c e l = ‘ls *. fft | awk - v p = $k ’ NR == p ’ ‘ s l e e p 2 a c c e l s e a r c h - n u m h a r m $ n u m h a r m - z m a x $ z m a x $ g o a c c e l & 165 @ k ++

end t e r m i n a t o a c c e l : set a c c e l _ a t t i v i = ‘ps - fA | g r e p $ u s e r | g r e p a c c e l s e a r c h | g r e p - v g r e p | wc -l ‘ if ( $ a c c e l _ a t t i v i > 0) t h e n 170 s l e e p $ r i p a c c e l g o t o t e r m i n a t o a c c e l e n d i f rm *. fft ls *. dat | h e a d - $j | x a r g s - i mv {} t e m p d a t 175 end