Sumber daya komputasi dan manajemen sumber daya

Model sumber daya dan sumber daya klasikal

Dalam bagian ini, kita akan menyediakan kerangka untuk memikirkan lingkungan komputasi yang dapat diterapkan baik untuk laptop maupun yang ditingkatkan ke superkomputer. Pada akhir bagian ini, kamu akan memahami komponen fundamental dari lingkungan komputasi dan bagaimana mereka saling berhubungan. Semua ini dijelaskan oleh Iskandar Sitdikov dalam video berikut.

Model sumber daya

Setiap lingkungan komputasi klasikal dibangun dari beberapa sumber daya yang saling berhubungan yang bekerja sama untuk menjalankan aplikasi secara efisien. Sumber daya utama biasanya meliputi:

• CPU (Central Processing Unit): CPU adalah unit pemrosesan inti yang menginterpretasikan dan mengeksekusi instruksi program. Ia menangani operasi logika, aritmatika, dan kontrol, secara esensial bertindak sebagai "otak" sistem.

• Cache CPU (L1, L2, L3): Ini adalah yang tercepat dalam sistem, dibangun langsung ke dalam atau sangat dekat dengan inti CPU. Ia menyimpan porsi kecil data dan instruksi yang segera dibutuhkan CPU. Level yang berbeda (L1, L2, L3) merepresentasikan trade-off: L1 adalah yang terkecil dan tercepat sementara L3 adalah yang terbesar dan paling lambat, tetapi masih beberapa orde besaran lebih cepat dari RAM.

• RAM (Random Access Memory): Memori volatile yang menyediakan penyimpanan sementara yang besar untuk instruksi program dan data yang sedang aktif digunakan. Ini memastikan CPU dapat dengan cepat mengakses informasi yang diperlukan selama eksekusi tanpa ketergantungan konstan pada perangkat penyimpanan yang lebih lambat.

• Penyimpanan (lokal dan berbasis jaringan): Penyimpanan menyimpan data dan perangkat lunak bahkan saat sistem dimatikan, menyediakan persistensi jangka panjang untuk dataset dan aplikasi yang besar. Dalam komputasi berperforma tinggi, solusi penyimpanan harus menangani jumlah data ilmiah atau analitik yang sangat besar dengan kecepatan dan keandalan. Penyimpanan lokal termasuk solid-state drive (SSD) dan hard disk drive (HDD), dengan SSD yang lebih disukai karena latensi yang lebih rendah dan throughput yang lebih tinggi. Untuk penanganan data skala besar, sistem file paralel, penyimpanan jaringan bersama, dan sistem berbasis objek memungkinkan akses cepat di banyak node komputasi, sementara cloud dan tier penyimpanan arsip mendukung retensi jangka panjang dan skalabilitas.

• GPU (Graphics Processing Unit): Meskipun awalnya dirancang untuk merender grafis, GPU modern adalah prosesor paralel yang kuat. Mereka banyak digunakan untuk menangani tugas yang memerlukan banyak kalkulasi simultan seperti deep learning, simulasi fisika, dan analitik big data. Penting untuk dicatat bahwa GPU tidak menggantikan CPU; CPU mengarahkan logika program yang lebih tinggi dan GPU mempercepat langkah-langkah yang sangat paralel.

• Koneksi/Bus: Ini adalah jalur komunikasi yang menghubungkan CPU, memori, penyimpanan, dan periferal. Bus memungkinkan transfer data dan koordinasi antara bagian-bagian sistem, memastikan komunikasi yang lancar di seluruh lingkungan komputasi. Dalam sistem HPC, komponen seperti CPU, GPU, dan perangkat penyimpanan dihubungkan oleh interkoneksi berkecepatan tinggi yang memungkinkan pertukaran data yang cepat. GPU biasanya terhubung ke sistem melalui PCIe, antarmuka standar dengan beberapa jalur data untuk komunikasi yang efisien. Untuk performa yang lebih tinggi, NVLink menyediakan tautan langsung dan bandwidth tinggi antara GPU atau antara GPU dan CPU, mengurangi latensi dan mempercepat beban kerja paralel.

• Filesystem: Filesystem mengorganisir data pada perangkat penyimpanan. Ia menyediakan struktur untuk menyimpan, mengambil, dan mengelola file, memungkinkan program dan pengguna mengakses informasi dengan cara yang konsisten dan logis.

Setiap jenis sumber daya memiliki satuan pengukuran kinerja sendiri. Misalnya, CPU biasanya diukur berdasarkan "inti" dan "kecepatan clock." Saat membeli laptop, spesifikasinya biasanya mencakup jumlah inti. Konsep serupa berlaku untuk node komputasional di pusat data, di mana setiap node dikaitkan dengan jumlah inti tertentu. Lingkungan komputasi yang menyertakan berbagai jenis sumber daya (CPU, GPU, bahkan QPU) disebut sebagai lingkungan komputasi heterogen. Setup ini menangani beban kerja yang beragam dengan lebih efisien dengan memanfaatkan kekuatan setiap jenis prosesor. Misalnya, CPU akan digunakan untuk tugas umum dan GPU untuk pemrosesan paralel. Dalam konteks manajemen sumber daya dan penjadwalan - terutama untuk lingkungan komputasi heterogen - unit pengukuran tambahan mungkin diperlukan bersama dengan yang dijelaskan di sini.

Untuk memori, satuan ukurnya adalah Mega/Giga/Terabyte.

Untuk kartu grafis dan akselerator lainnya, satuan ukurnya tergantung pada konteks. Sementara kemampuan komputasi sebenarnya diukur dengan metrik yang lebih halus - jumlah inti pemrosesan, ukuran memori, dan bandwidth memori, dalam diskusi tingkat tinggi tentang sumber daya cluster atau penjadwalan job, GPU dan akselerator serupa dapat dikuantifikasi di tingkat perangkat berdasarkan jumlah seluruh perangkat yang ditugaskan (misalnya, tiga GPU).

Jaringan/konektivitas/bus adalah aspek krusial dari infrastruktur komputasi mana pun karena mereka menentukan seberapa cepat data ditransfer antara komponen komputasi. Dari LPU ke cache CPU, ke RAM, ke kartu PCI, ke perangkat yang terhubung ke jaringan; semuanya adalah komunikasi dan sangat penting untuk memiliki model mental yang akurat tentang hal itu untuk merancang algoritma yang sangat dioptimalkan untuk HPC.

Skala sumber daya klasikal

High-Performance Computing (HPC) melibatkan skala sumber daya klasikal ini untuk mencapai waktu pemrosesan yang lebih cepat atau meningkatkan data yang dapat ditangani secara bersamaan (misalnya, untuk meningkatkan ukuran ruang solusi yang dapat dicari). Ini dapat dicapai melalui:

• Skala vertikal: Meningkatkan daya sumber daya individual, seperti menggunakan CPU yang lebih kuat atau menambahkan lebih banyak memori dalam satu node fisik, di mana node adalah unit cluster komputasi yang merangkum beberapa sumber daya komputasi di dalamnya.

• Skala horizontal: Menambahkan lebih banyak sumber daya, seperti beberapa CPU atau GPU, untuk bekerja sama pada satu node atau, lebih umum, pada beberapa node, memungkinkan komputasi terdistribusi.

Beberapa konsep skala dari bagian ini akan berlaku untuk bagian berikutnya tentang sumber daya komputasi kuantum. Beberapa aspek lain dari sumber daya kuantum akan dikuantifikasi dengan cara baru.

Uji pemahamanmu

Gunakan deskripsi di atas untuk menyimpulkan beberapa keunggulan dan kelemahan dari pendekatan skala yang berbeda: vertikal dan horizontal?

Jawaban:

Mungkin ada banyak jawaban yang benar. Skala vertikal sering lebih sederhana, terutama jika kamu memiliki beban kerja yang dapat diprediksi yang akan membutuhkan jumlah sumber daya yang tetap. Tetapi skala vertikal bisa lebih mahal untuk ditingkatkan, karena unit komputasi fundamental tidak dapat dipecah semudah dalam skala horizontal. Skala horizontal lebih kompleks untuk dikelola dan kadang-kadang ada kesulitan atau latensi yang terkait dengan koneksi antara node. Tetapi ini jauh lebih adaptif terhadap persyaratan sumber daya yang bervariasi dan bersifat modular ketika peningkatan diperlukan.

Jenis sumber daya baru: QPU (Quantum Processing Unit)

Dalam bagian ini, kita akan memperkenalkan jenis sumber daya baru - sumber daya kuantum - dan mengeksplorasi definisi, satuan ukur, dan konektivitasnya ke infrastruktur klasikal.

Definisi QPU

• Quantum processing unit (QPU): QPU mencakup semua hardware yang bertanggung jawab untuk menerima set instruksi kuantum yang dapat dieksekusi, atau rangkaian kuantum, dan mengembalikan jawaban yang akurat.

Itu berarti QPU mencakup satu atau lebih chip kuantum (misalnya Heron), berbagai komponen tambahan dalam dilution refrigerator seperti penguat kuantum, elektronik kontrol, dan komputasi klasikal yang diperlukan untuk tugas-tugas seperti menyimpan instruksi dan gelombang dalam memori, mengakumulasi hasil, dan dekoding koreksi kesalahan di masa depan. Meskipun dilution refrigerator diperlukan untuk melakukan tugas-tugas ini, kami mengecualikan dilution refrigerator dari definisi ini untuk memungkinkan kasus beberapa QPU dalam satu lemari pendingin.

• Komputer kuantum: Komputer kuantum terdiri dari QPU ditambah komputasi klasikal yang menghosting lingkungan runtime.

• Lingkungan runtime: Kombinasi hardware dan perangkat lunak yang memungkinkan jalannya program.

Lapisan dalam rangkaian kuantum

Dalam komputasi klasikal maupun kuantum, proses dapat dieksekusi secara berurutan atau paralel. Karena qubit memiliki ruang state yang kaya dibandingkan dengan bit klasikal, kadang-kadang masuk akal bagi beberapa gate qubit tunggal untuk dieksekusi pada qubit secara berurutan (seperti gate R_x diikuti oleh gate R_z). Karena keterikatan antara qubit sangat penting untuk komputasi kuantum, juga umum untuk rangkaian kuantum memiliki sekumpulan gate yang melilit yang bekerja di banyak qubit. Faktor-faktor ini dan lainnya membuat umum untuk mengidentifikasi proses yang dapat dieksekusi secara paralel pada skala operasi gate individual dalam rangkaian kuantum. Dalam komputasi klasikal, paralelisme tingkat bit juga mungkin tetapi kurang umum dipertimbangkan pada tingkat gate; lebih umum untuk merujuk pada proses paralel dan berurutan pada skala yang lebih besar.

Dalam komputasi kuantum, seseorang merujuk pada "lapisan" gate yang semuanya dapat dieksekusi secara bersamaan. Dalam banyak aplikasi berguna untuk melakukan serangkaian rotasi pada semua qubit dan kemudian gate yang melilit antara pasangan qubit. Dalam konteks ini, seseorang merujuk pada "lapisan rotasi" (lapisan gate seperti R_x, R-y, dan/atau R_z) dan "lapisan entangling" (seperti satu dengan gate CNOT). Jumlah lapisan dalam rangkaian adalah "kedalaman rangkaian", ukuran penting karena kedalaman yang lebih besar berarti lebih banyak lapisan noise dan kesalahan yang menumpuk.

Bisa sulit untuk mengidentifikasi lapisan gate secara visual ketika lapisan tidak disejajarkan menggunakan barrier. Di Qiskit, barrier berfungsi sebagai instruksi dalam rangkaian kuantum yang bertindak sebagai pemisah visual dan batasan selama kompilasi. Baik dalam menggambar rangkaian maupun mengeksekusinya, tidak ada gate yang akan dipindahkan melewati barrier. Ini bisa penting dalam konteks seperti dynamical decoupling, di mana seseorang dengan sengaja mengimplementasikan gate yang menyederhanakan ke identitas untuk menekan jenis kesalahan tertentu. Untuk lebih lanjut tentang dynamical decoupling lihat panduan ini. Untuk efek visual dari barrier, bandingkan dua gambar rangkaian yang sama ini, yang pertama tanpa barrier dan yang kedua dengan barrier untuk memaksa perataan lapisan.

Ini adalah rangkaian yang sama dan memiliki jumlah lapisan yang sama. Tetapi dalam yang kedua, perataan memudahkan untuk melihat bahwa rangkaian memiliki:

• Dua lapisan rotasi: satu di sekitar sumbu Y sebesar $\pi/5$, satu di sekitar sumbu Z sebesar $\pi/4$.
• Tiga lapisan entangling. Perhatikan bahwa seseorang dapat menyebut setiap CNOT sebagai "lapisan" tersendiri, karena CNOT tidak dapat diurutkan ulang untuk menjadi paralel tanpa mengubah operasi logisnya.
• Dua lapisan rotasi lagi: satu di sekitar sumbu Y sebesar $\pi/3$, satu di sekitar sumbu Z sebesar $\pi/2$.
• Dua lapisan entangling lagi. Perhatikan bahwa kali ini lapisan pertama telah sedikit lebih diparalelkan daripada dalam set pertama lapisan entangling.

Kedalaman setiap rangkaian adalah 9.

Satuan ukur

Dalam komputasi kuantum, kemampuan sistem kuantum biasanya dinilai menggunakan tiga metrik kinerja utama: skala, kualitas, dan kecepatan. Metrik-metrik ini tidak hanya menggambarkan potensi komputasional perangkat kuantum, tetapi juga menginformasikan bagaimana sumber daya dikelola dan dijadwalkan dalam aplikasi praktis.

• Skala mengacu pada jumlah bit kuantum (qubit) dalam sistem, yang merepresentasikan berapa banyak informasi kuantum yang dapat dipegang perangkat. Dalam manajemen sumber daya, ini secara langsung memengaruhi lebar rangkaian—jumlah qubit yang diperlukan untuk menjalankan tugas kuantum tertentu. Unit kuantum harus memiliki qubit yang cukup untuk mendukung tugas yang ditugaskan.

• Kualitas menggambarkan seberapa akurat operasi kuantum dilakukan. Ini sering dikuantifikasi oleh layer fidelity, yang mengukur akurasi eksekusi lapisan penuh gate kuantum di semua qubit. Dari perspektif penjadwalan, fidelitas yang lebih tinggi memungkinkan rangkaian yang lebih dalam untuk dieksekusi secara andal, memengaruhi kebutuhan untuk mitigasi kesalahan atau dekomposisi tugas.

• Kecepatan diukur oleh CLOPS (Circuit Layer Operations Per Second), menunjukkan berapa banyak lapisan operasi kuantum yang dapat dieksekusi sistem per detik. Ini memengaruhi throughput dan latensi dalam eksekusi tugas, dan membantu menentukan seberapa cepat unit kuantum dapat menyelesaikan beban kerja tertentu. Kecepatan ini sangat penting pada komputer kuantum, karena qubit mengalami noise dan kesalahan dalam tingkat yang lebih besar daripada rekan klasikal mereka. Waktu di mana mereka dapat mempertahankan informasi kuantumnya dengan cara yang berguna dijelaskan oleh coherence time, biasanya dalam urutan 200-300 $\mu\text{s}$ untuk prosesor Heron r3.

Perbedaan antara metrik kuantum dan klasikal

Kamu mungkin menganggap CLOPS sebagai analog kuantum yang longgar dari FLOPS, tetapi dengan beberapa perbedaan utama. CLOPS mengukur kecepatan prosesor kuantum dapat mengeksekusi rangkaian kuantum, khususnya lapisan operasi dalam rangkaian, termasuk komputasi kuantum dan klasikal yang diperlukan dalam menjalankan rangkaian. Ini dikembangkan oleh IBM Quantum sebagai ukuran holistik dari kecepatan eksekusi komputer kuantum, mencakup waktu eksekusi kuantum dan pemrosesan klasikal real-time yang diperlukan untuk pembaruan rangkaian, tidak seperti FLOPS yang murni mengukur kapasitas aritmatika floating-point dalam prosesor klasikal.

CLOPS menyediakan metrik kinerja yang dapat diukur yang dapat dibandingkan pada hardware yang ada. IBM Quantum telah menggunakan CLOPS untuk membandingkan prosesor kuantum yang berbeda dan nilainya dapat ditemukan di halaman Compute resources di IBM Quantum Platform. Nilai CLOPS bergantung pada kemampuan hardware, kecepatan gate, kecepatan pemrosesan klasikal, dan integrasi keduanya.

Jumlah qubit adalah angka tetap untuk QPU tertentu. CLOPS dan kualitas bergantung pada kalibrasi dan pemeliharaan rutin dan dapat sedikit bervariasi dari waktu ke waktu, bahkan untuk QPU tunggal.

Bersama-sama, metrik-metrik ini memandu bagaimana sistem kuantum dialokasikan dan dijadwalkan. Dalam banyak kasus, seluruh sistem kuantum diperlakukan sebagai satu unit. Namun, ketika tugas melebihi kapasitas satu unit—baik dalam hal jumlah qubit, kedalaman rangkaian, atau kecepatan eksekusi—teknik seperti pemotongan/penjahitan rangkaian dapat digunakan. Pemotongan rangkaian adalah proses memecah tugas kuantum yang besar menjadi sub-tugas yang lebih kecil dan dapat dikelola yang dapat didistribusikan di beberapa chip kuantum, memungkinkan komputasi kuantum yang skalabel meskipun ada keterbatasan hardware. Penjahitan rangkaian mengacu pada proses yang datang setelah pemotongan rangkaian — langkah pasca-pemrosesan klasikal yang "menjahit" atau menggabungkan hasil dari subrangkaian yang lebih kecil kembali bersama.

Komputer kuantum tidak memiliki memori tradisional, dalam arti penyimpanan persisten dan dapat dialamatkan seperti RAM atau memori GPU. Sumber daya komputasi klasikal memiliki bit diskret yang tersimpan dalam memori, memungkinkan data untuk disimpan, diambil, dan digunakan kembali selama komputasi. Sumber daya kuantum menggunakan qubit yang tidak menyimpan memori dalam arti klasikal. Sebaliknya, qubit ada dalam state kuantum yang merepresentasikan superposisi 0 dan 1 secara bersamaan, memungkinkan paralelisme eksponensial dalam ruang state. Namun, state qubit bersifat rapuh dan tidak dapat di-clone atau dibaca secara deterministik pada langkah-langkah perantara tanpa meruntuhkan state kuantum, sehingga perilaku seperti memori persisten selama komputasi tidak ada. Qubit harus dijaga dalam state yang koheren sepanjang eksekusi, dan "memori" pada dasarnya adalah state kuantum itu sendiri. Memori klasikal hanya dapat digunakan bersama prosesor kuantum, bukan sebagai memori kuantum internal. Ini memiliki implikasi yang signifikan: sumber daya komputasi klasikal dapat menggunakan kembali dan menyimpan hasil perantara secara bebas; sumber daya kuantum tidak dapat melakukan ini tanpa pengukuran yang mengganggu komputasi.

Konektivitas ke infrastruktur klasikal

QPU dapat dihubungkan ke infrastruktur klasikal melalui jaringan dan berbagai antarmuka pemrograman aplikasi (API) yang memungkinkan pengembang perangkat lunak berinteraksi dengan QPU secara terprogram. API-API ini biasanya tersembunyi di balik software development kit (SDK) dan pustaka (seperti Qiskit) dan diekspos ke ilmuwan komputasional dalam bentuk abstraksi pemrograman (seperti Qiskit Primitives, yang akan kita bahas di Bab 3: model pemrograman).

Penting untuk membuat perbedaan antara integrasi ketat dan longgar dari sumber daya kuantum dan klasikal. Saat ini QPU tidak berada di node yang sama dengan sumber daya komputasi klasikal. Bahkan, QPU saat ini tidak terhubung melalui PCIe, tetapi melalui jaringan. Ini bisa berubah di masa depan, tetapi ada tantangan rekayasa yang terkait dengan kondisi lingkungan yang optimal untuk QPU dan sumber daya komputasi klasikal.

Skala sumber daya kuantum

Skala sumber daya kuantum juga dapat dikategorikan menjadi vertikal dan horizontal.

• Skala vertikal berarti meningkatkan jumlah qubit per chip atau meningkatkan fidelitas perangkat.
• Skala horizontal berarti menghubungkan chip dengan coupler atau dengan interkoneksi klasikal.

Uji pemahamanmu

Apa analog kuantum dari (a) bit informasi klasikal, dan (b) kecepatan prosesor?

Jawaban:

(a) Bit kuantum atau qubit - unit informasi yang tidak seperti rekan klasikal mereka (yang hanya bisa mengadopsi state 0 atau 1), dapat berada dalam superposisi 0 dan 1 secara bersamaan.

(b) Circuit layer operations per second atau CLOPS - jumlah operasi berurutan yang dapat dilakukan QPU setiap detik, termasuk beberapa antarmuka dengan sumber daya komputasi klasikal, seperti dalam memuat parameter dari rangkaian.

Manajemen sumber daya

Baik sumber daya HPC maupun kuantum sama-sama berharga dan kompleks; mereka harus dikelola dengan hati-hati. Dalam bagian ini, kita akan menjelaskan cara mengelola sumber daya untuk program pengguna. Manajemen sumber daya dalam infrastruktur komputasi mengacu pada proses (1) perencanaan, (2) alokasi, dan (3) kontrol/manajemen penggunaan sumber daya komputasi seperti CPU, memori, penyimpanan, dan bandwidth jaringan untuk memastikan utilisasi sumber daya yang efisien dan efektif.

Perencanaan - estimasi sumber daya

Setiap program mengonsumsi sumber daya, dan memperkirakan sumber daya yang diperlukan sangat penting untuk manajemen sumber daya yang efisien. Ini termasuk memperkirakan jumlah CPU, memori, dan sumber daya lain yang diperlukan untuk mengeksekusi program. Hal yang sama berlaku untuk sumber daya kuantum. Namun, sumber daya kuantum ada pada skala yang sama sekali berbeda. Prosesor kuantum IBM Quantum® Heron r3 memiliki 156 qubit, dibandingkan dengan miliaran bit klasikal pada laptop biasa. Waktu dan biaya juga menjadi pertimbangan. Saat ini, IBM Quantum memiliki paket gratis, Open Plan, yang memungkinkan pengguna untuk menjelajahi komputasi kuantum menggunakan 10 menit waktu QPU per bulan. Beberapa organisasi penelitian memerlukan waktu QPU yang begitu banyak sehingga mereka memiliki komputer kuantum IBM khusus di tempat.

Satu langkah dalam estimasi sumber daya yang unik untuk komputasi kuantum adalah kedalaman rangkaian. Seperti disebutkan sebelumnya, setiap gate kuantum dan setiap waktu tunda antara operasi memiliki noise dan probabilitas kesalahan tertentu. Semakin dalam rangkaian kuantum, semakin besar noisenya. Ada dua hal yang perlu diperhatikan: gate dua qubit memiliki tingkat kesalahan yang jauh lebih tinggi daripada gate satu qubit, sehingga seseorang sering dapat mengabaikan kedalaman satu qubit. Selanjutnya, tidak semua qubit pada chip kuantum langsung terhubung. Terkadang informasi harus ditukar dari qubit ke qubit untuk melakukan entanglement yang diperlukan dan proses pertukaran ini sendiri memerlukan gate dua qubit. Pertukaran tersebut ditangani dalam proses yang disebut "transpilasi", proses kompleks yang juga memiliki tujuan lain; ini dibahas lebih detail dalam pelajaran berikutnya. Kuantitas pembatas yang relevan adalah kedalaman dua qubit yang ditranspilasi. Kedalaman maksimum yang tepat di mana hasil fidelitas tinggi dapat diperoleh bergantung pada rangkaian. Tetapi memanfaatkan teknik mitigasi kesalahan modern, seseorang dapat memperoleh hasil fidelitas tinggi dengan kedalaman dua qubit yang ditranspilasi sebesar 80 atau lebih.

Alokasi - penjadwalan

Penjadwalan adalah proses mengalokasikan sumber daya ke program dan mengelola eksekusinya. Ini melibatkan:

• Pengiriman job: Proses di mana pengguna mengirimkan permintaan (job) ke sistem HPC, menentukan pekerjaan komputasional dan sumber daya apa yang diperlukan untuk eksekusi.
• Alokasi sumber daya: Penugasan sumber daya sistem HPC yang tersedia (seperti node, CPU, memori) ke job yang dikirimkan berdasarkan persyaratannya.
• Eksekusi job: Jalannya sebenarnya dari tugas komputasional yang didefinisikan oleh job pada sumber daya HPC yang dialokasikan.

Ada analog dari semua proses ini untuk komputer kuantum.

• Job dikirimkan oleh pengguna, memanfaatkan Qiskit Runtime, dan biasanya menggunakan primitif Qiskit Runtime, seperti Sampler, Estimator, atau lainnya.
• Pengguna memilih dari daftar Backend yang dapat mereka akses. Daftar lengkap Backend yang tersedia dapat dilihat di halaman Compute resources di IBM Quantum Platform. Umum untuk cukup menggunakan komputer kuantum yang paling tidak sibuk. Tetapi ada kasus di mana mungkin penting untuk menggunakan yang spesifik karena pertimbangan tata letak perangkat, pengulangan perhitungan sebelumnya, dan sebagainya.
• Eksekusi job kuantum mirip dengan kasus HPC. Meskipun beberapa perbedaan telah diuraikan, beberapa layak diulang di sini. QPU saat ini umumnya tidak berlokasi di node yang sama dengan sumber daya komputasi klasikal tetapi terhubung melalui jaringan. Ini mungkin memiliki implikasi penjadwalan. Selanjutnya, komputer kuantum mungkin memiliki waktu antrian yang cukup lama, dan waktu antrian ini bervariasi, membuat kontrol waktu yang tepat menjadi sulit. Situasi ini mungkin berbeda untuk sistem yang didedikasikan; itu tergantung pada administrasi internal komputer kuantum.

Kontrol/Manajemen - manajemen beban kerja

Manajemen beban kerja, juga dikenal sebagai orkestrasi, adalah proses mengelola beberapa program dan persyaratan sumber daya mereka. Ini melibatkan:

• Provisi sumber daya: Proses mempersiapkan dan membuat sumber daya HPC tersedia dan siap digunakan oleh job, termasuk setup hardware dan perangkat lunak. Seperti yang akan kita lihat nanti, QPU adalah sumber daya komputasi yang dapat diprovisikan mirip dengan sumber daya HPC klasikal, dengan peringatan dari bagian sebelumnya.
• Penjadwalan job: Aktivitas perangkat lunak penjadwal dalam memutuskan job mana yang dijalankan, kapan, dan pada sumber daya mana, mengelola prioritas dan antrian untuk memanfaatkan sistem HPC secara efisien. Meskipun pernyataan luas ini berlaku untuk sumber daya kuantum, mungkin ada kontrol waktu yang lebih sedikit daripada sumber daya lainnya.

Contoh:

Pertimbangkan tugas yang terkenal sebagai konteks untuk memahami manajemen sumber daya: menemukan faktor prima dari bilangan besar. Mari kita asumsikan lebih lanjut bahwa algoritma yang digunakan bergantung pada pengecekan brute force setiap pembagi potensial. Meskipun ini sering bukan metode yang paling efisien, mudah untuk memahami bagaimana beban kerja mungkin dikelola.

Perencanaan - estimasi sumber daya

• Perkirakan berapa banyak waktu CPU dan memori yang mungkin diperlukan faktorisasi prima.
• Rencanakan paralelisasi tugasmu - berapa banyak CPU/inti yang akan kamu gunakan?

Alokasi - penjadwalan

• Setelah pengiriman job, penjadwal menugaskan inti CPU dan memori ke tugas faktorisasi prima. Misalnya, mungkin mengalokasikan semua pembagi potensial yang berakhir dengan digit 1, 3, 7, 9 ke salah satu dari empat inti, masing-masing.
• Eksekusi job: Algoritma faktorisasi prima berjalan, melakukan pembagian atau langkah faktorisasi lainnya pada sumber daya yang dialokasikan hingga tugas selesai.

Kontrol/Manajemen - manajemen beban kerja

• Sistem mengorkestra urutan dan waktu dari job faktorisasi prima untuk mengoptimalkan throughput.
• Kasus termudah untuk dibayangkan adalah bahwa salah satu inti menemukan faktor prima target. Ini harus menghentikan perhitungan pada inti lain sehingga mereka dapat digunakan untuk tugas berikutnya.

Lingkungan high-performance computing menggunakan perangkat lunak khusus untuk menjalankan langkah-langkah ini dan mengelola sumber daya. Dalam bagian berikutnya, kita akan mempelajari tentang sistem perangkat lunak manajemen sumber daya yang banyak digunakan: Slurm.

Contoh dengan sumber daya kuantum:

Alur kerja yang akan menjadi subjek pelajaran lain dalam kursus ini adalah menentukan ground state dan energi kimia menggunakan sample-based quantum diagonalization (SQD). Ini dibahas lebih detail dalam Pelajaran 4, dan kamu juga bisa mengunjungi kursus tentang SQD ini dan metode terkait di IBM Quantum Learning. Yang perlu kita ketahui untuk diskusi ini adalah bahwa alur kerja melibatkan yang berikut:

• Siapkan rangkaian kuantum
• Ukur rangkaian kuantum
• Gunakan hasil pengukuran untuk memproyeksikan masalah ke subruang yang berguna
• Diagonalisasi matriks yang lebih kecil dan diproyeksikan menggunakan sumber daya komputasi klasikal
• Iterasi, baik untuk memastikan konsistensi diri melalui pertimbangan seperti konservasi muatan, dan kemungkinan iterasi dari rangkaian kuantum jika memiliki parameter variasional.

Perencanaan - estimasi sumber daya

• Petakan orbital elektronik ke qubit untuk menetapkan jumlah qubit yang kamu butuhkan.
• Kombinasikan Hamiltonian sistem yang dipetakan dan state (mungkin variasional) ke dalam rangkaian kuantum dan periksa kedalaman dua qubit yang ditranspilasi. Pastikan ini wajar.
• Perkirakan ukuran subruang ke mana kamu akan memproyeksikan; dari ini, perkirakan berapa banyak waktu CPU dan memori yang mungkin diperlukan diagonalisasi.
• Rencanakan paralelisasi tugasmu - berapa banyak CPU/inti yang akan kamu gunakan?

Alokasi - penjadwalan

• Pengguna memilih QPU; proses transpilasi secara otomatis memetakan qubit dalam rangkaian kuantum abstrak kamu ke qubit fisik pada QPU. Ini penting karena rangkaian abstrak mungkin mengasumsikan konektivitas langsung yang tidak ada pada chip, di antara alasan lainnya.
• Setelah pengiriman job melalui Qiskit Runtime, job memasuki antrian untuk QPU yang dipilih. Pengguna tidak memiliki kontrol atas waktu antrian, meskipun ini mungkin berbeda untuk sistem yang didedikasikan.
• Sumber daya komputasi klasikal menunggu hasil kuantum.
• Job diagonalisasi dikirimkan ke sumber daya HPC; setelah pengiriman job, penjadwal menugaskan inti CPU dan memori ke tugas diagonalisasi.
• Eksekusi job: Algoritma diagonalisasi berjalan, mendiagonalisasi matriks yang diproyeksikan lebih kecil hingga tugas selesai.

Kontrol/Manajemen - manajemen beban kerja

• Sistem mengorkestra urutan dan waktu langkah-langkah kuantum dan klasikal sepanjang waktu. Misalnya, setelah matriks yang diproyeksikan telah didiagonalisasi dan energi ground state diperoleh, tergantung pada kriteria konvergensi, alur kerja mungkin kembali ke rangkaian kuantum baru (dengan parameter variasional baru).
• Ketika kriteria konvergensi dipenuhi oleh energi ground state, perhitungan pada semua inti berhenti.

Lingkungan high-performance computing menggunakan perangkat lunak khusus untuk menjalankan langkah-langkah ini dan mengelola sumber daya. Dalam bagian berikutnya, kita akan mempelajari tentang sistem perangkat lunak manajemen sumber daya yang banyak digunakan: Slurm. Penting untuk dicatat bahwa Slurm tidak memiliki alat untuk semua langkah yang dijelaskan di atas. Slurm tidak menyediakan dukungan untuk perencanaan job, maupun manajemen beban kerja terperinci seperti komunikasi antara komponen beban kerja. Ini sangat cocok dengan keadaan komputasi kuantum saat ini di HPC, karena QPU biasanya diakses melalui jaringan.

Uji pemahamanmu

Misalkan kamu mencoba mencari database yang tidak diurutkan untuk menemukan elemen yang akan kita sebut 'target'. Untuk masing-masing tindakan berikut, nyatakan ke tahap manajemen sumber daya mana tindakan tersebut sesuai: (a) Memperkirakan ukuran database dan waktu yang diperlukan untuk memeriksa setiap elemen (b) Memastikan bahwa menemukan target pada satu GPU menghentikan proses pada GPU lain untuk membebaskannya bagi masalah berikutnya. (c) Membagi ruang pencarian menjadi wilayah untuk masing-masing dari (katakanlah 10) GPU kamu untuk dicari

Jawaban:

(a) Perencanaan (b) Kontrol/manajemen (c) Alokasi/penjadwalan,

Perangkat lunak: Slurm

Dalam bagian ini, kita akan menerapkan konsep yang dipelajari dalam bab ini untuk mempraktikkan penggunaan sistem manajemen sumber daya populer, Slurm.

Pengantar Slurm

Slurm adalah sistem manajemen sumber daya open-source yang banyak digunakan dalam lingkungan high-performance computing. Ia menyediakan seperangkat alat komprehensif untuk mengelola sumber daya, menjadwalkan job, dan memantau kinerja sistem.

Kita akan membahas dasar-dasar penggunaan Slurm, termasuk:

• Pengiriman job
• Alokasi sumber daya
• Pemantauan job

Karena sangat sulit untuk menyediakan sumber daya HPC kepada setiap mahasiswa kursus ini, kita akan sedikit menipu dan menyediakan repositori dengan image Docker yang meniru cluster HPC aktual dengan Slurm, tetapi dalam skala kecil. Ini akan membantu kita untuk mempraktikkan konsep yang dipelajari dalam lingkungan yang aman dan dapat direproduksi.

Perhatikan bahwa saat ini semua sumber daya kuantum dan klasikal dialokasikan untuk durasi seluruh eksperimen. Saat ini tidak ada alokasi sumber daya campuran yang diselingi. Peringatan terakhir adalah bahwa bahkan setelah job diluncurkan, sistem kuantum tidak akan dikontrol secara langsung seperti yang mungkin diharapkan pengguna HPC yang sering. Job diluncurkan pada node x86 sewenang-wenang, yang mengeksekusi layanan Qiskit Runtime dan layanan runtime tersebut terhubung ke penjadwal lain yang tidak memiliki kontrol langsung dari pengguna. Alur kerja dan masalah terkait ini mungkin dikenal oleh pengguna HPC yang memiliki pengalaman awal dalam mengejar akses eksklusif ke node GPU (penggunaan asli gres).

Instruksi instalasi dan gambaran umum setup

Untuk mempraktikkan kombinasi sumber daya kuantum dan HPC, kamu memerlukan akses ke lingkungan HPC nyata atau perlu mensimulasikan lingkungan HPC pada mesin lokalmu. Panduan instalasi untuk setup lokal menggunakan Docker dapat ditemukan di repositori ini. Panduan tersebut menghubungkan ke dukungan untuk menyiapkan akun IBM Cloud® dan menginstal plugin SPANK untuk QRMI. Juga dalam repositori tersebut adalah beberapa file Python untuk menguji lingkunganmu.

Setelah kamu menyelesaikan instalasi, mari gunakan perintah di bawah ini untuk memeriksa sumber daya komputasi Slurm di terminalmu. Jika instalasi berhasil, kamu harus dapat mengonfirmasi total tiga node virtual.

$ 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
...

Kita memiliki dua partisi atau kelompok node: normal dan quantum. Partisi normal terdiri dari node yang hanya memiliki akses ke sumber daya klasikal. Partisi quantum memiliki akses ke sumber daya kuantum. Kamu bisa melihat detail setiap node dengan mengeksekusi scontrol show nodes.

Jalankan contoh hello world sederhana di Slurm

Mari kita jalankan terlebih dahulu contoh hello world klasikal sederhana dengan Slurm. Kita akan menggunakan Python untuk contoh-contoh. Mari buat hello_world.py, yang sudah cukup jelas.

$ vim hello_world.py

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

Sekarang kita perlu memberi tahu manajer sumber daya sumber daya apa yang kita butuhkan untuk mengeksekusi program ini. Slurm menyediakan cara untuk menentukan semua metadata untuk job melalui skrip pengiriman, yang hanyalah skrip shell dengan anotasi khusus Slurm. Anotasi-anotasi ini memungkinkan kamu untuk menentukan persyaratan sumber daya, parameter jadwal, dan banyak lagi. Mari buat skrip shell hello_world.sh untuk ini.

$ 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
~

Mari tinjau file pengiriman dan lihat apa yang terjadi di sini.

Direktif #SBATCH adalah anotasi khusus untuk memberi tahu persyaratan apa yang kita miliki untuk eksekusi program. Di sini kamu bisa menentukan jumlah sumber daya - jumlah node, jumlah tugas per node, jumlah tugas dan CPU per node dan tugas - dan opsi lain seperti nama file output. Daftar lengkap opsi tersedia dalam dokumentasi untuk Slurm.

Sekarang saatnya menjalankan job Slurm kita. sbatch adalah perintah yang menerima file pengiriman dan memasukkan job ke antrian untuk eksekusi di Slurm.

$ sbatch hello_world.sh

Submitted batch job 63

Mari periksa status program kita menggunakan perintah squeue.

$ squeue

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

Setelah job selesai, kita bisa memeriksa hasilnya dengan melihat file output.

$ cat hello_world_logs.txt
Hello, World!

Uji pemahamanmu

Diberikan skrip shell Slurm di bawah ini, apa (a) nama job, (b) nama file Python, dan (c) nama file output? (d) Terakhir, apakah ini bisa menggunakan sumber daya kuantum atau tidak?

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

Jawaban:

(a) hello-learner (b) hello-learner_qm.py (c) hello-learner.out (d) Ya, bisa. Ini menggunakan partisi quantum.

Jalankan contoh Qiskit hello world sederhana di Slurm

Selanjutnya, mari coba menggunakan sumber daya kuantum juga. Mari buat dan jalankan program "Hello, Qiskit" sederhana yang menggunakan sumber daya kuantum.

$ 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)

Di sini kita akan menggunakan antarmuka manajemen sumber daya kuantum (QRMI), plugin Slurm SPANK untuk dukungan sumber daya dan job kuantum yang dikembangkan bersama oleh IBM, Pasqal, The Hartree Center, dan RPI. Kita membuat rangkaian pauli-2-design sederhana dengan nilai awal acak dan observabel sederhana, dan kita akan menjalankannya menggunakan Estimator untuk mendapatkan nilai ekspektasi. Untuk menjalankannya kita akan membutuhkan lagi skrip pengiriman hello_qiskit.sh, yang akan memiliki sumber daya kuantum sebagai persyaratan.

$ 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
~

Mari tinjau file pengiriman dan lihat apa yang terjadi di sana. Kita memiliki satu opsi baru, yaitu gres. gres adalah opsi Slurm untuk mendefinisikan sumber daya komputasi tambahan. Dalam kasus kita, sumber daya baru ini adalah sumber daya kuantum kita. Karena kita menentukan sumber daya dan partisi dari cluster kita di mana sumber daya kuantum tersedia, Qiskit primitives kita akan menggunakan sumber daya yang dialokasikan ini untuk mengeksekusi payload kuantum.

Sekarang saatnya menjalankan job Slurm kita.

$ sbatch hello_qiskit.sh

Kemudian, mari periksa status program kita menggunakan perintah squeue.

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

Kita bisa menjelajahi log dan hasil setelah job selesai.

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

Ringkasan

Sejauh ini, kita telah belajar apa itu sumber daya komputasi dan bagaimana menggunakannya untuk menjalankan program dalam lingkungan heterogen. Kita juga telah membuat dan mengeksekusi dua program 'Hello World' sederhana: satu untuk sumber daya klasikal dan yang lain untuk sumber daya kuantum, dan kita telah belajar cara membuat skrip shell untuk mengirimkan tugas dan melihat hasil.

Dalam pelajaran berikutnya, kita akan membangun pengetahuan tentang kontrol sumber daya ini untuk menerapkan model pemrograman ke sumber daya yang kita peroleh selama eksekusi job.

Semua kode dan skrip yang digunakan dalam bab ini tersedia untukmu dalam repositori GitHub kami.