Job queue dapat memproses banyak item secara paralel, tetapi menambah worker tidak otomatis meningkatkan throughput. Worker yang berebut lock, menulis ke cache line yang sama, atau mengambil tugas terlalu kecil dapat menghabiskan waktu untuk koordinasi alih-alih pekerjaan.

Gagasan compiler kernel data-parallel adalah menyatakan operasi atas elemen sebagai kernel, lalu menentukan bagaimana elemen dibagi dan dijalankan. Untuk queue, terapkan gagasan ini dengan mengelompokkan job independen ke dalam batch, membagi batch menjadi rentang kerja yang tidak tumpang tindih, dan membatasi sinkronisasi. Tidak perlu membangun compiler lengkap: mulai dari fungsi kernel biasa dan penjadwal yang eksplisit.

Model kerja: kernel, batch, dan tugas independen

Kernel adalah fungsi yang memproses satu item atau satu rentang item dengan aturan yang konsisten. Misalnya, menghitung nilai turunan dari setiap rekaman. Pemrosesan data-parallel aman jika setiap item dapat dihitung tanpa bergantung pada hasil item lain, atau jika ketergantungan tersebut ditangani pada tahap terpisah.

Alur sederhananya adalah:

  1. Ambil sejumlah job dari queue sebagai satu batch.
  2. Validasi batch dan bentuk rentang item yang dapat diproses secara independen.
  3. Jalankan kernel pada rentang-rentang tersebut menggunakan sejumlah worker yang dibatasi.
  4. Kumpulkan hasil, simpan dengan mekanisme yang aman terhadap pengulangan, lalu akui job ke queue.

Pemisahan ini tidak mengubah semantik queue: queue tetap menjadi sumber pengiriman dan pengakuan kerja. Batch hanya mengurangi biaya pengambilan serta penjadwalan lokal. Jika satu job memiliki efek samping yang bergantung pada urutan, jangan memprosesnya secara paralel tanpa menjaga urutan tersebut.

Menjadwalkan batch tanpa berebut cache

Pilih ukuran batch berdasarkan biaya nyata

Batch kecil mengurangi waktu tunggu sebelum pekerjaan mulai, tetapi menambah overhead pengambilan, deserialisasi, penjadwalan, dan acknowledgment. Batch besar mengamortisasi overhead itu, tetapi meningkatkan penggunaan memori, waktu tunggu item pertama, dan dampak ketika batch gagal.

Ukur waktu pemrosesan kernel dan biaya di luar kernel sebelum menetapkan ukuran batch. Mulai dengan batch yang cukup besar untuk membuat biaya koordinasi kecil dibandingkan pekerjaan, lalu uji beberapa ukuran di bawah beban representatif. Gunakan batas maksimum agar satu batch tidak menahan terlalu banyak memori atau memperpanjang latensi antrean secara berlebihan. Jika ukuran pekerjaan sangat bervariasi, batas berdasarkan jumlah item saja mungkin kurang tepat; pertimbangkan juga batas perkiraan biaya atau ukuran payload.

Bagikan rentang, bukan satu item setiap kali

Penjadwal yang memberikan satu item per worker melalui counter bersama dapat menimbulkan contention pada counter dan memperbanyak operasi sinkronisasi. Untuk pekerjaan berbiaya relatif seragam, bagi batch menjadi rentang berurutan dan berikan satu rentang kepada setiap worker. Worker kemudian membaca dan menulis data yang berdekatan, sehingga locality cache biasanya lebih baik.

Contoh Rust berikut memakai thread scoped dan rentang output yang saling terpisah. Fungsi kernel diasumsikan deterministik dan tidak melakukan efek samping bersama:

use std::thread;

fn process_batch(input: &[u64], workers: usize) -> Vec<u64> {
    assert!(workers > 0);

    let mut output = vec![0; input.len()];
    let worker_count = workers.min(input.len().max(1));
    let chunk_size = input.len().div_ceil(worker_count);

    thread::scope(|scope| {
        for (in_chunk, out_chunk) in input
            .chunks(chunk_size)
            .zip(output.chunks_mut(chunk_size))
        {
            scope.spawn(move || {
                for (src, dst) in in_chunk.iter().zip(out_chunk) {
                    *dst = kernel(*src);
                }
            });
        }
    });

    output
}

fn kernel(value: u64) -> u64 {
    value.wrapping_mul(3).wrapping_add(1)
}

Setiap worker membaca bagian input dan menulis bagian output yang berbeda. Karena hasil dikumpulkan pada posisi yang sama dengan input, urutan hasil tetap konsisten meskipun waktu penyelesaian thread berbeda. Pada sistem produksi, hindari membuat thread baru untuk setiap batch jika biaya pembuatan thread terukur; gunakan pool thread yang sudah tersedia atau worker tetap.

Ukuran chunk dalam contoh dibentuk agar jumlah rentang tidak melebihi jumlah worker. Ini cocok sebagai titik awal untuk pekerjaan seragam, bukan aturan universal. Jika durasi item sangat bervariasi, pembagian statis dapat membuat sebagian worker menganggur menunggu worker paling lambat. Gunakan chunk lebih kecil atau pembagian dinamis dalam kelompok, tetapi ukur biaya koordinasi dan contention sebelum memilihnya.

Kenali false sharing dan lock bersama

False sharing terjadi ketika worker memperbarui variabel berbeda yang kebetulan berada pada cache line yang sama. Secara logis tidak ada data yang dipakai bersama, tetapi cache koherensi antarkore tetap harus menangani line tersebut. Risiko ini lebih besar pada penghitung atau statistik kecil yang sering diperbarui daripada pada rentang output besar yang terpisah.

  • Hindari memperbarui satu counter global pada setiap item. Akumulasikan statistik per worker, lalu gabungkan setelah kernel selesai.
  • Hindari satu mutex di jalur panas untuk melindungi hasil yang sebenarnya dapat ditempatkan pada indeks terpisah.
  • Gunakan batch atau chunk berurutan untuk mengurangi pengambilan tugas dan menjaga locality.
  • Jika profil menunjukkan false sharing, pisahkan atau pad nilai per worker sesuai tata letak dan ukuran cache line pada target. Jangan menambah padding tanpa bukti dari pengukuran.

Lock tetap sesuai untuk bagian yang memang membutuhkan koordinasi. Tujuannya bukan menghapus semua sinkronisasi, melainkan memindahkannya keluar dari jalur per-item atau mengurangi frekuensinya.

Memilih jumlah worker

Jumlah worker perlu dibatasi oleh sumber daya dan karakter pekerjaan. Untuk kernel yang dominan memakai CPU, jumlah worker yang mendekati jumlah core yang tersedia menjadi titik awal pengujian, bukan jaminan nilai terbaik. Worker tambahan dapat menambah perpindahan konteks, tekanan cache, dan kompetisi dengan proses lain. Untuk pekerjaan yang banyak menunggu I/O, jumlah worker dapat berbeda karena thread sering tidak memakai CPU.

Uji beberapa tingkat paralelisme dengan beban yang sama. Pantau pemakaian CPU, throughput, latensi, panjang antrean, dan penggunaan memori. Jika throughput berhenti naik sementara latensi memburuk, menambah worker biasanya bukan solusi. Periksa contention, biaya deserialisasi, akses storage, ukuran batch, dan apakah kernel sudah menjadi bottleneck.

Pastikan kapasitas worker lokal tidak melampaui batas worker atau koneksi yang tersedia pada seluruh replika layanan. Jika setiap replika membuat pool sendiri, jumlah worker total bertambah seiring jumlah replika. Batas global perlu mempertimbangkan kapasitas CPU dan layanan downstream, bukan hanya konfigurasi satu proses.

Konsistensi hasil dan kegagalan worker

Jaga determinisme dan keamanan pengulangan

Untuk menguji konsistensi, jalankan input yang sama dengan jumlah worker dan ukuran chunk berbeda, lalu bandingkan hasil dengan eksekusi serial. Uji juga batch kosong, satu item, ukuran yang tidak habis dibagi jumlah worker, input batas, serta urutan hasil. Kernel yang memakai operasi floating-point dapat menghasilkan selisih jika urutan reduksi berubah; tetapkan toleransi atau gunakan strategi reduksi deterministik bila kesamaan bit demi bit diperlukan.

Queue umumnya dapat mengirim ulang job ketika worker gagal atau acknowledgment tidak sampai. Karena itu, anggap pemrosesan dapat dijalankan lebih dari sekali. Gunakan operasi idempoten, kunci deduplikasi, atau penulisan hasil dengan identitas job dan versi yang membuat pengulangan tidak menggandakan efek. Hindari mengakui job sebelum hasilnya tersimpan dengan aman.

Uji kegagalan, bukan hanya jalur sukses

Sisipkan kegagalan terkontrol pada sebagian item atau worker, lalu verifikasi bahwa kegagalan terlihat, job tidak hilang, dan retry tidak menggandakan efek samping. Tentukan kebijakan untuk batch parsial: gagal dan ulangi seluruh batch, atau pisahkan item gagal dan ulangi hanya item tersebut. Mengulang seluruh batch lebih sederhana, tetapi dapat mahal; retry parsial mengurangi pekerjaan ulang, tetapi memerlukan pencatatan hasil per item yang benar.

Tambahkan batas retry dan jalur penanganan untuk job yang terus gagal, seperti dead-letter queue jika sistem queue mendukungnya. Catat ID job, jumlah percobaan, dan kategori error. Jangan mengubah kegagalan menjadi hasil sukses kosong hanya agar worker terus berjalan; hal itu menyembunyikan kehilangan data.

Metrik dan langkah penerapan

Pantau metrik pada tingkat queue dan kernel agar masalah penjadwalan dapat dibedakan dari masalah downstream:

  • Throughput: job selesai per detik, disertai jumlah item per batch.
  • Latensi: waktu tunggu di queue dan waktu pemrosesan; gunakan persentil untuk menangkap ekor latensi.
  • Backlog: panjang antrean dan usia job tertua, untuk melihat apakah kapasitas mengejar laju masuk.
  • Efisiensi worker: waktu kerja aktif, waktu idle, penggunaan CPU, serta jumlah retry dan kegagalan.
  • Kontensi: waktu menunggu lock atau counter bersama, jika runtime dan alat profiling dapat mengukurnya.

Mulai dengan kernel yang deterministik, pembagian rentang statis, dan jumlah worker terbatas. Bandingkan hasil paralel dengan jalur serial, lalu uji ukuran batch dan jumlah worker secara terpisah. Profilkan sebelum mengoptimalkan cache line atau mengganti scheduler. Pendekatan ini menjaga implementasi tetap sederhana sambil memberi data untuk menentukan kapan penjadwalan dinamis, retry parsial, atau pemisahan data lebih lanjut benar-benar diperlukan.