• Navigation überspringen
  • Zur Navigation
  • Zum Seitenende
Organisationsmenü öffnen Organisationsmenü schließen
Friedrich-Alexander-Universität Lehrstuhl für Informatik 4 (Systemsoftware)
  • FAUZur zentralen FAU Website
  1. Friedrich-Alexander-Universität
  2. Technische Fakultät
  3. Department Informatik
Suche öffnen
  • English
  • Campo
  • StudOn
  • FAUdir
  • Stellenangebote
  • Lageplan
  • Hilfe im Notfall
  1. Friedrich-Alexander-Universität
  2. Technische Fakultät
  3. Department Informatik
Friedrich-Alexander-Universität Lehrstuhl für Informatik 4 (Systemsoftware)
Menu Menu schließen
  • Lehrstuhl
    • Team
    • Aktuelles
    • Kontakt und Anfahrt
    • Leitbild
    • 50-jähriges Jubiläum
    Portal Lehrstuhl
  • Forschung
    • Forschungsbereiche
      • Betriebssysteme
      • Confidential Computing
      • Eingebettete Systemsoftware
      • Verteilte Systeme
    • Projekte
      • AIMBOS
      • BALu
      • BFT2Chain
      • DOSS
      • Mirador
      • NEON
      • PAVE
      • ResPECT
      • Watwa
    • Projektkampagnen
      • maRE
    • Seminar
      • Systemsoftware
    Portal Forschung
  • Publikationen
  • Lehre
    • Sommersemester 2025
      • Applied Software Architecture
      • Ausgewählte Kapitel der Systemsoftware
      • Betriebssystemtechnik
      • Projekt angewandte Systemsoftwaretechnik
      • System-Level Programming
      • Systemnahe Programmierung in C
      • Systemprogrammierung 1
      • Verteilte Systeme
    • Wintersemester 2024/25
      • Betriebssysteme
      • Middleware – Cloud Computing
      • Systemprogrammierung 2
      • Verlässliche Echtzeitsysteme
      • Virtuelle Maschinen
      • Web-basierte Systeme
    Portal Lehre
  • Examensarbeiten
  1. Startseite
  2. Extern

Extern

Bereichsnavigation: Lehre
  • Betriebssystemtechnik
    • Vorlesung
      • Folien
      • Glossar
    • Übung
      • Aufgaben
      • Dokumentation
        • Blog
          • Entwicklungsumgebung
            • Assembler Crashkurs
              • C++ Crashkurs
                • 🔗 Testrechnerverwaltung
                • Kontakt
              • Evaluation

              Dokumentation

              Static Public Member Functions | List of all members
              Scheduler Class Reference

              The scheduler plans the threads' execution order and, from this, selects the next thread to be running. More...

              #include <thread/scheduler.h>

              + Inheritance diagram for Scheduler:
              [legend]
              + Collaboration diagram for Scheduler:
              [legend]

              Static Public Member Functions

              static void schedule ()
               Start scheduling. More...
               
              static void ready (Thread *that)
               Include a thread in scheduling decisions. More...
               
              static void exit ()
               (Self-)termination of the calling thread. More...
               
              static void kill (Thread *that)
               Kills the passed thread. More...
               
              static void resume ()
               Issue a thread change. More...
               
              static bool isEmpty ()
               Checks whether the ready queue is empty.
               
              static void block (Waitingroom *waitingroom)
               Blocks the calling thread in and enqueues the thread in the provided waitingroom. More...
               
              static void wakeup (Thread *customer)
               Wake up a sleeping thread. More...
               
              - Static Public Member Functions inherited from Dispatcher
              static Thread * active ()
               Returns the thread currently running on the CPU core calling this method.
               
              static bool isActive (const Thread *thread, unsigned *cpu=nullptr)
               Check if thread is currently active. More...
               
              static void go (Thread *first)
               This method stores first as life pointer for this CPU core and triggers the execution of first thread. More...
               
              static void dispatch (Thread *next)
               Updates the life pointer to next and issues a thread change from the old to the new life pointer. More...
               

              Detailed Description

              The scheduler plans the threads' execution order and, from this, selects the next thread to be running.

              The scheduler manages the ready queue (a private Queue object), that is the list of threads that are ready to execute. The scheduler arranges threads in a FIFO order, that is, when a thread is set ready, it will be appended to the end of the queue, while threads to be executed are taken from the front of the queue.

              Member Function Documentation

              void Scheduler::schedule ( )
              static

              Start scheduling.

              This method starts the scheduling by removing the first thread from the ready queue and activating it. MPStuBS needs to call this method once for every CPU core to dispatch the first thread.

              void Scheduler::ready ( Thread *  that)
              static

              Include a thread in scheduling decisions.

              This method will register a thread for scheduling. It will be appended to the ready queue and dispatched once its time has come.

              Parameters
              thatThread to be scheduled
              void Scheduler::exit ( )
              static

              (Self-)termination of the calling thread.

              This method can be used by a thread to exit itself. The calling thread will not be appended to the ready queue; a reschedule will be issued.

              void Scheduler::kill ( Thread *  that)
              static

              Kills the passed thread.

              This method is used to kill the Thread that. For OOStuBS, it is sufficient to remove that from the ready queue and, thereby, exclude the thread from scheduling. For MPStuBS, a simple removal is not sufficient, as the thread might currently be running on another CPU core. In this case, the thread needs to be marked as dying (a flag checked by resume prior to enqueuing into the ready queue) and the executing CPU core needs to be notified.

              Note
              The thread should be able to kill itself.
              void Scheduler::resume ( )
              static

              Issue a thread change.

              This method issues the change of the currently active thread without requiring the calling thread to be aware of the other threads. Scheduling decisions, i.e. which thread will be run next, are made by the scheduler itself with the knowledge of the currently ready threads. The currently active thread is appended to the end of the queue; the first thread in the queue will be activated (to implement the FIFO policy).

              void Scheduler::block ( Waitingroom *  waitingroom)
              static

              Blocks the calling thread in and enqueues the thread in the provided waitingroom.

              Calling this method will issue a reschedule and, resultingly, pass the processor to the next thread from the ready queue. The calling thread will be waiting in the provided waitingroom.

              void Scheduler::wakeup ( Thread *  customer)
              static

              Wake up a sleeping thread.

              Waking up a thread means inserting the thread into the ready queue and removing it from the event it might be waiting for.

              Parameters
              customerSleeping thread to be woken up.

              The documentation for this class was generated from the following files:
              • thread/scheduler.h
              • thread/scheduler.cc
              Friedrich-Alexander-Universität
              Erlangen-Nürnberg

              Schlossplatz 4
              91054 Erlangen
              • Impressum
              • Datenschutz
              • Barrierefreiheit
              • Facebook
              • RSS Feed
              • Xing
              Nach oben