pegasus-mpi-cluster - Online di Awan

PROGRAM:

NAMA

pegasus-mpi-cluster - alat untuk menjalankan alur kerja komputasi yang dinyatakan sebagai DAG
(Directed Acyclic Graphs) pada klaster komputasi menggunakan MPI.

RINGKASAN

pegasus-mpi-cluster [pilihan] alur kerja.dag

DESKRIPSI

pegasus-mpi-cluster adalah alat yang digunakan untuk menjalankan HTC (High Throughput Computing) ilmiah
alur kerja pada sistem yang dirancang untuk HPC (High Performance Computing). Banyak sistem HPC memiliki
arsitektur khusus yang dioptimalkan untuk aplikasi paralel yang digabungkan erat. Ini
sistem umumnya memiliki eksotik, jaringan latensi rendah yang dirancang untuk melewati short
pesan dengan sangat cepat antar node komputasi. Banyak dari jaringan ini sangat tinggi
dioptimalkan bahwa node komputasi bahkan tidak mendukung tumpukan TCP/IP. Ini membuatnya
tidak mungkin menjalankan aplikasi HTC menggunakan perangkat lunak yang dirancang untuk komoditas
cluster, seperti Condor.

pegasus-mpi-cluster dikembangkan untuk mengaktifkan aplikasi HTC yang digabungkan secara longgar seperti:
alur kerja ilmiah untuk memanfaatkan sistem HPC. Untuk menyiasati jaringan
masalah yang diuraikan di atas, pegasus-mpi-cluster menggunakan MPI (Message Passing Interface), a
API yang umum digunakan untuk menulis aplikasi paralel SPMD (Single Process, Multiple Data).
Sebagian besar sistem HPC memiliki implementasi MPI yang bekerja pada jaringan eksotis apa pun
arsitektur yang digunakan sistem.

An pegasus-mpi-cluster pekerjaan terdiri dari proses master tunggal (proses ini adalah peringkat 0 di
bahasa MPI) dan beberapa proses pekerja. Proses master mengelola alur kerja dan
memberikan tugas alur kerja kepada pekerja untuk dieksekusi. Para pekerja menjalankan tugas dan kembali
hasilnya ke master. Keluaran apa pun yang ditulis ke stdout atau stderr oleh tugas akan ditangkap
(Lihat TUGAS STDIUM).

pegasus-mpi-cluster aplikasi dinyatakan sebagai DAG (Grafik Asiklik Berarah) (lihat DAG
FILE). Setiap simpul dalam grafik mewakili tugas, dan tepinya mewakili dependensi
antara tugas-tugas yang membatasi urutan tugas-tugas yang dijalankan. Setiap tugas adalah
program dan satu set parameter yang perlu dijalankan (yaitu perintah dan beberapa opsional
argumen). Ketergantungan biasanya mewakili dependensi aliran data dalam
aplikasi, di mana file output yang dihasilkan oleh satu tugas diperlukan sebagai input untuk yang lain.

Jika terjadi kesalahan saat menjalankan DAG yang menyebabkan alur kerja berhenti, bisa jadi:
dimulai ulang menggunakan file penyelamatan, yang mencatat kemajuan alur kerja (lihat MENYELAMATKAN
FILE). Ini memungkinkan pegasus-mpi-cluster untuk mengambil menjalankan alur kerja di mana ia berhenti.

pegasus-mpi-cluster dirancang untuk berfungsi baik sebagai alat yang berdiri sendiri atau sebagai pelengkap untuk
Sistem Manajemen Alur Kerja Pegasus (WMS). Untuk informasi lebih lanjut tentang menggunakan PMC dengan
Pegasus lihat bagian di PMC DAN pegasus.

pegasus-mpi-cluster memungkinkan aplikasi yang dinyatakan sebagai DAG untuk dieksekusi secara paralel pada a
sejumlah besar node komputasi. Ini dirancang untuk menjadi sederhana, ringan dan kuat.

PILIHAN

-h, --membantu
Cetak pesan bantuan

-V, --Versi: kapan
Informasi versi cetak

-v, --bertele-tele
Meningkatkan verbositas logging. Menambahkan beberapa -v meningkatkan tingkat lebih. Standarnya
tingkat log adalah INFO. (Lihat masuk)

-q, --diam
Kurangi verbositas logging. Menambahkan beberapa -q menurunkan tingkat lebih. Standarnya
tingkat log adalah INFO. (Lihat masuk)

-s, --skip-penyelamatan
Abaikan file penyelamatan untuk alur kerja.dag jika itu ada. Perhatikan bahwa pegasus-mpi-cluster
masih akan membuat file penyelamatan baru untuk proses saat ini. Perilaku default adalah untuk
gunakan file penyelamatan jika ditemukan. (melihat MENYELAMATKAN FILE)

-o path, --stdout path
Jalur ke file untuk tugas stdout. (melihat TUGAS STDIUM dan --per-tugas-stdio)

-e path, --stderr path
Jalur ke file untuk tugas stderr. (melihat TUGAS STDIUM dan --per-tugas-stdio)

-m M, --max-kegagalan M
Berhenti mengirimkan tugas baru setelah M tugas telah gagal. Satu kali M telah tercapai,
pegasus-mpi-cluster akan menyelesaikan menjalankan tugas apa pun yang telah dimulai, tetapi tidak akan
memulai tugas lagi. Opsi ini digunakan untuk mencegah pegasus-mpi-cluster dari
terus menjalankan alur kerja yang mengalami kesalahan sistematis, seperti:
biner yang hilang atau jalur yang tidak valid. Standar untuk M adalah 0, yang berarti tidak terbatas
kegagalan diperbolehkan.

-t T, --mencoba T
Cobalah untuk menjalankan setiap tugas T kali sebelum menandai tugas sebagai gagal. Perhatikan bahwa T
percobaan tidak dihitung sebagai kegagalan untuk tujuan -m pilihan. Sebuah tugas hanya
dianggap gagal jika dicoba T waktu dan semua T percobaan menghasilkan bukan nol
kode keluar. Nilai dari T harus minimal 1. Standarnya adalah 1.

-n, --tidak terkunci
Jangan kunci DAGFILE. Secara default, pegasus-mpi-cluster akan mencoba untuk memperoleh
kunci eksklusif pada DAGFILE untuk mencegah beberapa pekerjaan MPI menjalankan DAG yang sama di
waktu yang sama. Jika opsi ini ditentukan, maka kunci tidak akan diperoleh.

-r, --menyelamatkan path
Jalur untuk menyelamatkan log. Jika file tersebut ada, dan -s tidak ditentukan, maka log akan menjadi
digunakan untuk memulihkan keadaan alur kerja. File terpotong setelah dibaca dan
log penyelamatan baru dibuat sebagai gantinya. Standarnya adalah menambahkan .menyelamatkan ke DAG
nama file. (melihat MENYELAMATKAN FILE)

--skrip host path
Jalur ke skrip atau yang dapat dieksekusi untuk diluncurkan pada setiap host unik yang pegasus-mpi-cluster
sedang berjalan. Jalur ini juga dapat diatur menggunakan lingkungan PMC_HOST_SCRIPT
variabel. (melihat HOST SKRIP)

--host-memori ukuran
Jumlah memori yang tersedia pada setiap host dalam MB. Defaultnya adalah menentukan jumlahnya
RAM fisik secara otomatis. Nilai ini juga dapat diatur menggunakan PMC_HOST_MEMORY
variabel lingkungan. (melihat BERBASIS SUMBER DAYA PENJADWALAN)

--host-cpus cpus
Jumlah CPU yang tersedia di setiap host. Defaultnya adalah menentukan jumlah CPU
core secara otomatis. Nilai ini juga dapat diatur menggunakan lingkungan PMC_HOST_CPUS
variabel. (melihat BERBASIS SUMBER DAYA PENJADWALAN)

--batas-ketat
Ini memungkinkan batas penggunaan memori yang ketat untuk tugas-tugas. Ketika opsi ini ditentukan, dan
tugas mencoba mengalokasikan lebih banyak memori daripada yang diminta di DAG, memori
operasi alokasi akan gagal.

--waktu dinding maksimal menit
Ini adalah jumlah menit maksimum yang pegasus-mpi-cluster akan memungkinkan alur kerja
untuk berlari. Kapan waktu ini berakhir pegasus-mpi-cluster akan membatalkan alur kerja dan bergabung
semua file stdout/stderr pekerja. Nilainya dalam menit, dan
default adalah waktu dinding tidak terbatas. Opsi ini ditambahkan sehingga output dari alur kerja
akan dicatat bahkan jika alur kerja melebihi waktu dinding maksimum dari pekerjaan batchnya. Ini
nilai juga dapat diatur menggunakan variabel lingkungan PMC_MAX_WALL_TIME.

--per-tugas-stdio
Ini menyebabkan PMC menghasilkan file .out.XXX dan .err.XXX untuk setiap tugas alih-alih
tugas menulis stdout/stderr ke --stdout dan --stderr. Nama filenya adalah
"TASKNAME.out.XXX" dan "TASKNAME.err.XXX", di mana "TASKNAME" adalah nama tugas
dari DAG dan "XXX" adalah nomor urut yang bertambah setiap kali tugas
dicoba. Opsi ini menimpa nilai untuk --stdout dan --stderr. Argumen ini adalah
digunakan oleh Pegasus ketika alur kerja direncanakan dalam mode khusus PMC untuk memfasilitasi debugging
dan pemantauan.

--log status pekerjaan
Opsi ini menyebabkan PMC menghasilkan file jobstate.log untuk alur kerja. Filenya adalah
bernama "jobstate.log" dan ditempatkan di direktori yang sama di mana file DAG berada
terletak. Jika file sudah ada, maka PMC menambahkan baris baru ke file yang ada.
Opsi ini digunakan oleh Pegasus saat alur kerja direncanakan dalam mode khusus PMC untuk
memudahkan pemantauan.

--monitord-retas
Opsi ini menyebabkan PMC menghasilkan file .dagman.out untuk alur kerja. File ini
meniru konten file .dagman.out yang dibuat oleh Condor DAGMan. intinya
opsi ini untuk mengelabui monitor agar berpikir bahwa itu berurusan dengan DAGMan sehingga
itu akan menghasilkan acara yang sesuai untuk mengisi database STAMPEDE untuk
tujuan pemantauan. File tersebut bernama "DAG.dagman.out" di mana "DAG" adalah jalur ke
file PMC DAG.

--tidak ada-log sumber daya
Jangan menghasilkan alur kerja.dag.resource file untuk alur kerja.

--tidak-tidur-di-recv
Jangan gunakan polling dengan sleep() untuk mengimplementasikan penerimaan pesan. (melihat Diketahui Masalah: CPU
penggunaan)

--maxfds
Atur jumlah maksimum deskriptor file yang dapat dibiarkan terbuka oleh master untuk I/O
penerusan. Secara default nilai ini diatur secara otomatis berdasarkan nilai
getrlimit(RLIMIT_NOFILE). Nilainya harus minimal 1, dan tidak boleh lebih dari
RLIMIT_NOFILE.

--keep-afinitas
Secara default, PMC mencoba mengatur ulang afinitas CPU dan memori. Ini untuk memastikan bahwa
semua CPU dan memori yang tersedia dapat digunakan oleh tugas PMC pada sistem yang tidak
dikonfigurasi dengan benar. Bendera ini memberi tahu PMC untuk menyimpan pengaturan afinitas yang diwarisi dari
induknya. Perhatikan bahwa kebijakan memori hanya dapat dihapus jika PMC dikompilasi dengan
libnuma. Afinitas CPU dihapus menggunakan jadwal_setaffinity(), dan kebijakan memori adalah
dibersihkan dengan set_mempolicy().

DAG FILE

pegasus-mpi-cluster alur kerja diekspresikan menggunakan format berbasis teks sederhana yang mirip dengan
yang digunakan oleh Condor DAGMan. Hanya ada dua jenis rekaman yang diizinkan dalam file DAG: TUGAS
dan EDGE. Setiap baris kosong di DAG (baris dengan semua karakter spasi) diabaikan,
seperti halnya setiap baris yang dimulai dengan # (perhatikan bahwa # hanya dapat muncul di awal baris,
tidak di tengah).

Format dari TUGAS catatan adalah:

"TUGAS" id [opsi...] dapat dieksekusi [argumen...]

Where id adalah ID tugas, Pilihan adalah daftar opsi tugas, executable adalah jalannya
ke executable atau skrip untuk dijalankan, dan argumen... adalah daftar yang dipisahkan oleh ruang dari
argumen untuk diteruskan ke tugas. Contohnya adalah:

TUGAS t01 -m 10 -c 2 /bin/program -a -b

Contoh ini menentukan tugas t01 yang membutuhkan memori 10 MB dan 2 CPU untuk dijalankan
/bin/program dengan argumen -a dan -b. Opsi tugas yang tersedia adalah:

-m M, --permintaan-memori M
Jumlah memori yang dibutuhkan oleh tugas dalam MB. Standarnya adalah 0, yang berarti memori
tidak dipertimbangkan untuk tugas ini. Opsi ini dapat diatur untuk pekerjaan di DAX dengan
menentukan profil pegasus::pmc_request_memory. (melihat BERBASIS SUMBER DAYA PENJADWALAN)

-c N, --permintaan-cpus N
Jumlah CPU yang dibutuhkan oleh tugas. Standarnya adalah 1, yang menyiratkan bahwa
jumlah slot pada host harus kurang dari atau sama dengan jumlah CPU fisik
agar semua slot dapat digunakan. Opsi ini dapat diatur untuk pekerjaan di DAX dengan
menentukan profil pegasus::pmc_request_cpus. (melihat BERBASIS SUMBER DAYA PENJADWALAN)

-t T, --mencoba T
Berapa kali mencoba menjalankan tugas sebelum gagal secara permanen. Ini adalah
setara tingkat tugas dari --mencoba opsi baris perintah.

-p P, --prioritas P
Prioritas tugas. P harus bilangan bulat. Nilai yang lebih besar memiliki prioritas yang lebih tinggi.
Standarnya adalah 0. Prioritas hanyalah petunjuk dan tidak ketat—jika tugas tidak dapat
cocok dengan slot yang tersedia (misalnya karena ketersediaan sumber daya), tetapi dengan prioritas yang lebih rendah
tugas dapat, maka tugas tersebut akan ditangguhkan dan tugas dengan prioritas lebih rendah akan dijalankan.
Opsi ini dapat diatur untuk pekerjaan di DAX dengan menentukan pegasus::pmc_priority
profil.

-f VAR = FILE, --pipa-maju VAR = FILE
Teruskan I/O ke file FILE menggunakan pipa untuk berkomunikasi dengan tugas. Lingkungan
variabel VAR akan disetel ke nilai deskriptor file untuk pipa tempat
tugas dapat menulis untuk memasukkan data ke dalam FILE. Misalnya, jika tugas menentukan: -f
FOO=/tmp/foo maka variabel lingkungan FOO untuk tugas akan diatur ke angka
(misalnya 3) yang mewakili file /tmp/foo. Untuk menentukan argumen ini dalam a
Pegasus DAX Anda perlu mengatur profil pegasus::pmc_arguments (perhatikan bahwa nilai
pmc_arguments harus berisi bagian "-f" dari argumen, jadi nilai yang valid adalah:
-f A=/tmp/a ). (melihat I / O
KE DEPAN)

-F SRC = TANGGAL, --file-maju SRC = TANGGAL
Teruskan I/O ke file TANGGAL dari file SRC. Ketika tugas selesai, pekerja
akan membaca data dari SRC dan kirimkan ke master di mana itu akan ditulis ke
fillet TANGGAL. Setelah SRC dibaca itu dihapus. Untuk menentukan argumen ini dalam a
Pegasus DAX Anda perlu mengatur profil pegasus::pmc_arguments. (melihat I / O KE DEPAN)

Format dari sebuah EDGE catatan adalah:

Anak orang tua "EDGE"

Where induk adalah ID dari tugas induk, dan anak adalah ID tugas anak. Sebuah
contoh EDGE catatan adalah:

TEPI t01 t02

Alur kerja sederhana berbentuk berlian akan terlihat seperti ini:

# berlian.dag
TUGAS A / bin / gema "Saya adalah seorang"
TUGAS B / bin / gema "Saya B"
TUGAS C / bin / gema "Saya C"
TUGAS D / bin / gema "Saya D"

TEPI AB
TEPI AC
EDGE BD
CD EDGE

MENYELAMATKAN FILE

Berbagai jenis kesalahan dapat terjadi saat menjalankan DAG. Satu atau lebih tugas mungkin
gagal, pekerjaan MPI mungkin kehabisan waktu, pegasus-mpi-cluster mungkin segfault (kami harap
tidak), sistem mungkin macet, dll. Untuk memastikan bahwa DAG tidak perlu
restart dari awal setelah error, pegasus-mpi-cluster menghasilkan file penyelamatan
untuk setiap alur kerja.

File penyelamatan adalah file teks sederhana yang mencantumkan semua tugas dalam alur kerja yang
telah selesai dengan sukses. File ini diperbarui setiap kali tugas selesai, dan dihapus
secara berkala sehingga jika alur kerja gagal dan pengguna memulai ulang, pegasus-mpi-cluster
dapat menentukan tugas mana yang masih perlu dijalankan. Dengan demikian, file penyelamatan adalah semacam
log transaksi untuk alur kerja.

File penyelamatan berisi nol atau lebih catatan SELESAI. Format catatan ini adalah:

"SELESAI" *tugas*

Where tugas adalah ID tugas yang berhasil diselesaikan.

Secara default, file penyelamatan diberi nama DAGNAME.penyelamatan dimana NAMA DATANG adalah jalur ke input
berkas DAG. Nama file dapat diubah dengan menentukan -r argumen.

PMC DAN pegasus

Menggunakan PMC untuk Pegasus tugas Kekelompokan
PMC dapat digunakan sebagai pembungkus untuk mengeksekusi pekerjaan berkerumun di Pegasus. Dalam mode ini
Pegasus mengelompokkan beberapa tugas bersama-sama dan mengirimkannya sebagai tugas berkelompok tunggal ke a
sistem jarak jauh. PMC kemudian menjalankan tugas individu di cluster dan mengembalikan
hasil.

PMC dapat ditetapkan sebagai pengelola tugas untuk pekerjaan berkerumun di Pegasus dalam tiga cara:

1. Secara global di file properti

Pengguna dapat mengatur properti di file properti yang menghasilkan semua clustered
pekerjaan dari alur kerja yang dieksekusi oleh PMC. Dalam file properti Pegasus tentukan:

#FILE PROPERTI PEGASUS
pegasus.clusterer.job.aggregator=mpiexec

Dalam contoh di atas, semua pekerjaan yang dikelompokkan di semua situs jarak jauh akan diluncurkan melalui
PMC selama nilai properti tidak diganti dalam katalog situs.

2. Dengan mengatur kunci profil "job.aggregator" di katalog situs:


...
mpiexec


Dalam contoh di atas, semua pekerjaan berkerumun di siteX akan dieksekusi melalui
PMC selama nilainya tidak ditimpa dalam katalog transformasi.

3. Dengan menyetel kunci profil "job.aggregator" di katalog transformasi:

tr B {
situs situsX {
pfn "/path/ke/tugasku"
lengkungan "x86"
atau "linux"
ketik "TERPASANG"
profil pegasus "clusters.size" "3"
profil pegasus "job.aggregator" "mpiexec"
}
}

Dalam contoh di atas, semua pekerjaan yang dikelompokkan untuk transformasi B di siteX akan menjadi
dieksekusi melalui PMC.

Biasanya Anda perlu memiliki entri pegasus::mpiexec di katalog transformasi Anda
yang menentukan a) jalur ke PMC di situs jarak jauh dan b) profil globus yang relevan
seperti xcount, host_xcount dan maxwalltime untuk mengontrol ukuran pekerjaan MPI. entri itu
akan terlihat seperti ini:

tr pegasus::mpiexec {
situs situsX {
pfn "/path/ke/pegasus-mpi-cluster"
lengkungan "x86"
atau "linux"
ketik "TERPASANG"
profil globus "maxwalltime" "240"
profil globus "host_xcount" "1"
profil globus "xcount" "32"
}
}

Jika entri katalog transformasi ini tidak ditentukan, Pegasus akan mencoba membuat
jalur default berdasarkan profil lingkungan PEGASUS_HOME yang ditentukan di situs
katalog untuk situs jarak jauh.

PMC dapat digunakan dengan pengelompokan horizontal dan berbasis label di Pegasus, tetapi kami
merekomendasikan penggunaan pengelompokan berbasis label sehingga seluruh sub-grafik Pegasus DAX dapat
dikelompokkan menjadi satu pekerjaan PMC, bukan hanya satu tingkat alur kerja.

Pegasus profil untuk PMC
Ada beberapa profil Pegasus yang dipetakan ke opsi tugas PMC:

pmc_request_memori
Profil ini digunakan untuk mengatur opsi tugas --request-memory dan biasanya ditentukan
dalam DAX atau katalog transformasi.

pmc_request_cpus
Kunci ini digunakan untuk menyetel opsi tugas --request-cpus dan biasanya ditentukan dalam
DAX atau katalog transformasi.

pmc_prioritas
Kunci ini digunakan untuk mengatur opsi tugas --priority dan biasanya ditentukan dalam
DAX.

Profil ini digunakan oleh Pegasus saat membuat DAG input PMC saat PMC digunakan sebagai
task manager untuk pekerjaan berkerumun di Pegasus.

Profil dapat ditentukan dalam DAX seperti ini:


-a 1 -b 2 -c 3
...
1024
4
10


Contoh ini menentukan tugas PMC yang membutuhkan memori 1GB dan 4 core, dan memiliki
prioritas 10. Ini menghasilkan tugas di DAG PMC yang terlihat seperti ini:

TUGAS mytask_ID00000001 -m 1024 -c 4 -p 10 /path/ke/mytask -a 1 -b 2 -c 3

Menggunakan PMC untuk itu Seluruh Pegasus DAX
Pegasus juga dapat dikonfigurasi untuk menjalankan seluruh alur kerja sebagai satu pekerjaan PMC. Di dalam
mode Pegasus akan menghasilkan satu PMC DAG untuk seluruh alur kerja serta PBS
skrip yang dapat digunakan untuk mengirimkan alur kerja.

Berbeda dengan menggunakan PMC sebagai alat pengelompokan tugas, dalam mode ini tidak ada pekerjaan di
alur kerja dijalankan tanpa PMC. Seluruh alur kerja, termasuk pekerjaan tambahan seperti:
pembuatan direktori dan transfer file, dikelola oleh PMC. Jika Pegasus dikonfigurasi dalam ini
mode, maka DAGMan dan Condor tidak diperlukan.

Untuk menjalankan dalam mode PMC saja, setel properti "pegasus.code.generator" ke "PMC" di Pegasus
file properti:

pegasus.code.generator=PMC

Untuk mengirimkan pekerjaan PBS yang dihasilkan, Anda mungkin perlu membuat perubahan pada file .pbs
dihasilkan oleh Pegasus untuk membuatnya bekerja dengan cluster Anda. Mode ini eksperimental dan
belum digunakan secara luas.

masuk

Secara default, semua pesan logging dicetak ke stderr. Jika Anda mengaktifkan logging menggunakan
-v maka Anda mungkin berakhir dengan banyak stderr yang diteruskan dari pekerja ke
menguasai.

Level log dalam urutan keparahan adalah: FATAL, ERROR, WARN, INFO, DEBUG, dan TRACE.

Tingkat logging default adalah INFO. Level logging dapat ditingkatkan dengan -v dan
berkurang dengan -q.

TUGAS STDIUM

Secara default stdout dan stderr tugas akan dialihkan ke stdout master dan
stderr. Anda dapat mengubah jalur file-file ini dengan -o dan -e argumen. Anda juga bisa
aktifkan file stdio per tugas menggunakan --per-tugas-stdio argumen. Perhatikan bahwa jika per-tugas
file stdio tidak digunakan maka stdio semua pekerja akan digabung menjadi satu dan satu
err file oleh master di akhir, jadi I/O dari pekerja yang berbeda tidak akan disisipkan,
tetapi I/O dari setiap pekerja akan muncul dalam urutan yang dihasilkan. Perhatikan juga bahwa,
jika pekerjaan gagal karena alasan apa pun, output tidak akan digabungkan, tetapi akan ada
satu file untuk setiap pekerja bernama DAGFILE.out.X dan DAGFILE.err.X, di mana DAGFILE adalah jalurnya
ke input DAG, dan X adalah pangkat pekerja.

HOST SKRIP

Skrip host adalah skrip shell atau yang dapat dieksekusi yang pegasus-mpi-cluster diluncurkan pada setiap
host unik yang menjalankannya. Mereka dapat digunakan untuk memulai layanan tambahan, seperti:
memcached, yang dibutuhkan oleh tugas dalam alur kerja.

Skrip host ditentukan menggunakan salah satu dari --skrip host argumen atau PMC_HOST_SCRIPT
variabel lingkungan.

Skrip host dimulai ketika pegasus-mpi-cluster dimulai dan harus keluar dengan kode keluar
dari 0 sebelum tugas apa pun dapat dieksekusi. Jika skrip host mengembalikan kode keluar bukan nol,
maka alur kerja dibatalkan. Skrip host diberikan 60 detik untuk melakukan pengaturan apa pun yang
diperlukan. Jika tidak keluar dalam 60 detik maka sinyal SIGALRM dikirimkan ke
proses, yang jika tidak ditangani, akan menyebabkan proses berhenti.

Ketika alur kerja selesai, pegasus-mpi-cluster akan mengirimkan sinyal SIGTERM ke host
grup proses skrip. Setiap proses anak yang dibiarkan berjalan oleh skrip host akan menerima
sinyal ini kecuali mereka membuat grup proses mereka sendiri. Jika ada proses yang tersisa
untuk menerima sinyal ini, maka mereka akan diberikan beberapa detik untuk keluar, maka mereka akan
mengirim SIGKILL. Ini adalah mekanisme di mana proses yang dimulai oleh skrip host dapat
diberitahu tentang penghentian alur kerja.

BERBASIS SUMBER DAYA PENJADWALAN

Sumber daya komputasi berkinerja tinggi sering kali memiliki rasio memori terhadap CPU yang rendah. Pada saat yang sama
waktu, tugas alur kerja sering memiliki persyaratan memori yang tinggi. Seringkali, persyaratan memori
tugas alur kerja melebihi jumlah memori yang tersedia untuk setiap CPU pada host tertentu. Sebagai
hasilnya, mungkin perlu menonaktifkan beberapa CPU untuk mengosongkan memori yang cukup untuk menjalankan
tugas-tugas. Demikian pula, banyak kode memiliki dukungan untuk host multicore. Dalam hal ini adalah
diperlukan untuk efisiensi untuk memastikan bahwa jumlah inti yang dibutuhkan oleh tugas yang berjalan
pada sebuah host tidak melebihi jumlah core yang tersedia pada host tersebut.

Untuk membuat proses ini lebih efisien, pegasus-mpi-cluster mendukung berbasis sumber daya
penjadwalan. Dalam penjadwalan berbasis sumber daya, tugas dalam alur kerja dapat menentukan seberapa banyak
memori dan berapa banyak CPU yang mereka butuhkan, dan pegasus-mpi-cluster akan menjadwalkannya sehingga
tugas yang berjalan pada host tertentu tidak melebihi jumlah memori fisik dan CPU
tersedia. Ini memungkinkan pegasus-mpi-cluster untuk memanfaatkan semua CPU yang tersedia
ketika kebutuhan memori tugas rendah, tetapi juga menonaktifkan beberapa CPU saat tugas
kebutuhan memori lebih tinggi. Ini juga memungkinkan alur kerja dengan campuran inti tunggal dan
tugas multi-inti untuk dieksekusi pada kumpulan yang heterogen.

Jika tidak ada host yang tersedia yang memiliki cukup memori dan CPU untuk menjalankan salah satu dari
tugas dalam alur kerja, maka alur kerja dibatalkan.

Memori
Pengguna dapat menentukan jumlah memori yang diperlukan per tugas, dan jumlah memori
tersedia per tuan rumah. Jika jumlah memori yang dibutuhkan oleh tugas apa pun melebihi yang tersedia
memori semua host, maka alur kerja akan dibatalkan. Secara default, memori host adalah
ditentukan secara otomatis, namun pengguna dapat menentukan --host-memori untuk "berbohong" untuk
pegasus-mpi-cluster. Jumlah memori yang diperlukan untuk setiap tugas ditentukan dalam DAG
menggunakan -m/--permintaan-memori argumen (lihat DAG File).

CPU
Pengguna dapat menentukan jumlah CPU yang dibutuhkan per tugas, dan jumlah total CPU
tersedia di setiap host. Jika jumlah CPU yang dibutuhkan oleh suatu tugas melebihi yang tersedia
CPU di semua host, maka alur kerja akan dibatalkan. Secara default, jumlah CPU pada a
host ditentukan secara otomatis, tetapi pengguna dapat menentukan --host-cpus untuk over- atau
di bawah-berlangganan host. Jumlah CPU yang diperlukan untuk setiap tugas ditentukan dalam:
DAG menggunakan -c/--permintaan-cpus argumen (lihat DAG File).

I / O KE DEPAN

Dalam alur kerja yang memiliki banyak tugas kecil, biasanya I/O ditulis oleh tugas-tugas tersebut
menjadi sangat kecil. Misalnya, alur kerja mungkin memiliki 10,000 tugas yang masing-masing menulis beberapa KB
dari data. Biasanya setiap tugas menulis ke filenya sendiri, menghasilkan 10,000 file. I/O ini
pola sangat tidak efisien pada banyak sistem file paralel karena memerlukan file
sistem untuk menangani sejumlah besar operasi metadata, yang merupakan hambatan di banyak
sistem file paralel.

Salah satu cara untuk menangani masalah ini adalah dengan membuat 10,000 tugas menulis ke satu file. Itu
Masalah dengan pendekatan ini adalah mengharuskan tugas-tugas tersebut untuk menyinkronkan akses mereka ke
file menggunakan kunci POSIX atau mekanisme pengecualian bersama lainnya. Jika tidak, tulisannya
dari tugas yang berbeda dapat disisipkan dalam urutan sewenang-wenang, menghasilkan data yang tidak dapat digunakan.

Untuk mengatasi kasus penggunaan ini, PMC mengimplementasikan fitur yang kami sebut "Penerusan I/O".
Penerusan I/O memungkinkan setiap tugas dalam pekerjaan PMC untuk menulis data ke sejumlah
berbagi file dengan cara yang aman. Ini dilakukan dengan meminta proses pekerja PMC mengumpulkan data
ditulis oleh tugas dan mengirimkannya melalui jaringan berkecepatan tinggi menggunakan pesan MPI ke
proses master PMC, di mana ia ditulis ke file output. Dengan memiliki satu proses (the
proses master PMC) menulis ke file semua I/O dari banyak tugas paralel dapat
disinkronkan dan ditulis ke file dengan aman.

Ada dua cara berbeda untuk menggunakan penerusan I/O di PMC: pipa dan file. Pipa lebih banyak
efisien, tetapi file lebih mudah digunakan.

I / O ekspedisi menggunakan pipa
Penerusan I/O dengan pipa bekerja dengan meminta proses pekerja PMC mengumpulkan data dari setiap tugas
menggunakan pipa UNIX. Pendekatan ini lebih efisien daripada pendekatan berbasis file, tetapi itu
membutuhkan kode tugas untuk diubah sehingga tugas menulis ke pipa alih-alih
sebuah berkas biasa.

Untuk menggunakan penerusan I/O, tugas PMC hanya perlu menentukan -f/--pipa-maju
argumen untuk menentukan nama file untuk meneruskan data, dan nama
variabel lingkungan di mana proses pekerja PMC dapat menginformasikannya tentang file
deskriptor untuk pipa.

Misalnya, jika ada tugas "mytask" yang perlu meneruskan data ke dua file:
"myfile.a" dan "myfile.b", akan terlihat seperti ini:

TUGAS mytask -f A=/tmp/myfile.a -f B=/tmp/myfile.b /bin/mytask

Ketika proses /bin/mytask dimulai, ia akan memiliki dua variabel di lingkungannya: "A=3"
dan "B=4", misalnya. Nilai dari variabel-variabel ini adalah nomor deskriptor file dari
file yang sesuai. Dalam hal ini, jika tugas ingin menulis ke "/tmp/myfile.a", itu mendapat
nilai variabel lingkungan "A", dan memanggil write() pada nomor deskriptor itu. Dalam C
kode untuk itu terlihat seperti ini:

char *A = getenv("A");
int fd = atoi(A);
char *message = "Halo, Dunia\n";
tulis(fd, pesan, strlen(pesan));

Dalam beberapa bahasa pemrograman tidak mungkin menulis ke deskriptor file secara langsung.
Fortran, misalnya, merujuk ke file dengan nomor unit alih-alih menggunakan deskriptor file. Di dalam
bahasa-bahasa ini Anda dapat menautkan fungsi CI/O ke dalam biner Anda dan memanggilnya dari
rutinitas yang ditulis dalam bahasa lain, atau Anda dapat membuka file khusus di Linux / proc
sistem file untuk mendapatkan pegangan lain ke pipa yang ingin Anda akses. Untuk yang terakhir, file
yang harus anda buka adalah "/proc/self/fd/NUMBER" dimana NUMBER adalah nomor deskriptor file yang anda
didapat dari variabel lingkungan. Untuk contoh di atas, pipa untuk myfile.a
(variabel lingkungan A) adalah "/proc/self/fd/3".

Jika Anda menggunakan pegasus-kickstart, yang mungkin terjadi jika Anda menggunakan PMC untuk a
Alur kerja Pegasus, maka ada trik yang bisa Anda lakukan untuk menghindari memodifikasi kode Anda. Kau gunakan
itu / proc sistem file, seperti dijelaskan di atas, tetapi Anda membiarkan pegasus-kickstart menangani jalurnya
konstruksi. Misalnya, jika aplikasi Anda memiliki argumen, -o, yang memungkinkan Anda untuk
tentukan file output maka Anda dapat menulis tugas Anda seperti ini:

TUGAS mytask -f A=/tmp/myfile.a /bin/pegasus-kickstart /bin/mytask -o /proc/sendiri/fd/$A

Dalam hal ini, pegasus-kickstart akan menggantikan $A dalam argumen aplikasi Anda dengan
nomor deskriptor file yang Anda inginkan. Kode Anda dapat membuka jalur itu secara normal, menulis ke sana, dan
kemudian tutup seolah-olah itu adalah file biasa.

I / O ekspedisi menggunakan arsip
Penerusan I/O dengan file bekerja dengan meminta tugas menulis data dalam file di disk lokal.
Proses pekerja PMC membaca file-file ini dan meneruskan data ke master di mana ia bisa
ditulis ke file output yang diinginkan. Pendekatan ini mungkin jauh kurang efisien daripada menggunakan
pipa karena melibatkan sistem file, yang memiliki lebih banyak overhead daripada pipa.

Penerusan file dapat diaktifkan dengan memberikan -F/--file-maju argumen untuk tugas.

Berikut ini adalah contohnya:

TUGAS mytask -F /tmp/foo.0=/scratch/foo /bin/mytask -o /tmp/foo.0

Dalam hal ini, proses pekerja akan mengharapkan untuk menemukan file /tmp/foo.0 ketika mytask keluar
berhasil. Ia membaca data dari file itu dan mengirimkannya ke master untuk ditulis ke
akhir dari /scratch/foo. Setelah /tmp/foo.0 dibaca itu akan dihapus oleh pekerja
proses.

Pendekatan ini bekerja paling baik pada sistem di mana disk lokal adalah sistem file RAM seperti Cray
mesin XT. Atau, tugas dapat menggunakan /dev/shm pada cluster Linux biasa. Itu mungkin
juga bekerja secara relatif efisien pada disk lokal jika cache sistem file dapat
menyerap semua membaca dan menulis.

I / O ekspedisi peringatan
Saat menggunakan penerusan I/O, penting untuk mempertimbangkan beberapa peringatan.

Pertama, jika pekerjaan PMC gagal karena alasan apa pun (termasuk saat alur kerja dibatalkan karena
melanggar --waktu dinding maksimal), maka file yang berisi I/O yang diteruskan mungkin rusak. Mereka
bisa termasuk sebagian arsip, artinya hanya sebagian dari I/O dari satu atau lebih tugas yang
tertulis, dan mereka dapat menyertakan duplikat arsip, artinya I/O ditulis, tetapi
Pekerjaan PMC gagal sebelum tugas dapat ditandai sebagai berhasil, dan alur kerjanya
restart nanti. Kami tidak menjamin isi file data dalam kasus ini.
Terserah kode yang membaca file untuk a) mendeteksi dan b) pulih dari masalah tersebut.
Untuk menghilangkan duplikat, catatan harus menyertakan pengidentifikasi unik, dan untuk menghilangkan
sebagian catatan harus menyertakan checksum.

Kedua, Anda tidak boleh menggunakan penerusan I/O jika tugas Anda akan menulis banyak data ke
berkas. Karena pekerja PMC sedang membaca data dari pipa/file ke dalam memori dan mengirim
itu dalam pesan MPI, jika Anda menulis terlalu banyak, maka proses pekerja akan menjalankan sistem
kehabisan memori. Juga, semua data harus masuk ke dalam satu pesan MPI. Dalam penerusan pipa
tidak ada batasan keras pada ukuran, tetapi dalam penerusan file batasnya adalah 1MB. Kami belum
membandingkan kinerja pada I/O besar, tetapi apa pun yang lebih besar dari sekitar 1 MB mungkin
terlalu banyak. Bagaimanapun, jika data Anda lebih besar dari 1MB, maka penerusan I/O mungkin tidak akan
memiliki banyak manfaat kinerja pula.

Ketiga, I/O tidak ditulis ke file jika tugas mengembalikan kode keluar bukan nol. Kita
asumsikan bahwa jika tugas gagal, Anda tidak ingin data yang dihasilkannya.

Keempat, data dari tugas yang berbeda tidak disisipkan. Semua data ditulis oleh
tugas yang diberikan akan muncul secara berurutan di file output. Perhatikan bahwa Anda masih bisa mendapatkan
catatan parsial, namun, jika ada data dari tugas yang muncul, itu tidak akan pernah dibagi di antara
rentang yang tidak berdekatan dalam file output. Jika Anda memiliki 3 tugas yang menulis: "Saya adalah tugas" Anda
bisa mendapatkan:

Aku adalah tugasAku adalah tugasAku adalah tugas

dan:

Saya adalah tugasSaya adalah tugas

tapi tidak:

Saya adalah tugasSaya adalah tugas, saya adalah tugas

Kelima, data dari tugas yang berbeda muncul dalam urutan arbitrer di file output. Tergantung
atas urutan apa tugas dijalankan oleh PMC, yang mungkin sewenang-wenang jika tidak ada
ketergantungan antar tugas. Data yang ditulis harus mengandung informasi yang cukup
bahwa Anda dapat menentukan tugas mana yang menghasilkannya jika Anda memerlukannya. PMC tidak
tambahkan header atau cuplikan apa pun ke data.

Keenam, tugas hanya akan ditandai sebagai berhasil jika semua I/O-nya berhasil
tertulis. Jika alur kerja berhasil diselesaikan, maka I/O dijamin telah
tertulis.

Ketujuh, jika master tidak dapat menulis ke file output karena alasan apa pun (mis
master mencoba menulis I/O ke file tujuan, tetapi panggilan write() mengembalikan sebuah
error) maka tugas ditandai sebagai gagal meskipun tugas menghasilkan kode keluar bukan nol. Di dalam
dengan kata lain, Anda mungkin mendapatkan catatan kickstart bukan nol bahkan ketika PMC menandai tugas gagal.

Kedelapan, pipa hanya dapat ditulis. Jika Anda perlu membaca dan menulis data dari file, Anda
harus menggunakan penerusan file dan bukan penerusan pipa.

Kesembilan, semua file dibuka oleh master dalam mode append. Ini agar, jika alur kerja
gagal dan harus dimulai ulang, atau jika tugas gagal dan dicoba lagi, data yang
ditulis sebelumnya tidak hilang. PMC tidak pernah memotong file. Ini salah satu alasannya
mengapa Anda dapat memiliki catatan parsial dan catatan duplikat di file output.

Akhirnya, dalam penerusan file, file output dihapus saat tugas keluar. Kamu tidak bisa
mengandalkan file untuk berada di sana ketika tugas berikutnya berjalan bahkan jika Anda menulisnya ke file bersama
sistem.

MISC

Sumber Pemanfaatan
Di akhir alur kerja, master akan melaporkan pemanfaatan sumber daya dari
pekerjaan. Ini dilakukan dengan menjumlahkan total runtime dari semua tugas yang dieksekusi (termasuk
tugas yang gagal) dan dibagi dengan total waktu dinding dari pekerjaan kali N, di mana N adalah keduanya
jumlah proses termasuk master, dan jumlah pekerja. Dua ini
nilai pemanfaatan sumber daya disediakan sehingga pengguna bisa mendapatkan ide tentang bagaimana
efisien mereka memanfaatkan sumber daya yang mereka alokasikan. Pemanfaatan sumber daya yang rendah
nilai menyarankan bahwa pengguna harus menggunakan lebih sedikit inti, dan waktu dinding yang lebih lama, di masa mendatang,
sementara nilai pemanfaatan sumber daya yang tinggi menunjukkan bahwa pengguna dapat menggunakan lebih banyak inti untuk
masa depan berjalan dan mendapatkan waktu dinding yang lebih pendek.

DIKETAHUI MASALAH

garpu() dan exec ()
Agar proses pekerja untuk memulai tugas pada node komputasi node komputasi
harus mendukung garpu() dan exec () panggilan sistem. Jika mesin target Anda berjalan a
OS yang dilucuti pada node komputasi yang tidak mendukung panggilan sistem ini, lalu
pegasus-mpi-cluster tidak akan bekerja.

CPU penggunaan
Banyak implementasi MPI yang dioptimalkan sehingga pesan yang dikirim dan diterima tidak sibuk menunggu
(yaitu mereka memutar / polling pada pesan yang dikirim atau diterima alih-alih tidur). Alasannya adalah
bahwa tidur menambah overhead dan, karena banyak sistem HPC menggunakan berbagi ruang pada dedicated
perangkat keras, tidak ada proses lain yang bersaing, jadi berputar alih-alih tidur bisa
menghasilkan kinerja yang lebih baik. Pada implementasi tersebut, proses MPI akan berjalan pada CPU 100%
penggunaan bahkan ketika mereka hanya menunggu pesan. Ini adalah masalah besar untuk multicore
tugas dalam pegasus-mpi-cluster karena slot idle menghabiskan sumber daya CPU. Untuk memecahkan
masalah ini pegasus-mpi-cluster proses tidur untuk waktu yang singkat antara pemeriksaan untuk
menunggu pesan. Ini mengurangi beban secara signifikan, tetapi menyebabkan penundaan singkat dalam
menerima pesan. Jika Anda menggunakan implementasi MPI yang tidur saat mengirim pesan dan
terima alih-alih melakukan menunggu sibuk, maka Anda dapat menonaktifkan tidur dengan menentukan
--tidak-tidur-di-recv pilihan. Perhatikan bahwa master akan selalu tidur jika --waktu dinding maksimal is
ditentukan karena tidak ada cara untuk menginterupsi atau menghentikan panggilan pemblokiran di MPI
(misalnya SIGALRM tidak menyebabkan MPI_Recv mengembalikan EINTR).

LINGKUNGAN VARIABEL

Variabel lingkungan di bawah ini adalah alias untuk opsi baris perintah. Jika lingkungan
variabel hadir, kemudian digunakan sebagai default untuk opsi terkait. Jika keduanya
hadir, maka opsi baris perintah digunakan.

PMC_HOST_SCRIPT
Alias ​​untuk --skrip host .

PMC_HOST_MEMORY
Alias ​​untuk --host-memori .

PMC_HOST_CPU
Alias ​​untuk --host-cpus .

PMC_MAX_WALL_TIME
Alias ​​untuk --waktu dinding maksimal .

Gunakan pegasus-mpi-cluster online menggunakan layanan onworks.net