# emerge download e compilazione: tempo totale

## HexDEF6

Premessa: non ho cercato molto nel forum, anche perche' non sapevo cosa di preciso cercare, quindi se il problema e' gia stato trattato chiedo scusa.

Molte volte mi capita di dover compilare una bella serie di pacchetti (tipo oggi volevo iniziare ad instalare kde3.4)

dopo aver messo a posto package.keywords mi basta fare:

emerge kde

in questa maniera emerga prima scarica un pacchetto e poi lo compila e quindi il tempo totale (da quando lancio il comando, fino a kde totalmente installata) e' il tempo di compilazione + il tempo di download 

per guadagnare tempo, di solito faccio un:

emerge -f kde 

in un terminale, e dopo che ha scaricato un paio di pacchetti faccio un 

emerge kde

in un altro terminale..

Di solito in questa maniera va tutto bene, anche se possono sorgere problemi (tipo se e' piu' veloce la compilazione dello scaricamento), ma di sicuro il processo non e' perfettamente ottimizzato.

Siccome la mia linea adsl fa abbastanza schifo sarebbe bello che emerge, mentre sta compilando il primo pacchetto, iniziasse a scaricare il secondo, e se dopo aver scaricato il secondo sta ancora compilando il primo, potrebbe scaricarsi il terzo e cosi' via.

C'e' una "soluzione" a questo problema?

Ciao e grazie!

----------

## Onip

anche a me interessa molto 'sta cosa, ci stavo pensando l'altro giorno quando ho voluto provare gnome 2.10

----------

## gutter

Se ne era parlato e non c'è soluzione a questo problema per quanto mi è dato sapere.

----------

## fedeliallalinea

Se e' un pacchetto che hai gia' installaro puoi vedere con genlop -c

----------

## Raffo

 *fedeliallalinea wrote:*   

> Se e' un pacchetto che hai gia' installaro puoi vedere con genlop -c

 

ma hai letto il testo del primo post?  :Shocked: 

----------

## fedeliallalinea

 *Raffo wrote:*   

> ma hai letto il testo del primo post? 

 

Si ma ho capito male io. Ok ora ho riletto meglio... il problema e' che una volta fare un download mentre mergiava poteva combinare casini con la nuova versione questo problema si e' risolto ma come fa portage a sapere se un dato pacchetto e' scaricato del tutto o no?

----------

## grentis

L'md5 non è diverso?

----------

## fedeliallalinea

 *grentis wrote:*   

> L'md5 non è diverso?

 

Si infatti ma emerge a quel punto si bloccherebbe.

----------

## grentis

Bisognerebbe trovare il modo di far partire i due processi di emerge e download

Il secondo quando completa un pacchetto lo scrve in un file temporaneo...

Se emerge finisce di compilare controlla se il pacchetto è presente nel file...altrimenti attende fino a quando non è finito

(qualcosa tipo tail -f)

La gestione del download non la farebbe + emerge ma un thread che viene fatto partire al momento dell'inizio della compilazione del primo pacchetto!

EDIT: ovviamente questo significa modificare emerge

----------

## fedeliallalinea

 *grentis wrote:*   

> EDIT: ovviamente questo significa modificare emerge

 

No puoi scrivere un script

----------

## grentis

ma emerge come lo fermi quando non trova il pacchetto?Il suo codice gli impone di iniziare a scaricare...

(penso)

----------

## Raffo

vabbè là si fa tutto con lo script. se nn trova il pacchetto (lo script nn emerge) fai terminare il programma o gli fai fare qualcosa... sinceramente nn so se può venire qualcosa di buono da uno script, nn so se effettivamente uno script del genere può funzionare e se le sue funzioni possono risultare utili ai fini del tempo...

----------

## grentis

Ma non è emerge lo script....che quindi puoi gestire....

nel senso...come fa il "tuo" script a sapere che emerge sta per iniziare a scaricare il nuovo pacchetto perchè non l'ha trovato?

----------

## neryo

interessa molto anche a me ottimizzare il funzionamento di emerge in questo senso.. magari si lo script potrebbe essere una soluzione.. ma sicuramente sarebbe piu figo avere un opzione

che utilizzandola ti ottimizza il funzionamento creando appunto piu' threads.. Bisognerbbe valautare bene le politiche per la gestione della banda e di quanti threads multipli creare per il download di piu' pacchetti e decidere le priorita' in base ovviamente alle dipendenze..  :Idea: 

----------

## neryo

 *grentis wrote:*   

> ma emerge come lo fermi quando non trova il pacchetto?Il suo codice gli impone di iniziare a scaricare...
> 
> (penso)

 

dipende che opzioni usi.. lo script e' piu' che fattibile..

----------

## Raffo

semplicemente fai emergere il pacchetto solo se il pacchetto è già stato scaricato

----------

## grentis

Ecco l'opzione che mi mancava... :Laughing: 

----------

## xchris

io ho fatto uno script ma rimane il problema che bisogna modificare emerge per non fare casini!

il mio script e' rispettoso e non scarica se emerge lo sta gia' facendo...ma il problema e' il viceversa!

ciao

edit:

 *Raffo wrote:*   

> semplicemente fai emergere il pacchetto solo se il pacchetto è già stato scaricato

 

ottima osservazione!

----------

## Raffo

@xchris: quello che hai detto è esattamente quello che intendevo con il mio primo post in questo topic...

----------

## gutter

Visto che attualmente emerge usa dei file di lock per i pacchetti che sta scaricando si possono usare quelli per avere o no la conferma se emerge sta scaricando o no un file.

Si dovrebbe vedere se funge anche al contrario.

----------

## neryo

 *gutter wrote:*   

> Visto che attualmente emerge usa dei file di lock per i pacchetti che sta scaricando si possono usare quelli per avere o no la conferma se emerge sta scaricando o no un file.
> 
> Si dovrebbe vedere se funge anche al contrario.

 

ottima idea!

----------

## Raffo

@gutter: file di lock? cosa e dove sono??

----------

## xchris

scusate ma essendo un viziato di banda non ho mai indagato

come dico a emerge di non scaricare se non ha gia' il sorgente?

----------

## neryo

 *Raffo wrote:*   

> @gutter: file di lock? cosa e dove sono??

 

Sono dei file che possono essere creati in modo atomico, quindi il processo che crea un determinato lock file, ha l accesso esclusivo a quella "sezione critica" (che e' la risorsa ad esso associata) e c'e' l ha finche' non viene rilasciato. Quindi altri processi non possono accedere alle risorse che il primo processo detiene.

----------

## gutter

 *Raffo wrote:*   

> @gutter: file di lock? cosa e dove sono??

 

Ti faccio un esempio:

Ho lanciato un:

```
emerge -v acroread
```

Poi ho premuto [Ctrl]+Z e ho lanciato lo stesso identico comando, ed il risultato è:

```
giskard ~ # emerge -v acroread

Calculating dependencies ...done!

>>> emerge (1 of 1) app-text/acroread-7.0 to /

waiting for lock on /usr/portage/distfiles/.locks/AdbeRdr70_linux_enu.tar.gz.portage_lockfile
```

----------

## gutter

 *neryo wrote:*   

> 
> 
> Sono dei file che possono essere creati in modo atomico, quindi il processo che crea un determinato lock file, ha l accesso esclusivo a quella "sezione critica" (che e' la risorsa ad esso associata) e c'e' l ha finche' non viene rilasciato.

 

Sembra preso paro paro da un libro di sistemi operativi  :Wink: 

----------

## neryo

beh in effetti ne ho studiati parecchi tra libri e dispense.. non credo che trovi la corrispondenza in nessun libro!  :Wink: 

EDIT: il tuo esempio e' molto piu' chiaro!

----------

## xchris

provavo... ma portage non si caga il mio lock file....

----------

## neon

Allora... uno script che fa una cosa simile si potrebbe fare. Magari utilizzando direttamente le funzioni python di emerge oppure in maniera piu' rozza avviando lo stesso emerge direttamente dallo script.

Comunque dal Portage utilities not in portage si trova...

```
appear downloads packages while emerge is compiling

http://l.armory.com/~cerise/appear-latest.tbz2 <b>Bad link. Any info?</b>

semerge downloads packages while compiling

http://forums.gentoo.org/viewtopic.php?t=37606
```

Si potrebbe riprendere il codice di semerge, dato che appear sembra morto, che ne dite?

----------

## Flonaldo

ma a fare prima un emerge -f ???? e poi compilarseli ?!?! :Shocked: 

----------

## xchris

 *Flonaldo wrote:*   

> ma a fare prima un emerge -f ???? e poi compilarseli ?!?!

 

il tempo e' denaro  :Very Happy: 

perche' non compilare mentre si scarica???

ciao

----------

## neon

 *Flonaldo wrote:*   

> ma a fare prima un emerge -f ???? e poi compilarseli ?!?!

 

Il problema e' proprio quello dei tempi morti... mentre scarichi i pacchetti il tuo computer non fa nulla e mentre compili non occupa banda se le cose avvenissero contemporaneamente si annullerebbero questi tempi morti e potresti emergere nuovi programmi in molto meno tempo

----------

## Raffo

@xchris: ci stavo mettendo mano, ma nn mi viene in mente nessun pacchetto che nn ho già scaricato e installato  :Laughing: 

potrei pulire /usr/portage/distfiles, ma sto facendo un emerge world di 41 pacchetti e quindi nn posso metterci mano...

/me che deve imparare ancora ad usare bene cut....

----------

## neon

 *xchris wrote:*   

> provavo... ma portage non si caga il mio lock file....

 

Perche' infognarsi con i lock? non basta una cosa tipo:

```
- prendo l'output di emerge -p e mi conservo i nomi delle dipendenze

- inizio a scaricare dep[1] dep[2] ... dep[N] (in ordine sequenziale o volendo anche contemporaneamente)

- appena finisce dep[I] (con I=1...N) la emergo (se e solo se ho emerso dep[N-1])

```

Ed il controllo sui download lo fa tutto lo script (ad esempio appena wget ritorna il prompt senza errori)... emerge deve solo emergere...

----------

## xchris

perche' era + elegante  :Smile: 

ma la vedo dura come strada.

Ho dato un occhio alla gestione dei lock di portage... altro che il mio "touch lock"  :Very Happy: 

ciao

----------

## gutter

 *xchris wrote:*   

> 
> 
> Ho dato un occhio alla gestione dei lock di portage... altro che il mio "touch lock" 
> 
> ciao

 

Effettivamente facendo due prove ho notato che non va  :Sad: 

----------

## HexDEF6

 *neon wrote:*   

> 
> 
> Perche' infognarsi con i lock? non basta una cosa tipo:
> 
> ```
> ...

 

anch'io pensavo qualcosa del genere:

prendere l'output di emerge -p, creare da questo un primo script con dentro:

emerge -f primopacchetto

echo "primopacchetto" >> coda_di_compilazione

emerge -f secondopacchetto

echo "secondopacchetto" >> coda_di_compilazione

ecc.

e un secondo script che fa qualcosa del tipo:

controlla coda di compilazione

c'e' qualche pacchetto da compilare?

-se si: emerge nomepacchetto, togli dalla coda_di_compilazione il nomepacchetto

-se no: abbiamo emergiato tutti gli N pacchetti (questo si ricava dall emerge -p iniziale)?

--se si: fine

--se no: ricontrolla la coda_di_compilazione

questo mi sembra abbastanza fattibile (ovviamente per chi e' piu' bravo di me con gli script bash!), anche se e' tutto tranne elegante...

Ciao!

----------

## xchris

dopo una nottata di bash-scripting  :Laughing:  ecco una bozza.

La soluzione a mio avviso e' usare i lock di emerge.

Ma se emerge non considera i nostri lock casalinghi come facciamo?

usiamo emerge per scaricare direttamente  :Smile: 

Ho invertito il download in modo tale che ci possa essere solo un punto in cui c'e' un attesa per il rilascio del lock

Come si usa?

```

./ahead_merge (opzioni solite di emerge che facciano compilazione)

```

a quel punto si scatena il casino totale in console  :Very Happy: 

Ho preferito la soluzione di avere tutto in una shell anche se l'output e' un casino  :Very Happy: 

ed ecco qui il complicatissimo script

ahead_merge

```

## trap function

killEmerge()

        {

        killall emerge

        exit 1

        }

## main

emerge -p $* | grep ebuild | cut -d"]" -f2 | cut -d"[" -f1 | tr -d " " >/tmp/dl_list

emerge $* &

## we listen for SIGINT

trap killEmerge 2

for x in `tac /tmp/dl_list`

do

        emerge --nodeps -f =$x

done

rm /tmp/dl_list

```

fatemi sapere come si comporta

EDIT: Considerazioni

Se volete che scarichi in ordine al posto di tac mettete cat.

Qual'e' il migliore? Tutto dipende dalla vostra banda! ,dal vostro processore e da quanti pacchetti devono essere scaricati!

Altrimenti se non vi piace si puo' splittare l'operazione in 2... ma non mi sembra poi molto comodo da usare.

(basta togliere emerge $* & e poi lanciare emerge normalmente e da altra shell lanciare ahead_merge in altra shell)

che dite?

EDIT:

Gutter mi ha gentilmente aggiunto il codice per trappare SIGINT.

Cosi' CTRL-C funziona

----------

## neryo

Dopo un po' di ricerche con lo strumentoz googlez... Guardate qui...........

https://forums.gentoo.org/viewtopic-t-37606-start-0-postdays-0-postorder-asc-highlight-.html

 :Very Happy: 

----------

## neon

 *neryo wrote:*   

> Dopo un po' di ricerche con lo strumentoz googlez... Guardate qui...........
> 
> https://forums.gentoo.org/viewtopic-t-37606-start-0-postdays-0-postorder-asc-highlight-.html
> 
> 

 

ehm... non per essere pignolo ma non c'era bisogno di google... bastava scorrere la barra laterale del tuo browser e leggere qualche post sopra...  :Cool: 

https://forums.gentoo.org/viewtopic-p-2202277.html#2202277

----------

## neryo

 *neon wrote:*   

> 
> 
> ehm... non per essere pignolo ma non c'era bisogno di google... bastava scorrere la barra laterale del tuo browser e leggere qualche post sopra... 
> 
> 

 

hai completamente ragione.. l'avevo tralasciato evidentemente.. sorry  :Embarassed: 

----------

## xchris

andrebbe provato....

volontari?

cmq con la modifica di gutter lo script sopra e' utilizzabile.

ciao

----------

## grentis

Parlando dello script...

cosa succede xchris se finisco di compilare prima della fine del download del pacchetto dopo?

Il primo emerge (che ha finito la compilazione) tenta di scaricare il pacchetto dopo che però è bloccato dal secondo emerge

Cosa succede? Il primo emerge si ferma:?:  :Question:   :Question: 

----------

## xchris

se usi il tac non succede perche' scarica dall'ultimo in su.

Cmq emerge si ferma e aspetta.

QUindi con il tac puo' esserci solo un punto critico in cui solo uno dei due processi e' fermo  :Smile: 

ciao

----------

## Lestaat

se non ho capito male:

1- fa il pretende dell'emerge che ci serve

2- fa partire il fetchonly del primo pacchetto della lista e ne aggiunge il nome alla coda di emerge

3- fa emerge --nodeps della coda creata dall'emerge fetchonly quindi solo dei file completamente scaricati uno alla volta

quindi per risponderti: si si ferma e aspetta che si popoli la coda

[edit]

lol xchris ho postato in contemporanea

[/edit]

----------

## grentis

Ok, pensavo che quando emerge trovava un file lockato usciva (tipo abort)

mentre invece rimane in attesa dello sblocco...

però il partire dal fondo a scaricare i pacchetti mi riduce l'ottimizzazione...

nel senso che per i primi pacchetti emerge aspetta a compilarli per scaricare prima i file...(e questo sempre)

Bisognerebbe vedere i tempi per stabilire se è meglio così o far iniziare subito la compilazione (dopo il primo pacchetto scaricato ovviamente) e farlo attendere (se necesessario...tempo di compilazione < tempo di download paccheto successivo) per i pacchetti dopo

----------

## bender86

Wow primo post!

Ciao a tutti!

Credo che si possa fare anche senza usare script: https://forums.gentoo.org/viewtopic-t-251573.html

Ciao

----------

## xchris

 *grentis wrote:*   

> 
> 
> però il partire dal fondo a scaricare i pacchetti mi riduce l'ottimizzazione...
> 
> nel senso che per i primi pacchetti emerge aspetta a compilarli per scaricare prima i file...(e questo sempre)
> ...

 

infatti.. leggi i commenti a fine script.

dipende tutto dal caso specifico,dalla banda,dal processore...

per emerge di pochi pacchetti (2,3) questo modo e' ragionevole...

altrimenti no.

 :Smile: 

cmq male che vada ci sono 2 emerge che scaricano  :Smile:  (meglio di uno solo  :Wink: )

EDIT:benvenuto bender86  :Smile: 

----------

## btbbass

Boh, io nn vedo la necessità di farci uno script troppo complicato... io ho sempre usato la tecnica indicata nel primo posto e cioè:

1) do un

```
 emerge -f <quellocheè>
```

2)in un'altra console do

```
 emerge <quellocheè>
```

e poi pensa a tutto emerge... nel senso che il secondo emerge mi dice 

```

Waiting for <qellocheè>_lock 

```

o qualcosa di simile, e poi nn appena il primo ha finito si scaricare il pacchetto, inizia la compilazione da parte del secondo.

Nel frattempo il primo comincia a scaricare immediatamente il pacchetto dopo...

Secondo me nn c'è nulla di più ottimizzato (a meno di prendersi fastweb)...

E' normale che il secondo processo aspetti ALMENO una volta, prima di iniziare a compilare...

E' una legge inviolabile a meno di nn avere già tutto sull'hard disk....

Il fatto che aspetti più di una volta dipende dal tempo di compilazione dei pacchetti E dalla velocità della linea...

----------

