In C ist Kontext der aktuelle Ausführungsstatus eines Programms, einschließlich Registern (kleine Speicherbereiche innerhalb der CPU, die zum Speichern von Daten und Anweisungen während der Programmausführung verwendet werden), Variablen und des Ablaufs von Anweisungen, entscheidend für Wechselaufgaben.

Kontextwechsel für Betriebssysteme

Die Hauptfunktion besteht darin, Multitasking zu ermöglichen. Dadurch wird sichergestellt, dass das System effizient zwischen Prozessen wechseln kann.

Die contexts.c-Datei wurde hier zur Verfügung gestellt. Es ist eine Demonstration, wie Kontexte funktionieren.

Ganz oben in dieser Datei bemerken wir den Import der ucontext.h-Bibliothek. Es ermöglicht Ihnen, den Ausführungskontext zu manipulieren.

Im Auszug unten sehen wir, dass drei Kontexte erstellt werden und diesen drei Kontexten Speicher in der Größe von STACKSIZE zugewiesen wird.

#define STACKSIZE 64 * 1024 /* tamanho de pilha das threads */

ucontext_t ContextPing, ContextPong, ContextMain;

Und kurz darauf die Ping- und Pong-Funktionen, die in ihren jeweiligen Kontexten ausgeführt werden:

void BodyPing(void *arg)
{
  int i;

  printf("%s: inicio\n", (char *)arg);

  for (i = 0; i 



In der Hauptfunktion wird malloc verwendet, um die Stacks zu reservieren, wo sie später mit uc_stack.ss_sp dem Kontext zugewiesen werden, und swapcontext wird verwendet, um zwischen ihnen zu wechseln.


int main(int argc, char *argv[])
{
  char *stack;

  printf("main: inicio\n");

  getcontext(&ContextPing);

  stack = malloc(STACKSIZE);
  if (stack)
  {
    ContextPing.uc_stack.ss_sp = stack;
    ContextPing.uc_stack.ss_size = STACKSIZE;
    ContextPing.uc_stack.ss_flags = 0;
    ContextPing.uc_link = 0;
  }
  else
  {
    perror("Erro na criação da pilha: ");
    exit(1);
  }

  makecontext(&ContextPing, (void *)(*BodyPing), 1, "    Ping");

  getcontext(&ContextPong);

  stack = malloc(STACKSIZE);
  if (stack)
  {
    ContextPong.uc_stack.ss_sp = stack;
    ContextPong.uc_stack.ss_size = STACKSIZE;
    ContextPong.uc_stack.ss_flags = 0;
    ContextPong.uc_link = 0;
  }
  else
  {
    perror("Erro na criação da pilha: ");
    exit(1);
  }

  makecontext(&ContextPong, (void *)(*BodyPong), 1, "        Pong");

  swapcontext(&ContextMain, &ContextPing);
  swapcontext(&ContextMain, &ContextPong);

  printf("main: fim\n");

  exit(0);
}




Ausgabe des ausgeführten Programms:


main: inicio
    Ping: inicio
    Ping: 0
        Pong: inicio
        Pong: 0
    Ping: 1
        Pong: 1
    Ping: 2
        Pong: 2
    Ping: 3
        Pong: 3
    Ping: fim
        Pong: fim
main: fim




Damit können wir sehen, dass auch beim Ändern der Kontexte die Werte, die durch die Funktion „fließen“, erhalten bleiben, ein Beispiel ist in diesem Fall der for-Index.

Sie haben vielleicht bemerkt, dass es einen Malloc für den Kontext von Ping und Pong gibt, aber wir sehen, dass es auch einen Kontext für Main gibt. Warum gibt es dafür keinen Malloc?

ContextMain benötigt keinen separaten Stapel, da es auf dem Stapel des Hauptthreads arbeitet, während Ping- und Pong-Kontexte ihre eigenen dynamisch zugewiesenen Stapel haben.

Wenn ich einen Kontext erstelle und ihm keinen Speicher zuordne, wird er bei Verwendung von Swap auf den Hauptstapel des Programms verschoben.

Dieser Code stammt von Professor Maziero und ist im entwickelten Unterprojekt von PingPongOS „Trocas de Contexto“ zu finden.