Resurse de calcul și gestionarea resurselor

Modelul de resurse și resursele clasice

În această secțiune, îți vom oferi un cadru de gândire despre mediile de calcul care poate fi aplicat atât unui laptop, cât și scalat la supercalculatoare. La finalul acestei secțiuni, vei înțelege componentele fundamentale ale unui mediu de calcul și modul în care acestea se raportează unele la altele. Toate acestea sunt prezentate de Iskandar Sitdikov în următorul videoclip.

Modelul de resurse

Orice mediu de calcul clasic este construit din mai multe resurse interdependente care lucrează împreună pentru a rula aplicații eficient. Resursele-cheie includ de obicei:

• CPU (Unitatea Centrală de Procesare): CPU-ul este unitatea de procesare de bază care interpretează și execută instrucțiunile programului. Gestionează operații logice, aritmetice și de control, acționând practic ca „creierul" sistemului.

• Cache-ul CPU (L1, L2, L3): Acesta este cel mai rapid din sistem, construit direct în nucleul CPU sau foarte aproape de acesta. Stochează porțiuni mici de date și instrucțiuni de care CPU-ul are imediat nevoie. Diferitele niveluri (L1, L2, L3) reprezintă un compromis: L1 este cel mai mic și cel mai rapid, în timp ce L3 este cel mai mare și cel mai lent, dar tot cu ordine de mărime mai rapid decât RAM-ul.

• RAM (Memorie cu Acces Aleatoriu): Memorie volatilă care oferă stocare temporară și extinsă pentru instrucțiunile programului și datele utilizate activ. Asigură că CPU-ul poate accesa rapid informațiile necesare în timpul execuției, fără a depinde constant de dispozitivele de stocare mai lente.

• Stocare (locală și bazată pe rețea): Stocarea păstrează datele și software-ul chiar și când sistemul este oprit, oferind persistență pe termen lung pentru seturi mari de date și aplicații. În calculul de înaltă performanță, soluțiile de stocare trebuie să gestioneze cantități vaste de date științifice sau analitice cu viteză și fiabilitate. Stocarea locală include unități solid-state (SSD) și hard disk-uri (HDD), SSD-urile fiind preferate pentru latența mai mică și debitul mai ridicat. Pentru gestionarea datelor la scară largă, sistemele de fișiere paralele, stocarea în rețea partajată și sistemele bazate pe obiecte permit acces rapid pe mai multe noduri de calcul, în timp ce nivelurile de stocare în cloud și arhivare susțin retenția pe termen lung și scalabilitatea.

• GPU (Unitatea de Procesare Grafică): Deși inițial proiectate pentru randarea graficii, GPU-urile moderne sunt procesoare paralele puternice. Sunt utilizate pe scară largă pentru sarcini care necesită multe calcule simultane, precum învățarea profundă, simulările fizice și analiza de date la scară mare. Este important de reținut că GPU-urile nu înlocuiesc CPU-urile; CPU-urile dirijează logica programului la nivel înalt, iar GPU-urile accelerează pașii înalt paralelizați.

• Conexiuni/Magistrale: Acestea sunt căile de comunicație care leagă CPU-ul, memoria, stocarea și perifericele. Magistralele permit transferul de date și coordonarea între componentele sistemului, asigurând o comunicare fluidă în mediul de calcul. În sistemele HPC, componente precum CPU-urile, GPU-urile și dispozitivele de stocare sunt conectate prin interconexiuni de mare viteză care permit schimbul rapid de date. GPU-urile se conectează de obicei la sistem prin PCIe, o interfață standard cu mai multe benzi de date pentru o comunicare eficientă. Pentru performanțe mai mari, NVLink oferă o legătură directă de mare lățime de bandă între GPU-uri sau între GPU-uri și CPU-uri, reducând latența și accelerând sarcinile de lucru paralele.

• Sistemul de fișiere: Sistemul de fișiere organizează datele pe dispozitivele de stocare. Oferă o structură pentru stocarea, recuperarea și gestionarea fișierelor, permițând programelor și utilizatorilor să acceseze informațiile într-un mod consistent și logic.

Fiecare tip de resursă are propriile unități de măsură legate de performanță. De exemplu, CPU-urile sunt măsurate de obicei prin „nuclee" și „viteză de ceas". Când cumperi un laptop, specificațiile sale includ de obicei numărul de nuclee. Un concept similar se aplică nodurilor de calcul dintr-un centru de date, unde fiecare nod este asociat cu un număr specific de nuclee. Mediile de calcul care includ mai multe tipuri de resurse (CPU-uri, GPU-uri, chiar și QPU-uri) sunt denumite medii de calcul eterogene. Aceste configurații gestionează sarcini de lucru diverse mai eficient, valorificând punctele forte ale fiecărui tip de procesor. De exemplu, CPU-urile ar fi utilizate pentru sarcini generale, iar GPU-urile pentru procesarea paralelă. În contextul gestionării resurselor și al planificării — mai ales pentru mediile de calcul eterogene — pot fi necesare unități de măsură suplimentare față de cele descrise aici.

Pentru memorie, unitatea de măsură ar fi Mega/Giga/Terabytes.

Pentru plăcile grafice și alți acceleratori, unitatea de măsură depinde de context. Deși capacitatea lor de calcul reală este măsurată prin metrici granulare — numărul de nuclee de procesare, dimensiunea memoriei și lățimea de bandă a memoriei — în discuțiile de nivel înalt despre resursele unui cluster sau planificarea joburilor, GPU-urile și acceleratoarele similare pot fi cuantificate la nivel de dispozitiv prin numărul de dispozitive întregi alocate (de exemplu, trei GPU-uri).

Rețeaua/conectivitatea/magistralele sunt aspecte esențiale ale oricărei infrastructuri de calcul, deoarece dictează cât de rapid sunt transferate datele între componentele de calcul. De la CPU la cache-ul CPU-ului, la RAM, la cardurile PCI, la dispozitivele conectate în rețea — totul este comunicație și este esențial să ai un model mental precis al acesteia pentru a proiecta algoritmi înalt optimizați pentru HPC.

Scalarea resurselor clasice

High-Performance Computing (HPC) implică scalarea acestor resurse clasice pentru a obține timpi de procesare mai rapizi sau a crește cantitatea de date care poate fi gestionată simultan (de exemplu, pentru a mări dimensiunea spațiilor de soluții care pot fi explorate). Acest lucru poate fi realizat prin:

• Scalare verticală: Creșterea puterii resurselor individuale, cum ar fi utilizarea unui CPU mai puternic sau adăugarea de memorie suplimentară într-un singur nod fizic, unde un nod este o unitate a unui cluster de calcul care înglobează mai multe resurse de calcul.

• Scalare orizontală: Adăugarea de resurse suplimentare, cum ar fi mai multe CPU-uri sau GPU-uri, pentru a lucra împreună pe un singur nod sau, mai frecvent, pe mai multe noduri, permițând calcul distribuit.

Unele dintre conceptele de scalare din această secțiune vor fi aplicabile și secțiunii următoare despre resursele de calcul cuantic. Alte aspecte ale resurselor cuantice vor fi cuantificate în moduri noi.

Verifică-ți înțelegerea

Folosind descrierile de mai sus, deduce câteva avantaje și dezavantaje ale diferitelor abordări de scalare: verticală și orizontală.

Răspuns:

Pot exista multe răspunsuri corecte. Scalarea verticală este adesea mai simplă, mai ales dacă ai sarcini de lucru previzibile care vor necesita o cantitate fixă de resurse. Dar scalarea verticală ar putea fi mai costisitoare de actualizat, deoarece unitatea fundamentală de calcul nu poate fi descompusă la fel de ușor ca în scalarea orizontală. Scalarea orizontală este mai complexă de gestionat și uneori apar dificultăți sau latențe legate de conexiunile dintre noduri. Dar este mult mai adaptabilă la cerințele variabile de resurse și este modulară când sunt necesare actualizări.

Noul tip de resursă: QPU (Unitatea de Procesare Cuantică)

În această secțiune, vom introduce un nou tip de resursă — o resursă cuantică — și vom explora definiția sa, unitățile de măsură și conectivitatea la infrastructura clasică.

Definiția QPU

• Unitate de procesare cuantică (QPU): Un QPU include tot hardware-ul responsabil pentru acceptarea unui set de instrucțiuni cuantice executabile, sau a unui Circuit cuantic, și returnarea unui răspuns precis.

Aceasta înseamnă că QPU-ul include unul sau mai multe cipuri cuantice (de exemplu, Heron), componentele suplimentare din refrigeratorul cu diluție, cum ar fi amplificatoarele cuantice, electronica de control și resursele de calcul clasice necesare pentru sarcini precum păstrarea instrucțiunilor și formelor de undă în memorie, acumularea rezultatelor și viitoarea decodificare a corecției erorilor. Deși un refrigerator cu diluție este necesar pentru a realiza aceste sarcini, îl excludem din această definiție pentru a permite cazul în care mai multe QPU-uri se află în același frigider.

• Calculator cuantic: Un calculator cuantic este compus din QPU plus resursele de calcul clasice care găzduiesc mediul de execuție.

• Mediu de execuție: Combinația de hardware și software care face posibilă rularea unui program.

Straturi în circuitele cuantice

Atât în calculul clasic, cât și în cel cuantic, procesele pot fi executate secvențial sau în paralel. Deoarece qubiții au un spațiu de stare bogat față de biții clasici, uneori are sens ca mai multe Gate-uri cu un singur qubit să fie executate pe un qubit în secvență (cum ar fi un Gate R_x urmat de un Gate R_z). Deoarece entanglementul între qubiți este esențial pentru calculul cuantic, este de asemenea obișnuit ca un Circuit cuantic să aibă un set de Gate-uri de entanglare acționând pe mulți qubiți. Acești factori și alții fac obișnuită identificarea proceselor care pot fi executate în paralel la scara operațiunilor individuale de Gate dintr-un Circuit cuantic. În calculul clasic, paralelismul la nivel de bit este de asemenea posibil, dar mai puțin frecvent considerat la nivel de Gate; este mai obișnuit să se facă referire la procesele paralele și secvențiale la o scară mai mare.

În calculul cuantic, se face referire la un „strat" de Gate-uri care pot fi executate simultan. În multe aplicații este util să se efectueze un set de rotații pe toți qubiții și apoi Gate-uri de entanglare între perechi de qubiți. În aceste contexte, se face referire la un „strat de rotație" (un strat de Gate-uri precum R_x, R_y și/sau R_z) și un „strat de entanglare" (cum ar fi unul cu Gate-uri CNOT). Numărul de straturi dintr-un Circuit este „adâncimea circuitului", o măsură importantă deoarece o adâncime mai mare înseamnă mai multe straturi de zgomot și erori cumulative.

Poate fi dificil să identifici vizual straturile de Gate-uri atunci când acestea nu sunt aliniate folosind bariere. În Qiskit, o barieră servește ca o instrucțiune în circuitele cuantice care acționează ca un separator vizual și o constrângere în timpul compilării. Atât la desenarea circuitului, cât și la executarea lui, niciun Gate nu va fi mutat dincolo de barieră. Acest lucru poate fi important în contexte precum decuplarea dinamică, în care se implementează intenționat Gate-uri care se simplifică la o identitate pentru a suprima anumite tipuri de erori. Pentru mai multe informații despre decuplarea dinamică, consultă acest ghid. Pentru efectul vizual al barierelor, compară aceste două imagini ale aceluiași circuit, prima fără bariere și a doua cu bariere pentru a forța alinierea straturilor.

Acestea sunt același circuit și au același număr de straturi. Dar în al doilea, alinierea face ușor de văzut că circuitul are:

• Două straturi de rotație: unul în jurul axei Y cu $\pi/5$, unul în jurul axei Z cu $\pi/4$.
• Trei straturi de entanglare. Rețineți că se poate numi fiecare CNOT un „strat" de sine stătător, deoarece CNOT-urile nu pot fi reordonate pentru a fi paralele fără a schimba operația logică.
• Încă două straturi de rotație: unul în jurul axei Y cu $\pi/3$, unul în jurul axei Z cu $\pi/2$.
• Încă două straturi de entanglare. Rețineți că de această dată primul strat a fost ușor mai paralelizat decât în primul set de straturi de entanglare.

Adâncimea fiecărui circuit este 9.

Unități de măsură

În calculul cuantic, capacitățile unui sistem cuantic sunt evaluate de obicei folosind trei metrici-cheie de performanță: scară, calitate și viteză. Aceste metrici nu doar descriu potențialul computațional al unui dispozitiv cuantic, ci informează și modul în care resursele sunt gestionate și planificate în aplicații practice.

• Scara se referă la numărul de biți cuantici (qubiți) din sistem, reprezentând cât de multă informație cuantică poate deține dispozitivul. În gestionarea resurselor, aceasta afectează direct lățimea circuitului — numărul de qubiți necesari pentru a rula o anumită sarcină cuantică. O unitate cuantică trebuie să aibă suficienți qubiți pentru a susține sarcina atribuită.

• Calitatea descrie cât de precis sunt efectuate operațiunile cuantice. Este adesea cuantificată prin fidelitatea stratului, care măsoară acuratețea executării unui strat complet de Gate-uri cuantice pe toți qubiții. Din perspectiva planificării, o fidelitate mai mare permite executarea fiabilă a unor circuite mai profunde, afectând nevoia de atenuare a erorilor sau de descompunere a sarcinilor.

• Viteza este măsurată prin CLOPS (Circuit Layer Operations Per Second), indicând câte straturi de operațiuni cuantice poate executa sistemul pe secundă. Aceasta afectează debitul și latența în execuția sarcinilor și ajută la determinarea cât de rapid poate finaliza o unitate cuantică o sarcină de lucru dată. Această viteză este deosebit de importantă pe un calculator cuantic, deoarece qubiții suferă de zgomot și erori într-o măsură mai mare decât omologii lor clasici. Intervalul de timp în care pot păstra informațiile cuantice într-un mod util este descris de timpul de coerență, tipic în ordinul a 200-300 $\mu\text{s}$ pentru procesoarele Heron r3.

Diferențe între metricile cuantice și clasice

Poți gândi la CLOPS ca la un analog cuantic aproximativ al FLOPS, dar cu câteva diferențe-cheie. CLOPS măsoară viteza cu care un procesor cuantic poate executa circuite cuantice, mai specific straturi de operațiuni din cadrul circuitelor, incluzând atât calculele cuantice, cât și calculele clasice necesare pentru rularea circuitelor. A fost dezvoltat de IBM Quantum ca o măsură holistică a vitezei de execuție a unui calculator cuantic, acoperind timpul de execuție cuantică și procesarea clasică în timp real necesară pentru actualizările circuitelor, spre deosebire de FLOPS care măsoară pur capacitatea aritmetică în virgulă mobilă a procesoarelor clasice.

CLOPS oferă o metrică de performanță măsurabilă care poate fi benchmarkată pe hardware existent. IBM Quantum a folosit CLOPS pentru a benchmarka diferiți procesori cuantici, iar valorile pot fi găsite pe pagina Resurse de calcul de pe IBM Quantum Platform. Valorile CLOPS depind de capacitățile hardware-ului, vitezele Gate-urilor, viteza de procesare clasică și integrarea acestora.

Numărul de qubiți este un număr fix pentru un QPU dat. CLOPS și calitatea depind de calibrarea și întreținerea regulată și pot varia ușor în timp, chiar și pentru un singur QPU.

Împreună, aceste metrici ghidează modul în care sistemele cuantice sunt alocate și planificate. În multe cazuri, întregul sistem cuantic este tratat ca o singură unitate. Totuși, când o sarcină depășește capacitatea unei unități — fie în termeni de număr de qubiți, adâncime a circuitului sau viteză de execuție — tehnici precum tăierea/îmbinarea circuitelor pot fi utilizate. Tăierea circuitelor este procesul de descompunere a sarcinilor cuantice mari în sub-sarcini mai mici și gestionabile, care pot fi distribuite pe mai multe cipuri cuantice, permițând calcul cuantic scalabil în ciuda limitărilor hardware-ului. Îmbinarea circuitelor se referă la procesul care urmează după tăierea circuitelor — pasul de post-procesare clasică care „îmbină" sau combină rezultatele din sub-circuitele mai mici.

Calculatoarele cuantice nu au memorie tradițională, în sensul de stocare persistentă și adresabilă precum RAM sau memoria GPU. Resursele de calcul clasice au biți discreti stocați în memorie, permițând salvarea, recuperarea și reutilizarea datelor în timpul calculului. Resursele cuantice utilizează qubiți care nu stochează memorie în sensul clasic. În schimb, qubiții există în stări cuantice care reprezintă suprapuneri de 0 și 1 simultan, permițând paralelism exponențial în spațiul de stare. Totuși, stările qubiților sunt fragile și nu pot fi clonate sau citite determinist la pași intermediari fără a colaps starea cuantică, deci comportamentul asemănător memoriei persistente în timpul calculului nu există. Qubiții trebuie menținuți într-o stare coerentă pe toată durata execuției, iar „memoria" este în esență starea cuantică în sine. Memoria clasică poate fi utilizată doar alături de un procesor cuantic, nu ca memorie cuantică internă. Aceasta are implicații semnificative: resursele de calcul clasice pot reutiliza și stoca liber rezultatele intermediare; resursele cuantice nu pot face acest lucru fără măsurători care perturbă calculul.

Conectivitate la infrastructura clasică

QPU-urile pot fi conectate la infrastructura clasică prin rețele și diverse interfețe de programare a aplicațiilor (API-uri) care permit dezvoltatorilor de software să interacționeze programatic cu QPU-urile. Aceste API-uri sunt de obicei ascunse în spatele kit-urilor de dezvoltare software (SDK-uri) și bibliotecilor (precum Qiskit) și expuse oamenilor de știință computaționali sub forma unor abstracții de programare (precum Qiskit Primitives, despre care vom vorbi în Capitolul 3: modele de programare).

Merită să se facă o distincție între integrarea strânsă și cea slabă a resurselor cuantice și clasice. În prezent, QPU-urile nu se află pe același nod ca resursele de calcul clasice. De fapt, QPU-urile nu sunt în prezent conectate prin PCIe, ci prin rețea. Acest lucru s-ar putea schimba în viitor, dar există provocări de inginerie legate de condițiile de mediu optime pentru QPU-uri și resursele de calcul clasice.

Scalarea resurselor cuantice

Scalarea resurselor cuantice poate fi de asemenea categorizată în verticală și orizontală.

• Scalarea verticală ar fi creșterea numărului de qubiți pe cip sau îmbunătățirea fidelității dispozitivelor.
• Scalarea orizontală ar fi conectarea cipurilor cu cuplori sau cu interconexiuni clasice.

Verifică-ți înțelegerea

Care sunt analogii cuantici ai (a) biților de informație clasici și (b) vitezei procesorului clasic?

Răspuns:

(a) Biți cuantici sau qubiți — unități de informație care, spre deosebire de omologii lor clasici (care pot adopta doar starea 0 sau 1), pot fi într-o suprapunere de 0 și 1 simultan.

(b) Operații per strat de circuit pe secundă sau CLOPS — numărul de operații secvențiale pe care QPU-ul le poate efectua pe secundă, incluzând o parte din interfațarea cu resursele de calcul clasice, ca la încărcarea parametrilor din circuit.

Gestionarea resurselor

Atât resursele HPC, cât și cele cuantice sunt prețioase și complexe; trebuie gestionate cu grijă. În această secțiune, vom explica cum să gestionezi resursele pentru programele utilizatorului. Gestionarea resurselor în infrastructura de calcul se referă la procesul de (1) planificare, (2) alocare și (3) control/gestionare a utilizării resurselor de calcul, cum ar fi CPU-urile, memoria, stocarea și lățimea de bandă a rețelei, pentru a asigura o utilizare eficientă și eficace a resurselor.

Planificare — estimarea resurselor

Orice program consumă resurse, iar estimarea resurselor necesare este esențială pentru gestionarea eficientă a resurselor. Aceasta include estimarea cantității de CPU, memorie și alte resurse necesare pentru a executa un program. Același lucru este valabil și pentru resursele cuantice. Totuși, resursele cuantice există la o scară complet diferită. Procesoarele cuantice IBM Quantum® Heron r3 au 156 de qubiți, față de multele miliarde de biți clasici de pe un laptop obișnuit. Timpul și costul sunt, de asemenea, considerații importante. În prezent, IBM Quantum are un plan gratuit, Open Plan, care permite utilizatorilor să exploreze calculul cuantic folosind 10 minute de timp QPU pe lună. Unele organizații de cercetare necesită atât de mult timp QPU încât au un calculator cuantic IBM dedicat la sediu.

Un pas în estimarea resurselor care este unic calculului cuantic este adâncimea circuitului. Așa cum s-a menționat anterior, fiecare Gate cuantic și fiecare timp de întârziere între operații vine cu zgomot și o anumită probabilitate de eroare. Cu cât circuitul cuantic este mai adânc, cu atât mai mare este zgomotul. Există două subtilități în acest sens: Gate-urile cu doi qubiți au rate de eroare mult mai mari decât Gate-urile cu un singur qubit, deci se poate ignora adesea adâncimea cu un singur qubit. Mai mult, nu toți qubiții de pe un cip cuantic sunt conectați direct. Uneori informațiile trebuie schimbate de la un qubit la altul pentru a efectua entanglamentele necesare, iar acest proces de schimb necesită el însuși Gate-uri cu doi qubiți. Acea schimbare este gestionată într-un proces numit „transpilare", un proces complex care servește și alte scopuri; acesta este discutat mai detaliat în lecția următoare. Cantitatea limitativă relevantă este astfel adâncimea transpilată cu doi qubiți. Adâncimea maximă exactă la care pot fi obținute rezultate de înaltă fidelitate depinde de circuit. Dar valorificând tehnicile moderne de atenuare a erorilor, se pot obține rezultate de înaltă fidelitate cu adâncimi transpilate cu doi qubiți de 80 sau mai mult.

Alocare — planificarea joburilor

Planificarea joburilor este procesul de alocare a resurselor pentru programe și gestionarea execuției acestora. Aceasta implică:

• Trimiterea jobului: Procesul prin care un utilizator trimite o cerere (job) către sistemul HPC, specificând ce muncă computațională și ce resurse sunt necesare pentru execuție.
• Alocarea resurselor: Atribuirea resurselor disponibile ale sistemului HPC (cum ar fi noduri, CPU-uri, memorie) unui job trimis, pe baza cerințelor sale.
• Execuția jobului: Rularea efectivă a sarcinilor computaționale definite de job pe resursele HPC alocate.

Există analogi ai tuturor acestor procese pentru calculatoarele cuantice.

• Joburile sunt trimise de utilizator, valorificând Qiskit Runtime, și folosind de obicei o primitivă Qiskit Runtime, precum Sampler, Estimator sau altele.
• Utilizatorul selectează dintr-o listă de Backend-uri la care are acces. Lista completă a Backend-urilor disponibile poate fi văzută pe pagina Resurse de calcul de pe IBM Quantum Platform. Este obișnuit să se utilizeze pur și simplu calculatorul cuantic cel mai puțin ocupat. Dar există cazuri în care ar putea fi important să se utilizeze unul specific din cauza considerațiilor legate de layout-ul dispozitivului, replicarea calculelor anterioare și altele.
• Execuția joburilor cuantice este similară cu cazul HPC. Deși unele diferențe au fost deja subliniate, câteva merită repetate aici. QPU-urile nu sunt în prezent situate în general pe același nod ca resursele de calcul clasice, ci sunt conectate printr-o rețea. Acest lucru poate avea implicații pentru planificare. Mai mult, calculatoarele cuantice pot avea timpi de așteptare substanțiali în coadă, iar acești timpi variază, îngreunând controlul precis al timpului. Situația poate fi diferită pentru sistemele dedicate; aceasta depinde de administrarea internă a calculatorului cuantic.

Control/Gestionare — managementul sarcinilor de lucru

Managementul sarcinilor de lucru, cunoscut și sub numele de orchestrare, este procesul de gestionare a mai multor programe și a cerințelor lor de resurse. Aceasta implică:

• Provizionarea resurselor: Procesul de pregătire și punere la dispoziție a resurselor HPC pentru utilizarea de către joburi, inclusiv configurarea hardware-ului și software-ului. Așa cum vom vedea mai târziu, QPU-urile sunt resurse de calcul care pot fi provizionate similar cu resursele HPC clasice, cu avertismentele din secțiunea anterioară.
• Planificarea joburilor: Activitatea software-ului de planificare în a decide ce joburi rulează, când și pe ce resurse, gestionând prioritățile și cozile pentru a utiliza eficient sistemul HPC. Deși această afirmație largă se aplică și resurselor cuantice, poate exista mai puțin control asupra timpului decât cu alte resurse.

Exemplu:

Consideră o sarcină bine-cunoscută ca un context pentru înțelegerea gestionării resurselor: găsirea factorilor primi ai numerelor mari. Să presupunem în plus că algoritmul utilizat se bazează pe verificarea brută a fiecărui potențial divizor. Deși aceasta nu este adesea cea mai eficientă metodă, este ușor de înțeles cum ar putea fi gestionată sarcina de lucru.

Planificare — estimarea resurselor

• Estimează cât timp CPU și memorie ar putea necesita factorizarea în numere prime.
• Planifică paralelizarea sarcinii tale — câte CPU-uri/nuclee vei folosi?

Alocare — planificarea joburilor

• La trimiterea jobului, planificatorul atribuie nuclee CPU și memorie sarcinii de factorizare în numere prime. De exemplu, ar putea aloca toți potențialii divizori care se termină în cifrele 1, 3, 7, 9 unuia din patru nuclee, respectiv.

• Execuția jobului: Algoritmul de factorizare în numere prime rulează, efectuând împărțiri sau alți pași de factorizare pe resursele alocate până când sarcina se finalizează. Control/Gestionare — managementul sarcinilor de lucru

• Sistemul orchestrează ordinea și sincronizarea joburilor de factorizare în numere prime pentru a optimiza debitul.

• Cel mai ușor caz de imaginat este că unul dintre nuclee găsește factorul prim țintă. Acest lucru ar trebui să oprească calculul pe celelalte nuclee, astfel încât să poată fi utilizate pentru sarcina următoare.

Mediile de calcul de înaltă performanță utilizează software special pentru a efectua acești pași și a gestiona resursele. În secțiunea următoare, vom învăța despre un sistem software de gestionare a resurselor larg adoptat: Slurm.

Exemplu cu resurse cuantice:

Un flux de lucru care va fi subiectul altor lecții din acest curs este determinarea stărilor fundamentale ale chimiei și energiilor folosind diagonalizarea cuantică bazată pe eșantioane (SQD). Acesta este tratat mai detaliat în Lecția 4, și poți vizita de asemenea acest curs despre SQD și metodele conexe pe IBM Quantum Learning. Tot ce trebuie să știm pentru această discuție este că fluxul de lucru implică următoarele:

• Pregătește un Circuit cuantic
• Măsoară circuitul cuantic
• Folosește rezultatele măsurătorii pentru a proiecta problema într-un subspațiu util
• Diagonalizează o matrice mai mică, proiectată, folosind resurse de calcul clasice
• Iterație, fie pentru a asigura auto-consistența prin considerații precum conservarea sarcinii, și posibile iterații ale circuitului cuantic dacă acesta are parametri variaționali.

Planificare — estimarea resurselor

• Mapează orbitalele electronice la qubiți pentru a stabili numărul de qubiți de care ai nevoie.
• Combină Hamiltonianul mapat al sistemului și starea (posibil variatională) într-un Circuit cuantic și verifică adâncimea transpilată cu doi qubiți. Asigură-te că este rezonabilă.
• Estimează dimensiunea subspațiului în care vei proiecta; din aceasta, estimează cât timp CPU și memorie ar putea necesita diagonalizarea.
• Planifică paralelizarea sarcinii tale — câte CPU-uri/nuclee vei folosi?

Alocare — planificarea joburilor

• Utilizatorul selectează QPU-ul; procesul de transpilare mapează automat qubiții din circuitul tău cuantic abstract la qubiții fizici de pe QPU. Acest lucru este important deoarece circuitul abstract poate presupune o conectivitate directă care nu există pe cip, printre alte motive.
• La trimiterea jobului prin Qiskit Runtime, jobul intră în coada pentru QPU-ul selectat. Utilizatorul nu are control asupra timpului de așteptare în coadă, deși acest lucru poate fi diferit pentru sistemele dedicate.
• Resursele de calcul clasice așteaptă rezultatele cuantice.
• Un job de diagonalizare este trimis la resursele HPC; la trimiterea jobului, planificatorul atribuie nuclee CPU și memorie sarcinii de diagonalizare.
• Execuția jobului: Algoritmul de diagonalizare rulează, diagonalizând matricea proiectată mai mică până când sarcina se finalizează.

Control/Gestionare — managementul sarcinilor de lucru

• Sistemul orchestrează ordinea și sincronizarea pașilor cuantici și clasici pe parcurs. De exemplu, odată ce matricea proiectată a fost diagonalizată și s-a obținut o energie a stării fundamentale, în funcție de criteriile de convergență, fluxul de lucru poate reveni la un nou Circuit cuantic (cu un nou parametru variațional).
• Când criteriile de convergență sunt satisfăcute de energia stării fundamentale, calculul pe toate nucleele se oprește.

Mediile de calcul de înaltă performanță utilizează software special pentru a efectua acești pași și a gestiona resursele. În secțiunea următoare, vom învăța despre un sistem software de gestionare a resurselor larg adoptat: Slurm. Este important de reținut că Slurm nu are instrumente pentru toți pașii descriși mai sus. Slurm nu oferă suport pentru planificarea joburilor și nici pentru managementul detaliat al sarcinilor de lucru, cum ar fi comunicarea între componentele sarcinii de lucru. Aceasta se potrivește bine stării actuale a calculului cuantic în HPC, deoarece QPU-urile sunt accesate de obicei prin rețea.

Verifică-ți înțelegerea

Să presupunem că încerci să cauți într-o bază de date nesortată pentru a găsi un element pe care îl vom numi „ținta". Pentru fiecare dintre următoarele acțiuni, indică la ce etapă a gestionării resurselor corespunde: (a) Estimarea dimensiunii bazei de date și a timpului necesar pentru a verifica fiecare element (b) Asigurarea că găsirea țintei pe un GPU oprește procesul pe celelalte GPU-uri pentru a le elibera pentru problema următoare. (c) Împărțirea spațiului de căutare în regiuni pentru fiecare dintre cele (să zicem 10) GPU-uri ale tale pentru a căuta

Răspuns:

(a) Planificare (b) Control/gestionare (c) Alocare/planificarea joburilor,

Software: Slurm

În această secțiune, vom aplica conceptele învățate în acest capitol pentru a practica utilizarea sistemului popular de gestionare a resurselor, Slurm.

Introducere în Slurm

Slurm este un sistem de gestionare a resurselor open-source utilizat pe scară largă în mediile de calcul de înaltă performanță. Oferă un set cuprinzător de instrumente pentru gestionarea resurselor, planificarea joburilor și monitorizarea performanței sistemului.

Vom acoperi elementele de bază ale utilizării Slurm, inclusiv:

• Trimiterea joburilor
• Alocarea resurselor
• Monitorizarea joburilor

Deoarece este foarte greu să furnizăm resurse HPC fiecărui student al acestui curs, vom trișa puțin și îți vom oferi un repository cu imagini Docker care imită un cluster HPC real cu Slurm, dar la scară mică. Aceasta ne va ajuta să exersăm conceptele învățate în medii sigure și reproductibile.

Rețineți că în prezent toate resursele cuantice și clasice sunt alocate pe durata întregului experiment. În prezent nu există nicio alocare intercalată de resurse mixte. Un avertisment final este că, chiar și după ce jobul este lansat, sistemul cuantic nu va fi controlat direct așa cum ar putea fi așteptat de un utilizator HPC experimentat. Jobul este lansat pe un nod x86 arbitrar, care execută serviciul Qiskit Runtime, iar acel serviciu de execuție se conectează la un alt planificator asupra căruia utilizatorul nu are control direct. Acest flux de lucru și problemele conexe ar putea fi cunoscute utilizatorilor HPC care au avut experiență timpurie în urmărirea accesului exclusiv la nodurile GPU (utilizarea originală a gres).

Instrucțiuni de instalare și prezentarea configurației

Pentru a practica combinarea resurselor cuantice și HPC, vei avea nevoie fie de acces la un mediu HPC real, fie va trebui să simulezi un mediu HPC pe mașina ta locală. Un ghid de instalare pentru configurarea locală folosind Docker poate fi găsit în acest repository. Ghidul face legătura cu suportul pentru configurarea unui cont IBM Cloud® și instalarea plugin-ului SPANK pentru QRMI. Tot în acel repository se află mai multe fișiere Python pentru a-ți testa mediul.

Odată ce ai finalizat instalarea, să folosim comanda de mai jos pentru a verifica resursele de calcul ale Slurm la terminalul tău. Dacă instalarea a reușit, ar trebui să poți confirma un total de trei noduri virtuale.

$ sinfo

PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
normal      up 5-00:00:00     2  idle c[1-2]
quantum*    up   infinite     1  idle q1

$ scontrol show node

NodeNAME=q1 Arch=x86_64 CoresPerSocket=1
CPUAlloc=0 CPUTot=1 CPULoad=0.34
AvailableFeatures=(null)
ActiveFeatures=(null)
Gres=qpu:1
NodeAddr=q1 NodeHostName=q1 Version=21.08.6
...

Avem două partiții sau grupuri de noduri: normal și quantum. Partiția normal este compusă din noduri care au acces doar la resurse clasice. Partiția quantum are acces la resurse cuantice. Poți vedea detaliile fiecărui nod executând scontrol show nodes.

Rulează un exemplu simplu hello world în Slurm

Să rulăm mai întâi un exemplu clasic simplu hello world cu Slurm. Vom folosi Python pentru exemple. Să creăm hello_world.py, care este de la sine înțeles.

$ vim hello_world.py

import time
time.sleep(10)
print("Hello, World!")
~

Acum trebuie să îi spunem managerului de resurse de ce resurse avem nevoie pentru a executa acest program. Slurm oferă o modalitate de a specifica toate metadatele pentru job printr-un script de trimitere, care este pur și simplu un script shell cu adnotări specifice Slurm. Aceste adnotări îți permit să specifici cerințele de resurse, parametrii de planificare și altele. Să creăm un script shell hello_world.sh pentru aceasta.

$ vim hello_world.sh

#SBATCH --job-name=hello-world
#SBATCH --output=hello-world.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=normal

srun hello_world.py
~

Să parcurgem fișierul de trimitere și să vedem ce se întâmplă acolo.

Directivele #SBATCH sunt adnotări specifice pentru a spune ce cerințe avem pentru execuția programului. Aici poți specifica cantitatea de resurse — numărul de noduri, numărul de sarcini pe nod, numărul de sarcini și CPU-uri pe nod și sarcină — și alte opțiuni, precum numele fișierului de ieșire. O listă completă a opțiunilor este disponibilă în documentația Slurm.

Acum este momentul să rulăm jobul nostru Slurm. sbatch este o comandă care acceptă un fișier de trimitere și pune jobul în coadă pentru execuție în Slurm.

$ sbatch hello_world.sh

Submitted batch job 63

Să verificăm starea programului nostru folosind comanda squeue.

$ squeue

#             JOBID PARTITION     NAME         USER ST       TIME  NODES NODELIST(REASON)
#                 1 main          hello_world  root R        0:01      1 c1

Odată ce jobul s-a terminat, putem verifica rezultatul uitându-ne la fișierul de ieșire.

$ cat hello_world_logs.txt
Hello, World!

Verifică-ți înțelegerea

Dat scriptul shell Slurm de mai jos, care este (a) numele jobului, (b) numele fișierului Python și (c) numele fișierului de ieșire? (d) În final, poate acesta folosi resurse cuantice sau nu?

vim hello_learner.sh

#SBATCH --job-name=hello-learner
#SBATCH --output=hello-learner.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=quantum

srun hello_learner_qm.py

Răspuns:

(a) hello-learner (b) hello-learner_qm.py (c) hello-learner.out (d) Da, ar putea. Folosește partiția quantum.

Rulează un exemplu simplu Qiskit hello world în Slurm

Acum, să încercăm să folosim și resurse cuantice. Să creăm și să rulăm un program simplu „Hello, Qiskit" care folosește resurse cuantice.

$ vim hello_qiskit.py

# hello_qiskit.py
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import EstimatorV2 as Estimator

# Create a new circuit with two qubits
qc = QuantumCircuit(2)

# Add a Hadamard gate to qubit 0
qc.h(0)

# Perform a controlled-X gate on qubit 1, controlled by qubit 0
qc.cx(0, 1)

observables_labels = ["IZ", "IX", "ZI", "XI", "ZZ", "XX"]
observables = [SparsePauliOp(label) for label in observables_labels]

# switch to QRMI service
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

backend = service.backend("...")

# Convert to an ISA circuit and layout-mapped observables.
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_circuit = pm.run(qc)

# Construct the Estimator instance.

estimator = Estimator(mode=backend)
estimator.options.resilience_level = 1
estimator.options.default_shots = 5000

mapped_observables = [
    observable.apply_layout(isa_circuit.layout) for observable in observables
]

# One pub, with one circuit to run against five different observables.
job = estimator.run([(isa_circuit, mapped_observables)])

job_result = job.result()

pub_result = job.result()[0]

print("Result", pub_result)

Aici vom folosi interfața de gestionare a resurselor cuantice (QRMI), un plugin SPANK pentru Slurm destinat suportului resurselor și joburilor cuantice, care a fost dezvoltat în comun de IBM, Pasqal, The Hartree Center și RPI. Am creat un circuit simplu pauli-2-design cu valori inițiale aleatoare și un observabil simplu, și îl vom rula folosind Estimator pentru a obține valoarea de așteptare. Pentru a-l rula, vom avea din nou nevoie de scriptul de trimitere hello_qiskit.sh, care va avea resursele cuantice ca cerință.

$ vim hello_qiskit.sh

#SBATCH --job-name=hello-qiskit
#SBATCH --output=hello_qiskit.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-nodes=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=quantum
#SBATCH --gres=qpu:1

srun python /data/ch2/hello_qiskit/hello_qiskit.py
~

Să analizăm fișierul de trimitere și să vedem ce se întâmplă acolo. Avem o opțiune nouă, care este gres. gres este o opțiune Slurm pentru a defini resurse computaționale suplimentare. În cazul nostru, această nouă resursă ar fi resursa noastră cuantică. Deoarece am specificat resursele și partiția clusterului nostru unde sunt disponibile resursele cuantice, primitivele noastre Qiskit vor folosi aceste resurse alocate pentru a executa sarcina cuantică.

Acum este momentul să rulăm jobul nostru Slurm.

$ sbatch hello_qiskit.sh

Apoi, să verificăm starea programului nostru folosind comanda squeue.

$ squeue
#             JOBID PARTITION     NAME         USER ST       TIME  NODES NODELIST(REASON)
#                 1 main          hello_qiskit  root R        0:01      1 q1

Putem explora jurnalele și rezultatele după ce jobul s-a terminat.

$ cat hello_qiskit.out | grep Exp
Expectation Value: 0.8372900070983516

Rezumat

Până acum, am învățat ce sunt resursele computaționale și cum să le folosim pentru a rula programe în medii eterogene. Am creat și executat de asemenea două programe simple „Hello World": unul pentru resursa clasică și celălalt pentru o resursă cuantică, și am învățat cum să creăm scripturi shell pentru a trimite sarcini și a vizualiza rezultate.

În lecția următoare, vom construi pe aceste cunoștințe despre controlul resurselor pentru a aplica modele de programare resurselor pe care le-am obținut în timpul execuției jobului.

Tot codul și scripturile folosite în acest capitol sunt disponibile pentru tine în repository-ul nostru GitHub.