MPI: Bcast

MPI_Bcast (broadcast) adalah salah satu collective communication primitive dalam MPI yang digunakan untuk menyalin data dari satu proses (root) ke seluruh proses lain dalam suatu communicator. Setelah pemanggilan selesai, semua proses memiliki salinan data yang identik.

Signature

int MPI_Bcast(
    void         *buffer,
    int           count,
    MPI_Datatype  datatype,
    int           root,
    MPI_Comm      comm
);

Parameter

Parameter	Arah	Deskripsi
buffer	in/out	Pointer ke buffer data. Di proses root, berisi data yang akan dikirim. Di proses lain, akan diisi dengan data yang diterima.
count	in	Jumlah elemen dalam buffer.
datatype	in	Tipe data tiap elemen (misal MPI_FLOAT, MPI_INT, MPI_DOUBLE).
root	in	Rank proses yang menjadi sumber data.
comm	in	Communicator tempat operasi dilakukan (umumnya MPI_COMM_WORLD).

Semantik

MPI_Bcast adalah operasi kolektif dan blocking (dalam standar MPI-3 dan sebelumnya):

• Kolektif: Semua proses dalam comm wajib memanggil MPI_Bcast dengan nilai root dan comm yang sama. Jika ada satu proses yang tidak memanggil, program akan deadlock.
• Blocking: Pemanggilan akan kembali (return) setelah buffer lokal aman untuk digunakan kembali; bukan setelah semua proses menerima data.

Perlu dicatat bahwa proses root juga memanggil MPI_Bcast, bukan hanya proses penerima. Ini berbeda dari pola send/recv di point-to-point communication.

Contoh penggunaan

Contoh: root (rank 0) menyiarkan sebuah matriks B berukuran 1024×1024 ke seluruh proses.

#include <mpi.h>
#include <stdlib.h>

int main(int argc, char **argv) {
    MPI_Init(&argc, &argv);

    int rank, size;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    const int N = 1024;
    float *B = (float*) malloc(N * N * sizeof(float));

    if (rank == 0) {
        // Hanya root yang menginisialisasi data
        for (int i = 0; i < N * N; i++) {
            B[i] = (float) i;
        }
    }

    // Semua proses memanggil MPI_Bcast
    MPI_Bcast(B, N * N, MPI_FLOAT, 0, MPI_COMM_WORLD);

    // Setelah baris ini, semua proses memiliki salinan B yang identik

    free(B);
    MPI_Finalize();
    return 0;
}

Pola penggunaan umum

MPI_Bcast sering muncul dalam pola berikut:

• Distribusi parameter konfigurasi dari root ke seluruh worker di awal program.
• Distributed matrix multiplication (C = A × B): matriks A di-scatter per baris dengan Template:Ml, sementara matriks B disiarkan utuh dengan MPI_Bcast karena setiap proses memerlukan seluruh B untuk menghitung bagiannya.
• Iterative solver (misal Jacobi, Conjugate Gradient): broadcast nilai konvergensi atau global reduction result tiap iterasi.

Implementasi internal

Implementasi MPI modern (Open MPI, MPICH) tidak melakukan broadcast secara naif (root mengirim ke tiap proses satu per satu). Sebaliknya, digunakan algoritma berbasis topologi seperti:

• Binomial tree: kompleksitas Template:Math langkah komunikasi, cocok untuk pesan kecil.
• Scatter + Allgather (Van de Geijn): lebih efisien untuk pesan besar karena memanfaatkan bandwidth agregat.
• Pipeline: memecah pesan besar menjadi chunk yang dialirkan overlap.

Pemilihan algoritma dilakukan otomatis oleh MPI runtime berdasarkan ukuran pesan, jumlah proses, dan topologi jaringan.

Performa

Biaya komunikasi MPI_Bcast dapat dimodelkan secara kasar dengan:

$T_{\text{bcast}}\approx \alpha {\log }_{2}P+\beta \cdot n$

dengan:

• $\alpha$ = latency per pesan
• $\beta$ = waktu per byte
• $n$ = ukuran pesan dalam byte
• $P$ = jumlah proses

Konsekuensinya:

• Untuk pesan kecil, latency ($\alpha$) yang dominan; semakin banyak proses semakin lama.
• Untuk pesan besar, bandwidth ($\beta \cdot n$) yang dominan; pengaruh jumlah proses berkurang.

Pada cluster heterogen (misal mencampur node cepat dan lambat), MPI_Bcast akan terhambat oleh node terlambat karena sifat synchronous-nya. Semua proses harus selesai menerima sebelum operasi dianggap selesai.

Hubungan dengan primitif lain

Primitif	Arah data	Keterangan
Template:Ml	1 → N	Semua proses menerima data yang sama dari root.
Template:Ml	1 → N	Root membagi data menjadi potongan-potongan ke tiap proses.
Template:Ml	N → 1	Root mengumpulkan data dari semua proses.
Template:Ml	N → N	Semua proses memiliki gabungan data dari semua proses.
Template:Ml	N → 1	Root menerima hasil agregasi (sum, max, dll).

Catatan

• Sejak MPI-3, tersedia versi non-blocking yaitu Template:Ml yang memungkinkan overlap komunikasi dengan komputasi.
• Buffer di proses root tidak boleh di-alias-kan dengan buffer penerima; meskipun praktiknya buffer yang sama digunakan untuk in/out.