Esempio n. 1
0
File: 3 Proc.cs Progetto: ratajx/SO
 public MESSAGE()
 {
     SENDER = null;
     NEXT = null;
     SIZE = 0;
     TEXT = new byte[255];
 }
Esempio n. 2
0
File: 1 Core.cs Progetto: ratajx/SO
 public PCB(string name)
 {
     zap_Z = null;
     zap2_Z = null;
     przywroc_z = false;
     przywroc1_z = false;
     odb_z = null;
     zap3_z = null;
     licz_z = 0;
     NAME = name;
     BLOCKED = false;
     STOPPED = false;
     NEXT_PCB_ALL = null;
     LAST_PCB_ALL = null;
     NEXT_PCB_GROUP = null;
     LAST_PCB_GROUP = null;
     FIRST_MESSAGE = new Queue<MESSAGE>();
     MESSAGE_SEMAPHORE_COMMON=new SEMAPHORE(1,"COMMON");
     MESSAGE_SEMAPHORE_RECEIVER=new SEMAPHORE(0,"RECEIVER");
     PAM_PODR = false;
     ADR_PODR = 0;
 }
Esempio n. 3
0
File: 1 Core.cs Progetto: ratajx/SO
        public static void Run()
        {
            while (true)
            {
                Format.LicznikWrite();//wypisanie aktualnej wartości licznka zawiadowcy
                Format.RejestyWrite();

                Format.CWrite(ConsoleColor.Green, "Zawiadowca");
               // Console.ReadLine();

                if (licznik==50||wymusZmiane==true)
                {

                    wymusZmiane = false;
                    NEXTTRY_MODIFIED = false;
                    bool i = true;
                    RUNNING.cpu_stan_zapisz();
                    Console.Clear();
                    while (i)

                   {
                        if (!NEXTTRY.BLOCKED && !NEXTTRY.STOPPED)
                        {

                            RUNNING = NEXTTRY;
                            NEXTTRY = RUNNING.NEXT_PCB_ALL;

                            RUNNING.cpu_stan_laduj();
                            i = false;
                            licznik = 0;
                            Console.WriteLine("Uruchomiony proces {0}", RUNNING.NAME);

                        }
                        else
                        {
                            NEXTTRY = NEXTTRY.NEXT_PCB_ALL;
                        }

                    }
                }
                Inter.Run();
                licznik++;
            }
        }
Esempio n. 4
0
File: 1 Core.cs Progetto: ratajx/SO
 public void cpu_stan_zapisz()
 {
     zap_Z = Proc.zap;
     zap2_Z = Proc.zap2;
     przywroc_z = Proc.przywroc;
     przywroc1_z = Proc.przywroc1;
     zap3_z = Proc.zap3;
     licz_z = Proc.licz;
     odb_z = Proc.odb;
     cpu_stan[0] = rejestry.r0;
     cpu_stan[1] = rejestry.r1;
     cpu_stan[2] = rejestry.r2;
     cpu_stan[3] = rejestry.r3;
     cpu_stan[4] = rejestry.lr;
     cpu_stan[6] = rejestry.r4;
     cpu_stan[7] = rejestry.r5;
     cpu_stan[8] = rejestry.r6;
     cpu_stan[9] = rejestry.r7;
     cpu_stan[10] = rejestry.r8;
     cpu_stan[11] = rejestry.r9;
     Console.WriteLine("Zapisano rejestry do PCB.");
 }
Esempio n. 5
0
File: 3 Proc.cs Progetto: ratajx/SO
        public static void XSM()
        {
            Console.WriteLine("Wysyłanie komunikatu");
            zap3 = rejestry.r2;

            int i = 0;
            UTF8Encoding kodowanie = new UTF8Encoding();
            byte[] c = new byte[8];
            for (; i < 8 && Mem.MEMORY[((int)rejestry.r2) + i] != 0; i++)
            {
                c[i] = Mem.MEMORY[((int)rejestry.r2) + i];
            }
            string odbiorca = kodowanie.GetString(c, 0, i);
            odb = XN(odbiorca);
            rejestry.r2 = odb;
        }
Esempio n. 6
0
File: 3 Proc.cs Progetto: ratajx/SO
        //usuniecie bloku
        public static void XJ(PCB x)
        {
            //usuniecie z grupy
            PCB pomoc1_grupa = zawiadowca.RUNNING;
            PCB pomoc2_grupa = pomoc1_grupa.NEXT_PCB_GROUP;
            PCB pomoc3_grupa = pomoc2_grupa.NEXT_PCB_GROUP;
            PCB rejestr = x;

            start:
            if (pomoc2_grupa == rejestr)
            {
                pomoc1_grupa.NEXT_PCB_GROUP = pomoc3_grupa;
                Console.WriteLine("Usunieto z grupy blok PCB o nazwie " + rejestr.NAME);
            }
            else
            {
                pomoc1_grupa = pomoc1_grupa.NEXT_PCB_GROUP;
                pomoc2_grupa = pomoc2_grupa.NEXT_PCB_GROUP;
                pomoc3_grupa = pomoc3_grupa.NEXT_PCB_GROUP;
                goto start;
            }

            //usuniecie z lancucha
            PCB pomoc1_lancuch = zawiadowca.RUNNING;
            PCB pomoc2_lancuch = pomoc1_grupa.NEXT_PCB_ALL;
            PCB pomoc3_lancuch = pomoc2_grupa.NEXT_PCB_ALL;

            start2:
            if (pomoc2_grupa == rejestr)
            {
                pomoc1_grupa.NEXT_PCB_ALL = pomoc3_lancuch;
                Console.WriteLine("Usunieto z lancucha blok PCB o nazwie " + rejestr.NAME);
            }
            else
            {
                pomoc1_lancuch = pomoc1_grupa.NEXT_PCB_ALL;
                pomoc2_lancuch = pomoc2_grupa.NEXT_PCB_ALL;
                pomoc3_lancuch = pomoc3_grupa.NEXT_PCB_ALL;
                goto start2;
            }
        }
Esempio n. 7
0
File: 3 Proc.cs Progetto: ratajx/SO
        //utworzenie procesu
        public static void XC()
        {
            object r2 = rejestry.r2;
            int i = 0;
            UTF8Encoding kodowanie = new UTF8Encoding();
            byte[] c = new byte[8];
            for (; i < 8 && Mem.MEMORY[((int)rejestry.r2) + i] != 0 && Mem.MEMORY[((int)rejestry.r2) + i] != '='; i++)
            {
                c[i] = Mem.MEMORY[((int)rejestry.r2) + i];
            }

              string nazwa = kodowanie.GetString(c, 0, i);

            PCB nowy = new PCB(nazwa);
            nowy.grupa = zawiadowca.RUNNING.grupa;
            nowy.STOPPED = true;
            nowy.BLOCKED = false;
            rejestry.r2 = nowy;
            XI();

              rejestry.r2 = r2;
        }
Esempio n. 8
0
File: 5 SVC.cs Progetto: ratajx/SO
        public static void Main()
        {
            Console.WindowHeight = 50;
               Console.WindowWidth = 100;
               Console.BufferWidth = 100;
               Console.BufferHeight = 50;
               Console.WindowTop = 0;
               Console.WindowLeft = 0;

               //tworzy swój PCB dodaje go na listę ustaiwa wszystkie wartości by wskazywały na niego
               PCB iplrtn = new PCB("*IPRTLN");
               rejestry.r2 = iplrtn;
               zawiadowca.RUNNING = iplrtn;
               zawiadowca.NEXTTRY = iplrtn;
               iplrtn.LAST_PCB_ALL = iplrtn;
               iplrtn.LAST_PCB_GROUP = iplrtn;
               iplrtn.NEXT_PCB_ALL = iplrtn;
               iplrtn.NEXT_PCB_GROUP = iplrtn;
               iplrtn.STOPPED = true;

            CWrite(ConsoleColor.Red, "                             dogeOS \n");
               CWrite(ConsoleColor.Green, "                 much improve. so amaze. WOW\n");
               Console.Write("Start programu"); CWrite(ConsoleColor.Cyan, " IPLRTN\n");
               Console.ReadLine();
               Console.WriteLine("Wczytywanie jądra systemu do pamięci");
               Console.ReadLine();

               int i = 0;
               int j = 0;

               adrProg[(int)Eprog.IBSUP] = i;
               i = IBSUP.zaladuj(0);

               adrProg[(int)Eprog.EXPUNGE] = i;
               i = IBSUP.zaladujEXPUNGE(i);
               CWrite(ConsoleColor.Cyan, "IBSUB");
               Console.Write(" - wczytano");
               Console.ReadLine();

               adrProg[(int)Eprog.IN] = i;
               i = Ext.zaladuj(i);
               CWrite(ConsoleColor.Cyan, "EXT ");
               Console.Write("- wczytano");
               Console.ReadLine();

               adrProg[(int)Eprog.A] = i;
               i = Mem.zaladujXA(i);
               CWrite(ConsoleColor.Cyan, "XA ");
               Console.Write("- wczytano");
               Console.ReadLine();

               adrProg[(int)Eprog.F] = i;
               i = Mem.zaladujXF(i);
               CWrite(ConsoleColor.Cyan, "XF ");
               Console.Write("- wczytano");
               Console.ReadLine();

               adrProg[(int)Eprog.D] = i;
               i = Proc.zaladujXD(i);
               CWrite(ConsoleColor.Cyan, "XD ");
               Console.Write("- wczytano");
               Console.ReadLine();

               adrProg[(int)Eprog.R] = i;
               i = Proc.zaladujXR(i);
               CWrite(ConsoleColor.Cyan, "XR ");
               Console.Write("- wczytano");
               Console.ReadLine();

               adrProg[(int)Eprog.S] = i;
               i = Proc.zaladujXS(i);
               CWrite(ConsoleColor.Cyan, "XS ");
               Console.Write("- wczytano");
               Console.ReadLine();

               adrProg[(int)Eprog.Q] = i;
               i = Proc.zaladujXQUE(i);
               CWrite(ConsoleColor.Cyan, "XQUE ");
               Console.Write("- wczytano");
               Console.ReadLine();//wpisywanie programów do pamięci głównej i początku każdego z nich do tablicy DODAC EXPUNGE!

               Console.Write("Opisywanie wolnej pamięci przy pomocy bloków FSB");
               if (Mem.start(i) == false) //całą pamięć wolną opisuje przy pomocy bloków FSB
               {
               Console.Write(" - ");
               CWrite(ConsoleColor.Red, "BŁĄD!");
               Console.ReadLine();
               return;
               }
               else
               {
               Console.Write(" - wykonano");
               Console.ReadLine();
               }//opisywanie wolnej pamięci blaokami FSB

               Console.Write("Tworzenie PCB dla pierwszego strumienia zlecień");
               Console.ReadLine();
               PCB ibsub1 = new PCB("*IBSUB");
               ibsub1.grupa = 1;
               ibsub1.cpu_stan[0] = 0;
               ibsub1.cpu_stan[1] = 0;
               ibsub1.cpu_stan[2] = 0;
               ibsub1.cpu_stan[3] = 0;
               ibsub1.cpu_stan[4] = adrProg[(int)Eprog.IBSUP];
               ibsub1.cpu_stan[6] = 0;
               ibsub1.cpu_stan[7] = 0;
               ibsub1.cpu_stan[8] = 0;
               ibsub1.cpu_stan[9] = 0;
               ibsub1.cpu_stan[10] = 0;
               ibsub1.cpu_stan[11] = 0;

               Console.Write("Tworzenie PCB dla drugiego strumienia zlecień");
               Console.ReadLine();

               PCB ibsub2 = new PCB("*IBSUB");
               ibsub2.grupa = 2;
               ibsub2.cpu_stan[0] = 0;
               ibsub2.cpu_stan[1] = 0;
               ibsub2.cpu_stan[2] = 0;
               ibsub2.cpu_stan[3] = 0;
               ibsub2.cpu_stan[4] = adrProg[(int)Eprog.IBSUP];
               ibsub2.cpu_stan[6] = 0;
               ibsub2.cpu_stan[7] = 0;
               ibsub2.cpu_stan[8] = 0;
               ibsub2.cpu_stan[9] = 0;
               ibsub2.cpu_stan[10] = 0;
               ibsub2.cpu_stan[11] = 0;

               Console.Write("Ustawianie wskazników we wszystkich PCB");
               Console.ReadLine();
               iplrtn.NEXT_PCB_ALL = ibsub1;

               ibsub1.NEXT_PCB_ALL = ibsub2;
               ibsub2.NEXT_PCB_ALL = iplrtn;

               ibsub1.LAST_PCB_ALL = iplrtn;
               ibsub2.LAST_PCB_ALL = iplrtn;

               ibsub1.NEXT_PCB_GROUP = ibsub1;
               ibsub2.NEXT_PCB_GROUP = ibsub2;

               ibsub1.LAST_PCB_GROUP = ibsub1;
               ibsub2.LAST_PCB_GROUP = ibsub2;

               Console.Write("Ustawienie NEXTTRY i wymuszenie zmiany procesu");
               Console.ReadLine();

               zawiadowca.NEXTTRY = iplrtn.NEXT_PCB_ALL;
               zawiadowca.wymusZmiane = true;

               Console.Write("Uruchomienie");
               CWrite(ConsoleColor.Green, " zawiadowcy\n");
               Console.ReadLine();

               zawiadowca.Run();
        }