Priority inversion terjadi ketika task berprioritas rendah menahan shared resource (seperti database row lock atau distributed lock), sementara task berprioritas tinggi terblokir menunggu resource tersebut. Masalah memburuk saat task berprioritas menengah menyita kapasitas compute worker pool, menyebabkan task berprioritas tinggi mengalami starvation tanpa batas waktu yang jelas.
Microkernel QNX menyelesaikan masalah ini pada level IPC (Inter-Process Communication) synchronous message-passing menggunakan priority inheritance: jika thread berprioritas tinggi mengirim pesan ke server thread atau memblokir pada channel yang sedang melayani client berprioritas rendah, prioritas thread penerima/pemegang lock dinaikkan secara dinamis mengikuti prioritas pemanggil tertinggi hingga resource dilepas.
Akar Masalah: Priority Inversion pada Worker Terdistribusi
Pada arsitektur message broker tipikal (misalnya RabbitMQ, Redis Streams, SQS), model pengantrian sering kali hanya memprioritaskan konsumsi pesan dari broker, bukan eksekusi downstream dependencies. Skenario starvation terjadi sebagai berikut:
- Task L (Low) mengambil lock resource X pada Redis/Postgres dan memulai eksekusi I/O panjang.
- Task H (High) dijadwalkan, membutuhkan lock resource X, lalu terblokir menunggu Task L selesai.
- Task M (Medium) dalam jumlah banyak membanjiri antrian. Task M tidak membutuhkan lock X, tetapi menghabiskan worker concurrency pool.
- Dampak: Task L tertunda mendapatkan alokasi thread/CPU untuk menyelesaikan pekerjaannya, sehingga Task H terhenti di belakang Task M. Inilah kondisi priority inversion klasik di level distributed runtime.
Pola Mitigasi: Priority Inheritance vs Dedicated Queue Pools
Terdapat dua arsitektur utama untuk memitigasi anomali ini:
- Priority Inheritance pada Distributed Lock: Mempertahankan antrian bersama, tetapi status prioritas lock holder dinaikkan secara dinamis saat lock contention terdeteksi.
- Dedicated Queue & Worker Pools: Memisahkan antrian dan pool worker berdasarkan SLA/prioritas secara statis. Task L dan Task H tidak berbagi kapasitas eksekusi yang sama.
Tabel Perbandingan Teknis
- Dedicated Pools: Konfigurasi operasional sederhana, isolasi komputasi terjamin, tetapi alokasi resource tidak efisien jika trafik bursty dan tidak menyelesaikan lock contention jika Task L dan H tetap berebut lock database yang sama.
- Priority Inheritance: Utilisasi resource optimal, meminimalkan durasi blocking task kritis, namun menambah kompleksitas koordinasi distributed state (heartbeat, metadata tracing).
Implementasi Dynamic Priority Boosting dengan Redis Lock
Kode Go berikut menerapkan distributed lock dengan mekanisme deteksi antrian contention. Ketika task prioritas tinggi terhalang, ia mendaftarkan dependensi prioritasnya ke metadata lock di Redis, memicu worker pemegang lock untuk mem-boost prioritas pemrosesan atau mengosongkan starvation.
package main
import (
"context"
"errors"
"fmt"
"time"
"github.com/redis/go-redis/v9"
)
type DistributedResourceLock struct {
client *redis.Client
key string
}
// Acquire mencoba mengambil lock. Mengembalikan status sukses atau ID task pemegang lock saat ini.
func (d *DistributedResourceLock) Acquire(ctx context.Context, taskID string, prio int, ttl time.Duration) (bool, error) {
// Script Lua: Atomic check-and-set lock + boost priority jika terblokir task lebih tinggi
luaScript := `
local current_lock = redis.call('GET', KEYS[1])
if not current_lock then
redis.call('SET', KEYS[1], ARGV[1], 'PX', ARGV[2])
redis.call('HSET', KEYS[2], 'holder', ARGV[1], 'priority', ARGV[3])
return {1, ARGV[1]}
end
local current_prio = tonumber(redis.call('HGET', KEYS[2], 'priority') or '0')
local incoming_prio = tonumber(ARGV[3])
-- Priority Inheritance: jika incoming prio lebih tinggi, update target metadata
if incoming_prio > current_prio then
redis.call('HSET', KEYS[2], 'priority', incoming_prio)
redis.call('HSET', KEYS[2], 'boost_requested', '1')
end
return {0, current_lock}
`
keys := []string{d.key + ":lock", d.key + ":meta"}
res, err := d.client.Eval(ctx, luaScript, keys, taskID, ttl.Milliseconds(), prio).Slice()
if err != nil {
return false, err
}
success := res[0].(int64) == 1
return success, nil
}
// Release melepaskan lock dan metadata asosiasinya
func (d *DistributedResourceLock) Release(ctx context.Context, taskID string) error {
luaScript := `
if redis.call('GET', KEYS[1]) == ARGV[1] then
redis.call('DEL', KEYS[1])
redis.call('DEL', KEYS[2])
return 1
end
return 0
`
keys := []string{d.key + ":lock", d.key + ":meta"}
_, err := d.client.Eval(ctx, luaScript, keys, taskID).Result()
return err
}
// CheckBoostStatus dipanggil oleh worker pemegang lock untuk yield / burst execution
func (d *DistributedResourceLock) CheckBoostStatus(ctx context.Context) (bool, error) {
val, err := d.client.HGet(ctx, d.key+":meta", "boost_requested").Result()
if errors.Is(err, redis.Nil) {
return false, nil
}
return val == "1", err
}
Catatan Implementasi: Pada level PostgreSQL, pola serupa dapat diterapkan menggunakan
pg_locksjoin dengan metadata table antrian untuk menaikkan priority worker process melalui sinyal atau dynamic statement timeout.
Observabilitas Latency Blocking (p99 Metrics)
Priority inversion tidak selalu memicu error rate; anomali ini lebih sering muncul sebagai degradasi latensi tinggi pada p95/p99. Metrik wajib yang perlu diekspos melalui Prometheus:
worker_queue_wait_duration_seconds{priority="high"}: Histogram waktu tunggu task di antrian sebelum diproses. Jika p99 melonjak sementara CPU idle, terjadi lock starvation.resource_lock_contention_duration_seconds: Durasi Task H memblokir pada antrian lock resource.priority_boost_events_total: Counter penanda seberapa sering priority inheritance terpicu. Peningkatan tajam menandakan alokasi resource tidak proporsional.
# Alur observabilitas mendeteksi lock contention
rate(priority_boost_events_total[5m]) > 10
histogram_quantile(0.99, sum(rate(worker_queue_wait_duration_seconds_bucket{priority="high"}[5m])) by (le)) > 2.0
Gunakan kombinasi dua metrik di atas pada alerting rule. Jika p99 latency task berprioritas tinggi melebihi SLA saat metrik boost aktif, evaluasi pemisahan shared resources atau turunkan TTL holding lock pada worker low-priority.
Komentar
0 komentar
Masuk ke akun kamu untuk ikut berkomentar.
Belum ada komentar
Jadilah yang pertama ikut berdiskusi!