Calcule Stiintifice de Inalta Performanta - Daniel Ioan Upb Elth (2016)

ALGORITMI NUMERICI
Calcule stiintifice de inalta

performanta (HPSC)
_
Daniel Ioan (daniel.ioan@upb.ro)

Universitatea Politehnica din Bucuresti –
Fac. Ingierie Electrica,
PUB - CIEAC/LMN
http://www.lmn.pub.ro/~daniel
A.N. Curs Master. Calcule stiintifice de inalta performanta 1 © Daniel Ioan 2016
Cuprins
• 0. Introducere – context • 3. Algoritmi numerici HPC, exemple si
• 1. Arhitectura si caracteristicile sistemelor aplicatii
de calcul • Tendinte in Modelarea EM,
• Calculul secvential Computational EM
• Paralelismul in procesoarele actuale • Aspectele HPC ale FEM
• Interactiunea cu memoria • Contributii LMN: FIT, Multiphsics, MOR
• Evaluarea performantei • Optimizari. Probleme Inverse,
Senzitivitati
• Sisteme paralele/multiprocesor, caracterizare
_ si clasificare • Probleme deschise
• Arhitectura sistemelor HPC actuale • 4. Concluzii
• 2. Programarea sistemelor multiprocesor • 5. Referinte
• Etapele conceptiei programelor paralele • Anexa A: Algoritmi numerici rapizi -
• Concurenta vs paralelism Multigrid, FMM, AFEM, MLFMA, AFEM
• Modele de programare (Design pattern) • Anexa B: Instrumente HPSC - Vim,
• Conceptele si argoul paralelizarii GCC, make, cvs, gdb, gprof, latex
• Medii si limbaje • Anexa C: dico – Distributed Computing
• Structuri de suport si modele in LMN
0. Introducere
• Obiectiv: Folosirea tehnicilor de
calcul de inalta performanta in
rezolvarea problemelor stiintifice si
ingineresti
• Tehnici de calcul de inalta performanta (HPC=High

Performace Computing): utilizarea eficienta a sistemelor de
_
calcul avansate – care de regula au mai multe unitati de
procesare (multiprocesor)
• Initial ele se foloseau pentru supercalculatoare, dar ulterior

datorita dezvoltarii si ieftinirii procesoareleor avansate precum
si a interconectarii, ele s-au “democratizat”, devenind
populare in majoritatea proiectelor IT avansate, creative,
referitoare la problemele complexe, de mari dimensiuni.
Domenii in care se folosesc
tehnicile HPC
• Electromagnetism computational, • Modelarea oceanelor si propagarea
compatibilitate em. cutremurelor
• Supravegherea radar, radio, internet • Modelarea organelor (electro-chimica
si mecanica): creier, inima
• Simularea si previziunea vremii si a
mediului inconjurator • Dinamica moleculara
• Analiza structurala, modelarea strivirii • Proiectarea moleculeleor
autovehiculelor medicamentelor
• CFD – computational fluid dynamics • Chimie moleculara cuantica
• Procesarea imaginilor/filmelor (Pixar) • Formarea structurilor cosmologice
_
[Dongarra03] Inima/Creier: • Optimizarea si proiectarea optimala
https://www.youtube.com/watch?v=hiKgDOXlPfk
https://www.humanbrainproject.eu/sp6
Introducere
HPSC are un puternic caracter interdisciplinar, implicand cunostinte de:
• Stiinta (in special de fizica) si inginerie (electrica, electronica, mecanica,
termotehnica, hidro si aero-dinamica);
• Algoritmi numerici (pentru ODE, PDE, si in special de algebra liniara numerica);
• Metodologii software.
Bazandu-se deci pe discitplina CSE (“Computational Science and Engineering”).
Pentru implementarea eficienta a aplicatiilor sunt necesare si cunostinte de
• Arhitectura si caracteristicile calculatoarelor, atat la nivel CPU cat si la cel al
_
sistemelor paralele si
• Deprinderi specifice ingineriei software, in vederea managementului software
profesional in dezvoltarea procedurilor si programelor de aplicatii pentru sistemele de
calcul multi-procesor
Disciplina HPSC (High Performance Scientific Computing) este deci o punte tripla intre
Metodele Numerice; Tehnicile de calcul paralel si distribuit, si modelarea
fizica/inginereasca pentru proiectarea optimala. Scopul este de a dezvolta
Algoritmi Numerici eficienti pentru rezolvarea problemelor de mari dimensiuni, tinand
cont de metodologiile software foosite in implementare, deci de structura reala a
sistemelor de calcul, si nu doar pentru un calculator ipotetic, virtual.
CSE - Computational Science and
Engineering
• CSE este o directie de cercetare si educatie strans inrudita cu HPSC, deseori
identificata cu aceasta (https://arxiv.org/pdf/1610.02608v3.pdf - raport SIAM care
prezinta nu numai caracteristicile acestei directii, ci si tendintele ei de viitor)
• CSE accentueaza pe caracterul multi- si inter-disciplinar, din disciplinele:
– Matematici aplicate
– Stiinta calculatoarelor
– Stiinta si inginerie
• CSE are metode si tehnici specifice, care
le exced pe cele ale acestor trei disicpline.
_
Este recunoscuta contributia ei la progresul
stiintei si tehnologiei, aducand prin simularea
pe calculator o a treia cale fata de teorie si
experiment. Asta ii da caracterul universal.
• Comunitatea CSE contine oameni de stiinta si ingineri, cercetatori, dezvoltatori de
metode, specialisti in diferite domenii, utilizatori de metode CSE/HPSC.
• Specifice sunt: aplicarea in multe domenii, stiintifice si tehnice, inclusiv bio-medicale,
dezvoltarea algoritmilor, omniprezenta paralelismului si mari masive de date (HPC).
Legea lui Moore, cresterea
numarului de tranzistore pe cip
_
Moore: De la inventarea
circuitelor integrate, numarul
tranzistoarelor pe cip se
dubleaza la fiecare cca doi ani
(mai precis la 18 luni).
Legea lui Moore, efecte
• Efecte legii lui Moore:
– creste complexitatea,
– sporeste viteza de lucru (totusi in 2005 viteza ceasului s-a plafonat
datorita incalzirii),
– scade pretul
Tot mai multa putere de calcul!
– 1971: Intel 4004,108kHz,4b
– 1972: 8008, 800kHz,8b
_ – 1974: 8080, 2MHz, 8b
– 1978: 8086, 5MHz, 16b
– 1985: 386, 40MHz, 32b
– 1992: DEC Alfa 200MHz, 64b
– 2001: Pentium4, 1.5GHz, 32->64b
– 2005: PentiumD, 3.2GHz, 64b, dual core
– 2007: Xeon Quad core, 3GHz, 64b
• Evolutia memoriei RAM:
https://www.top500.org/
TOP 500 = lista bianuala a celor mai puternice calculatoare din lume
Rpeak [Flop/s] performanta teoretica
Rmax [Flop/s] performanta practica la rezolvarea sistemelor liniare dense Ax=b cu Linpack
Acum top 1 este: Sunway TaihuLight din China are Rmax = 93 Pflop/s si
Rpeak =125 Pflop/s(Peta = 10^15) cu 10 mil. CPU core. Consuma 15MW.
Tehnologia HW/SW difuzeaza an de an de la supercalculatoare la sistemele
de inalta performanta.
1. Arhitectura si caracteristicile
sistemelor de calcul
1.1. Calculul secvential
1.2. Paralelismul in procesoarele actuale
1.3. Interactiunea cu memoria
1.4. Evaluarea performantei
1.5. Sisteme multiporcesor, caracterizare si clasificare
_
1.6. Arhitectura sistemelor HPC actuale: CPU, GPU,

cluster
1.1. Calculul secvential.
Arhitectura Von Neumann
Caracteristici:
Incarca instructiunea din memorie
Memorie instructiune
Decodifica instructiunea, determina
operatia si operanzii
Transfera operanzii din memorie
operand1 Procesor
Efectueaza operatia
Transfera rezultatul in memorie
Continua cu urmatoarea operatie operand2
Atat instructiunile cat si operanzii sunt codificati binar (sir de biti 0,1)
_
Viteza de excutie depinde de frecventa ceasului, rezultat
Nr instructiuni/perioada, viteza de acces a memoriei

Cuvantul CPU = numarul de biti incarcati
simultan din memorie (4, 8,16, 32,
in prezent e 64 biti), lungimea instructiunilor, a operanzilor. a adresei de
memorie (care determina marimea spatiului adresabil
https://msdn.microsoft.com/en-us/library/windows/desktop/aa366778 la Windows
https://access.redhat.com/articles/rhel-limits la Unix) sunt multipli ai cuvantului.
1.2. Paralelismul in procesoarele
actuale
In realitate, arhitecturile
noi nu mai sunt pur
secventiale:
– Procesoarele CPU noi au mai
multe nuclee (“cores”) si mai
multe unitati de calcul in fiecare
nucleu, care permit realizarea mai
multor fire de executie (“thread”)
_
simultan
– Se executa deci mai multe
operatii in paralel
– Unele se executa speculativ
– Operanzii pot fi in memorie, in
cache sau in registre
– Rezultatele pot necesita
coordonarea cu alte elemente de
calcul
Intel Sandy Bridge Layout
Procesoarele Intel pentru servere au trei nivele de cache,

cele mobile doar doua
Cum arata schema unui nucleu (core)
Viteza teoretica de varf (theoretical peak performance) a unui procesor =

Frecventa ceasului (in GHz) x nr de operatii SP/ciclu(2xFPU-threads/core ) x nr de nuclee (core)
Ex la E5520: 2.26GHz*2(mul,add)*2(SIMD double precision)*4(physical core) = 36.2.Gflop/sec
Arhitectura setului de instructiuni
• Setul de instructiuni al unui procesor exprima felul in care acestea se vad din
perspectiva programatorului si a compilatorului.
• Deosebim patru tipuri de instructiuni, cu operanzii in
– stiva
– acumulator
– registru – memorie (Intel)
– registru-registru (SPARC)
_
• Exemplu: secventa de instructiuni
pentru C = A+B in cele patru arhitecturi
Push X [Hennessy11]
Pop X
Add [X [,Y , Z]
Load X [, Y]
Store X [,Y]
Instructiuni
• Formatul instructiunii
• Operator type Examples
Arithmetic and logical add, subtract, and, or, multiply, divide, compare
Data transfer Load, store, move
Control Branch, jump, call, return
System Operating system call, virtual memory management instructions
Floating point Floating-point operations: add, multiply, divide, compare
Decimal Decimal add, decimal multiply, decimal-to-character conversions
String
_ String move, string compare, string search
Graphics Pixel and vertex operations, compression/decompression
• Adresarea memoriei: registre, memorie, adresata imediat direct, sau
indirect, indexat sau nu, sa permita compilarea eficienta limbajelor de nivel
inalt (structuri agregate: tablouri, pointeri, etc)
• Operanzii pot avea lungimile: byte (8 bits), half word (16 bits), word (32 bits),
double word (64 bits) si pot fi: caracer ASCII (8 biti), caracter Unicode UTF-
16 (16 biti), intreg (16 biti), intreg lung (1 word), single-precision floating point
(1 word), double-precision floating point (2 words). [Hennessy11]
Pipelining
Se executa mai multe instructiuni simultan – intr-un
ciclu de ceas (dar decalat):
– IF= incarcarea instructiunii
– ID = Decodificarea In cazul ramificarilor in
– EX= Executia
program, se fac predictii
– MEM = Locatie memorie
privind pozitia urmatoarei
– WB= Transfera rezultat
_
instructiuni
Efectul este accelerarea

executiei.
1.3. Ierarhizarea memoriei
• Memoria este mult mai lenta decat
procesorul
• Are o latenta de 100-1000 de cicluri de
ceas pana datele sunt disponibile
• Pe un ciclu se transfera ¼ dintr-un
numar real iar procesul asteapta 2
numere reale pentru o operatie
• Memoriile mai rapide sunt mai scumpe,
cache este o astfel de memorie, mai
_ mica dar mai rapida
• Sistemul de memorare este compus din:
Registre, Caches, Memoria principala Secondary memory NFS >T
(RAM) si Memoria secundara (pe disc,
mai lenta)
Interactiunea cu memoria
Aplicatiile (procesele) vad memoria “virtual” in mod continuu, chiar daca segmente
sunt plasate diferit (in cache, RAM. HDD/SSD). Daca cererea de memorie cate SO
depaseste spatiul disponibil in RAM, atunci RAM actioneaza ca un cache pentru
datele de pe disc: https://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Memory/virtual.html
Virtualizarea se realizeaza inclusiv in retea, pentru ca oricum sistemul de fisier este
distribuit prin Network File System (NFS https://en.wikipedia.org/wiki/Network_File_System ).
Cand este nevoie, cache-ul este actualizat de SO, prin incarcare de date din RAM
respectiv de pe disc.
Performanta interactiunii cu memoria este descrisa de:
– latenta: timpul necesar pentru a transfera un cuvant din memorie (cicluri de
_ ceas, ns sau ms in retea)
– banda: viteza cu care sunt transmise datele din moment ce conexiunea a fost
stabilita (B/sec, MB/sec, GB/sec)
Pentru a nu irosi banda, transferul se realizeaza cu un grup de cuvinte egal cel putin
cu: concurenta = latenta x banda
Cache management
cuvant
/* Before */
for (j = 0; j < 100; j = j+1) RAM cache
for (i = 0; i < 5000; i = i+1) X1 Linia 1
x[i][j] = 2 * x[i][j];
X2 Linia 2
Aici cache se incarca de 500 000 ori!
X3 bloc Linia 3
.. ..
/* After */ Xk
for
_ (i = 0; i < 5000; i = i+1)
Linie cache=bloc
for (j = 0; j < 100; j = j+1)
x[i][j] = 2 * x[i][j]; tablou
Aici cache se incarca numai de 5 000 ori!
Prin schimbarea buclelor, timpul de calcul scade de zeci de ori,

fara sa scada numarul de operatii (complexitatea alritgoritmului)
Atentie! In FORTRAN, matricile se memoreaza pe coloane,
nu pe linii, ca in C.
Cache flow
• Regula: la matricele din Fortran variati cel mai rapid indicele din stanga, iar in C si Python pe
cel din dreapta! [Landau]:
• Cod BUN in f90, SLAB in Python si C :
Dimension Vec(idim ,jdim) // suma patratelor elementelor
for j=1,jdim;
{ for i=1,idim ; Ans=Ans+Vec(i,j)∗Vec (i,j) }
// =======
for j=1,N; { // Coloana Produsul a doua matrice patrate
for i=1,N; { // Linie
c(i,j)=0.0 // Initializare
for k=1,N;
{ c(i,j)=c(i,j)+a(i,k)∗b(k,j)}}} // Suma
_
• Cod SLAB in f90, BUN in Python si C :
Dimension Vec(idim ,jdim) // suma patratelor elementelor
for i=1,idim;
{ for j=1,jdim ; Ans=Ans+Vec(i,j)∗Vec (i,j) }
// =======
for i=1,N; { // Linie Produsul a doua matrice patrate
for j=1,N; { // Coloana
c(i,j)=0.0 // Initializare
for k=1,N; { c(i,j)=c(i,j)+a(i,k)∗b(k,j)}}} // Suma
In realitate, in c sunt salvate contiguu in memorie elementele de pe pe ultima dimensiune a tabloului n-
dimensional alocat static sau a pointerului n-dimensional alocat dinamic. E la alegerea programatorului sa-si
reprezinte coloana pe ultima dimensiune adica sa considere matricea drept colectie de vectori coloana, ceea
ce revine la a trata indicele de linie ca fiind al doilea - daca e vorba de cazul 2-dimensional.
Effective Cache flow
Modul in care trebuie parcurse continuu matricile f90 in calculul paralel.
In c parcurgerea trebuie facuta orizontal.
pasj
[Landau] pasi Matricea de 400x400 nu incape in cache
C Transpune matrice pe blocuri de dim max pasj x pasi

do jj=1,n, pasj
do ii=1,n, pasi
do j=jj,min(n,jj+pasj-1)
do i=ii,min(n,ii+pasi-1)
b(i,j) = a(j,i)
1.4. Comparatie intre cateva
procesoare performante
• Au 6-8 nuclee (cores) pe CPU

• Fiecare nucleu poate avea 1-8 fire de executie in paralel (multithread)
• Executa 2-6 instructiuni din fir pe o perioada a ceasului
• Au frecvente de ceas intre 1.6 si 4.1 GHz
• Au 2-3 nivele cache de 4-32MB
• Un parametru important este eficienta energetica, cca 2GFlops/W la CPU
Standard Performance Evaluation SPEC
Benchmarks CPU 2006
• Benchmark Language Application Area https://www.spec.org/benchmarks.html
1. 410.bwaves Fortran Fluid Dynamics
2. 416.gamess Fortran Quantum Chemistry.
3. 433.milc C Physics / Quantum Chromodynamics
4. 434.zeusmp Fortran Physics / CFDZEUS-MP simulation of astrophysical phenomena.
5. 435.gromacs C, Fortran Biochemistry / Molecular DynamicsMolecular dynamics
6. 436.cactusADM C,Fortran Physics / General RelativitySolves the Einstein evolution eq
7. 437.leslie3d Fortran Fluid DynamicsComputational Fluid Dynamics (CFD)
8. 444.namd C++ Biology / Molecular DynamicsSimulates large biomolecular syst
_
9. 447.dealII C++ Finite Element Analysis
10. 450.soplex C++ Linear Programming, OptimizationSolves a linear program
11. 453.povray C++ Image Ray-tracingImage rendering.
12. 454.calculix C,Fortran Structural MechanicsFinite element code for linear and nonlinear 3D
13. 459.GemsFDTDFortran Computational Electromagnetics Solves the Maxwell equations
14. 465.tonto Fortran Quantum Chemistry X-ray diffraction data
15. 470.lbm C Fluid Dynamics Implements the "Lattice-Boltzmann Method”
16. 481.wrf C,Fortran Weather modeling from scales of meters to thousands of km
17. 482.sphinx3 C Speech recognition system from Carnegie Mellon University
Rezulatatul masuratorilor SPEC
pentru 2 calculatoare PC
• Dell Inc. Precision 7710 (Intel Xeon E3-1575M v5, 3.00 GHz) cca 1500$
SPECfp_rate2006 = 218 447.dealII = 324, 459.GemsFDTD = 92.8
Hardware CPU Name: Intel Xeon E3-1575M v5 CPU Characteristics: Intel Turbo Boost Technology
up to 3.90 GHz CPU MHz: 3000 FPU: Integrated CPU(s) enabled: 4 cores, 1 chip, 4 cores/chip,
2 threads/core CPU(s) orderable: 1 chip Primary Cache: 32 KB I + 32 KB D on chip per core
Secondary Cache: 256 KB I+D on chip per core Peak performance = 62.4 Gflop/sec
Software Operating System: Microsoft Windows 10 Pro Build 10586 Compiler: C/C++: Version
16.0.0.110 of Intel C++ Studio XE for Windows; Fortran: Version 16.0.0.110 of Intel Fortran
Studio XE for Windows; Libraries: Version 18.00.30723 of Microsoft Visual Studio 2013 Auto
Parallel: No
_
• Dell Inc. PowerEdge R330 (Intel Xeon E3-1240L v5, 2.10 GHz) cca 1000$
SPECfp_rate2006 = 137 447.dealII = 199, 459.GemsFDTD = 81.8
Hardware CPU Name: Intel Xeon E3-1240L v5 CPU Characteristics: Intel Turbo Boost Technology
up to 3.20 GHz CPU MHz: 2100 FPU: Integrated CPU(s) enabled: 4 cores, 1 chip, 4 cores/chip,
2 threads/core CPU(s) orderable: 1 chip Primary Cache: 32 KB I + 32 KB D on chip per core
Secondary Cache: 256 KB I+D on chip per core Peak performance = 51.2 Gflop/sec
Software Operating System: SUSE Linux Enterprise Server 12 3.12.28-4-default Compiler:
C/C++: Version 16.0.0.101 of Intel C++ Studio XE for Linux; Fortran: Version 16.0.0.101 of Intel
Fortran Studio XE for Linux Auto Parallel: No File System: ext4 System State: Run level 3 multi-
user https://www.spec.org/results.html
1.5. Sisteme paralele,
multi - procesor
• Ideea centrala: se distribuie operatiile pe mai multe procesoare
• Daca n operatii iau timpul t pe un procesor secvential, atunci speram ca vor
lua timpul t/p, de p ori mai mic, executate in paralel. pe p <n procesoare. In
realitate lucrurile nu stau deloc asa, dupa cum se va vedea imediat.
• In versiunea ideala p=n, fiecare procesor efectueaza o operatie:
for (i=0; i<n; i++) /* paralel! */

a[i] = b[i]+c[i]
_
• Daca p<n, fiecare procesor efectueaza mai multe operatii:
for (i=imin; i<imax; i++) P0 P1

a[i] = b[i]+c[i]
Caracterizarea paralelizarii
• Timpul de executie secventiala (pe un procesor): T1
• Timpul de executie in paralel (pe p procesoare): Tp
• Accelerarea (Speedup): S = T1/Tp
• Cea mai buna situatie Tp=T1/p S=p scalabilitatea perfecta
are loc in cazul aplicatiilor nativ paralele, in care datele fiecarui
procesor sunt independente (“embarrassingly parallel
_ applications”). Daca un muncitor sapa o groapa intr-o ora, 100
o sapa in 0,6min ☺ In majoritatea cazurilor insa: S<p
deoarece datele sunt dependente (sunt necesare asteptari),
exista parti secventiale sau se pierde timp (overhead) pentru
comunicatia intre procesoare. Toate astea fac ca paralelizarea
unor coduri si repartizarea sarcinilor intre procesoare sa fie
dificila. Tinta este o accelerare cat mai mare si cat mai
scalabila (independenta de p si cu Tp proportional cu p).
Legea lui Amdahl
Este legea fundamentala a accelerarii prin programarea paralela
• Unele parti ale codului nu pot fi paralelizabile, ele raman secventiale si
devin in executie ca o gatuitura similara gatului unei palnii (“bottleneck”)
• Daca de exemplu, acestea sunt 5%, atunci S nu poate depasi 20,
indiferent cat este p
• Daca partile secventiala si paralelizabila
au poderile Fp+Fs=1, atunci
_
Tp=T1(Fs+Fp/p),
cu valoarea asimptotica T1 Fs, cand p creste,

algoritmii paraleli nu sunt perfect scalabili.
Analiza complexitatii algoritmilor paraleli este
mai dificila si mai putin realista.
Legea lui Gustafson
f este fractiunea de cod care nu poate fi paralelizabila
Tp = f · Tp + (1-f) · Tp
Ts = f · Tp + (1-f) · p*Tp
S = Ts/Tp = f+ (1-f) · p S
S = f+p-fp = p+(1-p)f = f+p(1-f)
_ S = f+p(1-f)
Accelerarea este functie afina de numarul de procesoare p!

Pentru f=0.5 , S = 0.05+0.95p ≈ p
• Legea lui Amdahl se refera la probleme de dimensiune fixa
(executate in timpi diferiti).
• Legea lui Gustafson se refera la timp de executie fixat, dar

probleme de marime diferita. Ofera o viziune mai optimista.
Taxonomia lui Flynn
Prima clasificare a arhitecturii calculatoarelor paralele (1966):
• SISD = Single instruction, single data – arhitectura von
Neumann, al calculatoarelor cu un CPU clasic
• SIMD = Single instruction, multiple data – procesoare vectoriale
Cray1, extensii micro, procesoarele grafice GPU
• MISD = Multiple instruction, single data – procesoare
specializate, necomerciale
_
• MIMD = Multiple instruction, multiple data – majoritatea
procesoarelor actuale (multicore, multithread/core) SPMD
Extensii SIMD la CPU Intel
• MMX (1996): in paralel opt operatii intregi de 8-biti sau patru de
16-biti
• Streaming SIMD Extensions (SSE) (1999): opt operatii intregi
de 16-biti sau patru int/fp de 32-biti sau doua int/fp de 64-bit
• Advanced Vector Extensions (AVX) (2010): patru operatii int/fp
de 64-bit, registre de 256-bit cu 3-operanzi
Intensitatea calculului = nr de op. fp per octet accesat in memorie:
_
Viteza varf de exacutie (tinand cont si de viteza memoriei):
Clasificarea in functie de
modul de acces al memoriei
• Memorie comuna/partajata (shared): RAM pentru CPU-multicore(UMA/SMP)
• Memorie distribuita: retea/cluster multi-CPU
• Hibrida: de ex multi-core cache: L3 comuna, L2, L1 distribuite pe nuclee,
comuna-distribuita (NUMA/NSMP, DSM)
Shared memory Distributed memory
_
Echipament
de retea
sau bus
In consecinta, exista doua

modele fundamentale de
programare care se combina:
• Shared memory (memorie
partajata) (multithreading with
explicit syncronization)
• Message passing
Distributed-shared memory (DSM)
Clasificare dupa topologia
retelei de comunicatie internoduri
In cazul sistemelor distribuite, cu comunicare prin mesaje,
deosebim urmatoarele topologii reale sau virtuale (logice):
Si nu sunt
singurele
Dezvoltarea echipamentelor si tehnologilor de interconectare avansate (Ethernet,

switch, hub, bridge, etc.), mult mai flexibile permit comnicarea directa in oricare
pereche de noduri a facut ca aceste topologii sa ramana doar cu o importanta mai
mult teoretica, facand posibila realizarea topologiei dorite in mod virtual.
Granulatia
O alta clasificare este facuta in functie de raportul dintre efortul de
procesare si cel de comunicare:
• Paralelismul cu granulatie grosiera (Coarse–grain parallel): calculele sunt
repartizate pe procesoare (de regula interconectate in retea cu memorie
distribuita), care executa parti distincte ale problemei si comunica relativ
putin intre ele
• Paralelismul cu granulatie medie (Medium–grain parallel): procesoarele
care executa in paralel diferite proceduri si comunica intre ele, de obicei prin
_ memoria comuna, accesata printr-o singura magistrala.
• Paralelismul cu granulatie fina (Fine–grain parallel): procesoarele (de

regula cu o arhitectura masiv paralela), care executa in paralel diferite
proceduri si comunica intensiv intre ele, de obicei prin memoria sau prin
magistrala comuna.
Granulatia nu se refera numai la arhitectura paralela utilizata, ci mai ales la
problema care este rezolvata, si la felul in care ea este descompusa si apoi
repartizata unitatilor de calcul. Ea influenteaza eficienta paralelizarii. Exista
o granulatie optima care determina o balansare echilibrata a sarcinilor, iar o
granulatie prea fina creste timpul suplimentar necesar comunicarii.
1.6. GPU: structura Fermi GTX 480
Conectarea GPU pe placile de baza

biprocesor din LMN
GPGPU = General Purpose Graphic Processing Unit - placi grafice cu capacitate de calcul:
16 procesoare SIMD multifir (multithreaded), Programator fire (GigaThread scheduler),
6 DRAM de 64B, cu capacitate de 6GB, interfata PCI 16Giga. Arhitectura Multithreated SIMD.
Fiecare procesor are 2048 registre de 32 biti (32,768 in total), care pot fi alocati la 32 fire de
executie (max 64 registre pe fir). Firele au contor de program propriu si date independente. Firele
unui procesor impart o memorie comuna. Cu 512 fire, vorbim de un paralelism masiv.
Evolutia GPU
• GPU au fost inventate de Nvidia in 1999, ca placi grafice super-performante, dar până în 2006
le lipsea posibilitatea de a face calcule în virgulă mobilă si de citire/scriere aleatoare in memorie
Arhitectura G80/Tesla Fermi Kepler Maxwell

An 2006/2008 2010 2012 2014
Cores 128/240 512 13 SMX x 192 16 SMM x 128
Gflops/W 0.5 2 6 12
• Arhitectura G80, introdusa in 2006 a fost
prima care a suportat tehnologia de
_
programare CUDA si modelul SIMT
(single-instruction multiple-thread) care
rula mai multe fire independente de
execuȀie în mod concurent folosind o
singură instrucȀiune,
• CUDA (Compute Unified Device
Architecture), permite plăcilor GPU să fie
programate folosind diverse limbaje de
programare de nivel inalt, C, C++, Fortran
și Java cu extensii CUDA , tehnica numita
GPU computing.
Comparatie intre CPU si GPU
• GPU are mai multe unitati de calcul decat CPU si o viteza

teoretica de varf si o eficienta energetica mult mai mare (chiar si
de 10 ori)
• Totusi CPU este mai flexibil, permitand programarea si
executia algoritmilor universali, in timp ce GPU este folosita
pentru o clasa mai restransa de algoritmi masiv paraleli,
necesitand programare specializata.
Paralelismul masiv.
CPU vs GPU
GPU dedica mai multe tranzistoare procesarii datelor decat CPU,
care se concenteaza pe control
Totusi tendinta de viitor este de convergenta:

• CPU au tot mai multe nuclee de calcul
• Ambele tind spre arhitectura vectoriala a unitatii de executie
• Ambele tind spre performante de varf de ordinul TeraFlop/s
In concluzie, performantele sistemelor paralele se obtin prin: alegerea setului de
instructiuni, organizarea memoriei si a comunicarii intre procesoare
Structura serverului HPC Atlas al LMN
TESLA GPU-C1060 Conf [Iqbal05] acest switch da serverului caracterul HPC
w 240 thread proc. Internet,
6x1TB HDD
grid, cloud
Mellanox 20GBps
InfiniBand NIC Noduri:Supermicro 4HE SuperChassis SC745TQ-R800B
_
Sys
admin
LMNHub
6x4GB DDR3
Intel Xeon X5550 CPU,

SM-X8DAH-F 2.66 GHz, Quad Core,
8threads 8 MB Cache Lmn.pub.ro
LMN Wi-Fi Hub
2 x CISCO Catalyst 2960 24 10/100/1000, LAN Base Switch
Caracteristicile serverului HPC
Atlas al LMN
• Cu cele 14 noduri cu 28 CPU si 2 GPU care au un total de

_
112 nuclee de calcul pe care se pot gazdui peste 500 de fire
de executie se obtine o viteza de calcu de peste 1TFlop/s.
•Un rol mportant in asigurarea performantleor ridicate il are
comutatorul rapid InfiniBand care asigura viteza 20GB/s
• Memoira totala RAM este de peste 270GB iar cea de pe disc
depaseste 10 TB.
•Structura serverului este hibrida, avand opt nivele de calcul:
Paralel si distribuit prin clusterul de tip Beowulf
(http://www.beowulf.org/overview/faq.html), nodurile au doua CPU
cu memorie RAM comuna, fiecare CPU cu 4 nuclee de calcul ce
pot executa 2 fire fiecare, si 2 GPU cu 240 procesoare fiecare.
2. Programarea sistemelor
multiprocesor
2.1. Etapele conceptiei programelor 2.7. Structuri de suport si modele
paralele o Tasks parallel/SPMD
o Parallel Tasks/Loop
2.2. Concurenta vs paralelism o Geometric Data Decomposition on
2.3. Modele de programare (Design SPMD
o Master/worker parallel tasks
pattern)
o Divide & conquer with fork/join
_
2.4. Conceptele si argoul paralelizarii o Pipeline with fork/join
2.5. Medii si limbaje o Recursive data/SPMD si Event based
o Pthread
o Open MP
•
o CUDA
o MPI
o MATLAB Parallel Computing
o PETSc
2.1. Programarea paralela pe diferite
nivele, medii si limbaje
• Multithreading: POSIX Threads Programming [Lewis96]
https://computing.llnl.gov/tutorials/pthreads/
http://www.instructables.com/id/Matlab-Multithreading-EASY/
• Multi-core: Open MP [Akhter06]
http://www.inf.ed.ac.uk/teaching/courses/ppls/TBBtutorial.pdf
https://www.mathworks.com/discovery/matlab-multicore.html
• Shared memory multi-CPU: Open MP [OpenMP], [Quinn 04]
https://www.mathworks.com/products/parallel-computing/
_
• GPGPU: CUDA, MATLAB Parallel computing [Wilt13]
• Cluster of distribued nodes: MPI,PETSc, Fem++ [Quinn 04]
http://www.mpi-forum.org https://www.mathworks.com/products/distriben/
https://www.mcs.anl.gov/petsc/ http://www.freefem.org/
• Grid: MATLAB Parallel computing
https://www.mathworks.com/products/distriben/
• Cloud: MATLAB Parallel computing
https://www.mathworks.com/products/parallel-computing/parallel-computing-on-the-cloud/
Sfaturi pentru
programarea paralela
• Unitatile de calcul sunt tot mai multe si tot mai ieftine, nu viteaza in Gflop/s este
problema, ci comunicarea. Evitati-o chiar cu sacrificiul de Gflop.
• Sincronizarea proceselor (asteptarea altor precesoare sa-si faca treaba) poate
reduce viteza pana la blocare. Ea trebuie minimizata, ideal eliminate.
• Folositi de cate ori puteti precizie hibrida: calcule imprecise (in simpla precizie) pentru
a corecta (perturba) solutii calculate in dubla precizie
• Lasati programele specializate sa se ocupe de (auto)tuning pentru a optimiza
performantele pe cale experimentala. Instruiti compilatorul sa optimizeze codul, o va
face mai bine decat programatorul.
_• Algoritmii numerici trebuie sa fie stabili,robusti. Nu tintiti solutii perfecte, pot fi scumpe.
• Descompuneti problemele in sub-probleme mici, de preferinta care incap in cache,
• Tintiti flexibiliatea, eficienta si simplitatea. Conceptia si programarea orientate pe
obiecte (OO) sunt de mare folos (de exemplu, scheletele sau obiectul-thread, care nu
lasa resurse blocate, atunci cand moare, evitand astfel risipirea resurselor).
• Porniti de la un cod secvential testat si analizati bine problema, descompuneti datele
si taskurile ei, analizati dependentele, concurenta, datele comune si ordinea, apoi
recompuneti-o structurat, concentrandu-va pe punctele fierbinti.
• In paralelizare faceti modificari mici apoi testati. Alte sfaturi https://goparallel.sourceforge.net/
• Refolositi biblioteci si modele (Design Pattern) ! [Landau], [GoF97], Mattson04]
2.2. Concurenta vs paralelism
• Fie doua taskuri T1, T2, concurente (care colaboreaza la rezolvarea unei
probleme)
• Executia paralela este mai rapida, dar necesita doua unitati de executie
(CPU, core)
• Executie cu divizarea timpului (“time sharing”=“multitasking”) este mai lenta
dar se poate face pe un singur procesor, caz in care el comuta succesiv
intre taskuri, cu salvarea si reconstructia contextului (registre, stive, etc.)
tp tc > 2 tp
_
Paralel T1 CPU1 Timpul
T2 CPU2
Concurent T1 CPU1
T2
• Concurenta este un concept general care nu necesita paralelismul

• Dar identificarea concurentelor este esentiala in paralelizarea codului
• Se analizeaza algoritmul si se descompune in taskuri (de o anumita
granulatie). O diagrama Pert este utila. Laturile ei paralele sunt concurente.
2.3. Programarea paralela dupa
modele (“pattern”)
Parallel Programming Design Pattern
• Programele paralele nu exploateaza deplin performantele hardware din
cauza dificultatilor de programare si a faptului ca mediile de programare nu
sunt focalizate pe aspectele de conceptie.
• Este necesar un fel de retetar care sa ghideze programatorii pentru a atinge
performante in calculul paralel apropiate de cele de varf.
• Acesta ar trebui sa contina modele de: descompunere, algoritmi
fundamentali, structura de program, mediu de programare si optiuni,
_
optimizari.
• Si un dictionar cu termenii folositi frecvent in comunitatea programatorilor
sistemelor paralele. [Mattson04] este un exemplu.
• Obiectivul consta in promovarea reutilizarii si modularizarii programelor.
Valoarea unui profesionist de varf se exprima prin abilitatea de a reutiliza, si
nu prin cea de a scrie cod de la zero.
• Programatorilor li se recomanda deci, sa preia din aceste retetare modulele
similare cu ce au nevoie si sa le adapteze proiectului propriu, prin modificari
minime.
Decizii de proiectare privind
structura algoritmului [Mattson04]
• Organizarea dupa: taskuri, descopunerea datelor si fluenta datelor

• Poate fi liniara sau recursiva
• Rezulta urmatoarele 6 structuri fundamentale de algoritmi (pattern)
paraleli:
cu taskuri paralele, bazate pe divizare si stapanire, cu descompunere
geometrica (tablouri, vectori), cu date recursive (liste, arbori, grafuri), cu
model de tip conducta (pipeline), cu coordonare bazata pe evenimente.
Modelele principale de paralelizare
Paralelizarea taskurilor Paralelizarea datelor
Paralelizarea dupa fluenta datelor - presupune analiza dependentelor
Implementarea
Pentru finalizarea a proiectului mai trebuie parcurse
urmatoarele etape prin care se realizeaza implementarea lui:
– Definirea managementului unitatii de excutie (EU): control fire si
procese
– Precizarea sincronizarii: acces memorie, bariere, excluziune mutuala
– Stabilirea modului de comunicare: mesaje, colectiva, altfel
– Alegerea mediul de programare si a limbajului si implementarea
_
codului (scriere, testare)
– Asignarea: maparea pe hardware
• In sumar, realizarea programelor paralele are patru pasi:
– Identificarea concurentei (prin descompunerea taskurilor si datelor)
– Structurarea algoritmului
– Alegerea structurilor suport (pentru algoritmi si date)
– Descrierea mecanismelor de implementare
– [Mattson04]
Metodologia PCAM de proiectare a
lui Foster
• Descompunere/Partitionare:
problemei (taskuri/date) in parti
concurente si identificarea
dependentelor (determina
granulatia, gradul de paralelism Comunicare
si costul comunicarii)
• Comunicarea: Partitionare
Identificarea comunicarii Agregare
locale/globale intre parti, si a
Asignare
_
barierelor de sincronizare
• Agregarea:
Gruparea partilor pentru
minimizarea comunicarii
• Asignarea: realizeaza Metodologia PCAM in 4 etape (Partition, Communicate,

corespondenta dintre Agglomerate, Map) a lui Foster [Foster95] este mai
grupurile de taskuri si concreta (mai putin abstracta) decat cea a lui Mattson.
elementele hardware de Perfomanta paralelizarii depinde esential de adecvarea
executie, esentiala pentru comunicarii si asignarea optima la arhitectura sistemului
balansare [Heath] [Grama03]
de calcul disponibil (cu memorie comuna sau distribuita).
2.4. Conceptele si argoul
paralelizarii
• Thread = fir de executie (are acces la datele procesului care l-a generat)
• Process = proces de calcul gestionat de SO, care are la resursele sale (propriul spatiu de
memorie, descriptori I/O, stive, manipulatori de semnal, controlul accesului, etc). Comutarea
CPU la un alt proces se face intr-un timp semnificativ necesar salvarii contextului.
• Malloc = alocare dinamica de memorie in C. In C++ se recomanda new si delete
• Mutex = excluziunea mutuala a firelor, serializeaza executia lor
• OS = sistem de operare (SO)
• EU = “Execution Element - element de executie (UE)
• CPU = Central Processing Unit
_• FPU = Floting Processing Unit
• Core = nucelu de calcul, parte a CPU
• ADT = Abstract Data Type – tip abstract de date (ex: stiva, lista, graf, coada, set)
• STL = Standard Template Library - biblioceca C++ de tipuri abstracte de date din
categoriile: algorithms, containers, functional, iterators
• C Standard Libraries = Bibiotecile C standard: Data types; Character, Strings, Mathematics,
File I/O, Date/time, Localization, Memory allocation, Process control, Signals, Alternative tokens
• C POSIX library = Bibioteca C standard POSIX cu functii pentru control fire, soket, stream.
• Open Computing Language (OpenCL) framework pentru dezvoltarea programelor pentru
platforme heterogene: CPU, GPUs, DSP (digital signal processors), FPGA (field-programmable
gate arrays) sau alte acceleratoare de calcul.
Conceptele si argoul
paralelizarii
• API = Application Programming Interface – modul software care ofera servicii aplicatiei, ex: MPI,
OpenMP. Orice aplicatie poate fi recompilata pe OS-ul care suporta acel API.
• Bandwidth = exprima in Bytes per sec viteza unui canal (retea, memeorie, I/O)
• Latency = latenta este intarzierea sosirii unui mesaj pe un canal (mesajele scurte scad eficenta)
• Barrier = bariera – mecanism de sincronizare pentru un grup de UE, prin care se opreste executia oricarei
unitati care ajunge la ea, pana cand ajung toate din grup
• Beowulf cluster = cluster de PC-uri cu OS Linux
• Broadcast = trimiterea unui mesaj catre toate UE implicate in calcul
• Cahe = o unitate de memorie rapida, de mici dimensiuni, continuta in CPU sau Core. Oglindeste continutul
unui bloc din memoria centrala sau din cache-ul de nivel inferior. Este actualizat cand se proceseaza un
element din blocul respectiv, asigurand coerenta cache-urilor.
_• Copy on write = lucru pe draft, o tehnica prin care cu sincronizare minimala, firele concurente nu vad
niciodata structuri de date in stari inconsistente. Pentru a actuliza o structura de date se efectueaza o copie a
ei (draft), pe care se fac modificarile si apoi referinta la vechea structura este schimbata catre copie.
• Cyclic distribution = distributie ciclica a blocurilor dintr-un tablou sau a trecerilor dintr-un ciclu cu contor
catre o grupa de EU (ca impartirea cartilor la jucatori)
• Deadlock = blocaj – stare de eroare, in care calculul este oprit pentru ca toate EU asteapta
• Distributed/parallel computing = calcule pe sisteme cu memorie distribuita/comuna
• Embarrassingly parallel = taskuri complet independente nativ paralele,
• TCP/IP = Transmission Control Protocol/Internet Protocol sunt pprotocoalele de baza pentru comunicarea in
Internet. Sunt doua din cele 4 nivele ale suitei Internet.
• Atomic operation = operatie care nu poate fi intrerupta (de exemplul load, store, sau operatii care in
claculele paralelele se executa integral fara a fi intrerupte de alte unitati de executie). In cazul conflictului,
rezultatul depinde de ordinea executiei lor
paralelizarii
• Abstract Factory – metoda de generare ADT
http://www.holub.com/goodies/holub_design_patterns.pdf
• Design Pattern = Metoda de conceptie a algoritmilor si codului, bazata pe folosira modelelor de
solutii de inalta calitate (cea mai buna practica)
• Fork/join = un model de programare, in care un fir se bifurca, si se creaza noi fire de executie
care ulterior (in punctul de unire) se elimina si ramane doar cel vechi.
• Framework (Programming environment) = mediu de programare care ofera toate
componentel software necesare dezvoltarii unei aplicatii
• Grid = un tip de arhitectura pentru calcule distribuite si folosirea in comun a unor resurse
heterogene (servere de calcul, de date aplicatii, servicii informatice), interconectate local sau la
scara larga (inclusiv international), de regula prin Internet, ca servicii Web. Spre deosebire de
_ cluster, gridul nu este administrat dintr-un singur punct. Modulele software de controlul gridului
(middleware) este Incorporat dar politicile de acces la resurse apartin fiecarui proprietar.
• Load balance = repartitia echilibrata a sarcinilor intre elementele de procesare (taskuri pe EU),
astfel incat sa termine in timpi cat mai apropiati.
• Locality = localitatea este propietatea unui task de avea datele cat mai apropiate de EU (de
exemplu, problemele de algebra liniara sunt descompuse in blocuri care incap in cache)
• MPI = standard (API) pentru interfata de transmiterea mesajelor
• Node = nod este o unitatea pe procesare (uni sau multiporcesor) cu memoria sa conectata in
retea pentru a realiza un sitem de calcul distribuit
• OpenMP = un API standard care contine directive de compilator, biblioteca de rutine, variabile
de mediu, folosite pentru programarea sistemelor cu memorie comuna in in Fortran and C/C++
paralelizarii
• CUDA = API dezvoltat de Nvidia pentru programarea GPU
• Parallel file system = fisiere distribuit pe diferite discuri, dar care se vede de pe orice EU ca un
sistem unitar
• Parallel overhead = timpul suplimentar cheltuit pentru controlul paralelismului si nu pentru
calculul propriuzis, de exemplu cel pentru genrarea si planificarea firelor, a asteptarii in vederea
sincronizarii, si comunicarii
• P2P = Peer to Peer – model de calcul distribuit in care toate nodurile sunt echivalente (spre
deosebire de master-slave) si orice nod poate initia o comunicare cu altul.
• POSIX = the Portable Operating System Interface este un standard IEEE pentru interfata cu
OS de tip Unix, inclusiv Linux.
•
_
Precedence graph = graful de precedenta al instructiunilor indica ordinea in care acestea
(considerate noduri) vor fi executate. Existenta buclelor genereaza blocaje.
• Process migration = migrarea unui proces de la un CPU la altul, are loc in distribuirea
dinamica a sarcinilor si atunci cand un CPU se defecteaza
• Programming model = model de programare, poate fi secvential (von Neumann), paralel (cu
memorie comuna), distribuit (cu memorie distribuita), hibrid
• Reduction = o operatie prin care o colectie de obiecte repartizate pe diferite EU este
combinata intr-un singur obiect alocat unei EU
• Refactoring = tehnica de inginerie software prin care se modifica structura interna a
programului, fara a schimba comportarea sa externa (vazuta de utilizator). Paralelizarea
incrementala, in care un program secvential este paralelizat putin cate putin (cu teste
intermediare pentru a-i salva corectitudinea) este un exemplu de refactorizare.
paralelizarii
• RPC = Remote procedure call consta in apelul unei proceduri care se va executa de alta EU.
Metoda de comunicare in sistemele distribuite, in care un nod lanseaza o procedura pe alt nod.
• Semaphore = o ADT care controleaza executia unui fir. Are o valore care poate fi incrementata
sau decrementata, iar cand ajunge 0, firul stopeaza executia
• Network Socket = un ADT care reprezinta un conector, adica un terminal al unui canal de
comunicare <socket.h>. Permite comunicarea intre procese. Adresa sa este un manipulator
care permite indentificarea terminalului (ca un numar de telefon diin "combination of an IP
address and a port number"), iar transferul de date se face ca intr-un fisier.
• Stream = o secventa de date disponibila in timp, printr-un canal de comunicare intre un proces
si un dispozitiv I/O. In C aceasta comunicare este abstractizata ca operatii de citire si scriere in
fisiere de intrare si respectiv iesire, Cele trei “standard stream” stdin, stdout si stderr sunt
_ alocate initial tastaturii, si respectiv display-ului. <stdio.h>
• IPC = Interprocess Communication - mecanismul de comunicare intre procese. In Unix este
bazat pe concepte ca Signal, Pipe, Socket https://en.wikipedia.org/wiki/Inter-
process_communication
• Signal = este un mecanism asincron de comnicare prin care se transmite unui proces sau fir
de executie o cerere de intrerupere sau de terminare.
• Pipe = un canal unidirectional de comunicatie intre procese stabilit prin intermediul IPC. Datele
scrise la un capat sunt memorate de OS pana sunt citite la celalalt capat. Transferul
bidirectional este realizat de o pereche de canale
• I/O = Input/Output – canal de intrare/iesire
• Client-server = mecanism de comunicare in retea, initiat de clienti, care solicita servicii..
2.5. Medii si limbaje
Programele paralele se pot dezvolta in limbaje de programare generale sau specializate
: FORTRAN, C, C++, Python, Java, MATLAB, folosind diferite biblioteci de functii,
API, medii de dezvoltare, toolbox-uri dedicate paralelizarii. Ultimele doua au extensii
dedicate paralelizarii (http://www.elth.pub.ro/~preda/teaching/PPSD/PPSD_1.pdf ). In
unele paralelizarea este implicita (automata, realizata de compilator). Cele mai des
folosite pentru calculele stiintifice si ingineresti sunt:
– Pthread: POSIX Threads Programming – biblioteca functii C

– Open MP: Open Multi-Processing API pentru calcul paralel
_ – CUDA: Compute Unified Device Architecture API pentru GPU
– MPI: Message Passing Interface API pentru calcul distribuit
– Open CL: Open Computing Language (API pentru CPU si GPU)
– MATLAB Parallel computing: toolbox pentru calcul paralel si distribuit
– PETSc: Portable, Extensible Toolkit for Scientific Computation – biblioteca de
functii C, C++, FORTRAN, Python si structuri de date pentru calcule stiintifice
– FreeFem++: Finite Element Method - mediu de dezvoltare software (OOP-HPC)
pentru rezolvarea cu FEM a ecuatiilor cu derivate partiale
Programarea paralela pe diferite nivele,
medii si limbaje
• Multithreading: POSIX Threads Programming [Lewis96]
https://computing.llnl.gov/tutorials/pthreads/
http://www.instructables.com/id/Matlab-Multithreading-EASY/
• Multi-core: Open MP [Akhter06]
http://www.inf.ed.ac.uk/teaching/courses/ppls/TBBtutorial.pdf
https://www.mathworks.com/discovery/matlab-multicore.html
• Shared memory multi-CPU: Open MP [Quinn 04], [OpenMP]
https://www.mathworks.com/products/parallel-computing/
_
• GPGPU: CUDA, MATLAB Parallel computing [Wilt13]
http://docs.nvidia.com/cuda/cuda-c-programming-guide/
• Cluster of distributed nodes: MPI, PETSc, FEM++ [Quinn 04], [MPI]
https://www.mathworks.com/products/distriben/ http://www.freefem.org/ [PETSc]
• Grid: MATLAB Parallel computing
https://www.mathworks.com/products/distriben/
• Cloud: MATLAB Parallel computing
https://www.mathworks.com/products/parallel-computing/parallel-computing-on-the-cloud/
Pthread: POSIX Threads
Programming
• Management –genereaza si distruge fire de executie: int main (int argc, char *argv[])
– pthread_create (thread,attr,start_routine,arg) { pthread_t thread[NUM_THREADS];
– pthread_exit (status) pthread_attr_t attr;
– pthread_cancel (thread) int rc;
– pthread_attr_init (attr) long t;
– pthread_attr_destroy (attr) void *status;
– pthread_join (threadid,status) /* Initializare fire si obtine attr */
pthread_attr_init(&attr);
– pthread_detach (threadid)
pthread_attr_setdetachstate(&attr,
• Mutexes: Routine pentru sincronizare de tip excluziune PTHREAD_CREATE_JOINABLE);
mutuala a frelor for(t=0; t<NUM_THREADS; t++) {
– pthread_mutex_init (mutex,attr) printf("Main:creating thread %ld\n",t);
– pthread_mutex_destroy (mutex) rc = pthread_create(&thread[t],&attr,
– pthread_mutexattr_init (attr) BusyWork,(void*)t); }
_ – pthread_mutexattr_destroy (attr). /* Elibereaza atribue si asteapta unirea
firelor*/
• Condition variables: functii pentru creere, distrugere,
pthread_attr_destroy(&attr);
conditie (semnal de asteptare)
for(t=0; t<NUM_THREADS; t++) {
– pthread_cond_init (condition,attr) rc = pthread_join(thread[t], &status);}
– pthread_cond_destroy (condition) pthread_exit(NULL);
– pthread_condattr_init (attr)
[Lewis96]
– pthread_condattr_destroy (attr)
http://www.elth.pub.ro/~preda/teaching/PPSD/PPSD_3.pdf
• Synchronization: rutine pentru controlul (citire/scriere a)
stopurilor si bariereleor
– pthread_cond_wait (condition,mutex)
– pthread_cond_signal (condition)
– pthread_cond_broadcast (condition)
Curse, necesitatea sincronizarii,
reducerea
• Cursa este efectul prin care unele programe paralele nu dau rezultate reproductibile.
Este unul din cel trei mari pericole ale paralelizarii, alaturi de blocaje (cand toate
taskurile asteapta) sau nescalabilitatea (reparizarea gresita a sarcinilor).
• Cursa intre doua fire paralele pentru acces la memorie sa actualizeze date comune
Exemplu: process P1: S=S+2 process P2: S=S+3
scenariul 1. scenariul 2. .scenariul 3.
S = 0 P1 P2 S = 0 P1 P2 S = 0 P1 P2
read S=0 read S=0 read S=0 read S=0 read I=0
compute S=2 compute S=3 compute S=2 compute S=3 compute S=2
write
_ S=2 write S = 3 write S=2
write S=3 write S = 2 read S=2
computeS=5
write S = 5
S=3 S=2 S=5

% exemplu: O solutie: excluziunea mutuala, dar calculul nu este
%paralelizare ciclu
S=0 accelerat. Alta solutie este reducerea: un membru al
pentru i=1,n paralel grupului colecteaza datele de la ceilalti si executa o
s=s+1+i operatie (min, max, add, multiply, etc.) pe aceste date.
s=?
Open MP: Open Multi-Processing
API de paralelizare semiautomata, bazat pe Pthread
pentru programarea sistemelor mutiprocesor cu
memorie partajata
/* Exemplu de ciclu paralel */
int main(int argc, char **argv)
{ int a[100000];
#pragma omp parallel for
for (int i = 0; i < 100000; i++)
{ a[i] = 2 * i;}
return 0; }
_
Exemple de directive:
/* eroare datorita dependentei */ #pragma omp parallel for
int main(int argc, char **argv) #pragma omp parallel num_threads(10) shared
{ int a[100000]; #pragma omp parallel for private(temp)
a[0] = 0; #pragma omp parallel for reduction(+:sum)
#pragma omp parallel for #pragma omp parallel for schedule
for (int i = 1; i < 100000; i++)
{ a[i] = 2 * a[i-1];}
return 0; }
Open MP permite lansarea firelor si planificarea statica si dinamica a taskurilor pe fire
cu directiva schedule precum si sincronizarea firelor. [Akhter06]
CUDA: Compute Unified Device
Arhitecture (Nvidia GPU)
Extinde codul C pentru a controla procesele de pe dispozitivul GPU (device) conectat la
un CPU cu memoria sa (host). Procesele de pe host se executa secvential iar cele de
pe device paralel, pe un numar de fire ce alcatuiesc un bloc. Functiile cu calificativul
__global__ se executa implicit in paralel pe GPU. Fiecare fir din bloc are un
identficator intreg in variabila threadIdx (.x pentru drectia x in cazul 1D, .y si .z in
cazul blocului 3D) si are acces la o memorie locala ierarhizata:
// Definitie suma vect pe GPU // Suma de matrice pe GPU
__global__ void VecAdd(float* __global__ void MatAdd(float
A, float* B, float* C) A[N]{N], float B[N]{N], float
{ int i = threadIdx.x; C[N]{N])
C[i] = A[i] + B[i]; } { int i = threadIdx.x;
_ int j = threadIdx.y;
int main() { ... C[i][j] = A[i][j] + B[i][j];}
// apelare kernel cu N fire
int main() { ...
VecAdd<<<1, N>>>(A, B, C); ... // apelare kernel cu NxN fire
}
int numBlocks = 1;
dim3 threadsPerBlock(N, N);
[Wilt13] MatAdd<<<numBlocks,
threadsPerBlock>>>(A, B, C);
Inainte de apel trebuie alocata memorie pe device (cu cudaMalloc) , copiate datele (cu
cudaMemcpy), din host in device, iar apoi invers si eliberata in final memoria host cu cudaFree
MPI: Message Passing Interface
MPI = pachet de rutine standard, pentru comunicarea in retele (reale sau virtuale):
operatii de trimitere si receptie date, de tip P2P, alegere intre retele cu topologii
carteziana sau graf, combinarea partiala a calculelor, sincronizarea nodurilor prin
bariere, dar si obtinerea informatiilor despre retea.
Cand este lansat, mpirun asociaza fiecarui nod din retea cate un proces, care capata un numar de
identificare (rang: 0,1,2….) . Aplicatia MPI opereaza cu grupuri de procese.
MPI este API de baza pentru programare internod. el se bazeaza pe conceptele:
• Comunicator; Point-to-point: send/receive blocant/neblocant (cu tampon); Collective:
Sincronizari (bariera), transmiteri de dae (broadcast, scatter/gather, all to all), Calcule
colective (reductii); Derived datatypes: CHAR, INT, FLOAT , DOUBLE,COMPLEX,
_ LOGICAL, etc; One-sided communication; Extensions; Process management; I/O.
Majoritatea programelor MPI se bazeaza doar pe 6
functii, din care doar doua sunt mai complicat de folosit:
MPI_INIT; MPI_FINALIZE; MPI_COMM_SIZE;
MPI_COMM_RANK; MPI_SEND; MPI_RECV
SIZE da numarul proceselor iar RANK da ordinul
procesului.
Reductia este folosita de exemplu la
paraleleizarea integralelor (add) sau optimizarilor
(min, max).
http://www.elth.pub.ro/~preda/teaching/PPSD/PPSD_11.pdf
Exemple de programe cu
comunicare Send/Recv prin MPI
/* Procesul 0 trimite iar /* Exemplu de Master */
Procesul 1 primeste */ ! Aici trimiterea initiala a taskurilor
#include “mpi.h” do while(.not. Done)
! Preia raspuns de la oricine
#include <stdio.h>
call MPI_Recv( a,…, status, ierr )
int main( int argc, char *argv[]) ! Daca este ultimul, Done = .true.;
{ int rank, buf; ! Altfel trimite alte taskuri
MPI_Status status; call MPI_Send(b,…,status(MPI_SOURCE),&
MPI_Init(&argv, &argc); … , ierr )
MPI_Comm_rank( MPI_COMM_WORLD, Enddo
&rank );
_ if (rank == 0) { /* Exemplu de Worker */
buf = 123456; Do while (.not. Done)
! Primeste task de la Master
MPI_Send( &buf, 1, MPI_INT, 1,
0, MPI_COMM_WORLD); } call MPI_Recv( a, …, status, ierr )
! Daca nu este mesaj de terminare {
else if (rank == 1) {
… executa taskul
MPI_Recv( &buf, 1, MPI_INT, 0, ! Trimite rezultatul la Master
0, MPI_COMM_WORLD, call MPI_Send( b, …, ierr )}
&status ); !altfel Done = .true.
printf( “Received %d\n”, buf );} Enddo
MPI_Finalize(); [Quinn 04], [MPI] Alt exemplu (heat 2D MPI)::
return 0; http://www.elth.pub.ro/~preda/teaching/PPSD/PPSD_12.pdf
dar mai bine: https://dournac.org/info/parallel_heat2d
Calculul lui π in paralel cu
MPI Bcast/Reduce
#include "mpi.h" for (i=myid+1; i<=n; i+= numprocs) {
#include <math.h> x = h * ((double)i - 0.5);
#include <stdio.h> sum += 4.0 / (1.0 + x*x); }
int main(int argc, char *argv[]) mypi = h * sum;
MPI_Reduce(&mypi,&pi,1,MPI_DOUBLE,
{ int done = 0,n,myid,numprocs,i,rc;
MPI_SUM,0,MPI_COMM_WORLD);
double PI25DT = 3.141592653589793238462643; if (myid == 0)
double mypi, pi, h, sum, x, a; printf("pi este aprox %.16f,
MPI_Init(&argc,&argv); Error is .16f\n",pi,fabs(pi-
MPI_Comm_size(MPI_COMM_WORLD,&numprocs); PI25DT));
MPI_Comm_rank(MPI_COMM_WORLD,&myid); }
MPI_Finalize();
while (!done) {
_ return 0;
if (myid == 0) { y=f(x) f(xi)
printf(“Introduceti nr, de intervale
n:(0 = terminat!) ");
scanf("%d",&n);}
MPI_Bcast(&n,1,MPI_INT,0,MPI_COMM_WORLD); xi=(i-0.5)h
if (n == 0) break; 0 1 x
h = 1.0 / (double)n;
sum = 0.0;
h
1 1 n =1 / h
4
∫0 1 + x 2 dx =π ; ∫ f ( x)dx ≈ h ∑ f ((i − 0.5) ⋅ h);
0 i =1
Calculul lui π in paralel prin
integrare Monte Carlo cu MPI
Serial Paralel
npuncte = 10000 npuncte = 10000
in_cerc = 0 in_cerc = 0
pentru j = 1, npuncte p = numar de taskuri
% genereaza 2 numere aleatoare intre 0 si 1 num = npuncte / p ; nr puncte pe task
x = random1 Afla daca sunt MASTER sau WORKER
pentru j = 1, num
y = random2
% genereaza 2 numere aleatoare intre 0 si 1
daca (x,y) e in cerc x = random1
in_cerc = in_cerc +1 y = random2
PI
_ = 4.0* in_cerc / npuncte daca (x,y) e in cerc
Ap = 4 r 2 in_cerc = in_cerc +1
daca sunt MASTER
Ac = πr 2 Primesc de la WORKERS numaratoarea
Calcueaza PI (folosind rezultatele
2r Ac / Ap = π / 4 MASTER/WORKERS)
altfel
π ≈ 4Nc / N p trimite la MASTER in_cerc
. Q: Care este valorea optima pentru p?
MPI_Reduce man page la https://www.open-mpi.org/doc/current/man3/MPI_Reduce.3.php
Codul c paralel la https://computing.llnl.gov/tutorials/mpi/samples/C/mpi_pi_reduce.c
MATLAB Parallel computing
• Obiective: cresterea performantelor, executie mai rapida, prin
paralelizare; date de dimensiuni mai mari, exploatarea plenara a
resurselor disponibile.
• Toolbox dedicat sistemelor multicore, cu GPU si clustere, care asigura:
– Bucle paralelizate pentru algoritmi cu taskuri in paralel pe mai
multe unitati de procesare.
– Suport pentru GPU NVIDIA programabile in CUDA
– Exploatarea arhitecturelor multicore prin workeri executati local
– Suport pentru cluster si grid (prin MATLAB Distributed
Computing Server)
– Executia aplicatiilor paralele in mod interactiv si batch
_ – Tablouri distribuite si executiii SPMD pentru seturi de date de
mari dimensiuni
• Solutiile MATLAB pentru imbunatatirea performantelor
– Daca programul este prea lent, atunci vezi profil si vectorizeaza
(elimina for)
– Daca e inca lent, foloseste GPU, daca ai
– Altfel foloseste parfor, parfeval, spmd
– Daca datele nu incap in calculatorul tau, distribuie-le la alte
calculatoare, iar daca tot nu incap, folseste “tall array”
– Daca tot nu esti multumit, atunci foloseste cluster si apoi cloud
% Creeaza si termina un grup de 3 workeri:
parpool('local',3) ….. delete(gcp)
MATLAB Parallel computing:
parfor, batch, distributed
parfor i = 1:1024
for i = 1:1024 A(i) = sin(i*2*pi/1024);
A(i) = sin(i*2*pi/1024); end
end % trecerile sunt grupate si alocate workerilor
% pare simplu, dar nu e, ordinea nu conteaza!!!
% Script care executa 3 instante in paralel

job = batch('programulmeu','Grup',3)
wait(job)
load(job,'A')
plot(A)
delete(job)
_ clear job
% Tablou distrinuit la workeri

MM = distributed(M);
spmd % executa spmd in grup
R = rand(4);
end
X = R{3}; % R de la worker 3
X = X + 2;
R{3} = X; % trimite la worker 3.
parfeval, spmd
Instructiunea spmd defineste un bloc executat
Parfeval evalueaza asincron functii in secvential de fiecare worker. Astfel un cod
paralel, fara asteptare, rezultatele pot fi identic este executat in paralel de un grup de
folosite cand sunt disponibile workeri folosind date diverse. Ei pot comunica
LabSend si LabReceive.
p = gcp(); Clientului are acces la datele worker-ilor
%10 evaluari asincrone indexate cu { }, care formeaza un obiect
for idx = 1:10 compozit. In realitate pe client se afla doar
f(idx) = parfeval(p,@magic,1,idx); referintele la memoria workerilor.
end
% creaza grup de 3 workeri
% Colecteaza rezultatele parpool('local',3)
_
magicResults = cell(1,10); spmd
for idx = 1:10 MM = rand(labindex+2);
[completedIdx,value] = if labindex > 1 % index worker >1
fetchNext(f); HH = rand(4);
magicResults{completedIdx} = end
value; end
fprintf(‘Rezultat pentru idx = A = MM{2};transfera date W2 client
%d.\n', completedIdx); HH
end >> Lab 1: No data
>> Lab 2: class = double, size = [4 4]
delete(gcp) % sterge grup workeri
>> Lab 3: class = double, size = [4 4]
HH{3}= A; transfera client W3
datastore, tall
datastore initiaza o baza de date Programarea joburilor si a intercomunicarii
distribuita pe diferite medii c = parcluster(); % genereaza un cluster paralel
tall converteste baza de date intr-un masiv job1 = createJob(c); % creeaza job
de date procesat in paralel createTask(job1, @rand, 1, {{3,3} {3,3}
{3,3} {3,3} {3,3}}); % creeaza taskuri
gather aduna rezultatele in memoria
clientului submit(j1); % trimite job spre executie
submit(job1)
% Initiaza baza de date distribuita
wait(job1) % asteapta terminare job
ds = datastore('airlinesmall.csv');
results = fetchOutputs(job1)% incarca rez
varnames = {'ArrDelay', 'DepDelay'};
j1 = createJob(c);
ds.SelectedVariableNames = varnames;
_ for ii = 1:n
ds.TreatAsMissing = 'NA';
t(ii) = createTask(j1,...)
% converteste baza de date in masiv
end
tt = tall(ds);
cancel(t(4)); % anuleaza task
a = tt.ArrDelay;
findJob(c,'State','finished','Username','
% calculeaza media si abaterea standard joep')
m = mean(a,'omitnan'); delete(finished_jobs); % sterge job
s = std(a,'omitnan'); clear finished_jobs; % elibereaza mem
one_sigma_bounds = [m-s m m+s]; createCommunicatingJob(c,'Type','SPMD');
% aduna rezultatele labSend(outdata, to_lab_right);
sig1 = gather(one_sigma_bounds) indata = labReceive(from_lab_left);
GPU, gpuArray, arrayfun
% Transfera date intre host si GPU % compileaza codul sursa myfun.cu
X = rand(1000); # care calculeaza convolutia a 2 vectori
G = gpuArray(X); % spre GPU % scris in CUDA si creaza myfun.ptx
% (parallel thread execution file)
G = gpuArray(ones(100,'uint32'));
nvcc -ptx myfun.cu
D = gather(G); % aduna in host
% creeaza un obiect kernel
OK = isequal(D,ones(100,'uint32'))
k =
% Matrice I de 1024x1024 int in GPU parallel.gpu.CUDAKernel('conv.ptx','c
II = eye(1024,'int32','gpuArray'); onv.cu');
% Matrice din GPU transformata FFT, % specifica nr. fire din grupul GPU
% procesata si apoi adusa in host k.ThreadBlockSize = [500,1,1];
_ Ga = rand(1000,'single','gpuArray'); % executa codul obiect pe GPU
Gfft = fft(Ga); result =
Gb = (real(Gfft) + Ga) * 6; feval(k,rand(100,1),rand(100,1));
G = gather(Gb); % si transfera rezultatul in GPU
s = sparse(x); r1 = gather(result);
g = gpuArray(s); % sparse gpuArray
gt = transpose(g); % sparse gpuArray Aplicatiile simple sunt usor de programat in MATLAB
pentru a fi executate pe GPU
f = full(gt) % f is a full gpuArray
% executa functie proprie pe GPU Aplicatiile in care se doreste exploatarea eficienta a
rez = arrayfun(@myFunction,arg1,arg2); structurii particulare GPU se dezvolta in CUDA si apoi
se compileaza si apeleaza din MATLAB
Scalarea de la un calculator la
cluster si cloud
function a = MyCode(m)
tic
parfor i = 1:200
a(i) = max(abs(eig(rand(m))));
end
parpool(nrwrks);
a = MyCode(1000)
toc
delete(gcp);
_
Timpul de executie in functie de
numarul de workeri, pentru:
• Un sistem cu 4 core (o)
• Cluster cu 80 de core (x)
• Cloud (+)
Pe un singur sistem, timpul de calul
Timpul de calcul pe cluster scade nu mai creste dupa ce numarul
de 50 de ori, de la 200s la 4s de workeri din grup depaseste
In cloud, numarul de workeri este numarul de unitati de executie
limitat prin conventia de acces. (core sau threads)
PETSc: Portable, Extensible Toolkit for
Scientific Computing
PETSc ofera rutine pentru solutii paralele ale sistemelor de ecuatii generate
prin discretizarea ecuatiilor cu derivate partiale (PDE): Structura PETSc
• Sisteme liniare
• Sisteme neliniare
• Evolutie in timp
continand si rutine pentru
• Tablouri distribuite
_
• Asamblarea matricelor rare
• Distributii si colectari
generale (incl pentru griduri
nestructurate)
[PETSc]
Componentele numerice ale
PETSc
Etapele rezolvarii unei probleme
PDE cu PETSc
Cod scris de utilizator
Cod PETSC
/* Program principal */
. . .
/* Preprocesare */
. . .
/* Rezolvare */
/* Repeta
t = t + dt pasi in timp
_ cu una din metodele de
integrare ODE din TS
La fiecare pas se
apeleaza rutina dn SNES
de tip Newton pt rezolvarea
iterativa neliniara
Preprocesare Rezolvare
La fiecare iteratie neliniara se apeleaza rutina de rezolvare liniara
din SLES, care apeleaza rutina de preconditionare din PC si cea de
rezolvare iterativa din KSP
Pana cand este atins momentul final al simulare */
. . .
/* Postprocesare */
. . .
Exemplu de problema rezolvata in
PETSc: ecuatie Poisson 2D
• Sursa codului este disponibila la:
http://wgropp.cs.illinois.edu/bib/talks/tdata/2004/mpi-half-day-public.pdf
• Contine doar 7 ecrane (sliduri)
• Este complet paralelizata
• Gridul este descompus bidirectional
• Sistemul liniar are matricea rara (utilizatorul poate alege structura de date)
• Sistemul liniar poate fi rezolvat cu orice metoda de tip Krylov, aleasa de
utilizator
_
• Se folosesc metode iterative preconditionate, inclusiv GMRES cu ILU,
BiCGstab cu Additive Schwarz, etc.
• Este inclusa in cod o analiza completa a performantelor
• Si toate astea in 7 pagini de cod!
In literatura se gasesc mai multe exemple de folosirea mediilor si limbajelor

pentru paralelizare. Spre exemplu, [Heath] descrie paralelizarea
principalilor algoritmi numerici.
2.7. Conceptia programelor paralele:
Structuri de suport si modele
• De algoritmi: SPMD (Single Program Multiple Data); Loop paralelism;
Master/worker; Fork/Join
• De date: Comune, Cozi, Distribuite.
Cum
concepem
programele
_paralele?
Variante de
abordarea
conceptiei,
Design pattern:
http://www.cc.gatech.edu/~hyesoon/spr11/lec_parallel_pattern.pdf
In continuare vor fi prezentate si discutate modelele cele mai frecvent folosite.
Tasks parallel/SPMD
• Aceasta abordare este aplicata atunci cand problema a fost
descompusa intr-o colectie de taskuri concurente, care pot fi
executate in paralel. Intrebarea care se pune este cum aceasta
concurenta poate fi exploatata cat mai eficient (load balancing).
• Taskurile ar trebui sa indeplineasca urmatoarele conditi: sa fie in Repartitia echilibrata
numar cel putin egal cu cel al UE, pentru a avea flexibilitate in
planificarea executiei (scheduling) si efortul de calcul al fiecarui a taskurilor
task sa fie suficient de mare, pentru a depasi pierderile prin
paralelizare.
• Taskurile trebuie sa fie independente, dar se admit exceptii: de
ordinea executiei si cazul in are fac apel la memoria comuna, de
exemplu cand acumuleaza contributiile intr-o variabila comuna. In
aceasta ultima situatie vorbim de reducere. Cazul cel mai simplu
_ este ce in care taskurile sunt total independente, si vorbim de
paraleleism nativ (embarrassingly parallel). Exemple:
• Planificarea poate fi statica sau dinamica, caz in care fiecare % Reducere implicita:
worker primeste un nou task dintr-o coada unica, pe masura ce
termina, sau “fura” din cozile colegilor. sum=0;
parfor i = 0:n
Daca taskurile concurente sunt similare, atunci ele pot fi executate in ciclu sum = sum + f(i);
paralel.(“parallel loop”). In conditiile in care o secventa de program este end
executata in paralel, vorbim de SPMD (Single Program Multiple Data).
In acest model taskurile sunt deci planificate static, la fel ca si datele • Calculul lui Pi in paralel cu MPI
(tablouri distribuite). La parfor workerii au aces doar la datele locale, in Bcast/Reduce (plansa 58)
spmd ei pot comunca. SPMD este un model de programare deosebit de • Quadratura numerica si alte
parfor, care este un submodel al sau Burkardt11]. El este implementabil in exemple parfor si spmd in
MPI, OpenMP [Mattson04], sau evident in MATLAB. [Burkardt11], [Mattson04]
Parallel Tasks/Loop
• Ciclul paralel este un submodel computational al modelului spmd si se aplica atunci
cand taskurile sunt total independente si indexate, intr-un ciclu (de regula ciclu cu
contor). Trecerile sunt executate pe unitati de executie independente, deci in
paralel. Fiecare unitate poate executa mai multe treceri, astfel incat accelerarea
depinde de numarul unitatilor de executie, nu de numarul de treceri.
• Se preteaza la parelizarea automata (implicita). In MATLAB se implemeteaza cu parfor iar
in OpenMP cu #pragma omp parallel for cu declaratii de tipul private(ij,j,i)
care realizeaza copii locale ale varabilelor si indicilor, pentru evitarea curselor.
• Model de paralelism nativ (embarrassingly parallel). Exemple de utilizare:
– Studii parametrice [Burkardt11] % Optimizare paralela
_
– Integrarea numerica [Burkardt11] parfor i = 0:n
m(i) = minim(@f,i);
– Optimizari , inclusiv pe cluster sau cloud end
• Acest model poate fi folosit si pentru executia [Valmin,Ioptim] = min(m);
batch distribuita (RCP ) intr-un cluster a unui numar definit sau nu de joburi.
Poate fi realizata in limbajul “shell script”
(sh, ksh, csh) [sh], CORBA sau folosind un planificator de nvar in 1 2 3 4 5
joburi [Scheduler], [Torque], [Maui], [Iqbal05]. do
comanda $nvar
Java are o clasa dedicata RMI: Remote Method Invocation. done
dico - distributed computing:
RPC in LMN
In LMN folosim scriptul dico (distributed-computing) scris de Stefan Puscasu in Pyton+ SSH
(Secure Shell). Acesta indexeaza tascurile (cu 1, 2 sau 3 indici). Pentru a folosi aceasta
procedura, trebuei sa parcurgeti urmatorii pasi:
• Logati-va cu SSH pe (zet pentru reteua BluepC sau tau pe ATLAS) unde deschideti doua
ferestere (console-terminal) si creeati un director specific problemei;
• Descompuneti problema in subrobleme indexate cu un indice intreg, doi, trei...; si identificati
valorile initale si finale ale fiecarui indice;
• Scrieti un script care pentru variabilele $1, $2... ce au valorile indicilor calculeaza si scrie
rezultatul la iesirea standard cu prefixul REZ si plasati acest scrip in directorul creeat anterior;
• Testati acest script invocandu-l cu o valoare a indicilor. Daca este necesar, scrieti un script care
asambleaza rezultatele intr-un singur fisier si plasati acest script in acelasi director de lucru;
_
• In prima consola lansati comada de executie a serverului: ./server.py <scriptname> <counters>
• In a doua consola lansati comanda de executie a clientilor: ./run_clients.py
• Supravegheati prima consola pentru a vedea mesajele clientilor in timp ce rezolva
subproblemele;
• Dupa ce apare mesajul 'Nothing more to do, exiting' appears in prima consola, gasiti rezulatele
in directorul Rez/ si puteti lansa comanda de executie a scriptului de asamblare si interpretare a
lor.
Mai multe detalii si un exemplu de utilizare este prezentat in Anexa C.
Geometric Data Decomposition on
SPMD
• Datele geometrice sunt cele cu structura carteziana regulata (tablouri: vectori,
matrice), Tablourile de mari dimensiuni sunt structuri fundamentale pentru calculele
stiintifice. Ele apar prin discretizarea PDE si a marimilor continui, si necesita memorie
ce depaseste pe cea a unitatilor de executie. Descompunerea si distributia pe UE a
datelor cu structura carteziana sta la baza acesteui model de programare.
Distribuirea tablourilor urmareste echilibrarea taskurilor. In repartizarea datelor se tine
cont si de localizarea lor, pentru a exploata structrarea ierarhica a memoriei (cache).
Algoritmul
– pe blocuri este identic cu cel pe
elemente. Descrierea matematica a problemei si
solutiei se face folosind indici globali, in timp ce
_. fiecare UE lucreaza cu un sub-bloc, deci cu indici
intr-un tablou local. Una din problemele acestui

model este translatia clara intre cei doi indici.
Tipurile uzuale de distributie sunt:
• 1D – secventa de blocuri, folosita in cazul vectorilor, in
cazul matricilor asta insemna distirbutia coloanelor sau a
liniilor
• 2D – blocuri rectangulare, generate prin distribuirea
secventiala a matricilor mari Descompunerea datelor geometrice
• Bloc- ciclic, cand numarul de UE este mai mic decat
cel la blocurilor, repartitia se face ciclic
In MATLAB:
A.N. (co)distributed:
Curs Master. https://www.mathworks.com/help/distcomp/distribute-arrays.html
Calcule stiintifice de inalta performanta 79 © Daniel Ioan 2016
Exemplu: factorizarea LU paralela
j
/* Varianta secventiala */
pentru k = 1..n − 1
pentru i = k + 1..n `
k
lik = aik/akk
i
pentru j = k + 1 .. n
pentru i = k + 1..n
aij = aij − àik akj
/* Varianta paralela spmd */

pentru k = 1..n − 1
Descompunerea de Agregarea pe linii
broadcast {akj : k ≤ j ≤ n}
cea mai fina granulatie Comunicare simplificata
pentru i ∈ liniilemele, i > k, ` si comunicarea
_ lik = aik/akk
pentru j = k + 1 .. n Alocarea succesiva alocarea ciclica a linilor
pentru i ∈ liniilemele, i>k, a linilor in benzi pe procesoare pe procesoare
aij = aij − àik akj
Paralelizarea se realizeaza cu modificari minime.
Mai complicata este pivotarea. Comutand ciclurile kji,
agregarea poate fi facuta pe linii, pe coloane, sau pe
blocuri 2D, fiecare avand alta comunicare.
Importanta este si repartizarea taskurilor pe
procesoare. Ea poate fi facuta succesiv pe blocuri sau
ciclic, pentru a echilibra incarcarea. [Heath], [Hawe96].
HPC Numerical Linear Algebra [Dongarra11],[Tomov].
Linear algebra:
cel mai folosit software HPC
• Level 1 BLAS perform scalar, vector and vector-vector op., the Level 2 BLAS perform matrix-
vector op., and the Level 3 BLAS perform matrix-matrix operations. http://www.netlib.org/blas/ .
• Lapack - The Linear Algebra PACKage is a successor to LINPACK and EISPACK.
http://www.netlib.org/lapack/
• ScaLAPACK—Scalable Linear Algebra PACKage http://www.netlib.org/scalapack/
• ATLAS Automatically Tuned Linear Algebra Software (BLAS,LAPACK) . http://math-
atlas.sourceforge.net/ Folosirea ATLAS compilata pe host creste viteza chiar si de 10 ori!
• PLASMA Parallel Linear Algebra Soft for Multicore Architectures https://bitbucket.org/icl/plasma
• MAGMA Matrix Algebra for GPU and Multicore Architecture (CPU+GPU, sparse) [Tomov]
http://icl.cs.utk.edu/magma/ creste viteza de inca 10 ori
_
• NIST Sparse BLAS
http://math.nist.gov/spblas/
• SPOOLES 2.2 : SParse Object Oriented
Linear Equations Solver
http://www.netlib.org/linalg/spooles/spooles.2.2.html
• Trilinos Tpetra parallel linear algebra
https://trilinos.org/ Pentru matrice rare
• Alte Freely Available Software for Linear Algebra:
http://www.netlib.org/utk/people/JackDongarra/la-
sw.html
http://www.netlib.org/utk/papers/iterative-survey/
Master/worker parallel tasks
Se aplica in situatiile in care problema nu are Worker
o structura regulata. Ideea de baza consta in Cerere
client MASTER Worker
mentinerea unei cozi de taskuri concurente,
rezultatate din descompunerea prolbemei si
Raspuns Worker
un grup de unitati de executie. Pe masura ce server
o unitate termina exectia taskului curent Worker
primeste un altul din coada. In acest fel toate
unitatile raman ocupate si se obtine o
repartitie echilibrata a sarcinilor. Este deci o
_metoda dinamica de repartizarea taskurilor.
Granulatia mai fina creste echilibrarea, cu

pretul unui cost sporit pentru managentul
taskurilor. Practic, pentru a rezolva un set de
taskuri concurente, un proces sau un fir de
executie lanseaza in executie un grup de
procese sau fire, care primesc fiecare cate un
task. In unele cazuri masterul nu exista
explicit. Acest model se poate implementa in
OpenMP, MPI sau MATLAB.
Master/worker parallel tasks
Exista diferite variante ale acestui model. Masterul poate avea doua cozi: una pentru taskurile in
asteptare si alta pentru cele rezolvate si rezultate. Workerii pot avea fiecare cate o coada cu doua
capete, la unul se adauga taskuri si la cealalt se extrag taskurile spre rezolvare. Atunci cand coada
este goala, workerul poate “fura” taskuri de la colegi. Workerii defecti trebuie eliminati din lista, iar
taskul lor se retransmite. Ei pot fi identificati prin semnale periodice transmise catre Master.
Exemplu de pseudocod, prototip simplu pentru Master/worker:
% Pseudocod Master [Lazar11] prezinta doua metode de folosirea
for each worker w=0…no.of workers { arhitecturilor de calcul paralele pentru a extrage
f = FETCH next piece of work
modelel de ordin redus pentru dispozitivele
SEND f to w }
while ( not done) { pasive integrate de inalta frecventa.
RECEIVE result from any process Pentru obtinerea caracteristicii de frecventa a
_
w = process who sent result dispozitivului, Masterul distribuie esantioanele
STORE result de frecventa in maniera ciclica celor N noduri .
f = FETCH next piece of work Fiecare nod rezolva sistemul de ecuatii
if f != no more work left SEND f to w complexe corespunzator frecventei primite,
else SEND termination message to w }
folosind modelul SPMD cu mai multe fire .
% Pseudocod worker Rezultatele sunt trimise la Master care agrega
while ( not done ) { rezultatele si extrage modelul de ordin redus.
RECEIVE work f from master Algoritmul este reluat iterativ, pana este
If f equals termination signal exit obtinuta acuratetea dorita. In consecinta,
Else result r = execute work on f Masterul va continua sa alimenteze workerii
SEND r to master }
pana la atingerea acestui obiectiv.
Divide & conquer with fork/join
(imparte si stapaneste )
Devide&conquer
are mai mult un fork/join are un caracter
caracter spatial temporal (se refera al taskuri)
(se refera la date)
Task2 paralel
Fir master
Fork Task1 Join
Exemplu: sortare paralela

_ Codul generic Devide &conquer recurent
cu fort/joint parallel algorithm mergesort(A, lo, hi)
rezolva(problema) if lo+1 < hi then
daca problema este suficient de mica // Two or more elements.
rezolva problema secvential mid = ⌊(lo + hi) / 2⌋
altfel fork
pentru [part]=subdivide(problema) mergesort(A,lo, mid)
fork subtask mergesort(A, mid, hi)
rezolva(part) join
join subtasks merge(A,lo,mid,hi)
combina rezultate subtasks
Exemple: inmultirea paralela a matricilor , diagonalizare matriciala, FFT,
https://en.wikipedia.org/wiki/Matrix_multiplication_algorithm http://eecs.ceas.uc.edu/~jpaul/671/chap22.html
https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm
Pipeline with fork/join
(conducta cu “bifurca si reuneste”)
Fork/join: In unele programe numarul de fire variaza in timpul executiei. In conditiile in care numarul acestor fire
nu poate fi prevazut la un moment dat, atunci nu se poate folosi paralelizarea ciclurilor si este necesara creerea
dinamica a firelor prin comanda fork si ulterior eliminarea lor prin join, in timp ce firul principal continua.
Pipeline: Daca un program efectueaza calcule pe mai mute seturi de date, care sunt trecute printr-o serie de
stagii succesive (stream processing), atunci concurenta poate fi exploatat prin modelul de programare al
conductei (“pipeline”). Liniile de asamblare sunt bune analogii pentru acest model. Dupa ce conducta este plina si
pana incepe sa se goleasca, toti workerii sunt contnuu ocupati. Fiecare efectueaza operatiile specifice unui singur
stagiu, numarul lor fiind egal cu numarul stagiilor, deci gradul ce cocurenta este limitat de numarul de stagii.
Crestera numarului de stagii determina sporirea rafinarii granulatiei. Dar cresterea numarului de stagii creste
timpul de umplere si golire, care ar trebui sa fie cat mai mici fata de cei de plina functionare. Pentru performanta,
stagiile ar trebui sa aiba intensitate computationala similara, deoarece stagiile cu efort mic reprezinta strangulari.
Optimizarea acestui proces nu este simpla.
_
Fork/join Pipeline Programele dedicate
procesarii streamurilor pot folosi combinatia join
dintre cele doua abordari: pipeline si fork/join.
Fluxul de date procesate de program este
segmentat in stagii, urmand ca fiecare segment
care soseste din streamul de intrare sa timpul
comande creerea unui numar corespunzator de
fire, adecvat segmentului respectiv. In
F1
momentul in care se schimba structura
segmentului, se comanda join si un nou fork.
Open MP este mediul potrivit acestui model.
Recursive data/SPMD si
Event based
• Datele recursive sunt cele dinamice, cu
structura neregulata: liste, arbori, grafuri. Pentru
rezolvarea PDE, FDM si FIT folosesc retele
regulate de discretizare, iar FEM foloseste
triangulatii neregulate si are ofera o mai mare
flexbilitate.
• Descompunera si repartizarea lor pe taskuri nu
este simpla. Domain Decomposition Method
(http://www.ddm.org/) foloseste partitionarea
automata a grafurilor realizata de programe Retea regulata Retea neregulata adaptiva
ca METIS sau SCOTCH [Dolean15] ,care
urmaresc echilibrarea sarcinilor si minimizarea
_ comunicarii interprocesoare.
• Programe model pentru aceast abordare sunt
disponibile in [Rogers].
• Tot un model fara regularitate este si cel bazat Descompunere adaptiva, arborele ei,
pe evenimente. Acestea sunt semnale care repartizarea pe UE
influenteaza executia programlui, il poate
intrerupe, sau poate modifica configuratia firelor
de executie. Acesta se bazeaza pe intereuperi
hardware sau pe o bucla principla care asculta
semnalele emise de diferite taskuri.
http://www.alan-g.me.uk/l2p/tutevent.htm
A.N. Curs Master. Calcule stiintifice de inalta performanta 86 © Daniel Ioan

Exemplu de partitionare 2016
automata
“Scheletele” algoritmilor
• Un mod eficient de concepera programelor paralele, care formalizeaza
paternurile prezentate anterior, intitulat “Algorithmic skeleton” a fost propus
de Cole [Cole91, Loidl15, https://en.wikipedia.org/wiki/Algorithmic_skeleton,
http://homepages.inf.ed.ac.uk/mic/Skeletons/ ] si contine paternurile:
– FARM: modelul master-slave, in care taskurile sunt replicate si executate in paralel
– PIPE: descompunerea in etape, executate in paralel cu alte schelete
– LOOP: reluare ciclica de tip FOR sau WHILE a scheletelor, care pot fi concurente,
– IF: structura de executie conditionala, valaorea conditie decide daca se executa un schelet
sau altul
_
– MAP: bifurcarea, executia taskurilor sin paraleel, si apoi reunirea.
– D&C: modelul de paralelism de tip “divide and conquer” in care un task este divizat
recursiv, in subtaskuri, pana cand este indeplinita o conditie. Taskurile sunt rezolvate in
paralel.
– SEQ: un schelet care reprezinta o secventa neparalelizata.
care pot fi combinate (inlantuite si/sau imbricate - continute unul in altul). Numai FARM(M&S),
PIPE, MAP (F&J) si D&C sunt tehnici noi specifice programarii paralele, dar si din structurile
secventiale de decontrol, LOOP isi adauga sensuri noi, prin paraleleizarea trecerilor/iteratiilor .
Ele sunt modele de programare de inalt nivel, mai mult decat paternuri, fiind descrise in diferite
limbaje OOP sau nu, la care orhestrarea si sincronizarea activitatilor paralele este definita
implicit in paternul schelet. Asta face ca erorile de programare sa fie mai rare decat in cazul
folosirii modelelor de nivel scazut (MPI, threads).
Scheletele algoritmilor paraleli
FARM: PIPE:
D&C:
MAP:
Scheletii sunt functii de de nivel inalt folosite pentru paralelizare.

De exemplu, Biblioteca de schelete Skandium din Java, contine clase de obiecte cu
schelete. Este un mod de a aplica tehnologia OOP in paralelizare.
3. Algoritmi numerici HPC,
exemple si aplicatii
3.1. Tendinte in Modelare EM –
Computational EM
Casa lui Maxwell:
3.2. Aspectele HPC ale Metodei

_
Elementului Finit (FEM): DDM
3.3. Contributii LMN in folosirea tehnicilor HPC: FIT, MOR, MEMS-Multiphsics
3.4. Optimizari, Probleme Inverse, Senzitivitati, Algoritmi deterministi si PSO
3.5. Probleme deschise, tendinte de viitor
Anexa A - Algoritmi numerici rapizi: Multigrid, FMM, MLFMA, AFEM, MOR
Anexa B – Instrumente HPC: vim, gcc, make, cvs, gdb, gprof, latex
Anexa C – dico - distributed computing in LMN
3.1. Modelarea EM –
Computational Electromagnetics
Calculeaza campul electromagnetic in diferite regimuri pentru diverse dispozitive si
sisteme, prin rezolvarea numerica a ecuatiilor lui Maxwell cu conditii la limita adecvate.
Vedeti cele 14 directii de interes la http://compumag2017.org/Paper_Submission.php (incl
Tehnici numerice si Metodologii software). Modelarea multifizica abordeaza probleme cuplate.
Cele 7 etape ale modelarii
electromagnetice, procedura LMN
• Modelarea conceptuala (se
refera la modelarea gemetrica si
la cea fizica):
• Modelarea matematică: se
formulează modelul in limbaj
matematic, sub forma unei
probleme bine formulate
• Modelarea analitic-
aproximativă:
• Modelarea numerică: se
_ construiește un algoritm dedicat
rezolvării ecuaȀiilor modelului.
• Modelarea computationala:
se impleneteaza algoritmul
numeric intr-un program de
calculator (vedeti Anexa B)
• Extragerea modelului de
ordin redus.
• Verificarea si validarea
modelului.
In HPSC/CSE este esentiala incerderea in fiecare model, prin controlul acuratetii ( uncertainty quantification –UC).
Regimurile campului electromagnetic
Regim al campului el-mg: stare particulara a campului, in care anumite fenomene el-
mg dispar sau sunt neglijabile. Ecuatiile fundamentale ale fiecarui regim se obtin din
legile campului in ipotezele simplificatoare specifice regimului, identificat in
modelarea fizica. Problemele regimurilor particulare sunt mult mai simple decat cele
din cazul general. Cele mai importante regimuti intalnite in practica sunt:
1.Regimul electrostatic (ES) –campul electric in corpuri imobile, regim stationar si fara
transformari de energie
2.Regimul magnetostatic (MS) –campul magnetic in corpuri imobile, regim stationar si
fara transformari de energie
_3.Regimul electrocinetic stationar (EC) - distributia curentului electric stationar in
corpuri imobile
4.Regimul magneto-stationar (MG) - campul magnetic stationar in corpuri imobile
5.Regimul magneto-qvasistationar (MQS) -campul mg. lent variabil in corpuri imobile
6.Regimul electro-cvasistationar (EQS) - campul el. lent variabil in corpuri imobile
7.Regimul general variabil in medii imobile (FW) – campul em in medii imobile
8. Regimul armonic (a,c,) – in care campul variaza sinusoidal in timp
9. Regimul perodic permanent (pp) – in care campul variaza periodic in timp
10. Regimul tranzitoriu (tr) – in care campul variaza arbitrar in timp
Ecuatiile fundamentale ale
regimurilor statice
regimurilor stationare
regimurilor cvasistationare
rotrotH = − jµσωH in c.a.

_
regimului general varabil
_
rotrotH = −( jµσω − µεω 2 )H
Recapitularea regimurilor campului
electromagnetic
• Regimul tranzitoriu general variabil – fenomenul principal: propagarea
campului, descrisa de ecuatii cu derivate partiale de tip hiperbolic in care
intervin cele trei constante de material ε, µ, σ. Unda electromagnetica are
viteza finita nu mai mare decat viteza luminii in vid.
• Regimurile tranzitori cvasistationare – fenomenul principal: difuzia
campului electromagnetic, descris de ecuatii cu derivate partiale de tip
parabolic in care intervin doar doua constante de material µ, σ(MQS) sau ε,
σ(EQS). Alte efecte: curentii turbionari, efectul pelicular, proximitate, reaxarea
sarcinilor.
_ • Regimurile statice si stationare – fenomenul principal: distributia
campului electric, magnetic sau de conductie, descrisa de ecuatii cu
derivate partiale de tip eliptic, in care intervine doar cate o singura
constanta de material, in functie de regim: ε(ES), µ(MS si MG) sau σ(EC).
Regimurile studiaza distributia campurilor perturbata de proprietatile de
material: polarizare, magnetizare, conductie.
• Regimul armonic – campul variaza sinusodal in timp si daca se reprzinta in
complex, ecuatia obtinuta este una de tip eliptic (Helmholtz complexa).
Permite analiza in domeniul frecventei. Prin superpozitie de regimuri
armonice (serie Fourier) se analizeaza si regimul periodic permanent.
Similitudinea intre regimurile statice si
stationare
Problema fundamentala a analizei
campurilor stationare
cu conditii de frontiera Dirichlet nule
Elementul de circuit multipolar cu
parametri distribuiti
A-E:conditii de frontiera. D:
E:
Modelarea computationla a
campului electromagnetic
Programele de analiza numerica a campului electromagnetic sunt structurate in:
• Preprocesare: modulul prin intermediul caruia se descrie problema de camp ce va fi
rezolvata. Modul discretizeaza domeniul spatial (si cel temporal daca intervine) si
apoi discretizeaza ecuatiile cu derivate partialeale campului, cu FEM, BEM sau FIT,
generand un sistem de ecuatii cu un numar finit de necunoscute.
• Solverul: modul care rezolva sistemul de ecuatii obtinut in urma discretizarii.
• Postprocesorul: modulul in care se prelucreaza solutia numerica obtinuta in
vederea vizualizarii ei, salvarii, imprimarii sau calculului marimilor derivate de care
este interesat utilizatorul.
_Descrierea unei probleme de camp presupune descrierea: geometriei, a materilelor si
a surselor de camp prin marimi dedicate iar sursele externe prin conditiile de
frontiera. Starea initiala este descrisa de conditiile initiale. Descrierea geometriei se
face prin un editor grafic, interacitv (GUI), restul datelor fiind introduse ca texte (TUI).
Descrierea poate fi facuta si neinteractiv, printr-un limbaj dedicat (batch TUI).
Daca analiza este tranzitorie, discretizarea spatiala genreaza un sitem ODE de ecuatii
diferntiale ordinare, care se integreaza numeric. Metodele implicite impun ca la
fiecare pas de timp rezolvarea unui sitme de ecuatii algebrice liniare sau neliniare
dupa fipul problemei. Cele liniare se rezolva iterativ, la fiecare iteratie, metoda
Newton impune rezolvarea unui sitem algebric linar. Daca analiza este armonica,
sistemul de ecuatii este tot unul liniar, dar complex.
Categoriile de metode numerice pentru
calculul campului
Metode analitice:
• ES – integrala Coulomb
• MG- integrala Biot Savart-Laplace (BSL)

Anexa A prezinta o serie de metode si algoritmi super-rapizi, esemtiali pentru HPSC/SCE.
3.2. Metoda Elementului Finit FEM
(cazul regimului ES)
• Consideram ecuatie eliptica, de tip Poisson, cum este ce a potentialului ES:
Forma tare,  div (εgradV ) = − ρ pe Ω; cu
diferentiala: 
V = f D pe S D ⊂ ∂Ω , dV / dn = f N pe S N = ∂Ω − S D
• Formularea slaba (Galerkin) a problemei: sa se gaseasca v, a.i.
cu
_ g = f N naturala ; u 0 = f D esentiala
v minimizeaza functionala “de energie”
forma variatonala Ritz δF = 0;
• Considerand un subspatiu liniar Xh ( H, pt h 0), finit dimensional din H
FEM cauta: forma discreta.
• Folosind functiile de baza din Xh solutia numerica este:
cu coeficientii uh dati de solutia sistemului algebric liniar:
• ;
A.N. Curs Master. Calcule stiintifice de inalta performanta 103
Se demonstreaza ca aceasta solutie numerica este optimala, adica are cea© mai
Daniel Ioan 2016
mica eroare in Xh.
Detalii caracteristice FEM
• Domeniul din Rd cu d = 1, 2 sau 3 marginit, cu frontiera neteda pe portiuni este
acoperit de o triangulatie Th, de exemplu o reuniune disjuncta de elemente
poliedrale sau poligonale K. Frontieara se aproximeaza cu un poligon in 2D , cu un poliedru in 3D.
• Spatiul Xh consta din polinoame de grad p definite pe portiuni, mai exact restrictia functiei uh
din Xh pe elementul K de diam h din Th este un polinom de variabilele spatiale x, y si/sau z;
• Xh are o baza cu suport local, numite functii de forma, de exemplu functiile polinomiale
continui, definite pe portiuni, care se anuleaza în toate elementele K din Th, cu exceptia
celor care au un element geometric comun (nod, latura sau fata).
• Vom considera ca trangulatia Th este regulata (conforma):
_ – elementele nu se suprapun
– elemntele acopera domeniul de calcul
– nu are noduri agatate pe laturi, adica intersectia a doua elemente este fie în nod, o latura
sau fata care apartine ambele elemente . Unghiurile fiecarui K e bine sa fie > 10 grade..
• Spunem ca functiilede forma alcatuiesc o baza nodala, daca gradele de libertate sunt valorile
din noduri ale solutiei numerice, functia de baza j e nula în toate nodurile, cu exceptia nodului j
(au graficul piramidal pentru grad p=1 si de forma unei palarii, rotunjite, daca p.> 1).
• Pe scurt, în metoda elementului finit, domeniul de calcul marginit este discretizat de o
trangulatie, iar solutia este o functie continua, polinimiala pe pe portini, necunoscutele problemei
numerice fiind referitoare la nodurile, laturile sau fetele triangulatiei. Ordinul metodei este dat de
gradul polinoamelor. Matricea A a sistemului liniar este rara (cu 7 elemnte nenule in medie pe
linie in 2D), simetrica si pozitiv definita. Ea este numita si “matricea de rigiditate”.
FEM - de la teorie la cod
• Cod FEM de jucarie in 20 linii http://www.lmn.pub.ro/~daniel/BazeELTH-3-
Teoremele%20el-mg.pdf la pag. 73. Codul este similar, dar ceva mai
complicat decat cel pentru analiza circuitelor electrice rezistive, deoarece
stampilele sunt mai mari. De altfel sistemul de ecuatii liniare FEM este chiar
sistemul nodal al unui circit cu graful identic cu reteaua de discretizare.
• [Haldar] - Program MATLAB cu elemente finite triunghiulare de ordinul întâi, pentru
ecuatia Helmholtz scalara. Primeste la intrare descrierea retelei si genereaza în 30 de
instructiuni matricea sistemului FEM.
• [Chessa] - Functii MATLAB pentru programe de element finit cu aplicatii mecanice,
_ Lucrarea descrie modul eficient si flexibil de asamblare a matricei elementelor finite în
MATLAB, folosind integrarea numerica a elementelor finite Lagrange de grad ridicat
¸si jacobianul transformarii conforme. Partea de procesare contine aproximativ 100
instruçtiuni MATLAB (este un model).
• [Alberty] - program de numai 50 linii MATLAB care implementeaza MEF pentru retele
nestructurate de triunghiuri si patrulatere, pentru rezolvarea PDE de tip eliptic si
conditi mixte de frontiera. Se explica simplu si clar trecerea de la teorie la
implementare.
• [Shure] descrie cum pot fi asamblate rapid matricele FEM rare (timpul scade de la
200s la 1s!). Acest etehnici sunt prezentate si in Cap. 3 din [Ciuprina 13]. In C trebuie
folosite biblioteci de tipul https://github.com/wo80/CSparse.NET sau din pag 76.
FEM - de la teorie la cod
• [Funken] Program compact si foarte bine explicat, cu 30 linii MATALB care rezolva
cu MEF ecuatia Poisson 2D cu conditii de frontiera mixte Dirichlet-Neumann. Este
prezentata apoi o versiune cu matrice rare, si una auto-adaptiva/
• [Chen] descrie programul iFEM, de elemente finite adaptive, implementat în
MATLAB, folosind intensiv matrice. Sunt folosite retele de elemente finite adaptive
simpliciale (triunghiuri si tetraedre), nodala liniare. Rezolvarea se face direct cu \, dar
pentru sisteme mari, autorul recomanda solverele iterative bazate pe CG, cu precond
tionare multigrid, care sunt mai eficiente.
• Stampilele (de min 3x3 in cazul triunghiurilor) pe care fiecare element le aplica in
matricea A sunt prezentate in aceste articole, dar si in [Cheney08].
_
Aceste coduri sunt utile pentru a intelege cum se poate realiza un cod FEM simplu, dar
nu pentru coduri FEM dedicate sistemelor HPC, cum sunt [PETS] sau [Fem++].
• O lista de pachete software de element finit, comerciale ¸si din domeniul public este
disponibila la https://en.wikipedia.org/wiki/List_of_finite_element_software_packages .
Lista generatoarelor automate de retea http://en.wikipedia.org/wiki/Mesh_generation
este disponibila la http://www.robertschneiders.de/meshgeneration/software.html.
• Multe din programele noi se pot executa in parallel, inclusiv in MATLAB
https://www.mathworks.com/company/newsletters/articles/accelerating-finite-element-
analysis-in-matlab-with-parallel-computing.html aici asamblarea matricei ia peste
84% din timpul de executie, iar folosirea parfor redce timpul de calcul de peste 35 ori.
Exemplu de cod MATLAB simplu
Aplicati tehnicile de matrice rare descrise in capitolul 3 din [Ciuprina 13] pentru a accelera executia acestui cod!
Cum il puteti paraleliza? Determinati timpul de calcul si memoria necesara. Vizualizatai rezultatul si structra matricei
Aspecte FEM avansate
• Elemente finite de ordin superior si solutii adaptive hp
• Rezolvarea problemelor cu domenii nemarginite, FEM-BEM
• Controlul acuratetii si independenta solutiei fata de discretizare
• Rezolvarea ecuatiei de tip rot-rot, satisfacuta de potentialul magnetic vector in
regim magneto-stationar. Metoda elementelor de muchie.
• Analiza senzitivitatilor
• Calculul campului in medii neliniare. Modelarea materialelor cu histerezis si
semiconductoare
•_ Analiza in domeniul frecventei prin rezolvarea ecuatiei complexe de tip Helmholtz.
Trecerea in domeniul timpului prin iFFT
• Modelarea propagarii undelor em si imprastierii lor
• Frecvente si moduri proprii de rezonanta
• Analiza in regim tranzitoriu, in domeniul timpului.
• Probleme cuplate, camp electromagnetic, alte campuri fizice si circuite
• Extragerea modeleor de ordin redus, functii de circuit, optimizari em.
Aceste aspecte si alte detalii privind etapele modelarii, buna formulare, conditiile
frontiera in diverse regimuri si despre FEM in [Ioan00], [Ioan12].
Analiza in regim tranzitoriu
în care Jext¸si Kext sunt sursele de câmp, densitatea de curent electric (rotorul câmpului magnetic)
si de "curent magnetic" (rotorul câmpului electric), de regula nul. Se constata ca ecuatia are un
termen de propagare (derivata dubla fata de timp), unul de difuzie (derivata simpla fata de timp) si
un operator (de tip rot-rot) de derivare spatiala. Solutia FEM are forma:
in care W sunt functiile de baza (de forma).
Prin proiectie Galerkin se obtine un sistem ODE:
care se integreaza numeric:

_
Mε (ei +1 − 2ei + ei −1 ) / h2 + Mσ (ei +1 − ei ) / h + M µ (θei +1 + (1 − 2θ )ei + θei −1 ) = qi +1 ⇒ ei +!
Cele trei matrice sunt: Mu - matricea de rigiditate, Me - matricea de masa si Mo - matricea de
amortizare. În regimul MQS, Me = 0, deci ecuatia nu contine termenul cu derivata duba, în timp,
iar în regim EDFP, Mo = 0, deci ecuatia nu contine termenul cu derivata de ordinul întâi în timp.
/* Pseudocodul rezolvarii problemelor neliniare
Cat timp nu este atins momentul final al simularii, repeta
t = t + dt pasi in timp cu una din metodele de integrare ODE
La fiecare pas se aplica Newton pt rezolvarea neliniara iterativa
La fiecare iteratie se calculeaza Jacobianul si se pornesc
iteratile de rezolvare a sistemului liniar
Pana cand i */
Paralelizarea FEM
• Complexitatea rezolvarii cu metode directe [Dolean15] :
• In practica, datorita umplerii toti solverii directi merg pana la o bariera, de cca 100k
necunoscute 2D si 10K necunoscute 3D. Peste aceste limite se folosesc solveri
iterativi: Acestia se paralelizeaza mai simplu, chiar si in cazul rar, nu au umpleri, dar
_ au probleme de robustete. Preconditionarea poate genera in schimb umpleri.
• Noile abordari cum este DDM combina avantajele rezolvarii directe si iterative
• Alte abordari, cum este Multigrid foarte eficient, dar nu este aplicabil in toate
situatiile (de ex. Helmholtz complex) si este mai dificil de paralelizat.
• Complexitatea rezolvarii cu metode iterative (P=numar de procesoare):
Digrama bloc a codului FEM paralel
Mediile de dezvoltare FEM
contin instrumente pentru:
• generarea si manipularea
retelor de discretizare (mesh),
• distributa sarcinilor (load
balancing ),
• algebra liniara HPC,
• asamblarea sistemului de
ecuatii liniare
_ • solvere si preconditionere
• post-procesare.
Frameworks (Trilinos PETSc) vs

Integrated simulation environments
(FEniCS, deal.II, s DUNE, OpenFOAM,
LifeV, Feel++, Fem++). [Popescu13]
Repartitia liniilor matricei rare pe
procesele paralele:
DDM: Algoritmul Schwarz Aditiv
(ASM)
• Fie ecuatia Poisson pe domeniul Ω = Ω1 U Ω 2 (pentru simplitate avem doar 2 subdomenii, dar
generalizarea este naturala:
Poisson este o ecuatie de referinta pentru CSE.

• Metoda Schwarz iterativa: n=1,2,3,…rezolva concurent pentru i=1,2:
preluand deci conditia de pe frontiera

spre domeniul vecin de la iteratia
anterioara a acestuia
•_ Forma algebrica (FEM pe tot domeniul): Au = f
• Restrictia pe subdomeniul i:
Ri Au = Ri f Ai ui = fi cu Ai = Ri A RiT
• Extensia (E=RT) la intreg domeniul:
ui = Ai -1 fi u = RiT ui = RiT Ai -1 fi = RiT Ai -1Ri f
Dupa ce se parcurg cele N subdomenii, matricea de
iteratie are inversa de forma [Dolean15]: Partitia retelei pe procesare, fara si cu
( )
N N suprapunere ) obtinuta prin extensia
−1
M ASM = ∑ RiT Ai−1Ri = ∑ RiT Ri Ai−1RiT Ri retelei cu unul sau mai multe
i =1 i =1 siruri/straturi de elemente.
Gradienti Conjugati
cu sau fara preconditionare
[Dolean15]
paralelizabile
Preconditionarea presupune rezolvarea in plus la fiecare iteratie a sistmeului liniar Mzi+1=r i+1, ,
dar convergenta este mult mai rapida. Cel mai mare effort per iteratie consta in aceasta rezolvare
si in produsil Api intre o matrice si un vector, plus 3 produse scalare si doua sume de vectori.
In preconditionarea Aditiva Schwarz: cere rezolvarea unui sistem liniar in fiecare
subdomeniu, operatie concurenta.
ASM ca preconditionator pe doua nivele
_
Algoritmul Schwarz (ASM) ca solver (stanga) si ca
preconditionator (dreapta) pentru diferite suprapuneri.
Pentru a fi scalbil (rata de convergenta sa nu depinda pe nr.

de subdomenii) se infoloseste:
Ri este operatorul de restrictie la subdomeniul i, iar R0 se

refera discretizarea globala grosiera (nivelul doi). Cu doua
nivele se obtine scalablitatea si se elimina “platoul” in
convergenta. Cel mai bun rezultat cunoscut cu T=O(1)!
Exemplu de aplicatie DDM-Fem++
Modelarea numerica si calculul paralel rapid in Tomografia de Microunde, pentru
diagnosticul si monitorizarea acidentului vascular cerebral [Dolean16]
_
Problema
inversa:
gaseste
ε(r)
N=5x32 antene ceramice (ε =59) cu frecventa 1GHz, si timp total de achizitie de 30s Problema EM directa
rezolvata pe 18 milioane de tetraedre si 45 milioane necunoscute (elemente de muchie de ordin 2) si DDM
(Fem++), cu 512 subdomenii, cu un proces MPI si 2 fire Open MP pe fiecare. Problema inversa miniminimizeaza
pe J cu BFGS, dJ este determinat din problema adjuncta. Timpul total de calcul a fost 94s pe 4kcore. Forma slaba
a problemei directe :
Exemplu de aplicatie DDM-Fem++
Modelarea numerica si calculul paralel rapid in Tomografia de Microunde, pentru
diagnosticul si monitorizarea acidentului vascular cerebral [Dolean16]
_
Problema
inversa:
gaseste
ε(r)
N=5x32 antene ceramice (ε =59) cu frecventa 1GHz, si timp total de achizitie de 30s Problema EM directa
rezolvata pe 18 milioane de tetraedre si 45 milioane necunoscute (elemente de muchie de ordin 2) si DDM
(Fem++), cu 512 subdomenii, cu un proces MPI si 2 fire Open MP pe fiecare. Problema inversa miniminimizeaza
pe J cu BFGS, dJ este determinat din problema adjuncta. Timpul total de calcul a fost 94s pe 4kcore. Forma slaba
a problemei directe :
3.3.Metodologia LMN de extragerea a
modelelor reduse
Partitionarea in subdomenii: solutia pentru complexitate
Continuous
Reduced
model–
Discrete model –
Maxwell eqs.
model: Kirchhoff
and b.c.
FIT eqs.
• Problema de camp EM pentru componentel pasive:

_ - Ecuatiile Maxwell cu conditii
de frontiera potrivite pentru
- modelarea cuplajului EM
PDE
• Dupa discretizare (nu rezolvare!)
este generat modelul non-compact DAE
LAE
• Dupa reducerea ordinului este sintetizat
. un
circuit parametric redus ODE In domeniul
frecventei
Problema avuta in vedere:
instrumente EDA IC
Cuplaj EM intre blocuri
Variabilitate
tehnologica
zoom
Efecte avute in vedere
Scopul: Reducerea Modelelor
Sistem mare Sistem mic
e.g. >100 000 e.g. <100

DOFs
DoFs
Relatie I/O similara
_ Pre-grid Final grid
Continuous
Discrete Reduced
model–
model: model –
Maxwell eqs.
FIT DAE eqs. Kirchhoff
and b.c.
eqs.
Reducerea apriori Reducerea aposteriori:

Reduction “in zbor”
(discretizarea) MOR si sinteza
Divide & conqer: Partitionarea in
subdomenii a CI
Partitionarea verticala:
Aer
Mediul Connectori
< λ/10 = 500µ (“hooks”)
Componente pasive,
Conductoare, SiO2
Interconexiunile Componente
_
active
Substrat
Mediul
Connectori
(“hooks”)
Partitionarea planului orizontal:

Planurile mastilor chipului sunt partitionate in subdomenii 2D – componentele
din schema circuitului. EMCE: cea mai buna conditie de frontiera
Partitionarea cu diferite
regimurile ale campului EM
Partitionarea verticala:
Air
Environment Connectors
ES+MS C+Rm < λ/10 = 500µ (“hooks”)
Passive
components:
Metall: MQS RRm
SiO2: FW RCRm
Interconnects Active
_ TL RLC components:
Substrate Nonlinear,
Environment Drift-Diffusion
EQS+MS RC+Rm or
MQS+ES RRm+C Connectors
(“hooks”)
Partitionarea orizonatala: subdomenii 2D, conform schemei.

Fiecare subdomeniu are alt regim al campului (se reduce MEEC)
Modelel MEEC reduse sunt extrase si interconectate MEEC global
Formularea Matematica:
EMCE-Elementul EM de Circuit
• Fluxul magnetic trece numai prin
terminalele magnetice
n curl E(P,t ) = 0 ∀P ∈ Σ − U S k"

• Curentul electric trece doar prin
terminalele electrice
n curl H(P,t ) = 0 ∀P ∈ Σ − U S k'
• Terminalele electrice sunt echipotentiale
_
electric
n × E(P,t ) = 0 ∀P ∈ U S k'
• Terminalele magnetice sunt
echipotentiale magnetic
n × H(P,t ) = 0 ∀P ∈ U S k"
.
Aceste conditii de frontiera permit cuplarea cu circuite
electrice/magentice exterioare.
Cuplarea Camp-Circuit
Pentru terminalele
Componenta pasiva sau modelul ei
redus (circuitul echivalent) electrice:
ik (t ) = ∫ Hdr
Γk′
vk (t ) = ∫ Edr
Puterea P
C′k
_ Mediul electric: Madiul magnetic:
modelat de circuitul Modelat de circuitul Pentru terminalele
electric echivalent: magnetic echivalent magnetice:
RLC, surse alcatuit din
comandate, reluctantele Rm si ϕ& k (t ) = ∫ Edr
tranzistoare, etc. surse comandate
Γk′′
n ' −1
dϕ k n " −1
u k (t ) = ∫ Hdr
P = ∑ (vk ik ) + ∑ u k Puterea C k′′
k =1 k =1 dt
Abordarea numerica:
FIT (Finite Integration Technique)
Tehnica Integralelor Finite (FIT) este o metoda numerica
pentru rezolvarea problemelor de camp EM in regim general
variabil (FW-EM) bazata pe discretizari spatiala “fara functii
de forma”, folosind:
• Forma globala a ecuatiilor campului (nu cea diferentiala

folosita in MDF, nic cea slaba-variationala, folosita in MEF,
nici cea a ecuatiilor integrale din BEM/MEI);
_
• Marimi globale ca grade de liberate: tensiuni si fluxuri pe

laturile si fetele celulelor elementare ale retelei de discretizare
(si nu componente vectorilor campului ca in FDTD);
• Pereche de retele duale inlantuite, de obicei ortogonale (de

tip Yee = “complex de celule carteziene duale carteziene”),
dar pot fi si griduri neortogonale de tip Delaunay/Veronoi
Retelele duale de tip Yee
G (electric)
G’ (magnetic)
Aceste retelele ortogonale sunt potrivite pentru modelarea circuitelor
integrate, care au “geometrie Manhattan”
Principiile FIT
Legile generale ale campului EM in forma globala sunt satisfacute individual
pe fiecare celula, deci si pe intreagul complex al retelei de celule
Ecuatiile lui Maxwell pe Grid (MGE)
 ∂B  ∂B  dϕ
 curl E = − ∫ Ε = − ∫∫  Cu = −
 ∂t ⇒  ∂ t ⇒ dt
⇒ divB = 0 ⇒ B = 0 ⇒ D'ϕ = 0
 ∫∫
 ∂D  ∂D  dϕ
curlH = J + ∫ H = ∫∫ ( J + ) C' um = −
 ∂t ⇒  ∂t ⇒ dt
⇒ divD = ρ ⇒ D = ⇒ Dψ = q
_
 ∫∫ ∫∫∫ ρ
∂ρ ∂ρ dq
⇒ divJ = − ⇒ ∫∫ J = − ∫∫∫ ⇒ Di = −
∂t ∂t dt
• Ecuatiile fundamentale MGE nu au erori de discretizare

• Ele sunt DAE topologice (metric-free), rare, mimetice si
conservative, fara moduri false de oscilatie (spurious).
Operatorii Hodge
Descriu comportarea materialelor:
J = σE ⇒ i = M σ u

 D = εE ⇒ ψ = M ε u
H = νB ⇒ u = M ϕ
 m ν
_
Au caracter metric si poarta erorile de discretizare.
Abordarea FIT clasica (MGE+Hodge) a trebuit imbunatatita si

adaptata, pentru a face fata angajamentelor proiectului
Codestar.
Asta am facut!
Terminalele Electrice si Magnetice pe
gridul FIT
Un terminal electric pe gridul electric Un terminal magnetic, pe

gridul magnetic si umbra sa pe
gridul electric
TERMINAL = reuniune de fete ale celulelor gridului
Modelul MIMO in spatiul starilor
generat de FIT
FIT equations: C e 0  d v G e − B ′ v
 0 +  u  = 0
 G m  dt  u   B 0   
with boundary  C d x + G x = z
conditions  dt
 y = Lx Electric/magnetic terminals
may be excited in
in the frequency
_ domain (sC+G)x = z current/flux or in voltage:
y = Hz
.
State variables: Current Linear Time Voltage

electric and Invariant
Voltage Current
magnetic Descriptor
voltages of grid Magn. Circ.
System Flux
edge Flux Magn. Circ.
Circuitul Magneto-Electric Equivalent
(MEEC)
Circuitul Electric Circuitul Magnetic
MGE = CKL + VKL

Grafurile circuitelor electric/magneitc = gridurile duale FIT
Magneto-Electric Equivalent Circuits
(MEEC)
Forma discreta a teoremei conservarii sarcinii ⇒ KCL pentru circuitul electric
Di = 0 ⇔ Ai = 0;
dd
where i = j + i = i′ + i′′
dt
Forma discreta a legii fluxului magneitc ⇒ KCL pentru circuitul magnetic
D′b = 0 ⇔ A′ϕ = 0
Forma discreta a legii inductiei electormagentice ⇒ KVL pentru circuitul
_ db
Ce + = 0 ⇔ Bu = 0
dt
dϕ
u = u′ + F
dt
Forma discreta a legii circuitului magneitc ⇒ KVL pentru circuitul magnetic
C′h − i = 0 ⇔ B′u m = 0
u m = u′m + Si
De la MGE la Ecuatiile lui Kirchhoff!
(MEEC)
Operatorii Hodge ⇒ Relatiile Constitutive ale laturilor
du
d = Mεe ⇔ i′ = C
dt
b = Mµh ⇔ u′m = Rmϕ
D = Mσe ⇔ i′ = Gu′
R
_
i i′′ e = ∑ dϕ k ϕ Rm θ = ∑ ik
C dt
i′
u′ u′m
um
u
Latura tipica a circuitului electric Latura circuitului magnetic
(MEEC)
Operatorii Hodge ⇒ Relatiile Constitutive ale laturilor
du
d = Mεe ⇔ i′ = C
dt
b = Mµh ⇔ u′m = Rmϕ
D = Mσe ⇔ i′ = Gu′
R
_
i i′′ e = ∑ dϕ k ϕ Rm θ = ∑ ik
C dt
i′
u′ u′m
um
u
Latura tipica a circuitului electric Latura circuitului magnetic
Interconecarea modelelor MEEC
reduse
Reducerea timpului de simulare:
matrice rare si pivotare
• A: Matrice FIT tipica:
• B: Dupa reordonare simetrica folosind Reverse Cuthill-
McKee(RCM)
• C: Dupa factorizare LU
• D: Rezolvare directa vs iterativa preconditionata cu ILU E
Cea directa este de pana la 20 de ori mai rapida
• E: LU vs UMFPACK
D
_
Concluzie: nu s-a gasit inca o

metoda eficienta de
preconditioare a metodelor
iterative pentru FIT.
B Metodele directe (matrice rare)
sunt mai robuste si mai rapide in
A acest caz (<1min pentru 100
C
000 DoFs pe un sistem cu 8
core si memorie comuna dar, nu
si pe cluster/distribit).
Reducerea timpului de simulare
prin paralelizare
• Timpul de rezolvare directa
(UMFPACK) depinde de
dimensiunea sistemului si de
numarul de nuclee folosite, cu
accelerare de pana la 3.7 ori
[Andrei12], [Dita14]
• Dimensiunea maxima a
sistemului este de peste
_ 300 000 DoFs care necesita
mai mult de 8 minute pentru
rezolvare
• Aici s-a folosit un model FEM

generat de COMSOL,
rezolvarea find facuta pe CPU
cu metoda iterativa GMRES
din MATLAB iar pe GPU cu
CUSP
https://code.google.com/archiv Concluzie: necesitatea partitionarii in subdomenii, reducerea
e/p/cusp-library/. ordinului si interconectarea modelelor reduse (definite ca EMCE).
Etapele reducerii
Principiu: reducerea se face cat de curand posibil !
Etapele tehnologiei ALROM:
• Descompunerea in subdomenii: ecuatii EM Reducere apriori

• Calibrarea gridului 3D cu dFIT
Model extraction
• Calibrarea frontierei virtuale cu dELOB

_ Reducere din zbor
• Analiza in frecventa cu AFS
• Extragerea modelului parametric Reducerea aposteirori a
ordinului
redus cu VF
• Integrarea modelelor reduse parametrice ale efectelor
parazite, analiza variabilitatii si simularea Spice
Etapele algoritmului de
reducere a modelului
1. Calibrarea gridului cu dFIT: reteaua este rafinata succesiv pana la
nivleul optim (acuratete acceptabila)
2. Calibrarea Frontierei Virtuale cu dELOB: domeniul de calcul este
extins succeiv (in aer) pana la o dimensiune optima
3. Analiza in frecventa cu esantionare adaptiva (AFS). Pentru fiecare
pulsatie ω dintr-un set minimal se calculeaza raspunsul sistemului: Y(ω)
= (Yp(ω) + Ys(ω))/2, si sensitivitatea SY(ω):
_ • Yp (ω) - admitanta calculata cu FIT pe gridul primar cu
parametrii ELOB: εr = M >> 1, µr = 1;
• Ys (ω) - admitanta calculata cu FIT pe gridul secundar cu
parametrii ELOB: εr = 1, µr = M >>1;
4. Sinteza circuitului Spice parametric, extras cu AFT si redus cu
VF+DEM
PRINCIPIUL GENERAL: sa se aplice ROM cat mai devreme posibil, la
fiecare etapa a modelaraii
Extragerea in paralel,
cu AFS/VF a modelului redus
Algoritmul AFS-VF (Adaptive Frequency
Sample – Vector Fitting)
1. Genereaza modelul semistare (1)
folosind FIT pentru campul EM din
EMCE si distirbuie-l catre toate nodurile
2. Alege un set S initial de frecvente
3. Alege un set S’ de frecvente intermediare
4. Caluleaza cu (2) HFIT prin rezolvarea in
paralel a sistemelor liniare d ecuatii
complexe (G + jwC)x = B pentru
frecventel care nu au fost inca analizate
_ 5. Se aplica esantioaneleor HFIT(S)
algoritmul VF si se obtine o aproxiamtie a
functiei de tansfer de forma (3). Ordnul q
este crescut succesiv pana cand este
satisfacuta (4)
6. Calculaeaza HVF(S’) si se evalueaza
eroarea relativa a HVF fata de HFIT pe S’ (1)
si stop daca este sub limita impusa
(2)
7. Muta frecventele de test S’ in multimea S
si genreaza un alt set S’ de frecvente
intermediare (3)
8. Daca nu a fost depasit numarul maxim de
frecvente, reia de la pasul 4. (4)
Rezultate
CHR 201benchmark
AFS: Master – 5 worker (message with Zero

MQ encoded in JSON format) for 29 samples.
Linear system 104 102 DoFs solved with
UMFPACK/Open MP, ACML as a BLAS by 8
core. Accelerarea prin paralelizare > 11
[Lazar12]
Modelarea multifizica
Discipline tipice in modelara multifizica:
• Electromagnetic
• Termic
• Structural (elasto-dinamic)
• Fluidic
_
Spatiul atributelor unei probleme multifizice:
• Numar de campuri (discipline)
• Numar de subdomenii
• Numar de nivele
Modelarea multifizica: probleme in care sunt

cuplate campuri si/sau circuite de natura
diferita, in mai multe subdomenii sau la
diferite scari
IMT RF MEMS Switch
Modelul geometric parametrizat al
RF-MEMS
Reducerea modelelor:
de la milioane la zeci de stari
Aspecte studiate: electromagnetice/multifizice: formulare matematica (marimi si

ecuatii); algoritmi numerici de rezolvarea problemelor cuplate EM, Structurale, CFD
Instrumente folosite: MATLAB, COMSOL
Tinta: dezvoltarea de noi instrumente software pentru proiectanti, in vederea
(re)proiectarii optimale
INGINERIA ELECTRICA High Tech are la baza: camp – circuite – sisteme si
rezolvarea numerica a PDE-ODE. Avem responsabilitatea corectitudinii!!
Algoritmul numeric de extragere
a modelului multifizic redus al RF-MEMS
[Ciuprina16]
_
Ecuatii rezolvate cu algoritmi numerici proprii
implementati in MATLAB si validati in Comsol
Extragerea modelului redus al
RF-MEMS
Extragerea modelului redus al
RF-MEMS
Modelul SPICE multifizic al
RF-MEMS extras cu FEM/FIT
In perspectiva: extragerea unor

modele Spice parametrice si
folosirea lor pentru optimizarea
[Lup16] produsului cu tehnici HPC
Verificarea si validarea rezultatelor
modelarii multifizice MEMS
3.4. Optmizari, probleme inverse
• In problema directa se cunosc geometria, constantele de material si sursele de
camp, iar necunoscuta este campul em.
• In problema inversa se cunoaste campul peste tot sau numai partial si se determina
geometria, constantele de material sau sursele de camp. Ea se reduce prin tehnici
de optimizare la rezolvarea problemei directe.
• Optimizari:
Fara restrictii Cu restrictii
Mono- f : R n → R; y *R = minn f ( p ); f : Ω → R; Ω ⊂ R n ; g : Ω → R q ;
_ obiectv p∈R
p = arg minn f ( p )
* y * = min f ( p) cu g( p) = 0; y * = f ( p* )
p∈Ω
p∈R
f = [ f1 ,.. f r ]T : R n → R r ; [α1 ,..α r ]T ∈ R r ;
Multi- f = [ f1 ,.. f r ]T : Ω → R r ; [α1 ,..α r ]T ∈ R r ;
r
obiectiv y * = min ∑ α k f k ( p); r
p∈R n
k =1
Ω ⊂ R ; g : Ω → R ; y = min ∑ α k f k ( p);
n q *
p∈Ω
k =1
r
p * = arg minn ∑ α k f k ( p) r
p∈R
k =1
cu g ( p ) = 0; p * = arg min ∑ α k f k ( p )
p∈Ω
k =1
• Optimizarile cu restrictii si multiobiectiv se reduc la cele uniobiectiv fara restrictii

Clasificarea problemelor si
metodelor de optimizare
• Problemele cu functii obiectiv netede si convexe, se rezolva eficient cu metode
iterative deterministe, bazate pe calculul gradientului, aproximand local functia
obiecitv cu una patratica.
• Problemele cu functii obiectiv convexe, dar care nu sunt netede se rezolva eficient cu
metode deterministe, fara calculul gradientului
• Problemele cu functii obiecti neconvexe, pot avea minime locale multiple, in care sunt
atrase solutiile iterative. Pentru a evita aceste capcane se folosesc algoritmi
stohastici, nedeterministi de tip eurisitc. Acestia mimeaza diferite procese naturale:
calire, algoritimi genetici, roiuri de particule, etc. Ultimii folosesc populatii de
solutii numerice.
•_ Dificulatea optimizarilor electromagneitce si a probelmelor inverse consta in costul
ridicat al evaluarii functiei obiectiv, care presupune la fiecare evaluare rezolvarea
unei probleme directe de camp em (a unei PDE).
• Tehnicile HPC se folosesc in rezolvarea problemelor de optimizare astfel:
– In evaluarea functiei obiectiv, prin paralelizarea rezolvarii problemei directe de camp
– Estimarea in paralel a masurii in care o populatie se apropie de solutia optimala (fiecare membru
sau grup de membri din populatie este estimat in paralele cu ceilalti)
• O tehnica de mare eficienta in optimizare consta in folosirea modelelor surogat,
sau de ordin redus, ale caror acuratete creste pe masura progresului procesului de
optimizare.
Optimizarea prin metode
deterministe (BFGS)
• Extremul functiei obiectiv fara restrangeri corespunde anularii gradientului ei.
• Metoda Newton consta in rezolvarea iterativa a sinstmului neliniar de ecuatii care
corespunde anularii componentleor gradientlui, folosind joacobianul acestui sistem,
deci dubla derivata a functiei obiectiv. In consecinta, functia obiectiv la fiecare iteratie
este aproximata cu o functie patratica f(p) = pT H p + g p + c. Efortul de calcul este
mare, deoarece necesita estimarea la fiecare etapa a matricei hessian H.
• Metodele quasi-Newton folosesc aproximari ale jacobianului deci implicit ale
hessianului. Matricea hessian nu se calceaza explicit ci este este in schimb folosita o
aproximare B obtinuta prin analiza succesiva a vectoului gradient
https://en.wikipedia.org/wiki/Quasi-Newton_method … wiki/Broyden–Fletcher–Goldfarb–Shanno_algorithm
•_ .Cea mai frecvent folosita varianta este algoritmul BFGS (Broyden–Fletcher–
Goldfarb–Shanno): B0 = I
• Rezolvarea sistemului poate fi repeta
evitatata prin folosirea relatiei rezolva Bk p k = −∇f (x k )
Sherman-Morrison: caluleaza x k +1 = x k + α k p k cu α k prin minimizare linieca
sk = α kpk ; y k = ∇f (x k +1 ) − ∇f (x k )
y k y Tk Bk s k sTk Bk
Bk +1 = Bk + T − T
y k sk s k Bk s k
pana cand ∇f (x k +1 ) < ε
Calculul gradientului prin metoda
campului adjunct
Va fi exemplifcata pentru cazul ES, in care se Sp
Σ
determina senzitivitatea capacitatilor C (q = C * v )
fata de prametrii geometrici p. Din teorma
n
lui Ω
Tellegen din ES: (v,q) = <E,D> ⇔ ∑ vk qk = ∫ E ⋅ Ddv V1=1 (ε=ct)
Conform k =1 Ω
p
http://www.lmn.pub.ro/~daniel/ElectromagneticModelingDo
ctoral/Tutorials/Regimul%20electrostatic.pdf , rezulta V2=0
δCij = < δε E, E> /Vo2 V=0
_ ∂Cij1 ∂ε ε
= 2 ∫ E ⋅ EdΩ = 2 ∫ E ⋅ EdS Suprafata modificata de p
∂p V0 Ω ∂p V0 Sp
Campul original E (cand este excitat conductorul i cu Vo) si cel adjunct E (cand este
excitat conductorul j cu Vo) sunt calculate (in paralel), o singura data, independent de p.
Cele n(n-1)/2 capacitati se extrag prin rezolvarea (in paralel) a tot atatea probleme de
camp, din care se caluleaza si senzitivitatile, prin integrarea produsului EE (care si ea
poate fi estimata in paralel).
Senzitivitatea (gradientul) fata de parametru geometric se caluleaza prin integrare pe
suprafata, iar fata de ε, prin integrare pe volum. [Ioan00], [Nikolova04], [Bi08].
Cazuri de test – Optimization
benchmaks: Solenoidul lui Loney
Bobine cilindrice cu r1 = 11mm, r2 = 29mm, h = 120mm r3 = 30mm, r4 = 36mm, z0
= 2.5 mm si aceeasi densitate de curent in toate infasurarile.
• Se cere sa se determine s si l, pentru ca pe axa sa fie un camp cat mai uniform in
zona centrala.
• FuncȀia obiectiv care se minimizeaza (campul se calculeaza cu BSL):
f ( s, l ) =  max B ( z ) − min B( z )  / B (0)

 − z 0 < z < z0 − z0 < z < z0 
_
benchmaks: TEAM22 benchmark
Optimizarea unui SMES (Superconducting Magnetic Energy Storage), alcatuit din
doua bobine supraconductoare coaxiale, care sa acumuleze o energie data, sa aiba
un camp de dispersie cat mai mic, iar in conductor sa nu se depaseasta densitatea
critica de curent (la care starea superconductoare dispare)
• Functia obiectiv:
• Cu restirictia: J ≤ (−6.4 B + 54)

_
cu inductia magnetica B calculata cu BSL
• si restrictiile parametrilor:
benchmaks: JSAEM benchmark #2
Sistem de testare nedistructiva cu curetni turbionari: o placa de dim
40x40x1.25mm3 si conductivitate 10MS/m este scanata 2D cu o bobina cu 140
spire de diam int 1.2mm si ext 2,2mm, de inaltime 0.8mm, plasata la 0.5mm de
placa, cu impedanta Z cand e parcursa de un curent de 150kHz.
• O problema inversa in care se doreste determinarea formei si pozitia unui defect
paralelipipedic din placa precum si conductanta acestuia, descrise de vectorul
cu . Problema directa rezolvata cu FEM-BEM.
• Functia obiectiv:
Parametrizarea defectului:
Algoritmul de optimizare cu roi de
particule PSO (versiunea clasica)
pentru i = 1, ..., S ; fiecare din cei S membri ai populatiei CiCLU PARALELIZABIL!
xi = random(blo, bup) ; se initislizeaza pozitia arbitrar in spatiul de cautare
pi = xi ; se initializeaza performanta individuala
daca (f(pi) < f(g)) , atunci g = p ; se identifica performanta globala (a roiului)
vi = random(-|bup-blo|, |bup-blo|) ; se initislizeaza arbitrar viteza fiecarei particule
t = 0 ; se intializeaza contorul de iteratii
w=0.73, cp=1.49, cg=1.49 ; initalizari ponderi (inertiala, personala, globala)
repeta ; ciclul iteratilor
pentru i = 1, ..., S ; fiecare particula
rp = random(0,1) ; se alege o valoare aleatoare pentru ponderea performantei individuale
_ rg = random(0,1) ; se alege o valoare aleatoare pentru ponderea performantei globale
pentru j = 1, ..., n ; fiecare directie a spatiului de cautare
vi,j= w·vi,j + cp·rp·(pi,j– xi,j) +cg·rg·(gj – xi,j) ; se calculeaza comonenta vitezei particulei curente
; ca suma a trei componente: de inertie, spre performanta individuala si spre cea globala
xi,j = xi,j + vi,j ; apoi se deplaseaza particula cu aceasta viteza (si evetual testarea restrictiilor)
pentru i = 1, ..., S ; fiecare particula CiCLU PARALELIZABIL!
daca (f(xi) < f(pi) , atunci pi = xi ; se actualizeaza noua performanta individuala
daca (f(pi) < f(g)), atunci g = pi ; se actualizeaza noua performanta globala
t = t + 1 ; incremteaza contorul de iteratii
pana cand (t >= tmax || soluȀie_adecvată(g)) ; s-a depasit numarul maxim de iteratii admise sau f(g) este OK
intoarce g ; pozitia particulei care are cea mai buna performanta globala (minimul global al roiului)
Rezultatele numerice,
evolutia optimizarii
• Optimizarea Solenoidului Loney cu diferite versiuni PSO cu S=32
• Problema TEAM 22 (SMES) cu diferite versiuni PSO cu S=32, 64, 128
• JSAEM benchmark #2: PSO combinata cu diferite metode determineste

Numarul de iteratii necesare pentru
identificarea diferitelor defecte
PSO nu face fata singura (F=esec), pentru succes
ea a. fost combinata cu metode deteministe.
[Duca16]
Accelerarea evaluarii functiei obiecitv
• TEAM22 benchmark:
Paralelizarea sa realizat cu
tehnica pthread iar accelerarea
obtinuta are valori peste 2.
• JSAEM benchmark #2
In cazul unui sistem de 3696x3696
_ecuatii complexe, prin paralelizare
cu 12 fire, timpul a scazut de 7 ori,

iar prin rezolvare pe GPU a mai
scazut inca de 3,6 ori [Duca16]
Metoda Timp [ms]
Timpii de executie GPU vs CPU
Solenoidul Loney
• TEAM22 benchmark
• Concluzie: folosirea GPU este mai eficienta pentru
problemele simple, in timp ce
• in cazul problemelor mai complicate este preferabila solutia
CPU (pthread).
[Duca16]
3.5. Probleme deschise,
directii de cercetare
In acord cu [Rude 2016], urmatoarele directii przinta interes in cercetare:
• Noi solvere liniare, neliniare si de integrare in timp, care sa asigure acuratete,
eficienta si sclabilitate, bazati pe o abordare ierarhica a rezolutiei.
• Controlul erorii/acuratetii (UQ=“Uncertainty quantification”). Increderea in modele
este esentiala, mai ales in problemel: inverse, de predictie si cele de optimizare.
• Optimizarea cu modele bazate pe ODE si PDE, in care s-au identificat urmatorele
necesitati de cerceetare: extinderea la probleme compxe (multuscalare/multifizice),
cu parametri discreti, constrangeri si functi obiectiv care nu sunt netede, pentru
ecuatii stohastice si optimizarea cu modele reduse sau surogat.
_• Discretizari precise si rafinari adaptive ale retelei. Aplicarea unor metode de
discretizare mimetice, care salveaza proprietatiel conservative ale modelului si aduc
stabilitate, acuratete si buna convergenta. Studiul corelatiei dintre eroarea de
discretizare si cea de iteratie.
• O directie de cercetari se refera la rafinarea dinamica si la adaptarea pasului de
timp, in cazul unui numar tot mai mare de procesoare.
• Solutii robuste pentru probleme multisclare si multifizice de mari dimensiuni,
de relevanta industriala, pe platforme avansate de calcul, in special dezvoltarea de
solvere liniare, neliniare si tehnici de preconditionare, pentru astefle de probleme.
Probleme deschise,
• Aproximare, modele simplifcate, de ordin redus, surogat. Reducerea timpului de
simulare cu controlul riguros al erorii. Exemple de aplicatii in care se pot folosi:
optimizare, controlul erorii, studii parametrice si probleme inverse. Aproximatiile
mutinivel s-au dovedit utile pentru a obtine viteza de calcul in controlul acuratetii si in
metodele de tip Monte Carlo.
• Algoritmi nedeterministi, care folosesc generatoare de numere aleatoare,folositi la
rezolvarea numerica a PDE, reducerea modelelor, optimizare, probleme inverse, UQ,
machine learning. Sunt asteptate extensii ale lor in cazul neliniar, tensorial,
scalabilitate paralela si dezvoltarae de biblioteci pentru sistemele HPC.
• Metode mesoscopice si rezolvarea problemelor Multibody, la care interactiunile
_
apropiate, dominante sunt anlizate cu implementari paralele eficiente realiate cu
structuri de date adecvate unei partitionari dinamice a domeniului de calcul, in timp ce
iteractiunile departate, sunt descrise de structuri de date ierarhice si algoritmi paraleli
cu sunt FFT, FMM, MG sau bazate pe wavelet. Metodele mesoscopice folosesc
paradigma modelului cinetic, cu metoda laticei Boltzmann si principiile fizicii statistice.
• Modele multiscala si multifizice. In abordarile multiscalare s-au facut progrese
notabile, dar raman inca provocari referitoare la cuplarea continua/atomista si
rezolvare aproblemelor in care scarile nu sunt separate. Este de asteptat ca
abordarile multigrid sa conduca la algoritmi foarte puternici pentru rezolvarea
problemei cuplarii.
Probleme deschise,
• Formularea problemelor, descompunerea operatorilor multifizici, discretizarea
lor, retele adecvate de discretizare, conditii de frontiera si de interfata intre
subdomenii, interpolari, partitionarea psilor de timp si preconditionarea
specifica operatorilor sunt preocupari constnate, dar avansul semnificativ necesita
analiza matematica suplimentara si dezvoltarea de noi metodologii software pentru
cuplara tuturor acestor aspecte pentru a genera scheme precise, robuste, stabile si
consistente, implementate adecvat. Atat paradigmele de programre, cat si abordarile
matematice trebuie revizuite cu o atentie mai mare data algoritmilor paraleli, cu mai
putina sincronism, cum sunt cei bazati pe “furtul de sarcini”.
• Extinderea preocuparilor CSE prin tehnologia HPC. Puterea de calcul
_ semnificativa dar de pret redus oferita de acceleratoarele hardware, cum sunt placile
grafice GP-GPU ofera noi posibilitati de folosire a tehnologiilor HPC netraditionale.
Se prevad dezvoltari de sisteme CSE rapide, de noi simulatoare, software de
predictie, diagnostic si tratament medical personalizat. Pentru asta trebuie dezvoltate
noi metode de simulare, inventati noi algoritmi, formulate noi paradigme de modelare.
Noi tehnici de validare si verificare sunt necesare. Apar sanse noi pentru cercetarea
fundamentala, care patrunde dincolo de dezvoltarea de noi legi de material, in care
este cantonata in prezent.
• Interoperabilitate, extensibilitate si portabiliate software. Sunt cerinte practice
care fac dezvoltatrea software mai dificila dar assigura managmentul compelxisitatii si
valabiliatea solutiilor la schimbarile arhitecturii, si cand mediile software avanseaza.
Probleme deschise,
• Ingineria performantelor si co-design. Idea tratamentului apriori al tintelor de
performanta in ingineria software stiintific este corelata cu paradigma HD/SW co-
design (https://homes.cs.washington.edu/~bornholt/papers/hwsw-snapl15.pdf ) si a
devenit o noua tendinta pentru noile generatii de algoritmi si aplicatii software.
• Algoritmi ultrascalabili si asincroni. Algoritmii asincroni permit programului sa-si
continue executia, chiar daca un mumar limitat de procesoare raman in urma. Este
un domeniu larg de cercetare, care presupune o noua persepctiva asupra datelor si
a dependentelor dintre ele, cu posibilitati de planificarea nedeterminista a executiei.
Suport si instrumente pentru o astfel de abordare sunt inca necesare.
• Zidul puterii. Cresterea performantelor hardware a fost franata in ultima decada de
_
“zidul puterii”, adica de necesitatea de a disipa tot mai multa caldura genrata de
procesoarele care executa calcule intensive. Daca ne imaginam o problema de nivel
terascalar, cu N = 10^12 si o cmplexitate O(N^2), ea ar necesita o disipare de
energie de cca 277 GWh, care este de nivelul unei explozii nucleare, a aunei bombe
cu hidrogen. Este evident ca asa ceva este imposibil de realizat in practica, si pentru
a depasi zidul puterii trebuie dezvoltati algoritmi de compelxitate mult mai mica.
• Toleranta la defecte si rezilienta. Multi algoritmi CSE/HPSC au potential pentru a se
converti in metode tolerante la defecte, cum este tehnologia RAID (redundant array of
inexpensive disks), folosita pentru sitemele de fisiere ale clusterelor HPC. Algoritmii
iterativi sunt autocorectori, si converg catre aceeasi solutie, chiar daca ceva mai lent,
in cazul erorilor de calcul de la unele iteratii. O astfel de dezvoltare este promitatoare.
Probleme deschise,
• CSE/HPSC si revolutia datelor. Pe langa cele trei paradigme ale descoperirilor
stiintifice: teoria, experimentul si simularea, se profileaza si o a patra, prin care
analiza marilor masive de date cu abordari statistice scoate in evidenta noi
caracteristici fundamentale, mai ales in cazul in care modelele bazate pe principii
fundamentale (“first principle”) nu pot fi aplicate, pentru ca nu sunt cunoscute sau nu
sunt adecvate. Cantitatile mari de date disponibile in multe domenii (biologie,
medicina, fizica experimentala, astrofizica, etc.) fac necesare astfle de abordari, cum
sunt cel bazate pe tehnici de tip Monte Carlo, analiza Byesiana, procese de decizie
Markov, etc.
•_ Proiectarea sistematica si analiza componentelor software paralel, cu controlul
acurateii si complexitatii. In plus se adauga si cerinte privind flezibilitatea,
extensibilitatea si interoperabilitatea. Pe langa aplicatii sunt importante si
componentele software din sistemul de operare, modele de programare, limbaje,
compilatoare, depanatoare, profilere, translatoare, mangere de resurse, sisteme de
comunicare prin mesaje, intrare/iesire, controlul joburilor si taskurolor, etc. La
acestea se adauga, controlul versiunilor, testarea automata dar si documentarea.
• Este tot mai necesar software care sa perminta modelarea multifizica si
multisclara, si care sa aiba faciltati de controlul acuratetii (UQ) si de proiectare
optimala, in medii software si hardware tot mai complexe.
Probleme deschise,
• Programarea arhitecturilor heterogene. Sistemele de calcul moderne sunt
structurate ierarhic si pretind utilizarea pentru progamare a unei combinatii hibride de
limbaje si instrumente. Sarcina dificila mai ales in echipe care dezvolta software ce
tine cont de specificul hardware, in special pentru programarea GPU.
• Analiza cantitativa a performantelor algoritmilor si a programelor de calculator.
Sunt necesare cercetari pentru a cuantifica caracteristicile a tot mai multi algoritmi de
inalta complxitate, cum sunt cei de acces la memorie (cache reuse, uniformity of
access, utilization of block transfers, etc.), utilizarea procesoarelor, comunicatie si
sincronizarea, dar si a probramelor care implementeaza acesti algoritmi. Multe
teoreme din matematicile numerice nu sunt realmente cantiaitve, deoarece contin
_ constnate nederminate.
• Reprodictibilitatea si sustenabilitatea, Componentele software de aplicatie

CSE/HPSC capeaza esenta rezultatelor cercetarilor stiintifice. Ele trebuie deci sa
satisaca cerintele de caliatate pe care comunitatea le are pentru orice razultat
stiintific.
• Concluzia este ca majoritatea cuvintelor cheie din aceasta sectiune se regasesc pe

parcursul prezentarii, ceea ce dovedeste ca suntem pe calea cea buna. Daca
cercetarile voastre nu se incadreaza in aceste directii, probabil ca sunteti in balarii.
4. Concluzii generale
• HPSC este un domeniu activ de cercetare-dezvoltare, cu un puternic caracte
interdisciplinar: stiinte, matematica, IT, in care sunt folosite sisteme de calcul
multiprocesor pentru rezolvarea problemelor de mari dimensiuni
• Miniaturizarea ne ofera tot mai multa putere de calcul la un pret tot mai
redus, dar folosirea ei eficienta necesita noi competente (programarea
paralela fiind mult mai dificila decat cea secventiala). Paralelizarea este tot
mai prezenta, atat in interiorul CPU, in GPU, in retele, in cloud. Legea lui
Moore este valabila nu numai pentru circuitele integrate, ci si pentru software
• Arhitecturile cele mai intalnite sunt: cele cu memorie partajata si distribuita,
_
care determina si cele doua modele fundamnetale de programare
• Proiectarea programelor paralele se face cu Metodologia PCAM (Partitie/
Descompunere, Comunicare, Aglomerare/Grupare, Mapare/Asignare/
Implementare) bazata pe descompunerea taskurilor, datelor si/sau fluentei
• Programarea paralela se realizeaza in diferite limbaje, folosind tehnici (API)
ca: pthread, OpenMP, MPI, CUDA, RPC…
• Programarea paralela este simplificata de folosirea modeleor (design
pattern), cele mai frecvente fiind: MasterSlave, Pipe, ForkJoin,
Divide&Conquer si ParallelTasks (SPMD)
Concluzii generale
• Modelarea electromagnetica si multifizica beneficiaza de HPSC si toate
tehnicile ei numerice (AN) in rezolvarea celor mai diverse probleme practice
cu FEM, FIT, BEM, Algebra numerica. Ea a devenit standard in proiectare.
• HPSC a creeat proceduri super-rapide, cum sunt: Algoritmul Schwarz
Aditiv (ASM) din DDM, MG, FMM, MLFMA, AFEM, sau Krylov si POD-MOR
• Metodologia LMN pentru modelare si reducerea ordinului, care foloseste
FIT-MEEC la probleme cuplate camp-circuit a fost validata international
• Optimizarea si rezolvarea eficienta a probelmelor inverse se face cu
_ combinand metodele euristice si deterministe (iPSO e citait de >300 ori)
• HPSC se refera la tehnicile numerice si metodologiile software, gasirea
optimului dependent de problema, dar si de arhitectura sistemului (CPU,
GPU, Net) presupune analiza tuturor aspectelor ingineresti, matematice, IT
• HPSC foloseste instrumente software specifice pentru dezvoltarea
programelor: editare, compilare, constructia executabilelor, depanare,
estimarea performantelor, documentare
• Refolosirea (mathematic libraries, design pattern, frameworks) este
esentiala in dezvoltarea eficienta. Codul propriu este mai adevat cercetarii,
iar programele comerciale au fost folosite doar pentru verificare
Concluziile finale
• Succesul procedurilor HPSC depinde de intelegerea profunda a problemei
de rezolvat, a multimii de variante avute in solutionarea ei si felul in care
acestea influenteaza performanta finala: costul rezolvarii si acuratetea
obtinuta.
• Abundenta de tehnici, algoritmi, functii, limbaje si metode face rezolvarea
aparent simpla, dar in realitate gasirea abordarii optime cere experienta,
intuitie si viziune, in special in alegerea nivelului de abstractizare, fara sa se
piarda in detalii, dar nici sa se rupa legatura cu realitatea (atat cea
_ computationala, cat si cea fizica). Altfel dezvoltatorii risca sa devina
programatori zombi, lipiti de ecranul calculatorului, spre deosebire de cei
creativi, lideri de proiect, numiti pe buna dreptate manageri ai complexitatii,
care stiu in orice moment ce si de ce fac.
• Schimbarile tehnologice si cresterea exponentiala a performantelor
hardware si software face viata profesionistilor IT fara repere culturale foarte
dificila, mai ales in aplicatiile numerice, stiintifice, ingineresti si bio-medicale.
• Putini intelg aceste lucruri, dar cei care o fac sunt foarte apreciati pe plan
international. Merita efortul sa o faceti, nu veti regreta. Va urez succes!
5. Referinte
tratate de baza in HPC
• Dongarra, Jack, et al. Sourcebook of parallel computing. San Francisco: MKPublishers, 2003.
http://hpcuniversity.org/roadmap/ServedResources/SourcebookOfParallelComputing.pdf
• Jack Dongarra Scientific Computing for Engineers http://www.cs.utk.edu/~dongarra/WEB-PAGES/cs594-
2010.htm
• [Mattson04] Mattson, Timothy G., Beverly Sanders, and Berna Massingill. Patterns for parallel programming.
Pearson Education, 2004. ftp://ftp.gunadarma.ac.id/pub/.multimedia/Parallel%20Programming.pdf
• Victor Eijkhout, Introduction to High Performance Scientific Computing
http://pages.tacc.utexas.edu/~eijkhout/istc/istc.html
• [Heath] Michael T. Heath, CS 554 | CSE 512 – PARALLEL NUMERICAL ALGORITHMS
https://courses.engr.illinois.edu/cs554/fa2015/notes/
• Tannenbaum A., van Steen M. Distributed systems Principles and paradigms, 2002
http://www.cs.vu.nl/~ast/books/ds1/.
_
• Blaise Barney, Lawrence Livermore National Laboratory Introduction to Parallel Computing
https://computing.llnl.gov/tutorials/parallel_comp/ . .
• Ian Foster Designing and Building Parallel Programs http://www.mcs.anl.gov/~itf/dbpp/
• http://tldp.org/HOWTO/Scientific-Computing-with-GNU-Linux/
• Geoffrey C. Fox, Roy D. Williams and Paul C. Messina, Parallel Computing Works!
http://www.netlib.org/utk/lsi/pcwLSI/text/ Morgan Kaufmann Publishers, 1994
• [Eadline],Douglas Eadline,HPC for dummies http://hpc.fs.uni-lj.si/sites/default/files/HPC_for_dummies.pdf
• [Grama03] A. Grama, A. Gupta, G. Karypis, V. Kumar, “Introduction to Parallel Computing”, Second Edition,
Addison Wesley, 2003 .
• [Rude 2016] Ulrich Rude et all, Research and Education in Computational Science and Engineering, Sept.
2016, submitted to SIAM Review
Referinte
Pthread, Open MP, MPI, CUDA
• [Lewis96] Bil Lewis Daniel J. Berg, PThreads Primer A Guide to Multithreaded Programming,
SunSoft Press A Prentice Hall Title, 1996
• Victor Eijkhout , Parallel Programming in MPI and OpenMP
https://bitbucket.org/VictorEijkhout/parallel-computing-book/src
• [Quinn 04] M.Quinn, J. Parallel Programming in C with MPI and OpenMP McGraw-Hill Inc. 2004.
• HPC Applications
• [OpenMP] The OpenMP® API specification for parallel programming http://openmp.org/wp/.
• OpenMP versus Threading in C/C++
http://www.cs.colostate.edu/~cs675/OpenMPvsThreads.pdf.
• [MPI] Marc Snir, Steve W. Otto, Steven Huss-Lederman, David W. Walker, Jack Dongarra, MPI
_ - The Complete Reference, volumes 1&2 http://mitpress.mit.edu/books/mpi-complete-reference-
0 http://cecs.wright.edu/~schung/ceg820/mpi-book.pdf.
• William Gropp, MPI: The Once and Future King, Keynote at EuroMPI16, September, 2016,
Edinburgh, Scotland. http://wgropp.cs.illinois.edu/bib/talks/tdata/2016/eurompi-keynote.pdf
• William Gropp, Parallel Programming With MPI, invited guest lecture in APMA 4990
"Introduction to Parallel Scientific Computing", Columbia University, March 10, 2004.
http://wgropp.cs.illinois.edu/bib/talks/tdata/2004/mpi-half-day-public.pdf
• Ilya Raykhel, Hot plate OpenMP, PThreads and MPI performance comparison
http://students.cs.byu.edu/~ilyar/cs684/comparison.pdf.
• [Wilt13] Nicholas Wilt, The CUDA Handbook A Comprehensive Guide to GPU Programming,
2013 http://cgi.di.uoa.gr/~halatsis/HPC_course/Lecture%20notes/EU_PRACE_3.pdf
Referinte
Shell, OOP, diverse
• [sh] An Introduction To Shell Programming http://www.faqs.org/docs/air/tsshell.html
• [Scheduler] Job scheduler https://en.wikipedia.org/wiki/Job_scheduler
• El-Rewini, Hesham, and Mostafa Abd-El-Barr. Advanced computer architecture and parallel processing. Vol.
42. John Wiley & Sons, 2005.
• [Torque] TORQUE Resource Manager http://www.adaptivecomputing.com/products/open source/torque/
• [Maui] Maui Cluster Scheduler https://en.wikipedia.org/wiki/Maui_Cluster_Scheduler
• [Iqbal05] Saeed Iqbal, RINKU GUPTA; AND YUNG-CHIN FANG , Planning Considerations for Job
Scheduling in HPC Clusters, Dell Power Solutions, February 2005.
http://www.dell.com/downloads/global/power/ps1q05-20040135-fang.pdf
• [Akhter06] Akhter, Shameen, and Jason Roberts. Multi-core programming. Vol. 33. Hillsboro: Intel press,
2006. http://users.nik.uni-obuda.hu/vamossy/SZPE2011/Segedletek/Multi-
_
Core_Programming_Digital_Edition_(06-29-06).pdf
• ALLEN HOLUB, Holub on Patterns: Learning Design Patterns by Looking at Code, Apress 2004
http://www.holub.com/goodies/holub_design_patterns.pdf
• [GoF97], Gamma, Helm, Johnson, and Vlissides, Design Patterns Elements of Reusable Object-Oriented
Software, 97 http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf
• Parallel Computing Toolbox, User's Guide COPYRIGHT 2004–2016 by The MathWorks, Inc.
• [Linda] Tutorial on Parallel Programming with Linda, 2006 http://andrei.clubcisco.ro/cursuri/5master/scpd-
pp/misc/Tutorial%20on%20Parallel%20Programming%20with%20Linda.pdf
• [Cole89] Murray Cole. "Algorithmic Skeletons: structured management of parallel computation" MIT Press,
Cambdridge, MA, USA, 1989 http://homepages.inf.ed.ac.uk/mic/Pubs/skeletonbook.pdf
• [Loidl15] Hans-Wolfgang Loidl, Distributed and Parallel Technology Algorithmic Skeletons
http://www.macs.hw.ac.uk/~hwloidl/Courses/F21DP/l08_handout.pdf
Referinte
HPC linear algebra, FEM
• [Hawe96] Jeff Howe, Shawn Bratcher , Parallel Gaussian Elimination, CSE 160 Term Project (Fall 96)
http://cseweb.ucsd.edu/classes/fa98/cse164b/Projects/PastProjects/LU/
• [Dongarra11] Jack Dongarra, Jakub Kurzak. James Demmel, Michael Heroux, Linear Algebra Libraries for
HighPerformance Computing: Scientific Computing with Multicore and Accelerators, SuperComputing 2011,
http://www.netlib.org/utk/people/JackDongarra/SLIDES/sc2011-tutorial.pdf
• [Tomov] 15 Stan Tomov, Linear Algebra Software for High-Performance Computing, ISC High Performance
’15 Frankfurt, Germany July 12, 2015 http://icl.cs.utk.edu/projectsfiles/magma/pubs/38-MAGMA-Tutorial-
ISC15.pdf
• [Madden] Niall Madden, Numerical solution to differential equations using matlab: Part 3: a finite element
implementation for a 2d elliptic problem. 2012.
• [Chessa] Jack Chessa. Programing the finite element method with matlab. 3rd October 2002.
• [Alberty] Jochen Alberty, Carsten Carstensen, and Stefan A. Funken. Remarks around 50 lines of matlab:
_ short finite element implementation. Numerical Algorithms, 20(2):117–137, 1999.
• [Shure] Loren Shure Creating Sparse Finite-Element Matrices in MATLAB, "Loren on the art of MATLAB",
martie 2007. http://blogs.mathworks.com/loren/2007/03/01/creating-sparse-finite-element-matrices-in-matlab/
• [Funken], S. Funken, D. Praetorius, and P. Wissgott. Efficient implementation of adaptive p1-fem in matlab.
"Computational Methods in Applied Mathematics", 2012.
• [Chen], LONG CHEN. ifem: An innovative finite element method package in matlab. 2008.
• [Cheney08] Ward Cheney, David Kincaid, Numerical Mathematics and Computing, Thomson 2008
• [Fem++] http://www.freefem.org/
• [Haldar] M. K. Haldar, Introducing the Finite Element Method in electromagnetics to undergraduates using
MATLAB.
• [Ioan12] D. Ioan, Metoda Elementului Finit pentru Modelarea Electromagnetica, Bucuresti, 2012,
http://www.lmn.pub.ro/~daniel/ElectromagneticModelingDoctoral/Tutorials/carte_FEM-ME-DI-final2012.pdf
Referinte
de baza, DDM
• [Hennessy11] Hennessy, John L., and David A. Patterson. Computer architecture: a
quantitative approach. Elsevier, 2011.
• [Landau] Rubin H Landau, A Beginner’s Guide to High–Performance Computing,
http://www.shodor.org/media/content/petascale/materials/UPModules/beginnersGuideHPC/mo
duleDocument_pdf.pdf
• Osman Sarood, Abhishek Gupta and Laxmikant V. Kale, Cloud Friendly Load Balancing for
HPC Applications: Preliminary Work http://charm.cs.illinois.edu/newPapers/12-27/paper.pdf
• [Burkardt11] Parallel MATLAB at FSU: PARFOR and SPMD John Burkardt , FSU 2011
https://people.sc.fsu.edu/~jburkardt/presentations/matlab_parallel_2011_fsu.pdf
• Barry Smith, Petter Bjorstad, William Gropp, Cambridge University Press 1996. Domain
_ Decomposition, Parallel Multilevel Methods for Elliptic Partial Differential Equations,
• [Dolean15] Victorita Dolean, Pierre Jolivet and Frédéric Nataf , An Introduction to Domain
Decomposition Methods: Algorithms, Theory, and Parallel Implementation, SIAM, 2015.
• PETSc: Parallel numerical software for PDES. https://www.mcs.anl.gov/petsc/
• Satish Balay William D. Gropp Lois Curfman McInnes Barry F. Smith 1 Software for the
Scalable Solution of PDEs ftp://ftp.mcs.anl.gov/pub/tech_reports/reports/P834.pdf
• Hong Zhang , Portable, Extensible Toolkit for Scientific Computation (PETSc )
https://www.mcs.anl.gov/petsc/documentation/tutorials/PETSc-CCT07.pdf
• [Popescu13] Radu Popescu, Parallel algorithms and efficient implementation techniques for
finite element approximations, EPFL 2013
• [DDM] Domain Decomposition Method http://www.ddm.org/
Referinte
Aplicatii
• [Lazar11] Lazăr, I. A., Andrei, M. I., Căciulan, E., Ciuprina, G., & Ioan, D. (2011, May). Parallel algorithms for
the efficient extraction of fitting based reduced order models. In Advanced Topics in Electrical Engineering
(ATEE), 2011 7th International Symposium on (pp. 1-6). IEEE.
•[Lazar12] Lazăr, Ioan-Alexandru, Gabriela Ciuprina, Daniel Ioan. "Effective extraction of accurate reduced order
models for HF-ICs using multi-CPU architectures." Inverse Problems in Science and Engineering 20.1 (2012)
• [Rogers] Anne Rogers , John H. Reppy . Laurie J. Hendreny, Supporting SPMD Execution for Dynamic Data
Structures http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.34.2312&rep=rep1&type=pdf
• [Ioan00] D. Ioan, Modelarea dispozitivelor electromagnetice, UPB, 2000, draft disponibil la
http://www.lmn.pub.ro/~daniel/cursmde.pdf)
• [Dolean16] Pierre-Henri Tournier, Marcella Bonazzoli, Victorita Dolean,, et al. , Numerical Modeling and High
Speed Parallel Computing: New Perspectives for Tomographic Microwave Imaging for Brain Stroke Detection
and Monitoring, IEEE-AP-2016- https://hal.archives-ouvertes.fr/hal-01356092/file/Invited_IEEE-AP.pdf
_• [Top10] Jack Dongarra and Francis Sullivan, The Top Ten Algorithms of the Century
http://orion.math.iastate.edu/burkardt/misc/algorithms_dongarra.html.
http://www.uta.edu/faculty/rcli/TopTen/topten.pdf.
• Li, Dan, Chen Greif, and Dominik Schötzau. "Parallel numerical solution of the time‐harmonic Maxwell
equations in mixed form." Numerical Linear Algebra with Applications 19.3 (2012): 525-539.
• [Ciuprina13] G.Ciuprina Algoritmi numerici prin exeritii si implementari in Matlab Editura MatrixROM, 2013,
• Using the Domain Decomposition Solver in COMSOL Multiphysics https://www.comsol.com/blogs/using-the-
domain-decomposition-solver-in-comsol-
multiphysics/?utm_medium=email&sslid=MzEwMDQyMzIxsTCzAAA&sseid=MzQ1srA0NzcxNAIA&jobid=56195
06f-a4a4-4255-bb40-5e3c26920374
• [Nikolova04] Natalia K. Nikolova, John W. Bandler, Mohamed H. Bakr, Adjoint Techniques for Sensitivity
Analysis in High-Frequency Structure CAD,IEEE TRANSACTIONS ON MTT, VOL. 52, NO. 1, JANUARY 2004
Referinte
Aplicatii
• [Duca 16] L. Duca Tehnici de calcul de înaltă performanţă pentru optimizarea dispozitivelor
electromagnetice, Teza doctorat, UPB, 2016
• [Ioan08] Ioan, Daniel; Ciuprina, Gabriela; Schilders, W. H. A, Parametric models based on the
adjoint field technique for RF passive integrated components, Ieee Transactions on Magnetics
Volume: 44 Issue: 6 Pages: 1658-1661, JUN 2008
• [Bi08] Bi, Yu; van der Kolk, K.; Ioan, D.; et al. Sensitivity Computation of Interconnect
Capacitances with respect to Geometric Parameters, 2008 Ieee-Epep Electrical Performance
of Electronic Packaging, Pages: 193-196, IEEE, 2008
• [Andrei12] [Mihai-Iulian ANDREI - MODELAREA ELECTROMAGNETICA A
INDUCTOARELOR INTEGRATE PE SISTEME MULTIPROCESOR , Teza de doctorat, UPB,
2012;
_
• [Dita14] Bogdan DITA - MODELAREA ELECTROMAGNETIC A MULTIPROCESOR A
MICROSISTEMELOR INTEGRATE , Teza de doctorat, UPB, 2014.
• [Dan15] Daniel Vasile DAN - Analiza, caracterizarea si optimizarea electromagnetilor pentru
acceleratoarele de particule, Teza de doctorat, UPB , 2015.
• [Lup16] Sorin LUP - Electromagnetic Modeling of Radio Frequency Micro-Electro-Mechanical
Systems – Multipysics aspects Teza de doctorat, UPB.
• [Ciuprina16] Gabriela Ciuprina, Daniel Ioan, Aurel-Sorin Lup, Dragos Isvoranu, Anton Duca,
Alexandra Stefanescu , Compact Reduced Order Multiphysics Models for Electrostatic
Actuated MEMS Switches, SCEE 2016
• [Duca 16a] Anton Duca, Laurentiu Duca, Gabriela Ciuprina and Daniel Ioan, Neighborhood
strategies for QPSO algorithms to solve benchmark electromagnetic problems, ECAT 2016
ANEXA A: algoritmi numerici
rapizi
Multigrid (MG), Fast Multipole Method (FMM), The Multilevel Fast Multipole
Algorithm (MLFMA), Adaptive Finte Element Method (AFEM), Parallel MOR
(Krylov, POD, Discrete Empirical Interpolation Method – DEIM/
• Legea lui Moore pentru

software/hardware
• Evidentiaza dualitatea
software/hardware
_
Note:
• nu se poate face
deosebirea intre algoritmii
CSE si cei din HPSC.
• 5 din “Top 10 algorithms of
The century” [Top10] sunt
solveri.
Multigrid (MG)
• Multigrid este o metoda numerica de rezolvarea a ecuatiilor cu derivate partiale (PDE, in mod
tipic eliptice) bazata pe folosirea unei ierarhii de retele de discretizare (multi rezolutie). MG
poate fi folosit si la preconditionare.
• Ideea centrala a metodei este de a accelera metodele iterative de relaxare prin corectia
solutiei numerice realizata rezolvand problemei pe o retea grosiera. Corectia se reia recursiv
folosind retele tot mai grosiere pana cand problema se poate rezolva exact cu un cost redus.
O generalizare este AMG (Algebraic MG).
• MG se aplica in mod tipic ecuatiilor eliptice de tip Poisson, dar poate fi aplicata si ecuatiilor
parabolice, sistemelor de ecuatii nesimetrice sau neliniare.
• MG se aplica atat discretizarilor MDF cat si MEF, fiind tehnica de solutionare iterativa cea mai
rapida cunoscuta.
_
• Algoritmul MG are etapele (care se repeta recurent sau secursiv (ciclu V, W):
– Netezirea (Smoothing) – de exemplu prin cateva iteratii Dauss-Seidel
– Restrictia (Restriction) – se transfera eroarea reziduala pe o retea grosiera
– Interpolarea ( Interpolation or prolongation) – transferul de la reteaua grosiera la cea fina.
Algoritmul MG
https://www.mcs.anl.gov/petsc/documentati
on/tutorials/Columbia04/DDandMultigrid.pdf
MG se paralelizeaza mai eficient astfel:

- rezolvarea prin metoda directa si
netezirea pe gridurile grosiere pe CPU
- netezirea pe gridurile fine pe GPU
http://www.mgnet.org/mgnet-codes.html
The fast multipole method (FMM)
• FMM este o tehnica numerica ce a fost dezvoltata pentru a acelera calculul
interactiunilor indepartate in problema celor n corpuri (n-body problem).
• Se folosesc dezvoltarile multipolare (cu momentele Qlm) pentru a aproxima efectul
unei distributii arbitratre cu o suma de surse punctiforme:
• FMM este aplicata cu succes pentru acelerarea rezolvarii iterative in metoda

momentelor (MoM) din electromagnetismul computational. Aproximand interactiunile
_
indepartate scade necesarul de memorie, iar efortul de calcul pentru inmultirera
matrice-vector din fiecare iteratie se reduce de la ordinul patratic O(N2) la ordinul
liniar O(N). In felul acesta, matricile din BEM care sunt pline sunt tratate intr-o
maniera similara celor rare.
• Problema celor n corpuri se intalneste in astronomie/cosmologie, unde astrele sunt
aproximate prin puncte materile care interactioneaza prin forte gravitationale, miscara
lor fiind descrisa de sistemul de ecuatii diferentiale:
http://http.developer.nvidia.com/GPUGems3/gpugems3_ch31.html
• Ecuatii similare descriu miscarea corpurior sub actiunea fortelor coulombiene

FastCap si altele
Coduri si suport teoretic pentru FastCap, FastHenry, FastImp, etc.
http://www.rle.mit.edu/cpg/research_codes.htm RLE Computational Prototyping Group
http://www.rle.mit.edu/cpg/research_pubs.htm
http://materias.fi.uba.ar/6209/EMC08/download/FastCap.pdf FastCap
http://www.rle.mit.edu/cpg/publications/pub37.pdf Multiscale - vawelet
https://cseweb.ucsd.edu/classes/wi06/cse291-b/slide/let5/extract.pdf Inteconects
http://www.rle.mit.edu/cpg/publications/pub53.pdf FastHenry
http://www.fastfieldsolvers.com/ FastFieldSolvers
http://www.rle.mit.edu/cpg/documents/pub209.pdf FastImp
FastCap
Foloseste ecuatii integrale rezolvate FastHenry
Regimul MQS cu FastImp
_ cu GMRES, accelerate prin FMM .
La distanta mare panourile se vad ca discretizare in filamente
(PEEC) cu Lij = Foloseste ecuatii integrale cu nuclee
o sarcina punctiforma
dependente de frecventa pentru a
In abordarile ierarhice
extrage caracteristica de frecventa a
panourie sunt gruate in
impedantei, folosind tehnica GMRES cu
clustere structurate in arbori cu
precorectie pFFT . Elementele matricei
ordine FMM diferite pe fiecare nivel.
Circuitul este analizat cu sunt:
curenti ciclici folosind
GMRES preconditionat
FMM
Extractia rapida a capacitatilor prin
precorectie pFFT paralelela
Capaictatile a m conductoare sunt descrise de matricea simetrica C, de dimensiune mxm, in care
coloana j contine sarcinile conductoarelor cand conductorul j are potential unitar si celelalte sunt
puse la masa. Sarcina pe suprafata S a conductoarelor este solutia ecuatiei integrale:
ρ s (r ' )dA' 1 n qj n
V (r ) = ∫
S 4πε r − r '
; r ∈ S ⇒ Vk =
πε
∑ = ∑ Pkj q j ⇒
0 4 0 j =1 rk − r j j =1
dA' 1
v = Pq; v, q ∈ R n , P ∈ R n×n , cu Pkj = ∫ → ;
Sj 4πε 0 A j rk − r ' 4πε 0 rk − r j
S-a descompus S in n panouri mici, cu sarcinile q = [q1, q2,..,qn]T, distribuite constant pe fiecare.si
fost plasat punctul r in centrurl fiecarui panou k=1,2,…,n , de potential Vk cunoscut.
_
Sistemul liniar de ecuatii Pq=V se rezolva iterativ
cu GMRES, in care Pq este calculat rapid (cu
ordinul O(nlogn) ) folosind interactiunea directa
in apropiere (in cubul gri) si FFT in rest (sarcina
este repartizata in noduri iar potentilaul armonic
din noduri este apoi interpolat in centrul
panourilor).
Cea mai scumpa operatie este produsul Pq,
paralelizat prin repartizarea gridului pe
procesoare.
A.N. Curs Master. Calcule stiintifice de inalta performantaTimpul

http://www.rle.mit.edu/cpg/publications/pub71.pdf 184de calcul [s] © Daniel Ioan 2016
The Multilevel Fast Multipole
Algorithm (MLFMA)
MLFMA este dedicat analizei imprastierii campului EM pe conductori de forma arbirara.
• O varianta pralela este prezentata in: [Ergul08] Efficient Parallelization of the Multilevel Fast
Multipole Algorithm for the Solution of Large-Scale Scattering Problems
http://abakus.computing.technology/JP/JP42.pdf
• Suprafata conductorului este discretizata in N (peste 40 milioane) panouri, iar ecuatia integrala
de tip CFIE (combined-field integral equation) da sistemul liniar complex cu matrice plina:
in care an sunt coeficentii ce determina distributia

_
superficiala a curentului J(r).Functiile de baza bn
sunt de tip RWG (Rao-Wilton-Glisson
http://ece-research.unm.edu/summa/notes/In/0388.pdf) .
Expresiile pentru Zmn calculate cu CFIE sunt date in
http://abakus.computing.technology/JP/JP35.pdf
Interactiunile la distanta sunt aproximate ierarhic cu FMM:
Sistemul este rezolvat iterativ in paralel (in 290min.
pe un sitem cu 16 noduri si 71GB RAM), cu
O implementare de referinta cu ordin O(NlogN) a abordarii
metoda BiCGstab (de tip Krylov, din PETSc), multilevel folosita pentru determinarea RCS (Radar Cross
preconditionata pe blocuri diagonale (DBP). Secton) este FISC (Fast Illinois Solver Code):
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.
7.8263&rep=rep1&type=pdf
Adaptive Finite Element (AFEM)
Rafinarea h: in MEF eroarea numerica este majorata de: u − uh 2
L
≤ Ch p +1 u H p+1 = O(h p +1 )
in care h este norma retelei, p este ordinul elementelor (gradul polinoamelor de interpolare).
Cresterea acuratetii solutiei si accelerarea convergentei se realizeaza prin scaderea parametrului h,
realizata prin rafinarea retelei. In cazul elementelor liniare (p=1), convergenta este patratica O(h2),
dar in practica, singularitatile scad ordinul la unul liniar O(h), caz in care nu se justifica elemente de
ordine mai mari p>1. O metoda de recuperare a deprecierii este de a folosi un algoritm auto-adaptiv
de rafinare a retelei (AMR – Adaptive Mesh Refinement), in care se porneste de la o retea
grosiera si se rafienaza elementele care au o eroare inacceptabila. Rafinarea adaptiva este mai
eficienta decat cea uniforma, deoarece are convergenta de ordin mai mare:
Rafinare adaptiva
Adaptive Finite Element (AFEM)
• Rafinarea p: o alta metoda de accelerarea a convergentei consta in cresterea
ordinului p al elementelor finite. Acesta metoda se poate aplica doar daca solutia
exacta este suficient de neteda, de exemplu daca se rezolva ecuatia Laplace, intr-un
domeniu cu frontiera si conditii de frontiera netede.
• Pentru a recupera deprecierea determinata de singularitati se foloseste rafinarea hp
care combina rafinarea geometrica adaptiva cu rafinarea ordinului.
• Algoritmii AFEM de rafinare hp sunt super-convergenti, asigurand o scadere
exponentiala a erorii fata de numarul gradelor de libertate.
[Ioan12]; https://en.wikipedia.org/wiki/Hp-FEM Rafinarea h – cu albastru; rafinarea p –
cu rosu, rafinarea hp – cu verde
_
Rafinarea hp: numerele din fiecare element
reprezinta ordinul elementlui
Concluzia ultimilor algoritmi: organizarea ierarhica a

datelor aduce un enorm castig in perfotmanta
x = Vxr
Krylov MOR
• Modelul de ordin redus al unui sistem dinamic se poate obtine prin proiectia
realizata de transformarea liniara V, care reduce vectorul variabilelor de stare de la
dimensiunea n la dimensiunea q<<n: x=Vxr
• Inmultind ecuatiile de stare cu transpusa matricei W de dimensiune tot qxn, cu
proprietatea WTV=I (deseori W=V), se obtine sistemul redus de dimensiune q:
 x& = Ax + bu; Vx&r = AVxr + bu;  x&r = Ar xr + br u;

= ⇒ ⇒ = = =
T T T T
 x Vx   cu A W AV , b W b, c c V
= = =
T r T T r r r
 y c x  y c Vxr  y cr xr
• Krylov Subspace methods sunt o clasa de metode prin care sistemele de mari
_
dimensiuni descrise in domenul timpului prin ecuatii de stare sunt reduse prin
proiectare pe un subspatiu de tip Krylov, care este spatiul liniar generat de vectorii
K q ( A, r ) = span{r, Ar, A 2r,..., A q −1r} O proiectie pe acest subspatiu de dimensiune q
este un polinom de matricea A. Ele sunt folosite in rezolvarea iterativa a sistemelor
liniare, functii mariceale, valorilor proprii si in reducerea ordinului sistemelor liniare.
• Daca matricea V este o baza a spatiului Krylov Kq (A−1, A−1b), iar Ar este nesingulara,
atunci sistemul original si cel redus au primele q moment egale. Momentele sunt
coeficientii seriei Taylor ai functiei de transfer.
• Daca W este o baza a unui spatiu Krylov la stanga Kq (A−T, A−Tc), atunci cele doua
sisteme, au primele 2q moment in origine egale (procedura bilaterala).
Parallel Krylov
• Vectorii de baza din definitia substatiului Krylov tind sa devina aproape liniar dependenti chiar
si pentru valori mici ale lui q. Algoritimii robusti genereaza baze cat mai apropiate de una
ortogonala, folosind procedurile Lanczos sau Arnoldi. In algoritmul Arnoldi, vectorii de baza sunt
ortogonalizati prin tehnica Gram–Schmidt, iar Lanczos este bilateral (PVL fiind o varianta).
http://alexandria.tue.nl/extra2/200513451.pdf .
• Daca dezvoltarea are loc in punctual de la infinit, atunci
spunem ca am realizat o aproximare Pade, iar daca punctul de
dezvoltare este s0 cu pozitie arbitrara in planul complex, atunci
spunem ca avem o “interpolare rationala”.
• O varianta robusta a tehnicii Arnoldi este “PRIMA: passive
_ reduced-order interconnect macromodeling algorithm”, iar o
versiuen paralela a acestei proceduri este prezentata in
https://www2.mpi-
magdeburg.mpg.de/mpcsc/benner/pub/AntoniniDeLucaBenner_ACES2015_1.pdf
• Dezvoltarea multipunct asigura o acuratete pe o plaja mai
mare de fecvente de interes. Paralelizarea se face prin
repartizarea de master a frecventelor de dezvoltare catre
workeri, ca in [Lazar12].
• Paralelizrea tehnicii Krylov este discutat si in
http://www-users.cs.umn.edu/~saad/PDF/umsi-95-276.pdf
https://www.irisa.fr/sage/bernard/publis/cari94.pdf
POD MOR
• Proper Orthogonal Decomposition (POD) este o metoda (de tip “data-driven”), bazata pe
procesarea semnalelor de iesire esantionate in timp, si mai putin pe structura sistemului. Asta o
face usor de folosit, cu un cost redus, chiar daca nu are acuratete maxima.
• Fie un sistemul neliniar descries de o colectie de esantioane ale solutiei (vectorii de stare in
momente successive de timp).: S = [x(t1), x(t2),..,x(ts)] care este descompusa in valori singular
(SVD) S= UΣVT (cu Σ diagonala si U,V cu coloane ortonormale) si apoi trunchiata prin retinerea
doar a primelor k, cele mai importante valori singulare, se identifica un subspatiu din cel de stare in
care se afla traseul dependentei fata de timp a solutiei. Celelalte directii ale spatiului starilor sunt
practic combinatii liniare ale elementelor din subspatiul selectat, deci pot fi aproximate cu directii din
acest spatiu. In consecinta, x(t) ≈ Ukξ(t) este aproximat cu un vector k-dimensional ξ(t), iar sistemul
redus
_ are ecuatia de stare Uk dξ(t)/dt = f(Ukξ(t), u(t)) sau echivalent dξ(t)/dt = Uk* f(Ukξ(t), u(t)).
• Vectorii singulari U, V identifica componentele principale
ale matricei S (cele puternic liniar independente).
https://www.cs.cmu.edu/~venkatg/teaching/CStheory-
infoage/book-chapter-4.pdf Concluzia este ca prin
ierarhizarea datelor, SVD permite eliminarea componentelor
neesentiale , crescand performanta claculelor. Paralelizarea
SVD in: https://www.irisa.fr/sage/bernard/publis/SVD-
Chapter06.pdf iar descompunerea SVD pe sisteme GPU in
http://www.pascal-man.com/navigation/faq-java-
browser/GPU/Sheetal09Singular.pdf
Discrete Empirical Interpolation
Method (DEIM)
DEIM (Metoda Interpolarii Empirice Discrete) este o metoda pentru reducerea complexiatii
sistemelor si functiilor nelinire, o completare la metoda POD
https://pdfs.semanticscholar.org/9298/debbd1e37f924a9dd121a40b9725220375bc.pdf
• Se considera sistemul dinamic neliniar (cu A de dimensiune nxn) :
• Sistemul de ordin redus are forma:

• Matricea de proiectie Wk de dim nxk, cu k<<n se detrmina cu POD sau Krylov.
Se constata totusi ca termenul neliniar are un ordin dependent de n. Este dficultatea majora a
reducerii sistemelor neliniare prin proiectie: Solutia este sa se aproximeze
_termenul neiniar cu o functie independenta de n,
in care c(t) se obtine prin interpolare,

iar U este o matrice determnata cu POD de dimensiune nxm cu m<<n.
• Interpolarea functiei neliniare
Din matricea U de dim nxm a sistemului supraderminat
se selecteaza m linii (cele cu reziduul maxim)
si se rezolva sitemul liniar echivalent cu
T
In care P este matricea de selectie a liniilor alese. Interpolarea functiei neliniare consta in proiectia
oblica relizata prin P.
Rezulatatul este un model redus in care partea neliniara are o dimensiune ce nu depinde ne n.
ROM se aplica si PDE, nu numai ODE.
ANEXA B: instrumente
pentru HPC
Editoare, Compilatoare si biblioteci, Editarea legaturilor, Make , Controlul
versiunilor, Depanare, Testare, Profil, Latex.
Despre metodologia de dezvoltare software, puteti citi mai mult in:

http://codecourse.sourceforge.net/materials/The-New-Software-Development-Methodology.html
Editoare de texte, Vim
• vi/Vim Editor http://www.vim.org/
• Emacs Editor http://www.gnu.org/software/emacs/
• gEdit Editor http://projects.gnome.org/gedit/
• nano Editor http://www.nano-editor.org/
• gVim Editor http://vimdoc.sourceforge.net/htmldoc/gui.html
• Kate Editor https://kate-editor.org/
.Manualul Vim:
ftp://ftp.vim.org/pub/vim/doc/book/vimbook-OPL.pdf
Functii Vim:
_
• Completare, comparare, reunire de fisier (vimdiff);
• Sistem help integrat, diferite stiluri de indentare automata, veririficare paranteze;
• Manipulare de expresii regulate, si limbaj de script (nativ si Perl, Python, Ruby, Tcl, etc.)
• Interfata garfica GUI (gvim), recunoastereea structurilor de program si colorarea cuvintleor cheie;
• Mediu integrat de dezvoltare (unele functii IDE - Integrated Development Environment);
• Arhivare si comprimare fisiere (cu gzip, bzip2, zip, sau tar) in diferite formate si protocoale de
retea (SSH, FTP, si HTTP) ;
• Prezervarea starii sesiunii de lucru, verificare shell;
• Separare ferestre multiple (orizontale si verticale); Suport Unicode si muti-limbaj;
• Cautare si istoria pozitiei cursolului, undo/redo pe mai multe nivele
Editorarele sunt folosite pentru cod, dar si pentru alte fisiere de text, de spcificatii, design si documentare.
Instrumentele GNU
Arhitectua Linux:
• Hardware: CPU, RAM, HDD…
• Kernel: functiile de baza ale SO
• Shell: interfata cu aplicatiile
• Utilitare: cc, vi, cd, grep, date,...
Pentru lista alfabetica a comenzilor
vezi http://ss64.com/bash/
• GNU toolchain este un set de
_instrumente realizate in proiectul GNU:
• GNU make: compilare si construire automata

• GNU build system (autotools): Autoconf, Automake si Libtool
• GNU Compiler Collection (gcc): o suita de compilatoare pentru diferite limbaje de
programare C, Objective-C, C++, Fortran, Java, Ada
• The GNU C Library (glibc) contine C standard library; GNU C++ Library (STL);
• GNU Binutils: o suita de utilitare pentru editarea legaturilor si asamblare
• GNU Bison: un generator de parser, utilizat deseori cu analizorul lexical Flex
• GNU Debugger (GDB): depanator de cod https://en.wikipedia.org/wiki/List_of_GNU_packages
•A.N. Curs Master. Calcule stiintifice de inalta performanta 194 © Daniel Ioan 2016
Biblioteci de functii
Acestea extind puterea limbajelor de programare, introducand noi functii fara de care
programarea ar fi extrem de ineficienta.
• Standard C library: manipulare stringuri, calcule (functii) matematice, i/O, socket,
mangementul memoriei, apeluri sistem https://en.wikipedia.org/wiki/C_standard_library
• GNU Portable Threads (pth) – POSIX-compatible, permite paralelizarea multi-nucleu
• C++ Library (STL): se refera la structuri abstracte de date de tip algoritmi,
contianere, functionale si iteratori. Este o bibloteca cu patru obiective: programare
generica, abstracitzare fara pierderea eficientei si a valorii semnatice, ce a influentat
puternic progrmarea OOP din C++. https://en.wikipedia.org/wiki/Standard_Template_Library
_• GUI, Windows,https://en.wikipedia.org/wiki/List_of_platform-independent_GUI_libraries
• GSL - GNU Scientific Library - https://www.gnu.org/software/gsl/ Basic mathematical

functions; Complex numbers; Polynomials; Special functions; Vectors, Matrices,
Sorting, BLAS, Linear algebra, Eigensystems, FFT, Numerical integration, Random
number generation, Statistics, Monte Carlo integration, Simulated annealing, Ordinary
differential equations, Interpolation, Numerical differentiation, Chebyshev approx.,
Series acceleration, Hankel transform, Root-finding, Minimization, Least-squares
fitting, Nonlinear least-squares fitting, Physical constants, IEEE floating-point
arithmetic, Spline, Sparse matrix. Contine cei mai importanti A.N.
• Alte biblioteci Matematice: https://en.wikipedia.org/wiki/Netlib https://sourceforge.net/projects/math-atlas/
.https://en.wikipedia.org/wiki/List_of_numerical_libraries https://software.intel.com/en-us/intel-mkl
GNU Make
• make este un utilitar care care controleaza managementul procesului de construire a unui
proect software
• make examineaza fisierele sunsa si cele obiect, pentru a identifica acele fisiere surse ce trebuie
recompilat pentru a genera noi fisiere obiect si lanseaza comanda de recompilare
• Pentru acesata este nevoie de in fisier Makefile care sa spuna utilitarului make ce sa faca.
• Acest fisier contine o serie de reguli pentru construire si tintele asociate lor, precum si
dependentele, folosind comenzi de forma:
tinta: dependente
<TAB> comanda
tinta
_ este numele fisierului care trebuie generat iar dependinte este numele fisierului(lor) de care
depinde fisierul tinta.
• make cauta fisierele tinta si verifica in ce masura sunt
actualizate, folosind regulule descrise in fisier, apoi sunt
excutate actiunile care duc la indepinire acestor reguli.
• In makefile se pot folosi macro-uri numite cu majuscule si
definite prin MACRO1=valoare :
$(MACROx) $(MACROy) optiuni $(MACROz) ... $(MACROxx)
http://www.slideshare.net/a_elarabawy/cu-cmp445-
lec13introductiontotoolchain1
Exemplu de makefile
Codul sursa ex1.c
============================
#include <stdio.h> Rezultatul executiei comenzii make:
#include <math.h>
int main() { root@slax:~# make ex1
int u=45; gcc -c -Wall ex1.c
double res; gcc -lm -Wall ex1.o -o ex1
res = sin((u*3.14)/180); root@slax:~# ./ex1
printf("sin(%d) = %lf\n", u, res); sin(45) = 0.706825
return 0; root@slax:~#
}
============================
_ Fisierul makefile • Este compilat, linkat si executat un cod
============================ sursa scris in c, aflat in fisierul ex1.c
OBJS = ex1.o
• Codul obiect generat este ext1.o
CC = gcc
CFLAGS = -c -Wall • Atat compilarea cat si editarea legatruilor
LFLAGS = -lm -Wall este realizata de, gcc dar folosind optiuni
ex1.o: ex1.c diferite: -c -Wall pentru compilare si -lm -
$(CC) $(CFLAGS) ex1.c
ex1: $(OBJS)
Wall pentru genrarea executabilului
$(CC) $(LFLAGS) $(OBJS) -o ex1 • La sfarsit se sterg fisierele obiect, cu
clean: extensia o.
rm -rf *.o ex1
================================
Controlul versiunilor
In dezvoltarea programelor, acestea trec succesiv prin mai multe faze (versiuni, care
primesc cate o “stampila” cu data generarii. Deosebim revizii majore, indexate cu v1,
v2, v3,.. Sau revizii minore, indexate cu doi indici v1.1, v1,2, … etc.
De multe ori este necesara revenirea la o versune mai veche, motiv pentru care
versiunile sunt arhivate. Controlul versiunilor este esential in proiectele colaborative.
Managementul versiunilor (cod C, Matlab, HTML, LaTeX. ) este realizat de programe
specializate https://en.wikipedia.org/wiki/Comparison_of_version_control_software
Controlul distribuit al versiunlor intampina dificultati similare ca in programrea paralela cu
memorie partajata (curse, sincronizare) https://en.wikipedia.org/wiki/Version_control
Cele mai cunoscute pachete software pentru controlul versiunilor sunt:
_
• Concurrent Versions System (CVS) http://savannah.nongnu.org/projects/cvs
• GNU Bazaar (bzr) http://bazaar.canonical.com/en/ http://doc.bazaar.canonical.com/latest/en/mini-tutorial/
• Subversion (SVN) https://subversion.apache.org/
• Git https://git-scm.com/
CVS nu mentine mai multe copii ale codurilor sursa ci o singura copie si toate
modificariele aduse ei. Cand un dezvoltator are nevoie de anumita versiune aceasta
este recostruita din modifcarile inregistrate. CVS tine urmam modificarilor aduse de
fiecare dezvolatator in drectoare separate. Cand se doreste v++, toate modificarile
echipei sunt fuzionate intr-o arhiva comuna (repository), Modificarile individuale pot fi
facute in repository, daca sunt asumate de programator, cu o comanda “commit”.
Exemplu de utilizare CVS
• Creaza repository: cvs -d ~/cvsroot init
si adaugati o linie in fisierul .cshrc sau .bashrc, ce seteaza variabila CVSROOT la $HOME/cvsroot,
pentru a spune CVS care este directorul repository implicit.
• Adauga un proiect la repository si informeaza CVS (poate fi apoi sters):
mkdir ~/cvsexample
cd ~/cvsexample
cvs import -m "dir structure" cvsexample yourname start
cd ~
rm -r cvsexample
• Check out proiect si creeaza o copie de lucru CVS:
cd ~
_ cvs checkout cvsexample
• Adaugare fisier si eventual “commit”:
cd ~/cvsexample
cvs add sample.tex
cvs commit -m "original file" sample.tex
• Lucru la proiect: update (actualizeaza directorul de lucru conf. repository), diff
(vizualizeaza modificari), commit (se lanseaza editor, salvarea incremnteaza v)
cvs update
cvs diff sample.tex
cvs commit sample.tex http://www-mrsrl.stanford.edu/~brian/cvstutorial/quicker.html
Testarea, depanarea si masurarea
performantelor
• Testerea este o etapa important a procesului de dezvoltare sofware
(https://en.wikipedia.org/wiki/Software_development_process ). Ea consta in investgarea calitatii produsului,
existenta erorilor (software bug) si masura in care acesta satisface specificatiile, raspunde corect si in timp
acceptabil la diferite intrari, poate fi instalat si executat in mediile tinta si rasunde asteptarilor utilizatorilor.
• Se recomanda ca strategiile de testare sa fie definite odata cu specificatiile. O metoda moderna de dezvoltare
este Agile https://en.wikipedia.org/wiki/Agile_software_development
• Testarea se realizeza in diferite moduri: functional (black-box), strctural (white-box), hibrid (gray-box) si la
diveirte nivele: a unitatilor, a integrarii, a interfetelor si la nivelul global al sistemului. Ea poate fi realizata
manual sau automat (uneori continuu, pe masini dedicate, fofosind scripturi care simuleaza utilizaotrii, cazuri
de test-benchmark), pe parcursul dezvoltarii sau doar la final. https://en.wikipedia.org/wiki/Software_testing In
unele metode de dezvoltare, unitatile de testare se concep inaintea scrierii codului, iar unitatea este acceptata,
daca aceasta trece testele. Testarea de calitate se face de persoane specializate, nu de programatori.
• _ Depanarea (debugging) este procesul de cautare si eliminare a erorilor de programare, care impiedica
operarea corecta a programului. Pentru a ajuta programatorul, in acest proces se folosesc instrumente
software dedicate. https://en.wikipedia.org/wiki/Comparison_of_debuggers
• GNU Debugger (GDB) poate fi folosit pentru diverse limbaje, atat sub Unix cat Windows. El permite opriri
controlate, monitorzarea diferitelor variabile si modificarea valorilor lor, Permite apelul de functii, si chiar
executia inversa, pentru a intelege ce s-a intamplat ,inainte ca un program sa esueze. GDB se lanseaza cu
comanda: gdb program iar pentru GUI se folosesc editoare si IDE, cum sunt EMACS, Vim, DDD sau
Eclipse (http://clewn.sourceforge.net/ https://www.gnu.org/software/ddd/
http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/mars2) Depanarea programelor
paralele ridica probleme deosebite (http://heather.cs.ucdavis.edu/~matloff/pardebug.html )
• Evaluarea performantelor programelot se face cu instrumente dedicate ("program profiling“), care determina
memoria necesara si timpul pentru executia diferitelor parti, frecventa si durata apelurilor de functii, in vederea
optimizarii performantelor programului Un exemplu este GNU gprof cu dificultati specifice in cazul paralel
https://web.eecs.umich.edu/~sugih/pointers/gprof_quick.html https://computing.llnl.gov/tutorials/performance_tools/
Exemplu de utilizare gprof
•Compilare pentru profil:
unix% g++ -g -pg -o kruse kruse.cc
creeaza executabilul kruse din codul sursa kruse.cc cu optiuni de depanare si profil (-pg)
•Generare gmon.out
executia programului compilat cu optiunea -pg genereaza un fisier numit gmon,out
•Executie gprof
unix% gprof program-name [ data-file ] [ > output-file ]
numele implicit pentru data-file este gmon,out iar output-file este implicit iesirea standard, iar
pentru examinare ulterioara se recomanda un apel de forma
unix% gprof kruse > kruse.output
_ •Interpetarea rezultatelor (fiserul de iesire este un text ce poate fi citit cu vim)
Contine timpul si numarul de apeluri pentru fiecare functie :
Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls us/call us/call name
37.50 0.15 0.15 48000 3.12 3.12 Life::neighbor_count(int, int)
17.50 0.22 0.07 _IO_do_write
10.00 0.26 0.04 __overflow
7.50 0.29 0.03 _IO_file_overflow
………………………………………………………………………………………
0.00 0.40 0.00 1 0.00 170000.00 main
Documentarea
• Un alt aspect important in dezvoltarea programelor este documentarea.
• Se deosebesc urmatoarele categorii de documente:
Specificatii - descrie fuctiile programului ce va fi realizat;
Structura – descrie arhitectura programului, relatia cu mediul si principiile ce vor fi f
olosite in proiectarea componentelor software. UML (Uninfied Modeling Language) poate fi de folos
http://www.uml.org/ http://modeling-languages.com/uml-tools/ http://argouml.tigris.org/
Tehnica – documentarea codului, algoritmior, interfetelor si API folosite;
Maualele de utilizare – sunt destinate utilizatorilor finali, adminstratorilor care vor
insatala produsul si personalului de mentenanta;
Documentatia de maketing/valorizare, care analizeaza cerintele pietei si modul in care
va fi realizat marketingul. In cazul prgramelor stiintiintifice se vor redacta lucrari care descriu
_
aplicatii, performantele si rezultatele programului.
• Documenatia tehnica poate fi inclusa in codul sursa, sub forma de comentarii sau separata (de
obicei sub forma unor referinte pentru fiecare unitate, ordonate apoi alfabetic). Programe
specializate cum este Doxygen http://www.stack.nl/~dimitri/doxygen/ genereaza automat
documentatia (in format on-line HTML, LaTeX, RTF, PDF, sau Unix man pages), pe baza
comentariilor din codul sursa, ca in exemplul de functie: /** <A short one line description>
<Author(s), Date, Change history>
Folositi in programare regulile profesionale de stil:
https://en.wikipedia.org/wiki/Best_coding_practices <Longer description>
https://msdn.microsoft.com/en-us/library/aa260844(v=vs.60).aspx <Description of function’s goal, method>
https://code.tutsplus.com/tutorials/top-15-best-practices-for-writing-super- < function's input parameter >
readable-code--net-8118 < Description of the return value> */
LaTeX
• LaTeX este un sistem de pregatirea documentelor de inalta calitatate tipografica. Este
aplicat cu succes la realizarea documentelor tehnice si stiintifice de orice specialitate,
fiind standardul de facto pentru publicatiile stiintifice. https://www.latex-project.org/
• LaTeX separa prezentarea de continut, astfel incat autorii se pot concentra pe
continut, iar aspectul vizual rezulta automat de cea mai buna calitate. Autorii folsosec
conceptele logice uzuale: capitol, sectiune, tabel, figura, etc. lasand LaTeX sa se
ocupe de plasarea lor in pagina si de alegera fonturilor, in acord cu stilul ales: article,
book, report, etc. LaTeX foloseste un markup language pentru a descrie documentu
si se extinde pentru dezvolat noi formate cu un macro language. Acestea sunt
grupate in pachete, cum este amsmath sau Bibtex. https://tobi.oetiker.ch/lshort/lshort.pdf
_ • Structura fisierului de intrare:
• Pentru a creea un document LaTeX, se \documentclass [options]{class}
scrie un fisier, de ex. document.tex, \usepackage [options]{package}
folosind editorul preferat de texte. Acesta \begin {document}
este transferat (de obicei cu make) catre [\include{filename}]
LaTeX: latex documet.tex % comentarii
dvipdf documet.dvi
……. Text si \comenzi
converteste documentul din format dvi in pdf
\end {document}
Exemple de modele (template) pentru articolele IEEE:
http://www.ieee.org/publications_standards/publications/authors/author_templates.html
Exemplu latex
Fisirerul sursa LaTeX Documentul generat
O foarte scuta introdcere in LaTeX: :

https://www.cs.princeton.edu/courses/archive/spr10/cos433/Latex/latex-guide.pdf
ANEXA C: Tutorial dico –
distributed computing in LMN
• Dico este un program scris in Python+SSH de Stefan Puscasu in 2011 pentru a realiza calcule distribuite cu
modelul Master-Worker (implementat in maniera Client-server) pe reteaua LMN. Ele este executat pe statia
server (zet pe BluePC si tau pe ATLAS) care si transmite joburi (progame RCP) catre statiile din retea.
• Programul este util atunci cand trebuie executate calcule de mari dimensiuni, ce pot fi descompuse in probleme
mai mici, independente. Aceste subprobleme sunt indexate cu unul sau mai multi indici (1D, 2D,...). Scriptul va
fi executat pentru toate combinatiile posibile ale valorilor contoarelor, valorile lor vor fi transmise scriptului in
variabilelee $1, $2,... iar rezultatele vor fi scrise in iesirea standard precedate de prefixul REZ.
• Programul se afle pe server, pe care utilizatorul se logheaza cu SSH si il lanseaza cu comanda:
./server.py [-t<seconds>] <script_name> <counter1> [<counter2> [<counter3> ... ]]
- <seconds> este timpul "timeout" dupa care un worker care nu rapsunde este eliminat dupa lista celor active
(implicit 50 sec, valoare ce poate fi setata in parametrul TASKTIME din fisierul x_common.py);
- <script_name> este numele scriptului (cu direcotrul in care se afla, . Fiti siguri ca este executabil!)
_ - <counterN> contorul N>0 cu sintaxa <start>-<end>.
• Se recomanda ca valoarea "timeout" sa fie de cca 2-3 ori mai mare decat timpul maxim estimat pentru
rezolvarea unei subproblem. Se mai recomanda ca pentru fiecare problema particulara sa se foloseasca un
director dedicat, incare se afla atat scriptul specfic, cat si fisierele de intrare si iesire, ce vor fi grupate in
subdirectoare cu destinatii specifice Dupa lasarea cu succes este afisat mesajul 'Waiting for client requests‘
Dupa care utilizatorul lanseaza clienti (worker) pe statiile remote, folsind comanda:
/run_clients.py
tot de pe server, dar dintr-un termnal (window) diferit, si primeste mesajul: 'Running on host'.
• Odata lanasati,clientii vor cere de lucru, cereri vizibile in fereastra server.py in care vor fi vizibile si progesele
facute. Cand toate subproblemele au fost rezolvate, aici este afisat mesajul 'Nothing to be do, exiting' si
programul isi inchei executia dupa ce a plasat in directorul Run/ un raport in care sunt mentionate timpul si data
de start si terminare, precum si pentru fiecare subproblema, ce masina a rezolvat-o si in cat timp Acest raport
este realizat, chiar si atunci cand executia este oprita prin comanda Control/C.
• Fiecare subproblema (combinatie de indici) genereaza in directorul REZ/ un fisier de iesire cu numele
rez_<counter1>[_<counter2>[_<counter3>...]]_<machinename>
• Rezultatele din aceste fisiere poti fi asamblate intr-un singur fisier prin comanda (in exemplul nostru):
./MyWork/assemble.py
urmand ca fieserul asamblat sa fie MyWork/results. In timpul executiei, utlizatorul are posibilitatea sa afle
detalii despre stara executiei, cu comanda
inq.py
lansata pe server sau pe orice client, pentru a obtine un scurt raport privind numarul de taskuri incheiate, in
lucru si neatribuite inca. Comanda
inq.py 1
genereaza un raport mai detaliat cu starea fiecarui task.
_
Un exemplu unidimensional
Se caluleaza numarul de conditionare al unei serii de matirce patate aleatoare de dimensinea $1 * 100 Pentru
acesta se foloseste scriptul SSH numit "cli-script" cu continutul:
=======================================================================
#! /bin/bash
# First parameter ($1) is size of the matrix, in hundreds

octave --silent <<-EOF
matrixsize = 100*$1;
printf ("Computing conditioning for a matrix of size %d\n", matrixsize)
result = cond(rand(matrixsize, matrixsize));
printf("REZ%d %2.6e\n", matrixsize, result)
======================================================================
si scriptul auxiliar "anssemble.py":
================================================
#! /usr/bin/python
Import sys
import glob
import os
def SortKey(rezfile):
return int(rezfile.split('_')[1])
# Obtain the list of result files
fl = glob.glob("Rez/rez_*_*")
if fl == []:
print "No results found.“
_ # Sort it using the second field (separated by _) as key. This is the
# value of the first counter
fl.sort(key=SortKey)
outfn = "CondNumber/results"
F = open(outfn, "w")
for fil in fl:
f2 = open(fil, "r")
for lin in f2.readlines():
If lin.startswith('REZ'):
f.write(lin[3:])
f2.close()
f.close()
print "SUCCESS - output written to %s" % outfn
=================================================================
Acestea se afla in directorul CondNumber/. Executia pentru matricile de dimensiune 600, 700, ...1900 este lansata
de comanda
./server.py CondNumber/cli-script 6-19
urmata de
./run_clients.py
Dar comanda
./CondNumber/cli-script 7
poate fi folosit apentru testare si ar trebui sa afiseze REZ urmat de doua numere, dimensiunea matricei (700) si
numaurlde conditionare rezultat.
In final, comanda
./CondNumber/assemble.py
_data in prima fereastra genreaza fisierul de rezultate: CondNumber/results.

Calcule Stiintifice de Inalta Performanta - Daniel Ioan Upb Elth (2016)

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Calcule Stiintifice de Inalta Performanta - Daniel Ioan Upb Elth (2016)

Încărcat de

Drepturi de autor:

Formate disponibile

ALGORITMI NUMERICI

Calcule stiintifice de inalta

Daniel Ioan (daniel.ioan@upb.ro)

• Tehnici de calcul de inalta performanta (HPC=High

• Initial ele se foloseau pentru supercalculatoare, dar ulterior

• Evolutia memoriei RAM:

1.6. Arhitectura sistemelor HPC actuale: CPU, GPU,

Nr instructiuni/perioada, viteza de acces a memoriei

Procesoarele Intel pentru servere au trei nivele de cache,

Viteza teoretica de varf (theoretical peak performance) a unui procesor =

Efectul este accelerarea

Prin schimbarea buclelor, timpul de calcul scade de zeci de ori,

[Landau] pasi Matricea de 400x400 nu incape in cache

C Transpune matrice pe blocuri de dim max pasj x pasi

• Au 6-8 nuclee (cores) pe CPU

for (i=0; i<n; i++) /* paralel! */

• Daca p<n, fiecare procesor efectueaza mai multe operatii:

for (i=imin; i<imax; i++) P0 P1

cu valoarea asimptotica T1 Fs, cand p creste,

Accelerarea este functie afina de numarul de procesoare p!

• Legea lui Gustafson se refera la timp de executie fixat, dar

Viteza varf de exacutie (tinand cont si de viteza memoriei):

In consecinta, exista doua

Dezvoltarea echipamentelor si tehnologilor de interconectare avansate (Ethernet,

• Paralelismul cu granulatie fina (Fine–grain parallel): procesoarele (de

Conectarea GPU pe placile de baza

Arhitectura G80/Tesla Fermi Kepler Maxwell

• GPU are mai multe unitati de calcul decat CPU si o viteza

Totusi tendinta de viitor este de convergenta:

Intel Xeon X5550 CPU,

• Cu cele 14 noduri cu 28 CPU si 2 GPU care au un total de

• Concurenta este un concept general care nu necesita paralelismul

• Organizarea dupa: taskuri, descopunerea datelor si fluenta datelor

Paralelizarea taskurilor Paralelizarea datelor

Paralelizarea dupa fluenta datelor - presupune analiza dependentelor

• Asignarea: realizeaza Metodologia PCAM in 4 etape (Partition, Communicate,

– Pthread: POSIX Threads Programming – biblioteca functii C

scenariul 1. scenariul 2. .scenariul 3.

S=3 S=2 S=5

% Script care executa 3 instante in paralel

% Tablou distrinuit la workeri

In literatura se gasesc mai multe exemple de folosirea mediilor si limbajelor

Mai multe detalii si un exemplu de utilizare este prezentat in Anexa C.

intr-un tablou local. Una din problemele acestui

/* Varianta paralela spmd */

Granulatia mai fina creste echilibrarea, cu

Fork Task1 Join

Exemplu: sortare paralela

A.N. Curs Master. Calcule stiintifice de inalta performanta 86 © Daniel Ioan

Scheletii sunt functii de de nivel inalt folosite pentru paralelizare.

Casa lui Maxwell:

3.2. Aspectele HPC ale Metodei

rotrotH = − jµσωH in c.a.

cu conditii de frontiera Dirichlet nule

• MG- integrala Biot Savart-Laplace (BSL)

care se integreaza numeric:

Frameworks (Trilinos PETSc) vs

Poisson este o ecuatie de referinta pentru CSE.

preluand deci conditia de pe frontiera

Pentru a fi scalbil (rata de convergenta sa nu depinda pe nr.

Ri este operatorul de restrictie la subdomeniul i, iar R0 se

• Problema de camp EM pentru componentel pasive:

Cuplaj EM intre blocuri

e.g. >100 000 e.g. <100