सी में, संदर्भ एक प्रोग्राम की वर्तमान निष्पादन स्थिति है, जिसमें रजिस्टर (सीपीयू के भीतर छोटे भंडारण क्षेत्र, प्रोग्राम निष्पादन के दौरान डेटा और निर्देशों को संग्रहीत करने के लिए उपयोग किया जाता है), चर और प्रवाह शामिल हैं कार्यों को बदलने के लिए महत्वपूर्ण निर्देश।

ऑपरेटिंग सिस्टम के लिए संदर्भ स्विचिंग

मुख्य कार्य मल्टीटास्किंग की अनुमति देना है। यह सुनिश्चित करता है कि सिस्टम प्रक्रियाओं के बीच कुशलतापूर्वक स्विच कर सकता है।

Context.c फ़ाइल यहां उपलब्ध कराई गई थी। यह इस बात का प्रदर्शन है कि संदर्भ कैसे काम करते हैं।

इस फ़ाइल के ठीक शीर्ष पर, हम ucontext.h लाइब्रेरी के आयात को देखते हैं। यह आपको निष्पादन संदर्भ में हेरफेर करने की अनुमति देता है।

नीचे दिए गए अंश में हम देखते हैं कि 3 संदर्भ बनाए गए हैं, और इन 3 संदर्भों में मेमोरी को STACKSIZE का आकार आवंटित किया जाएगा।

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

ucontext_t ContextPing, ContextPong, ContextMain;

और इसके तुरंत बाद, पिंग और पोंग फ़ंक्शन जो उनके संबंधित संदर्भों में निष्पादित किए जाएंगे:

void BodyPing(void *arg)
{
  int i;

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

  for (i = 0; i 



मुख्य फ़ंक्शन में, मॉलॉक का उपयोग स्टैक को आरक्षित करने के लिए किया जाता है, जहां उन्हें बाद में संदर्भ में uc_stack.ss_sp के साथ सौंपा जाता है, और स्वैपकॉन्टेक्स्ट का उपयोग उनके बीच स्विच करने के लिए किया जाता है।


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);
}




निष्पादित प्रोग्राम का आउटपुट:


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




इसके साथ, हम देख सकते हैं कि संदर्भ बदलते समय भी, फ़ंक्शन के माध्यम से "प्रवाह" करने वाले मान बनाए रखे जाते हैं, इस मामले में एक उदाहरण सूचकांक के लिए है।

आपने देखा होगा कि पिंग और पोंग के संदर्भ के लिए एक मॉलोक है, लेकिन हम देखते हैं कि मुख्य के लिए भी एक संदर्भ है, इसके लिए कोई मॉलोक क्यों नहीं है?

ContextMain को एक अलग स्टैक की आवश्यकता नहीं है क्योंकि यह मुख्य थ्रेड के स्टैक पर काम करता है, जबकि पिंग और पोंग संदर्भों के पास अपने स्वयं के गतिशील रूप से आवंटित स्टैक होते हैं।

यदि मैं एक संदर्भ बनाता हूं और इसके लिए मेमोरी आवंटित नहीं करता हूं, तो जब हम स्वैप का उपयोग करते हैं, तो यह प्रोग्राम के मुख्य स्टैक में चला जाता है।

यह कोड प्रोफेसर माज़िएरो का है, जो पिंगपोंगओएस के विकसित उप-प्रोजेक्ट "ट्रोकास डी कॉन्टेक्स्टो" में पाया गया है।