RTOS ve Multiprocessing-Multithreading Kavramları

Gerçek zamanlı işletim sistemleri ve çoklu işleme yöntemleri

Günlük hayatta işletim sistemi denilince aklımıza Windows, macOS, iOS, Android, Linux gibi örnekler gelir. Bu sistemler, genel amaçlı bilgisayarlar ve mobil cihazlarda kullanılan, kullanıcı dostu arayüzleri ve çok çeşitli uygulama destekleri ile bilinir.

Ancak, özellikle gömülü sistemler, robotik, otomotiv, tıbbi cihazlar ve endüstriyel kontrol sistemleri gibi alanlarda, kesin zamanlama ve güvenilirlik gerektiren uygulamalar için Gerçek Zamanlı İşletim Sistemleri (RTOS) kullanılır.

RTOS (Real-Time Operating System) belirli zamanda görevleri yerine getirmeyle yükümlü sistemlerde kullanılan özel işletim sistemleridir. 3 ana özelliği ile bilinir.

1- Deterministik:

Aynı görevlerde her zaman aynı çıktıyı önceden bilinen sürede üretmesi

2- Görev Son Teslimi (Task Deadline):

Talep edilen her görevi son teslim zamanı olarak belirlenen süre içinde tamamlamalıdır.

3- Kesme Gecikmesi (Interrupt Latency)

Harici görevlere kesme gecikmesi (interrupt latency) olarak bilinen hızlı bir sürede cevap vermesi gerekir.

Genel anlamda RTOS ikiye ayrılır.

1- Sıkı RTOS (Hard)

Hata ve gecikme kabul etmeyen sistemlerde kullanılır. Zamanlama kesin ve kritiktir. Görevin beklenen sürede tamamlanmaması, ciddi sorunlara yol açabilir.

Kullanım Alanları: Otomotiv kontrol sistemleri (örneğin, fren sistemleri), medikal cihazlar, uçakların uçuş kontrol sistemleri gibi kritik uygulamalarda kullanılır. Zamanında tamamlanmayan işlemler can kaybı veya ciddi maddi hasara yol açabilir.

2- Yumuşak RTOS (Soft)

Zamanlama önemli olsa da, görevlerin belirlenen süreyi nadiren kaçırması sistemde ciddi hasara yol açmaz, genel işlevselliğini etkilemez. Kaçırılan teslim, performans düşüklüğüne sebep olabilir.

Kullanım Alanları: Video akışı, ses işleme, iletişim sistemleri gibi sistemlerde kullanılır.

Interrupt Nedir?

RTOS’lar gibi birçok gerçek zamanlı işletim sistemi, kritik görevlerin doğru ve zamanında çalışmasını sağlamak için kesme (interrupt) mekanizmasını kullanır.

Interrupt’lar, işlemcinin normal görev akışını keserek acil olarak işlenmesi gereken durumlara hızlı bir şekilde tepki vermesini sağlar. RTOS, bu kesmeleri ele alarak daha yüksek öncelikli veya acil durumları işlemek için görevler arasında geçiş yapar. Bu da gerçek zamanlı sistemlerde hızlı yanıt sürelerini sağlamak ve kritik görevlerin gecikmeden yerine getirilmesi açısından hayati öneme sahiptir.

Bazı kesme çeşitlerini kısaca öğrenecek olursak:

Donanımsal kesmelerde klavye, fare, buton, timer gibi donanımsal aygıtlardan gelen komut ile kesme yapılır. Bu işlemden sonra ISR (Interrupt Service Routine) protokolü devreye girer ve kesmeyi yapan donanımın belirlediği rutin devreye girer.

Yazılımsal kesmeler yazılımın kendi belirlediği koşula göre işlemciyi keser. Bu koşullar başka uygulamalardan gelecek olan sistem çağrıları gibi sıfıra bölme, bellek erişim hatası vb. beklenmeyen durumlar da olabilir. Şimdi C++ üzerinde bir örnek verelim:

#include <iostream>
int main() {
 int a = 10;
 int b = 0;

 try {
   if (b == 0) {
   throw “Division by zero error!”; // interrupt olusturuldu.
 }
 int result = a / b;
 std::cout << “Result: “ << result << std::endl;
 } catch (char* msg) {
 std::cerr << “Exception: “ << msg << std::endl;
 }
return 0;
}

Kod üzerinden de görüleceği üzerethrowvecatch fonksiyonlarıyla bir istisna yakalama (exception handling) düzeneği oluşturmuş olduk. Burada b = 0 olduğu durumlarda programı kesmesini sağlamış olduk.

Başka bir interrupt türü olan maskelenebilir kesmelerde ise bu kesmeler, işlemci tarafından engellenebilir (maskelenebilir). Bazı kesme türleri işlevi gereği maskelenemez sınıfına girer (non-Maskable). Bunlar genelde donanım arızaları ve acil durumlarda devreye girer.

Son olarak senkron kesmeler, işlemcinin yürüttüğü komutlarla doğrudan ilişkilidir ve komutların sonucunda meydana gelir (örneğin, az önceki sıfıra bölme hatası). Bu kesmeler komutla aynı anda gerçekleşir.

Asenkron kesmeler ise işlemcinin yürüttüğü işlemlerden bağımsızdır ve harici olaylar (örneğin, klavye girişi, zamanlayıcı kesmesi) tarafından tetiklenir. Herhangi bir anda gerçekleşebilirler.

Kesme mekanizmasını öğrenmiş olduk, fakat işlemciyi hangi durumlarda kesmeliyiz, hangi çekirdeği veya belleği nereye ve nasıl paylaştırabiliriz? Bu gibi sorulara yanıt aramak için bir sonraki bölüme geçelim.

Görev Yönetimi

RTOS’ta görev yönetimi, görevlerin önceliklendirilmesi, zamanlanması, durumlarının izlenmesi ve gerektiğinde görevler arasında geçiş yapılması olarak özetlenebilir.

RTOS ile birden çok görev yapılırken bu görevlerin çekirdeklerce paylaştırılması, aynı çekirdekte ise görevin önceliğine göre görev değişimi yapılması işlemcilerde toplam işlem süresini kısaltır ve sistemin tepki hızını artırır.

Introduction to multitasking and scheduling in Embedded systems

Görev Durumları

Bir görev, döngüsü boyunca çeşitli durumlar arasında geçiş yapar. RTOS, bu görevleri belirli durumlarda izler ve yönetir. Ana görev durumları:

• Hazır (Ready): Görev çalışmaya hazırdır ancak henüz işlemciyi kullanmamaktadır.
• Çalışan (Running): Görev, işlemci üzerinde aktif olarak çalışmaktadır. Aynı anda yalnızca bir görev bu durumda olabilir.
• Beklemede (Blocked/Waiting): Görev, belirli bir olayın (örneğin, bir sensörden veri gelmesi veya bir zamanlayıcının süresinin dolması) gerçekleşmesini beklemektedir.
• Askıya Alınmış (Suspended): Görev geçici olarak durdurulmuştur ve RTOS zamanlayıcısı tarafından dikkate alınmaz.

Görev Önceliği (Task Priority)

RTOS, görevler arasında öncelik seviyeleri belirleyerek, hangi görevin işlemciyi ne zaman kullanacağını yönetir. Önceliklendirme iki ana algoritma sayesinde yapılır.

1- Rate Monotonic Scheduling (RMS)

Rate Monotonic Scheduling (RMS), sabit öncelikli bir zamanlama algoritmasıdır.

Görevlerin öncelikleri, frekanslarına göre belirlenir. Daha yüksek frekanslı görevler daha yüksek önceliğe sahiptir. Yani, daha sık tekrar eden görevler daha yüksek öncelikli olur.

Adından da anlaşılacağı üzere görevlerin öncelikleri sabittir ve görevin periyodu temel alınarak belirlenir. Görevlerin periyotları değişmediği sürece, öncelikler de değişmez.

2- Earliest Deadline First (EDF)

Earliest Deadline First (EDF), dinamik önceliklendirme kullanan bir zamanlama algoritmasıdır. Bu algoritma, her görev için en yakın bitiş süresine (deadline) göre öncelik verir. Yani en yakın deadline’a sahip görev, en yüksek önceliğe sahiptir. Bu, dinamik bir önceliklendirmedir çünkü deadline’lar zamanla değişebilir ve buna bağlı olarak sürekli güncellenir.

Görev Zamanlayıcısı (Scheduler)

RTOS’taki zamanlayıcı, işlemcinin görevler arasında nasıl ve ne zaman geçiş yapacağını kontrol eder. Zamanlayıcı, önceliklere göre hangi görevin çalışacağına karar verir. İki temel zamanlayıcı stratejisi:

**Preemptive Scheduling (Öncelikli Zamanlama): **Preemptive scheduling, bir görev çalışırken daha yüksek öncelikli bir görev geldiğinde mevcut görevi kesip yüksek öncelikli görevi çalıştıran bir zamanlama tekniğidir. Bu yaklaşım, gerçek zamanlı sistemlerde zaman kritik görevlerin hızlı bir şekilde işlenmesini sağlar.

Introduction to RTOS | Digi-Key Electronics

Yukarıdaki örnekte görüldüğü gibi işlemci üzerince görevler, belirli periyotlar halinde işlem görür, önceliği yüksek bir görev geldiğinde ise önceki görevi keserek “önemi yüksek” göreve geçmiş olur.

Non-Preemptive Scheduling (Kesintisiz Zamanlama): Bu yöntemde, bir görev çalıştırılmaya başladığında, görev tamamlanana kadar diğer görevler devreye girmez. Bu, görevler arasında daha az kesinti ve daha öngörülebilir performans sağlar, ancak acil görevler için uygun olmayabilir.

Multiprocessing veya Multithreading. Hangisini, Nerede?

RTOS ile çoklu işlemeden önce bu kavramların genel tanımlarını bir tablo ile gösterecek olursak:

Yukarıdaki tablodan da anlaşılacağı üzere:

• Multitasking: Çokça rastladığımız daha genel bir terimdir, bir sistemde birden fazla görevin aynı anda yürütülmesini ifade eder. Bu görevler thread’ler veya süreçler olabilir.
• Multithreading: Bir süreç (process) içinde, aynı bellek alanını paylaşarak birden fazla iş parçacığının (thread) çalıştırılmasıdır ve genellikle tek bir çekirdek üzerinde görevler arasında hızlı geçişlerle yapılır.
• Multiprocessing: Birden fazla süreç, birden fazla çekirdek veya işlemci üzerinde paralel olarak çalışır. Gerçek anlamda fiziksel paralellik sunar.

Multiprocessing, iş yükü dağılımı bakımından ikiye ayrılır (AMP ve SMP).

SMP (Symmetric Multi-Processing), birden fazla çekirdeğin aynı bellek alanını genelde bölerek ve aynı işletim sistemini kullanarak eşit haklarla çalıştığı bir mimaridir.

AMP (Asymmetric Multi-Processing), birden fazla çekirdeğin farklı görevlerle ve farklı iş yükleriyle çalıştığı bir mimaridir. Her işlemci belirli bir göreve atanmış olabilir ve işlemciler genellikle aynı işletim sistemini paylaşmaz.

AMP heterojen bir yapı iken SMP daha homojen yapıdadır.

Aşağıdaki örnekte de görüleceği üzere ESP32 (Multicore), SMP mimarisi ile oluşturulmuştur. PRO_CPU ve APP_CPU iki çekirdeğimizi temsil eder ve görevleri paylaşır. Orta kısımda ise her bir çekirdek için ayrılmış bir önbellek görmekteyiz.

esp32_technical_reference_manual_en.pdf (espressif.com)

Multithreading ise bir uygulamanın birden fazla işlem parçasının eşzamanlı olarak çalışmasını mümkün kılar. Genelde aynı bellek üzerinden daha çok verim almak için kullanılır. Bir örnek ile pekiştirelim:

#include <Arduino.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define LED_PIN 2 // LED 2.pine tanimlandi
#define BUTTON_PIN 4 // BUTON 4.pine tanimlandi

// LED görev fonksiyonu
void ledTask(void *parameter) {
    while (true) {
        digitalWrite(LED_PIN, HIGH);  // LED on
        vTaskDelay(500 / portTICK_PERIOD_MS);  // 500ms delay
        digitalWrite(LED_PIN, LOW);   // LED off
        vTaskDelay(500 / portTICK_PERIOD_MS);  // 500ms delay
    }
}

// Button görev fonksiyonu
void buttonTask(void *parameter) {
    while (true) {
        int buttonState = digitalRead(BUTTON_PIN);
        if (buttonState == HIGH) {
            Serial.println("Button Pressed!");
        }
        vTaskDelay(200 / portTICK_PERIOD_MS);  // butonda debounce önlemi için 200ms delay
    }
}

void setup() {
    // Seri haberlesme baslangici
    Serial.begin(115200);

    // LED OUTPUT olarak tanimlandi
    pinMode(LED_PIN, OUTPUT);

    // Buton input olarak tanimlandi
    pinMode(BUTTON_PIN, INPUT_PULLUP); // esp32'ye dahili bir pull-up direnci bagladik

    // iki gorev olusturduk: biri LED digeri Buton icin
    xTaskCreate(
        ledTask,           // Cagrilacak fonksiyon  
        "LED Task",        // Fonksiyon ismi
        1024,              // Yiginin buyuklugu (bytes)
        NULL,              // Gorev giris parametresi
        1,                 // Gorev onceligi
        NULL               // Task handle
    );

    xTaskCreate(
        buttonTask,        // Cagrilacak fonksiyon  
        "Button Task",     // Fonksiyon ismi
        1024,              // Yiginin buyuklugu (bytes)
        NULL,              // Gorev giris parametresi
        1,                 // Gorev onceligi
        NULL               // Task handle
    );
}

void loop() {
    // gerek yok. gorev fonk zaten loopta calisiyor.
}

Yukarıdaki kod FreeRTOS kullanarak çoklu işlem sağlamaktadır (buton ve LED bağımsız yönetimi). Görevler xTaskCreate fonksiyonu ile oluşturularak hangi öncelikte, büyüklükte olacağı ile ilgili bilgileri girilmiştir. Ben şimdilik iki göreve de aynı öncelik verdim, bu nedenle iki görev de çok yakın zaman dilimlerinde çalışmaktadır.

LED görevine, Buton görevine kıyasla öncelik verilseydi; butonun açık olup olmadığı kontrolü seyrek yapılacaktı, fakat kodumuz gereği LED hala 500ms aralıklarla yanıp sönmeye devam edecekti.

Bu yazıda gömülü sistemlerde RTOS, Multiprocessing-Multihreading kavramlarını ve anahtar kelimeleri açıklamaya çalıştım. Okuduğunuz için teşekkürler.

Kaynakça:

1. Wang, K. C. (2023). Embedded and Real-Time Operating Systems. Almanya: Springer International Publishing.
2. https://openaccess.izu.edu.tr/xmlui/handle/20.500.12436/3475
3. https://www.digikey.com/en/maker/videos/shawn-hymel/getting-started-with-stm32-and-nucleo-part-3-how-to-run-multiple-threads-with-cmsis-rtos-interface
4. https://www.geeksforgeeks.org/difference-between-multiprocessing-and-multithreading/
5. https://www.toppr.com/guides/computer-science/computer-fundamentals/operating-system/real-time-operating-system-rtos/
6. https://mehmettopuz.net/freertos-notlari-1-freertosa-giris-cmsis-rtos-ve-bellek-yonetimi/.html
7. https://www.linkedin.com/pulse/introduction-multitasking-scheduling-embedded-systems-omar-ehab/