İçeriğe geç

SA-MP Pluginlerde ProcessTick ve Thread Güvenliği

Dosya, HTTP veya ağır hesaplama işleri sunucu thread’ini bekletirse bütün oyuncular gecikmeyi hisseder. Bu işleri arka planda çalıştırmak çözümün yalnızca ilk yarısıdır. Sonucu Pawn’a veya SA-MP API’sine yanlış thread’den gönderirsen yarış durumu ve rastgele çökmeler üretirsin.

ProcessTick, worker thread ile SA-MP ana döngüsü arasında kontrollü bir teslim noktası kurmak için kullanılır.

Önce Supports dönüşüne SUPPORTS_PROCESS_TICK ekle:

PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports()
{
return SUPPORTS_VERSION |
SUPPORTS_AMX_NATIVES |
SUPPORTS_PROCESS_TICK;
}

Ardından export edilen fonksiyonu tanımla:

PLUGIN_EXPORT void PLUGIN_CALL ProcessTick()
{
// Main-thread work will run here.
}

Windows’ta starter.def dosyasını da güncelle:

starter.def
EXPORTS
Supports
Load
Unload
AmxLoad
AmxUnload
ProcessTick

Bayrağı ekleyip fonksiyonu export etmezsen sunucu var olmayan bir giriş noktasını çağırmaya çalışabilir. Fonksiyonu yazıp bayrağı eklemezsen de ProcessTick çağrılmaz.

ProcessTick, sunucu döngüsünün her turunda çağrılır. İki çağrı arasındaki sürenin her makinede sabit olduğunu varsayma. “100 tick eşittir 500 ms” gibi hesaplar yük altında ve farklı sleep ayarlarında kayar.

Gerçek süre gerektiğinde monoton saat kullan:

#include <chrono>
using Clock = std::chrono::steady_clock;
Clock::time_point nextRun = Clock::now();
void RunScheduledWork()
{
const auto now = Clock::now();
if (now < nextRun)
{
return;
}
nextRun = now + std::chrono::seconds(1);
// Execute lightweight work.
}

steady_clock, sistem saati ileri veya geri alındığında süre hesabının bozulmasını önler.

Worker thread yalnızca kendi işini yapmalı ve sonucunu thread güvenli kuyruğa bırakmalıdır. Kuyruktaki callback’ler ProcessTick içinde, yani ana sunucu thread’inde çalıştırılır:

#include <exception>
#include <functional>
#include <mutex>
#include <queue>
#include <utility>
std::mutex taskMutex;
std::queue<std::function<void()>> mainThreadTasks;
void EnqueueMainThreadTask(std::function<void()> task)
{
std::lock_guard<std::mutex> lock(taskMutex);
mainThreadTasks.push(std::move(task));
}
void DrainMainThreadTasks()
{
std::queue<std::function<void()>> pendingTasks;
{
std::lock_guard<std::mutex> lock(taskMutex);
pendingTasks.swap(mainThreadTasks);
}
while (!pendingTasks.empty())
{
try
{
pendingTasks.front()();
}
catch (const std::exception& exception)
{
logprintf("[starter] Main-thread task failed: %s", exception.what());
}
catch (...)
{
logprintf("[starter] Main-thread task failed with an unknown error");
}
pendingTasks.pop();
}
}
PLUGIN_EXPORT void PLUGIN_CALL ProcessTick()
{
DrainMainThreadTasks();
}

Kilit yalnızca iki kuyruğun yerini değiştirirken tutulur. Gerçek işler mutex kilitliyken çalışmadığı için worker thread yeni sonuç eklemeye devam edebilir.

ProcessTick sunucunun çağırdığı bir ABI giriş noktasıdır. Kuyruktaki C++ exception’larının bu sınırdan dışarı çıkmasına izin vermediğimiz için hatalı bir görev doğrudan sunucu sürecini sonlandırmaz.

Worker thread içinde yapılabilecekler:

  • dosya okuma ve kontrollü veri dönüştürme,
  • harici kütüphanenin thread güvenli API’si,
  • ağ isteği veya ağır hesaplama,
  • yalnızca worker’a ait veriyi işleme.

Ana thread’e bırakılması gerekenler:

  • amx_FindPublic, amx_Push*, amx_Exec ve diğer AMX çağrıları,
  • Pawn callback tetikleme,
  • sampgdk üzerinden SA-MP fonksiyonu çağırma,
  • aktif AMX listesini değiştirme.

Kuyruğa ham AMX* pointer’ı yakalayan uzun ömürlü lambda bırakma. İlgili filterscript görev çalışmadan önce unload olabilir. Worker sonucu yalnızca veri olarak taşısın; hedef AMX’i ProcessTick sırasında güncel loadedScripts listesinden seç.

Plugin unload edilirken worker thread hâlâ plugin kodu çalıştırıyorsa sunucu serbest bırakılmış koda dönebilir. Thread yaşam döngüsünü açıkça yönet:

#include <atomic>
#include <thread>
std::atomic<bool> workerRunning{false};
std::thread workerThread;
void StartWorker()
{
workerRunning = true;
workerThread = std::thread([]
{
while (workerRunning)
{
// Wait for or process background work.
}
});
}
void StopWorker()
{
workerRunning = false;
if (workerThread.joinable())
{
workerThread.join();
}
}

StartWorker ancak Load içindeki zorunlu adresler ve bağımlılıklar hazırlandıktan sonra çağrılmalıdır. Unload ise önce yeni işi durdurmalı, bekleyen worker’ı join etmeli, sonra diğer kaynakları bırakmalıdır.

Boş dönen bir while döngüsü CPU tüketir. Gerçek uygulamada condition variable, bloklayan I/O veya kontrollü bekleme mekanizması kullan. Worker girişinde exception’ları yakala; yakalanmayan bir exception bütün süreci sonlandırabilir. Thread’i detach etmek unload güvenliğini ortadan kaldırdığı için pluginlerde genellikle yanlış tercihtir.

Kuyrukta binlerce sonuç birikirse hepsini aynı tick’te işlemek sunucuyu yine dondurabilir. Production plugininde zaman veya adet bütçesi kullan:

constexpr std::size_t maxTasksPerTick = 32;

Kalan işleri sonraki tick’e bırak. Kuyruk için üst sınır ve backpressure davranışı da tanımla: yeni işi reddetmek, eski işi düşürmek veya üreticiyi yavaşlatmak seçeneklerinden birini bilinçli seç.

ProcessTick void döner. Bir işin başarı sonucunu bu fonksiyondan sunucuya döndüremezsin. Sonuçları plugin durumunda sakla, Pawn callback ile ilet veya ilgili native’in daha sonra sorgulayacağı bir job ID üret.

  • Supports bayrağı ve .def export’u birlikte güncellendi.
  • Tick sayısı süre ölçümü olarak kullanılmıyor.
  • AMX ve SA-MP çağrıları ana thread’de yapılıyor.
  • Worker thread Unload sırasında durdurulup join ediliyor.
  • Kuyruk sınırsız büyümüyor ve tick başına iş bütçesi var.

Sıradaki adım: sampgdk ile SA-MP API’sini C++ tarafından kullan.