Recompilare kernel Linux [603521]

UNIVERSITATEA POLITEHNICA DIN BUCURE TI Ș
FACULTATEA DE ELECTRONICĂ, TELECOMUNICA II I TEHNOLOGIA IMFORMA IEI Ț Ș Ț
PROIECT
Recompilare kernel Linux
Student: [anonimizat] – anul I
Bucure ti ș
2015

Cuprins
I. INTRODUCERE ………………………………………………………………………………………… 3
1.1. Multi-core scheduler support ………………………………………………………………….. 3
II. COMPILAREA I INSTALAREA KERNEL-ULUI ……………………………………… 4 Ș
III. REZULTATE EXPERIMENTALE …………………………………………………… .,………. 6
3.1. Configura ia sistemului ……………………………………………………………………….. 6 ț
3.2. Teste de performan ă …………………………………………………………………………… 6 ț
3.2.1. Phoronix Test Suite ……………………………………………………………………. 6
3.2.2. Algoritm paralel ………………………………………………………………………… 7
3.3. Rezultate …………………………………………………………………………………………… 7
CONCLUZII ……………………………………………………………………………………………….. 10
BIBLIOGRAFIE ………………………………………………………………………………………….. 11
ANEXĂ ……………………………………………………………………………………………………… 12
2

I. INTRODUCERE
În această lucrare s-a studiat kernelul sistemului de operare Linux pe distribu ia ț
Ubuntu 14.04 LTS, mai exact, versiunea de kernel 3.4.0. S-a instalat în primă fază
kernelul nemodificat, iar apoi s-a instalat kernelul modificat cu op iunea țMulti-core
scheduler support dezactivată.
Kernelul reprezintă nucleul sistemului de operare open-source care a fost creat
de Linus Torvalds în 1991 i care a fost îmbunătă it ulterior cu ajutorul ș ț
programatorilor din întreaga lume. Acesta a fost dezvoltat ini ial pentru ț
microprocesorul Intel 80386, însă ulterior a fost portat pe multe alte platforme. Este
scris aproape în întregime în limbajul de programare C, împreună cu ni te extensii ș
GNU C i cu câteva linii de cod scrise în limbajul de asamblare. ș [2]
1.1. Multi-core scheduler support [1]
Op iunea țMulti-core scheduler support sau CONFIG_SCHED_MC se găse te ș
în sec iunea țProcessor Type and Features a fi ierului de configura ie ș ț Kconfig.
Aceasta îmbunătă e te procesul decizional al planificatorului procesorului atunci ț ș
când se ocupă de gestionarea procesoarelor cu mai multe nuclee, cu un cost de
overhead u or crescut în unele locuri.ș
Atunci când această op iune este utilizată în modul implicit, va încerca să ț
optimizeze performan a în principal prin distribuirea sarcinilor în mod egal pe toate ț
core-urile disponibile.
Această op iune încearcă de asemenea, distribuirea sarcinilor de lucru pe cât ț
mai pu ine țcore-uri pentru a optimiza astfel consumul de energie.
3

II. COMPILAREA I INSTALAREA KERNEL-ULUI Ș
În cadrul acestui proiect s-a folosit versiunea de kernel 3.4.0 care a fost
compilată i instalată în două cazuri: ș
Op iunea țMulti-core scheduler support activată;
Op iunea țMulti-core scheduler support dezactivată;
În ambele cazuri, atât compilarea cât i instalarea s-au realizat în următoarea ș
succesiune de pa i: ș
Se descarca i se instalează instrumentele necesare (comenzile care urmează ș
sunt valabile doar în distribu iile Linux bazate pe .deb: Ubuntu, Debian, Mint, ț
etc.) cu următoarea comandă:
# apt-get install kernel-package libncurses5-dev fakeroot wget bzip2
 Se schimba directorul de lucru pentru compilare cu comanda:
# cd /usr/src
Se dezarhivează sursa kernel-ului cu următoarea comandă:
# tar -xvf linux-3.4.tar.gz
Se schimbă directorul astfel:
# cd linux-3.4
Se deschide interfa a de configurare a kernel-ului cu ajutorul comenzii: ț
# make menuconfig
În această interfa ă se modifică op iunea dorită a a cum este prezentată în figura ț ț ș
următoare:
Figura 1. Interfa a de configurare a kernel-ului. Op iunea modificată. ț ț
4

După realizarea i salvarea modificărilor în configura ie, se compilează kernel- ș ț
ul cu următoarea comandă:
# make
Se compilează modulele kernel-ului astfel:
# make modules
După terminarea etapei de compilare se instalează modulele kernel-ului astfel:
# make modules_install
În final, după realizarea tuturor acestor etape, se instalează noul kernel cu
ajutorul următoarei comenzi:
# make install
Se restartează sistemul i se verifică noua versiune de kernel astfel: ș
$ uname -r
Figura 2. Noua versiune de kernel
5

III. REZULTATE EXPERIMENTALE
3.1. Configura ia sistemului ț
Sistemul pe care s-a realizat instalarea i testarea kernel-ului are următoarea ș
configura ie: ț
Hardware:
Procesor: Intel Pentium Dual-Core T4500 2,30 GHz (2 core-uri);
Placă de bază: LENOVO NITU1;
Chipset video: Intel Mobile 4 MCH + ICH9M;
Memorie RAM: 2048 MB;
Hard-disk: SSHD Seagate 500 GB + 8 GB SSD;
Placă de re ea ț: Broadcom NetLink BCM5906M Fast PCI;
Software:
Sistem de operare : Ubuntu 14.04.1 LTS;
Versiune kernel: 3.13.0.44 alături de care s-a instalat 3.4.0;
Desktop: Unity 7.2.3;
OpenGL: 2.1 Mesa 10.1.3;
Compilator: GCC 4.8.2;
Sistem de fi iere ș: ext4;
Rezolu ie ecran ț: 1366×768.
3.2. Teste de performan ă ț
3.2.1. Phoronix Test Suite
Phoronix Test Suite este cea mai cuprinzătoare platformă de testare i evaluare ș
comparativă disponibilă, care oferă un cadru extensibil în care pot fi u or adăugate ș
noi teste. Software-ul este conceput pentru a- i îndeplini eficient evaluările calitative ș
i cantitative într-o manieră curată, reproductibilă, i u or de utilizat.ș ș ș
Software-ul se bazează pe testarea extinsă i instrumente interne elaborate de ș
către Phoronix.com din 2004. Acest software este open-source i sub licen a GNU ș ț
GPL.
Testele acoperă întreaga gamă de benchmarking hardware: procesoare,
memorii, hard-disk-uri, periferice, placi grafice, etc. În urma modificărilor asupra
6

kernelului, principalul impact va fi asupra modului în care lucrează procesorul
sistemului, deci se vor efectua teste care evaluează performa a acestuia în cele doua ț
situa ii. ț
3.2.2. Algoritm paralel
Pe lângă software-ul Phoronix Test Suite s-a realizat un test de calcul paralel
(distribuit) bazat pe un program de înmul ire a două matrici scris în limbajul C++. ț
Programul folose te biblioteca MPI (Message Passing Interface), ce specifică ș
conven ii de apel, i prime te următorii parametri: ț ș ș
– n: dimensiunea matricelor;
– p: numărul de thread-uri în care se împarte procesul.
Codul acestui program este prezentat în ANEXĂ.
3.3. Rezultate
Testul 7-Zip Compression
Primul test realizat pentru a pune în eviden ă efectul op iunii ț ț Multi-core
scheduler support este testul 7-Zip Compression din cadrul soft-ului Phoronix.
În urma rulării testului pe ambele versiuni ale kernel-ului 3.4.0 s-au ob inut ț
următoarele rezultate:
Figura 3. Rezultatele testului 7-Zip Compression
Din aceste rezultate se poate observa că dezactivând op iunea Multi-core ț
Scheduler Support, se ob ine un scor mai mic datorită planificării i sincronizării mai ț ș
proaste între core-uri.
7

Figura 4. Rezultatele testului 7-Zip Compression. Op iunea activată (Stânga) ț
i op iunea dezactivată (Dreapta).ș ț
De asemenea, se observă o devia ie standard de 4,53% mai mare pentru ț
op iunea dezactivată decât în cazul în care aceasta este activă, ob inându-se o eroareț ț
de 3,36%.
Testul NAS Parallel Benchmarks
În urma rulării testului pe ambele versiuni ale kernel-ului 3.4.0 s-au ob inut ț
următoarele rezultate:
Figura 5. Rezultatele testului NAS Parallel Benchmarks
i din rezultatele acestui test se poate observa că dezactivând op iunea Multi-Ș ț
core Scheduler Support, se ob ine un scor mai mic ilustrând performan e mai slabe. ț ț
8

Figura 6. Rezultatele testului NAS Parallel Benchmarks. Op iunea activată (Stânga) ț
i op iunea dezactivată (Dreapta).ș ț
Se poate observa că pentru cazul dezactivării op iunii, timpul de execu ie a ț ț
testului este mai mare (15 minute) decât timpul de execu ie al testului în cazul ț
activării op iunii (8 minute). De asemenea, devia ia standard este aproximativ 4 ori ț ț
mai mare (11,77%) în cazul kernel-ului modificat.
Algoritmul paralel
În urma rulării programului din ANEXĂ s-au ob inut următoarele rezultate: ț
– Pentru cazul în care op iunea Multi-core Scheduler Support este activată: ț
n=1024; //dimensiunea matricelor
p=2; //numărul de thread-uri
t = 35,439 secunde. // timpul de rulare al programului
– Pentru cazul în care op iunea Multi-core Scheduler Support este dezactivată: ț
n=1024; //dimensiunea matricelor
p=2; //numărul de thread-uri
t = 37,89 secunde. // timpul de rulare al programului
9

CONCLUZII
În lucrarea de fa ă s-a studiat comportamentul kernel-ului în situa ia modificării ț ț
op iunii Multi-core Scheduler Support.ț
S-a folosit versiunea de kernel 3.4.0 care a fost compilată i instalată atât în ș
varianta originală, nemodificată (op iunea Multi-core Scheduler Support activată), cât ț
i în varianta modificată (op iunea Multi-core Scheduler Support dezactivată).ș ț
Pentru ambele variante de kernel s-au realizat două teste din cadrul soft-ului
Phoronix Test Suite i un test folosind un program de calcul paralel scris în limbajul ș
C++ pentru înmul irea a două matrici. ț
În toate cele trei teste, s-a ob inut o performan ă considerabil mai bună pentru ț ț
kernelul cu op iunea activată. ț
În urma acestor scenarii experimentale s-a constatat efectul destul de mare al
op iunii Multi-core Scheduler Support asupra performan ei globale a sistemului.ț ț
10

BIBLIOGRAFIE
[1] Joachim Sjöblom, ” Power Efficient Scheduling for a Cloud System ”, Master of
Science Thesis, Åbo Akademi University, 2011;
[2] http://ro.wikipedia.org/wiki/Linux_(nucleul ), accesat la data 20.01.2015.
11

ANEXĂ
Înmul irea a două matrici folosind calculul paralel: ț
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <string.h>
#include <math.h>
#include <mpi.h>
int main(int argc, char *argv[]) {
int n = 16; // Dim matrice
int p = 4; // Nr procese MPI
int max_rep = 1; // Numar de repetari executie
int root = 0;
int rank; // rangul procesului (q)
int i, j, k, s, rep;
struct timeval t1, t2;
float tp;
FILE * fp;
char* fn = "Res_Matrix_Mult_MPI.txt";

// Citire parametri
if (argc >= 2 && strcmp(argv[1],"-help") == 0) {
printf("%s\n",help);
return 0;
}
if (argc >= 2) n = atoi(argv[1]);
if (argc >= 3) max_rep = atoi(argv[2]);
// Testare parametri
if (n < 2){
printf("Eroare: n < 2 \n");
exit(0);
}
if (max_rep < 1){
printf("Eroare: max_rep < 1 \n");
MPI_Finalize();
exit(0);
}
MPI_Init (&argc,&argv);
MPI_Comm_rank (MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &p);
// Test n divizibil cu p
if ( n % p != 0) {
if (rank == root) printf("Eroare: n = %d nu este divizibil cu p = %
d\n",n, p);
MPI_Finalize();
exit(0);
}
12

s = n / p;
// Alocarea matricelor
float **a = (float**)malloc(sizeof(float*)*n);
float **b = (float**)malloc(sizeof(float*)*n);
float **c = (float**)malloc(sizeof(float*)*n);
float *ma = (float*)malloc(sizeof(float)*n*n);
float *mb = (float*)malloc(sizeof(float)*n*n);
float *mc = (float*)malloc(sizeof(float)*n*n);
for (i = 0; i < n; i++){
a[i] = ma; ma += n;
b[i] = mb; mb += n;
c[i] = mc; mc += n;
}
// Initializare matrice a, b
if (rank == root){
if (n <= 16)
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
a[i][j] = i;
b[i][j] = 1;
}
else
for (i = 0; i < n; i++)
for(j = 0; j < n; j++){
a[i][j] = rand()/(float)RAND_MAX;
b[i][j] = rand()/(float)RAND_MAX;
}
gettimeofday(&t1, NULL);
}
for (rep = 0; rep < max_rep; rep++){
// Inmultire secventiala daca p = 1
if (p == 1){
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++){
c[i][j] = 0;
for (k = 0; k < n; k++)
c[i][j] += a[i][k] * b[k][j];
}
}
}
// Inmultire paralela (p > 1)
else {
// Transmitere matrice a, b
if (rank == root && root == 0)
MPI_Scatter(a[0], s*n, MPI_FLOAT, MPI_IN_PLACE, s*n, MPI_FLOAT, root,
MPI_COMM_WORLD);
else MPI_Scatter(a[0], s*n, MPI_FLOAT, a[0], s*n, MPI_FLOAT, root,
MPI_COMM_WORLD);
MPI_Bcast(b[0], n*n, MPI_FLOAT, root, MPI_COMM_WORLD);
// Inmultire submatrice de s linii in fiecare proces
13

for (i = 0; i < s; i++)
for (j = 0; j < n; j++){
c[i][j] = 0;
for (k = 0; k < n; k++)
c[i][j] += a[i][k] * b[k][j];
}
// Colectare rezultate
if (rank == root && root == 0)
MPI_Gather(MPI_IN_PLACE, s*n, MPI_FLOAT, c[0], s*n, MPI_FLOAT,
root, MPI_COMM_WORLD);
else MPI_Gather(c[0], s*n, MPI_FLOAT, c[0], s*n, MPI_FLOAT, root,
MPI_COMM_WORLD);
} // end else
} // end rep
// Scriere si afisare rezultate
if (rank == root) {
gettimeofday(&t2, NULL);
tp = ((float)(t2.tv_sec – t1.tv_sec) + 0.000001*(t2.tv_usec –
t1.tv_usec))/max_rep;
fp = fopen(fn, "a");
if (p == 1) fprintf(fp, "\n%f ",tp);
else fprintf(fp, "%f ",tp);
fclose(fp);
printf("%d rep, n = %d, p = %d, t = %f sec\n", max_rep, n, p, tp);
if (n <= 16)
{
for (i = 0; i < n; i++) {
for (j = 0;j < n; j++)
printf("%4.0f ", c[i][j]);
printf("\n");
}
}
}
MPI_Finalize();
return 0;
}
14