Universitatea Politehnică București

Facultatea de Electronică, Telecomunicații și Tehnologia Informației

Sisteme de Operare Avansate

-proiect-

Recompilarea unui kernel Linux

- SMT (Hyperthreading) scheduler support (activate / deactivate) -

Student: Mihai Atena Andreea

Master IISC 1

- 2011 -
 Cuprins
Cuprins...................................................................................................................................................2
Introducere Ubuntu...............................................................................................................................3
Nucleul Linux..........................................................................................................................................3
Compilarea unui kernel Linux.................................................................................................................4
Opțiunile unui kernel Linux................................................................................................................4
Hyperthreading..................................................................................................................................6
Virtual Box..........................................................................................................................................6
Pași de compilare...............................................................................................................................7
Aplicații de test.......................................................................................................................................9
Anexa: Programul de benchmark.........................................................................................................13
Introducere Ubuntu

Ubuntu este un sistem de operare bazat pe Linux pentru computere personale, server-e și
netbook-uri. Rudă apropiată a sistemului de operare Debian GNU/Linux, Ubuntu se dorește a
fi ușor de instalat și folosit, des actualizat și neîngrădit de restricții legale. Ubuntu este
sponsorizat de Canonical Ltd. o companie privată fondată de antreprenorul sud-african Mark
Shuttleworth.

Numele sistemului de operare provine din limba zulusă, unde „ubuntu” este o ideologie ce
poate fi definită pe scurt drept „credința într-o legatură universală ce unește întreaga
omenire”. Sloganul adoptat, „Linux pentru ființe umane” încorporează unul din scopurile
declarate ale proiectului, acela de a face din Linux un sistem de operare popular și ușor de
folosit. Cea mai recentă versiune cu asistență pe termen lung este Ubuntu 10.04 LTS „Lucid
Lynx” și a fost lansată pe data de 29 aprilie 2010.

Nucleul Linux

Nucleul Linux sau kernel-ul reprezintă nucleul sistemului de operare GNU/Linux, fiind
unul dintre cele mai cunoscute exemple de software liber şi dezvoltare de soft liber sau open
source. Termenul Linux se referă la nucleul Linux dar se foloseşte pentru descrierea
întregului sistem de operare. Nucleul, deşi a fost dezvoltat iniţial pentru microprocesorul de
tip Intel 386, la ora actuală a ajuns să suporte o mare gamă de arhitecturi şi microprocesoare,
care sunt folosite pentru supercomputere, PC-uri sau la sisteme încapsulate ca telefoane
mobile sau video recordere. Nucleul Linux 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. Distribuţiile de software bazate pe nucleul Linux se numesc distribuţii
Gnu/Linux.

Nucleul ca atare este aplicaţia de sistem de nivel scăzut (low-level) care crează nivelul
de abstractizare al componentelor hardware, controlează accesul la componenta hdd
(harddisk) şi la sistemul de fişiere, permite accesul distribuit la reţea, modul de lucru
multitasking şi constrângerile de securitate informatică. În schimb trebuie să înţelegem că
nucleul Linux nu este un sistem de operare complet, cum spun sau cum cunosc mulţi oameni.
Dar să facem un foarte scurt istoric despre apariţia nucleului Linux şi dezvoltarea lui prin
apariţia a mai multor versiuni.

Aşadar, concepţia de a face un sistem de operare simplu îi aparţine lui Linus Torvalds,
şi datează din anul 1991, an în care trimite un mesaj grupului de ştiri comp.os.minix, în care
declară că scrie un sistem de operare simplu (gratis), fiind un hobby de al lui. Mai declară
printre altele că este scris în C dar unele fişiere sunt scrise în limbaj de asamblare. Tot în
acelaşi an lansează prima versiune de nucleu Linux şi anume versiunea 0.01 care conţine
10.239 linii de cod. După mai multe versiuni, printre care reuşeşte să lanseze şi prima
versiune de self-hosted adică putându-se compila Linux sub Linux, şi în 1992 să poată rula un
X-Windows System, reuşeşte să ajungă la o versiune care deja conţine peste 5.900.000 linii de
cod, versiune care este desigur mult mai stabilă şi mai complexă. În prezent nucleul Linux
(sau kernel-ul) este în contiună dezvoltare. Fiind open source este pus la dispoziţia
programatorilor să poată efectua modificări la liberă alegere cu condiţia ca modificările să fie
puse la rândul lor pe internet, liber.

În concluzie, din cele amintite mai sus reiese încă odată de ce Linux este o platformă
ideală pentru dezvoltare software.

Compilarea unui kernel Linux

Avantaje și dezavantaje:

Kernel-ul poate fi instalat în două variante:

1. se scoate o versiune precompilata pentru distributia de Linux pe care o avem si se
instaleaza
2. se scoate versiunea vanilla, versiune pe care o găsim pe http://kernel.org sau se scot sursele
de kernel specifice distributiei pe care o avem și se compilează.
Ce inseamna versiune vanilla? Aceasta versiune este versiunea de Kernel neprelucrată absolut
deloc de distribuțiile de Linux existente la ora actuală. Nu este recomandată această versiune
de Kernel datorită posibilelor incompatibilități ce pot apărea la nivel de distribuție sistem de
operare. Astfel, fiecare distribuție de Linux preia ultima versiune vanilla și o prelucrează
pentru sine, pentru ca apoi să o lanseze pentru utilizatorii săi. Acest lucru poate dura de obicei
destul de mult, având ca rezultat un foarte mare delay între ultima versiune de Kernel vanilla
și ultima versiune de Kernel apărută pentru distribuția de Linux folosită.
De ce ar fi mai utilă compilarea unui Kernel decât folosirea versiunii precompilate? Ei bine se
pot înșira destul de multe motive, însă cele mai importante ar fi:
• distribuțiile standard precompilate de kernel pot fi inadecvate deoarece pot apărea
Incompatibilități hardware sau chiar lipsa suportului pentru anumite componente
• pentru distribuțiile precompilate, prea mult suport harware activat in interiorul
kernelului poate duce la:
o folosirea de prea multă memorie de către acesta, sau
o lansarea sistemului de operare într-un timp mai lung decât cel optim
• în cazul compilării kernel-ului putem alege noi elemente neactivate în kernel-ul
precompilat sau deselecta elemente de care nu avem nevoie
• putem îmbunătați performanțele computerului prin setarea modulelor kernel-ului în
așa fel încât să se potrivească într-un mod cât mai bun cu sistemul hardware deținut.

Opțiunile unui kernel Linux

Există multe configurații de kernel care au un impact mai mic sau mai mare asupra
performanței generale a sistemului. Iata o scurtă descriere a acestor opțiuni:

a. Processor Type And Features >> ScaleMP vSMP

Aceasta opțiune se recomandă a fi activată doar daca dețineți un procesor EM64T.

b. Processor Type And Features >> Processor Family

 Selectaţi valoarea cea mai apropiată pentru procesorul pe care il dețineți pentru a
permite diverse optimizări CPU specifice.

c. SMT (Hyperthreading) Scheduler Support

Dezactivaţi această opţiune, cu excepţia cazului în care procesorul dvs. este un

Pentium 4.

d. Processor Type And Features >> Preemption Model

Această opţiune este utilizată pentru a permite acces la codul de kernel la un grad mai
mare sau mai mic. Mai precis este vorba de dreptul proceselor cu prioritate scăzută de
a executa un sistem de apel. Ea are trei valori posibile:

- No Forced Preemption (server): Această setare dă cel mai mare throughput. Acest
lucru ar trebui să fie alegerea pentru un server sau un sistem de calcul ştiinţific.

- Voluntary Kernel Preemption (desktop): Această setare adaugă mai multe credite
explicit la kernel în scopul de a minimiza latenţa de rescheduling(de reeşalonare).
Procese cu prioritate scăzută de executare de cod kernel pot să se autoprivilegieze,
pentru a permite prelucrarea de evenimente interactive. Acesta are rezultate într-un
sistem mult mai reactiv cu randament uşor mai scăzut.

- Preemptible Kernel (low-latency desktop): Această setare execută tot codul de

kernel, în afară de secţiunile critice, preemptible. Procese cu prioritate scăzută pot fi,
prin urmare activate involuntar, chiar dacă acestea nu sunt în nici un punct de
preempțiune. Această setare este foarte potrivită pentru desktop-uri de jocuri.

e. Processor Type And Features >> Numa Memory Allocation and Scheduler
Support

Dezactivați această opțiune dacă nu dețineți un procesor de tip NUMA. Intel i7 și

AMD Opteron sunt astfel de procesoare.

f. Processor Type And Features >> Relocatable Kernel

De obicei, codul kernel-ul îşi o locaţie fixă în memorie. Această opţiune permite kernel-ul
să fie într-o locaţie diferită. Construirea unui nucleu relocabil face imaginea de kernel sa
fie cu 10% mai mare, sporind astfel timpul de boot.

g. Power Management and ACPI Features >> CUP Frequency Scaling >> Default
CPUFreq Governor

Un procesorului cu o frecvență scăzută duce la creșterea consumul de energie cât şi la

scăderea performanţei. Această opţiune stabileşte ce strategie va folosi guvernatorul
frecvenţei procesorului. Opţiuni posibile sunt:

 performance – reține frecvența procesorului la frecvența sa maximă

 userspace - permite să aibă un program rulat de utilizator care să scaleze frecvenţa
procesorului
  ondemand – variază frecvența CPU în funcție de cum acesta e solicitat
 conservative – similară cu opțiunea ondemand, dar schimbă frecvențele mult mai
lent pentru a salva energie.

Hyperthreading
Hyperthreading-ul este un termen lansat de Intel pentru implementarile de multithreading
simultane implementate pe procesoarele Atom, Core i3,Core i5, Core i7, Itanium, Pentium 4
și Xenon.

Hyperthreading-ul este o tehnologie proprietară Intel dezvoltată cu scopul de a îmbunătăți

calculele realizate paralel pe microprocesoare. Pentru fiecare core al procesorului, sistemul de
operare adresează două procesoare virtuale și împarte toate calculele între cele două atunci
când acest lucru este posibil. Hyperthreading-ul necesita nu doar ca sistemul de operare sa
suporte procesoare multipe ci trebuie sa fie optimizat pentru HTT, cei de la Intel recomandând
dezactivarea acestei opțiuni în cazul sistemelor de operare care nu au fost dezvoltate pentru
această opțiune.

Hyperthreading-ul lucrează duplicând anumite secțiuni ale procesorului(cele care stocehază

starea arhitecturală) dar fără să facă asta și cu resursele principale de execuție. Acest lucru
permite unui procesor cu HTT să apară ca două procesoare logice sistemului de operare
permitându-i acestuia să programeze două thread-uri sau procese simultan. Atunci când
resursele de execuție nu sunt folosite de task-ul curent într-un procesor fără HTT, și mai ales
când procesorul stagnează, un procesor echipat cu HTT poate folosi acele resurse de execuție
pentru a rula un alt task.

Această tehnologie e transparentă sistemului de operare și celorlalte programe. Minimul

necesar pentru a facilita de această opțiune este suport pentru SMT(symmetric
multiprocessing) a sistemului de operare.

Virtual Box

În realizarea acestui proiect am utilizat aplicația

VirtualBox, un utilitar open source pentru generarea de
medii virtuale. Este unul din cele mai cunoscute programe
de virtualizare și este deasemenea un program cross-
platform. Cu ajutorul acestuia se poate crea un calculator
virtual în interiorul sistemului de operare real . Astfel se
pot testa soft-uri, setari, solutii de securitate sau chiar
viruși. Este un mediu sigur, neexistând scăpări între mediul virtual și cel real.

Ca o observație foarte importantă, în mediul virtual totul se produce mult mai rapid, când totul
ar trebui să fie mai greu, pentru că deja mai este un OS care folosește resursele PC, dar nu este
așa.
Cu ajutorul asistentului de creare cream masina virtuala de care avem nevoie alegand numele,
compatibilitatea, memoria RAM și discul virtual pe care vrem să o de dicăm noii mașini
virtuale la care ea va avea acces.

Pași de compilare

Pas 1: Obținerea kernel-ulului și a pachetelor de date necesare:

Acest pas ne învață cum sa obținem pachetele sursa ale kernel-ului de Linux a versiunii 2.6.35
folosită în acest proiect.

#sudo apt-get install kernel-package libncurses5-dev fakeroot wget bzip2

#sudo apt-get install linux-source

Se lucrează fie în directorul /usr/src , fie se copiază sursa, linux-source-2.6.35.tar.bz2,

în directorul în care se dorește a se lucra. Se schimbă directorul de lucru pentru compilare cu
comanda:

# cd /usr/src

Acest director va conține header-ele necesare în construirea kernel-ului. Acestea sunt

fișierele sursă.

Pas 2: Executați comanda de mai jos pentru dezarhiva pachetele :

# bzip2 -d linux-source-2.6.35.tar.bz2
# tar xvf linux-source-2.6.35.tar

Dupa acest pas, directorul va arăta astfel:

linux-source-2.6.35

Pas 3: Se creează o legătură simbolică către directorul sursă și se denumește linux.

# ln -s linux-source-2.6.35 linux

Acum se utilizează termenul linux ca și o legătură către acel fisier. Exemplu:

# cd linux

Pas 4: Fișierul de configurare este unul ascuns și deține configurația kernelului ce este
instalat.Copierea acestuia se face cu ajutorul comenzii:

# cp /boot/config-`uname -r` ./.config

Acest fișier reprezintă dispozitivele hardware-ul identificat de kernel la pornire și setare.

Pas 5: În acest moment se configurează meniul care va permite să se aleagă caracteristicile

kernelului. Comanda pentru a incepe configurarea este:
# make menuconfig

Pas 6: Alegerea opțiunilor se realizează în această interfață, aici putându-se selecta ca

anumite driver-e să facă parte din kernel sau să fie încărcate ca module. Symbolul “*” indică
faptul că acea funcționalitate va fi încărcată în kernel, iar o opțiune goală indică faptul ca acea
funcționalitate nu va fi plasată în kernel. Interfața pentru selectarea opțiunilor de compilare
este:

Odata ce s-a finalizat procesul de modificare, se salvează noul fisier .config:

Pas 7:Se ruleaza o comanda care elimina urmele modificarilor.

# make-kpkg clean

Pas 8: Următorul pas este de a crea o extensie pentru kernel pentru ca versiunile ulterioare să
poata fi diferențiate.

#sudo fakeroot make-kpkg --initrd --revision=custom.1.0 kernel_image kernel_headers

Pas 9: Instalarea kernelului se efectueaza cu ajutorul comenzilor:

#dpkg -i linux-image-2.6.35-custom.1.0_custom_i386.deb
#dpkg -i linux-headers-2.6.35-custom.1.0_custom_i386.deb

Dupa instalare, se restartează sistemul de operare iar noul kernel va apărea în meniul GRUB. Se
selectează modul de lucru cu acest nou kernel instalat.
În figurile de mai jos se pot observa câțiva pași din setul de pași enumerați mai sus de
compilare a unui kernel Linux.
Figura a. Ștergerea fișierelor ce indică modificările făcute

Figura b. Rularea fisierelor .deb obținute

Figura c. Desfășurarea procesului de instalare a kernel-ului. Cel mai costisitor proces din punct de vedere al
timpului(aprox. 6 ore)

Aplicație de test
Pentru a pune în evidență opțiunea de compilare a kernelului în cele două variante, am folosit
un program de înmulțire a două matrici de dimensiuni suficient de mari.

Caracteristicile CPU și de memorie ale sistemului folosit(Acer Aspire 5520G) sunt redate în
figurile de mai jos:
Figura 1. CPU Figura 2. Memorie

În primul caz în care opțiunea de SMT scheduler support este activată am folosit un număr de
100 de thread-uri pentru a putea realiza înmulțirea. Am contorizat timpul în care această
operație este realizată și am afișat folosind System Monitoring utilizarea celor două
procesoare.

Figura 2. Starea procesorului în timpul rulării aplicației de test. Se poate observa cu ușurință utilizarea la
maximum a celor două procesoare deținute de sistem.
 Figura 3. Rezultatele obținute în urma rulării aplicației de test în cazul opțiunii SMT inactive.

Figura 4. Rezultatele obținute în urma rulării aplicației de test în cazul opțiunii SMT active.

Un alt nbench pentru care s-au facut teste este luat de la adresa
http://www.tux.org/~mayer/linux/nbench-byte-2.2.3.tar.gz.

Ruland acest fisier de test am obținut:

Figura 5. Rezultatele obținute în urma rulării aplicației de test în cazul opțiunii SMT active.
 Figura 6. Rezultatele obținute în urma rulării aplicației de test în cazul opțiunii SMT inactive.

Comparând cele două imagini cu rezultate de mai sus,se poate observa cu ușurință că în cazul
opțiunii SMT active se obțin performanțe mai bune.

Concluzii

Această opțiune a fost introdusă pentru a putea fi pusă la dispoziția procesoarelor cu mai mult de un
nucleu pentru a îmbunătăți viteza de execuție. Pentru procesoarele cu un singur nucleu de procesare
această opțiune duce la scăderea performanțelor sistemului, insă pentru cele cu mai multe procesoare
rezultatul ar fi cu totul altul si anume o crestere a performantelor.

Resurse

[1] http://easylinuxcds.com/blog/?p=3244

[2] http://www.scribd.com/doc/39184485/Compiling-Linux-Kernel

[3] http://ubuntuforums.org/showthread.php?t=60264

[4] http://incearca.ubuntu.ro/

[5] http://en.wikipedia.org/wiki/Hyper-threading
Anexa: Programul de benchmark

/* matrix-alternat.c */
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<sys/time.h>
#include <time.h>
#define dim 1000

int nr_thread;
float a[dim][dim],b[dim][dim]; /*matricele a şi b*/
float c[dim][dim];
pthread_t *vector;
// functia apelata de thread-uri;
//fiecarui thread I se aloca o anumita parte pentru calculul matricei c
void *thread_calcul(void *var)
{
int nr=*(int *)var;
int i,j,k;
/*calcul produs*/
for(i=nr;i<dim;i=i+nr_thread)
for(j=0;j<dim;j++)
{
c[i][j]=0.0;
for(k=0;k<dim;k++)
c[i][j]+=a[i][k]*b[k][j];
}
pthread_exit(NULL);
}

int main()
{
int i,j,k;
int *index;
float *temp;
time_t t_start,t_stop;
// initializare matrice ; a si b sunt cele ce se inmultesc
for(i=0;i<dim;i++)
for(j=0;j<dim;j++)
{
a[i][j]=random();
b[i][j]=random();
}
/*
printf("\nMatricea A:\n");
for (i=0;i<dim;i++)
{
 for (j=0;j<dim;j++)
printf("%f ",a[i][j]);
printf("\n");
}

printf("\nMatricea B:\n");
for (i=0;i<dim;i++)
{
for (j=0;j<dim;j++)
printf("%f ",b[i][j]);
printf("\n");
}
*/
printf("\nIntroduceti nr de thread-uri nr_thread=");
fflush(stdout);
scanf("%d",&nr_thread);fflush(stdin);

vector=(pthread_t *)calloc(nr_thread,sizeof(pthread_t));
index=(int *)calloc(nr_thread,sizeof(int));

t_start=time(NULL);
// creare thread-uri
for(i=0;i<nr_thread;i++)
{
index[i]=i;
pthread_create(&vector[i],NULL,thread_calcul,(void *)&index[i]);
}
//omorare thread-uri
for(i=0;i<nr_thread;i++) pthread_join(vector[i],NULL);

t_stop=time(NULL);

printf("Operatia de inmultire se realizeaza in %ld secunde", t_stop-t_start);

printf("\n");

/*
for(i=0;i<dim;i++)
{
for(j=0;j<dim;j++)
printf("%f", c[i][j]);

}
*/
return 0;
}