Dezvoltarea aplicațiilor din codul sursă pentru unixoid este normală și chiar comună. Compilam aplicații pentru a încerca noi funcționalități, patch-uri sau pur și simplu instalați pachetul în sistem (salut pentru fanii BSD și Gentoo). Cu toate acestea, aplicațiile moderne sunt atât de mari încât uneori acest proces poate dura mai mult de o oră. Pentru a nu aștepta atâta timp, vă recomand să folosiți utilitare speciale care pot reduce în mod semnificativ timpul de construire a aplicației.
În general, există mai multe modalități de a crește viteza de asamblare a aplicațiilor în Nix, și nu toate acestea necesită utilizarea de software suplimentar. Una dintre cele mai simple și simple moduri este de a dezactiva orice steaguri de optimizare. Acest pas oferă într-adevăr un câștig semnificativ în viteza de asamblare, dar duce, de asemenea, la o scădere semnificativă a vitezei de execuție a software-ului compilat. Dacă sunteți de acord cu această stare de lucruri, atunci puteți comanda compilatorul să oprească forțat orice optimizare. Pentru a face acest lucru, adăugați următoarele rânduri la dvs.
export CFLAGS = '- O0'
export CXXFLAGS = $ CFLAGS
Utilizatorii FreeBSD și Gentoo pot folosi fișierul /etc/make.conf pentru a modifica valoarea acestor variabile:
În OpenBSD, fișierul este numit /etc/mk.conf.
Pentru a accelera procesul de compilare, puteți utiliza paralelizarea, adică compilația simultană a mai multor fișiere care conțin textul sursă. Cei care sunt familiarizați cu programarea ar trebui să știe că orice program mai mult sau mai puțin mare scrise în limba C constă din mai multe fișiere separate care conțin fragmente ale codului sursă. În timpul asamblării programului, aceste fișiere sunt gestionate independent de compilator și numai la sfârșitul lor sunt combinate de linker într-un singur fișier executabil. Datorită acestei caracteristici, construirea aplicației poate fi paralelizată astfel încât aceste fragmente-fișiere să fie compilate simultan.
În "clasicul Linux", parametrul -j trebuie să fie specificat direct în timpul construirii aplicației:
$ ./configurează
$ make -j5
$ sudo face instalare
În sistemele bazate pe port, există opțiuni speciale de configurare care permit ca acest steguleț să fie utilizat global. De exemplu, în Gentoo, orice opțiune de creare poate fi scrisă în variabila MAKEOPTS a fișierului /etc/make.conf. În FreeBSD, această variabilă este numită MAKE_ARGS.
În aceleași distribuții bazate pe "sursă" puteți utiliza un alt truc, care vă permite să reduceți timpul de asamblare cu o medie de 10%. Ideea este de a pune directorul utilizat pentru a stoca rezultatele compilației intermediare în tmpfs. Viteza de acces la fișiere va crește semnificativ, ceea ce va duce la o victorie. Majoritatea sistemelor utilizează una dintre subdirectoarele / var / tmp pentru a stoca fișiere temporare, așa că trebuie doar să montăm tmpfs la acesta. Exemplu pentru Gentoo:
$ sudo mount - t tmpfs tmpfs - o dimensiune = 1G, nr_inodes = 1M
/ var / tmp / portage
Bineînțeles, aparatul trebuie să aibă suficientă memorie (2 GB este suficient), astfel încât tmpfs să nu înceapă utilizarea swap-ului, ceea ce va întinde în continuare procesul de compilare. Dacă memoria din sistem este mică, atunci poate fi lansată completând toate aplicațiile "groase" și deconectându-vă din cutiile X.
cache
În mod implicit, compilatorul nu acordă atenție fișierelor compilate anterior și efectuează o recompilare completă a întregii aplicații în timpul repornirii procesului de construire. Se poate face rău mult dacă, de exemplu, reparați în mod repetat unul dintre fișierele sursă și de fiecare dată după aceea inițiați ansamblul. Acest lucru va spori, de asemenea, timpul petrecut în timpul experimentării cu kernel-ul atunci când re-compilați kernel-ul de mai multe ori, încercând să activați și să dezactivați diferite opțiuni. Pentru a rezolva problema, puteți utiliza serviciile ccache.
Programul ccache este un preprocesor de cache care evită re-compilarea fișierelor deja compilate. Acesta generează un hash pentru fiecare fișier compilat, deci dacă fișierul rămâne neschimbat față de compilația anterioară, acesta nu este reprocesat, dar se folosește fișierul obiect anterior compilat. Ccache vă permite să creșteți în mod semnificativ viteza de re-compilare a aplicației. În unele cazuri, creșterea poate fi de zeci de ori.
Pentru a utiliza ccache, este suficient să îl instalați în sistem și să începeți procesul de construire a aplicației utilizând o astfel de comandă:
$ CC = "ccache gcc" CXX = "ccache g ++" ./configurare
Fișierele de obiecte preprocesate stocate în director sunt stocate
/.ccache. Implicit, dimensiunea sa este limitată la 1 GB, dar aș recomanda creșterea acestuia la 4 GB:
Dacă spațiul din directorul de domiciliu nu este suficient pentru a stoca cache-ul, puteți spune ccache să folosească un alt director:
$ echo "export CCACHE_DIR =" / var / tmp /
ccache / "" >>
Pentru a fi credincios, creați un simbolink:
/.ccache
$ ln -s / var / tmp / ccache
Un loc special pentru ccache este în sistemele bazate pe porturi. Compilarea utilităților necesare numai în timpul asamblării portului, a bibliotecilor statice și a altor unelte "unice", în astfel de sisteme este de obicei efectuată de fiecare dată în timpul asamblării portului care le cere.
Prin urmare, ccache aduce beneficii neprețuite. În plus, fișierele existente din memoria cache pot fi refolosite când faceți upgrade la porturi. Mai jos sunt două rețete pentru utilizarea ccache: în distribuția Gentoo și în sistemul FreeBSD.
Pentru a activa cache-ul în Gentoo, este suficient să efectuați două acțiuni simple:
1. Instalați cache-ul:
$ sudo emerge -v ccache
2. Editați fișierul /etc/make.conf:
$ sudo vi /etc/make.conf
# Activați ccache
CARACTERISTICI = "ccache"
# Locul de stocare în cache
CCACHE_DIR = "/ var / tmp / ccache /"
Dimensiunea cache-ului
CCACHE_SIZE = "4G"
După efectuarea acestor pași, toate porturile vor fi construite folosind cache. Pentru a activa ccache în timpul asamblării kernel-ului folosind genkernel, utilizați următoarea comandă:
$ sudo genkernel - kernel-cc = / usr / lib /
ccache / bin / gcc --menuconfig toate
În cazul FreeBSD, totul este oarecum mai complicat, dar într-un cadru rezonabil:
1. Instalați cache-ul:
$ cd / usr / ports / devel / ccache
$ sudo face instalare curată
2. Editați /etc/make.conf:
$ sudo vi /etc/make.conf
# Dacă variabila de mediu NO_CACHE nu este
definite, activați ccache
.dacă este definit (NO_CACHE)
CC = / usr / local / libexec / ccache / lume-cc
CCX = / usr / local / libexec / ccache / lume-c ++
.endif
# Dezactivați ccache-ul când se construiește el însuși
.dacă $
NO_CCACHE = da
.endif
/.cshrc
# Variabile ccache standard
setenv PATH / usr / local / libexec / ccache: $ PATH
setenv CCACHE_PATH / usr / bin: / usr / local / bin
setenv CCACHE_DIR / var / tmp / ccache
setenv CCACHE_LOGFILE /var/log/ccache.log
# Stabiliți dimensiunea cache-ului
dacă (-x / usr / local / bin / ccache) atunci
/ usr / local / bin / ccache -M 4G> / dev / null
endif
Pentru a dezactiva cache-ul în timpul construirii unui anumit port, folosim această comandă în loc de standardul "make install clean":
$ sudo face NO_CACHE = da instalare curată
Compilație distribuită
Distcc este un pachet pentru gcc care vă permite să utilizați puterea altor mașini pentru a mări viteza de compilare a aplicației. Spre deosebire de alte soluții din această clasă, distcc este ușor de instalat și nu necesită modificarea codului sursă al aplicației sau a oricăror etape pregătitoare. Codul sursă care a fost procesat de preprocesor este transferat la o mașină la distanță, prin urmare, din partea sa, nu ar trebui să aibă fișiere antet sau biblioteci pentru compilarea reușită.
Clusterul distcc constă, de obicei, dintr-un singur client și din mai multe servere. Clientul rulează pe unitatea care inițiază procesul de construire și trece lucrările de compilare la servere care rulează pe mașini de la distanță. Lucrarea constă într-un fișier preprocesat care conține codul sursă și steagurile compilatorului. Toate acestea sunt trimise la server folosind o conexiune normală la rețea fără nici o criptare și autentificare a părții la distanță. De fapt, serverele de compilare pot rula Linux, BSD, Solaris sau Windows (trebuie să instalați gcc și distcc în mediul cygwin), dar versiunea gcc pe aceste mașini trebuie să fie aceeași.
Nu are nici un rost să utilizați distcc pentru o singură construcție a unei aplicații și un computer o poate face. Dar, în distribuția Gentoo și OS FreeBSD, aceasta poate da o creștere notabilă a vitezei de instalare și actualizare a aplicațiilor. Gentoo este deja pregătit să utilizeze distcc, deci proprietarii săi trebuie doar să ia câțiva pași simpli pentru a activa pachetul. Mai întâi, instalați distcc pe toate mașinile de tip cluster:
$ sudo emerge distcc
Apoi, mergeți la mașina client și editați fișierul /etc/make.conf:
$ sudo vi /etc/make.conf
# Specificați numărul de fire de compilare
MAKEOPTS = "- j8"
# Activați distcc
CARACTERISTICI = "distcc"
# Director pentru a stoca distcc-ul cache-ului
DISTCC_DIR = "/ tmp / .distcc"
În opțiunea MAKEOPTS, specificați numărul total de fire de compilare. De obicei, acest număr este calculat după cum urmează: numărul total de procesoare / nuclee pe toate mașinile * 2 + 1. Cu toate acestea, acest lucru nu este întotdeauna adevărat și este posibil să experimentați pentru a găsi valoarea optimă.
Pentru a specifica gazdele care participă la compilație, utilizați utilitarul distcc-config (de fapt modifică doar valoarea variabilei DISTCC_HOSTS):
$ sudo distcc-config -set-hosts "127.0.0.1
192.168.0.1 192.168.0.2 192.168.0.3 "
DISTCCD_OPTS = "$ -allow 192.168.0.0/24"
Acum, adăugați serverul la nivelul inițial de pornire și executați-l:
$ sudo rc-update adăugați distccd implicit
$ sudo /etc/init.d/distccd începe
Acum, toate porturile vor fi compilate în clusterul distcc. Pentru a construi kernelul folosind distcc, utilizați următoarea comandă:
$ sudo genkernel - kernel-cc = distcc toate
Spre deosebire de Gentoo, FreeBSD nu are infrastructura necesară pentru a implementa în mod transparent distcc, așa că va trebui să-l implantăm cu o procedură chirurgicală. Pentru aceasta, instalați distcc folosind sistemul de porturi:
$ cd / usr / ports / devel / distcc
$ sudo face instalare curată
Acest lucru ar trebui făcut pe toate mașinile care vor participa la procesul de compilare. Apoi, activați serverul distcc din /etc/rc.conf astfel încât să ruleze în momentul inițializării sistemului de operare și să primească lucrări de la client:
distccd_enable = "DA"
distccd_flags = "- frumos 5 - 192.168.1.0/24
--daemon -user distcc -P /var/run/distccd.pid "
Acest pas ar trebui să fie efectuat și pe toate mașinile, inclusiv pe client (pentru ca compilația să aibă loc pe mașina care a inițiat-o). Flagul "-allow" specifică subrețeaua a cărei mașini au permisiunea de a trimite sarcini serverului. Rulați serverul:
$ sudo /usr/local/etc/rc.d/distccd începe
Ne întoarcem la mașina clientului. Deschideți fișierul /etc/make.conf și adăugați următoarele linii:
# vi /etc/make.conf
# Utilizați distcc ca compilator
CC = distcc
CXX = distcc
# Numărul de sarcini
MAKE_ARGS = - j8
Am specificat distcc în variabilele CC și CXX, astfel încât porturile și lumea să se integreze automat în cluster, să distribuie ansamblul restului, să mergem pe un mic șic și să înlocuim compilatoarele standard gcc și g ++:
# mkdir -p / usr / local / lib / distcc / bin
# cd / usr / local / lib / distcc / bin
# ln -s / usr / local / bin / distcc gcc
# ln -s / usr / local / bin / distcc g ++
# ln -s / usr / local / bin / distcc cc
# ln -s / usr / local / bin / distcc c ++
Deschideți /root/.cshrc și plasați directorul pe care l-am creat la începutul căilor de căutare binare:
setenv PATH / usr / local / lib / distcc / bin: $ PATH
setenv DISTCC_HOSTS "127.0.0.1 192.168.1.2
192.168.1.3 192.168.1.4 "
Totul, pentru testare, puteți rula ansamblul unui port. Pachetul distcc vine cu un utilitar pentru a monitoriza procesul de construire a textului distccmon. Dacă executați programul fără parametri, veți vedea starea curentă a distcc pe ecran. Pentru a primi informații în timp real, utilizați comanda "distccmontext N", unde N este intervalul în secunde între afișarea informațiilor de pe ecran. Utilizatorii Gnome (și nu numai) pot folosi un monitor grafic numit distccmon-gnome.
Compilație în nor
Programul distcc devine o soluție eficientă atunci când vine vorba de construirea unei aplicații într-un grup de mașini găzduite pe rețeaua locală, dar din cauza vulnerabilității lor, acesta nu poate fi folosit pentru mașini de distribuție împrăștiate în întreaga lume compilare. Puteți crea VPN privat, pentru a rezolva această problemă, dar oferă o soluție simplă și eficientă - SSH-tunel.
Toate instrucțiunile următoare sunt relevante pentru distribuția Gentoo, dar nu va fi dificil să le potriviți într-o altă distribuție / sistem de operare.
# mkdir -p /etc/distcc/.ssh
# usermod -d / etc / distcc distcc
În al doilea rând, el trebuie să primească un shell:
# usermod -s / bin / bash distcc
În al treilea rând, trebuie să fie deblocat:
# passwd -u distcc
Acești trei pași trebuie făcuți pe toate mașinile. Pentru ca clientul să se conecteze la mașinile care folosesc ssh și
atribuiți joburile distcc, trebuie să aibă o cheie:
# ssh-keygen -t dsa -f /etc/distcc/.ssh/id_dsa
Cheia publică (id_dsa.pub) trebuie să fie copiată în directorul /etc/distcc/.ssh/authorized_keys al tuturor mașinilor care vor participa la compilație. Că ssh și portage ar putea lucra împreună, este necesar să se corecteze drepturile de acces. La lucrătorii-mașini executăm următoarele comenzi:
# chown -R distcc: daemon / etc / distcc
# chmod 644 /etc/distcc/.ssh/authorized_keys
Pe client, executați comenzile:
# chown portage: portage /etc/distcc/.ssh/id_dsa
# chmod 600 /etc/distcc/.ssh/id_dsa
# chmod 644 /etc/distcc/.ssh/id_dsa.pub
Că în timpul execuției emerge ssh nu este blocat la jumătatea drumului cu chestiunea acceptării cheii publice a fiecărui mecanic, vom colecta toate aceste chei în avans:
# ssh-keyscan -t rsa muncitor1 muncitor2 muncitor3 \
> /var/tmp/portage/.ssh/known_hosts
# chown portage: portage /var/tmp/portage/.ssh/ \
known_hosts
Acum creați un pachet pentru distcc:
# vi / etc / distcc / distcc-ssh
#! / bin / bash
exec / usr / bin / ssh -i /etc/distcc/.ssh/id_dsa "$ @"
Să facem executabil:
# chmod a + x / etc / distcc / distcc-ssh
Editarea fișierului /etc/make.conf:
# vi /etc/make.conf
MAKEOPTS = "- j8"
CARACTERISTICI = "distcc"
DISTCC_SSH = "/ etc / distcc / distcc-ssh"
DISTCC_HOSTS = "localhost / 2 distcc @ working1 / 3 distcc @
lucru 2/5 "
Compilație reușită
Programele precum ccache și distcc, împreună cu alte trucuri, pot da o creștere foarte semnificativă vitezei de construire, dar trebuie să rețineți că nu toate aplicațiile pot fi colectate cu ajutorul lor. Ansamblul unor programe complexe, alcătuite din mai multe componente, se termină de multe ori într-o eroare, cauza care este dificil de identificat. Așadar, fiți atenți, utilizați cea mai recentă versiune de ccache și aceeași versiune a gcc pe mașinile de tip cluster distcc, în plus, nu uitați să căutați în fișierul INSTALL.
- În distribuția Gentoo, diferite porturi de compilare a porturilor pot fi activate individual pentru fiecare port (a se vedea fișierul / etc / portage / package .cflags). Acest lucru poate fi folosit pentru a dezactiva forțat ccache și distcc când construiți anumite porturi.
- Prin atribuirea opțiunilor PORTAGE_NICENESS la / etc / make. conf în distribuția Gentoo este prea mare, puteți încetini foarte mult viteza de aplicare a acumulării de către dvs. înșivă.
- Programele ccache și distcc funcționează perfect împreună. În Gentoo, le puteți activa simultan adăugând șirul FEATURES = "ccache distcc" în fișierul /etc/make.conf.
Distribuiți acest articol cu prietenii dvs.:
Trimiteți-le prietenilor: