Question

For the purposes of this assignment, the Process Control Blocks (PCB) are implementation as follows: • PCBs are implemented as an array of structures (C++ struct) of size 10. • Each process is referred to by the array index. (i.e. PCB #0 is at PCB[0], PCB #1 is at PCB[1], etc.) Initially, PCB #0 is the only process that exists. All the other processes created build off of PCB #0; meaning they will either be a child of PCB #0 or child-of-a-child of PCB #0. For example, in the diagram below, PCB #1, #2, #3 are children of PCB #0. Whereas PCB #4 & #5 are children of PCB #2. OS OS

Answer 1

I try my best.

#include <iostream>

#include <unistd.h>

using namespace std;

int main()

{

    int a[10] = { 2, 4, 6, 7, 9, 0, 1, 5, 8, 3 };

    int n1, n2, i, j, key, c, temp;

    n1 = fork();

    n2 = fork();

    if (n1 > 0 && n2 > 0) {

        int c = 0;

        cout << "Parent process :" << endl;

  key = 7;

        cout << "the key to be searched is " << key << endl;

        for (i = 0; i < 10; i++) {

            if (a[i] == key)

                 c++;

        }

         cout << "the frequency of " << key << " is " << c << endl;

    }

         else if (n1 == 0 && n2 > 0) {

        cout << "1st child process :" << endl;

        for (i = 0; i < 10; i++) {

            for (j = 0; j < 9; j++) {

                if (a[j] > a[j + 1]) {

                    temp = a[j];

                    a[j] = a[j + 1];

                    a[j + 1] = temp;

                }

            }

        }

        cout << "the sorted array is" << endl;

        for (i = 0; i < 10; i++) {

            cout << a[i] << " ";

        }

        cout << endl;

    }

    else if (n1 > 0 && n2 == 0) {

        int f = 0;

        cout << "2nd child process :" << endl;

        for (i = 0; i < 10; i++) {

  if (a[i] % 2 == 0) {

                f++;

            }

        }

        cout << " Total even no are: " << f << " ";

        cout << endl;

    }

        else if (n1 == 0 && n2 == 0) {

        cout << "3rd child process :" << endl;

        int sum = 0;

                for (i = 0; i < 10; i++) {

            sum = sum + a[i];

        }

        cout << "the sum is :" << sum << endl;

    }

    return 0;

}

#include<iostream>

#include<process.h>

using namespace std;

int main()

{

int a[50],x,n,i,j,b[50];

cout<<"How many elements of Array you want to create?";

cin>>n;

cout<<"\nEnter elements of Array\n";

for(i=0;i<n;++i)

cin>>a[i];

cout<<"\nEnter element to delete:";

cin>>x;

for(i=0,j=0;i<n;++i)

{

if(a[i]!=x)

b[j++]=a[i];

}

if(j==n)

{

cout<<"\nSoory!!!Element is not in the Array";

exit(0);

}

else

{

cout<<"\nNew Array is ";

for(i=0;i<j;i++)

cout<<b[i]<<" ";

}

return 0;

}

Create:

To create a replacement kid method, the parent method calls the produce primitive with the input parameters: initial central processor state s0, initial main memory m0, and priority pi. The m0 field may well be a reasonably complicated structure, for instance, encompassing real and virtual space for programs, data, and stacks. The initial standing are going to be prepared s—ready as a result of the new method ought to be in position to proceed while not anticipating any resources and suspended as a result of it should be fascinating to form a method well before its activation. The Create primitive returns the distinctive id (pid) of the new method as associate output parameter.

The first preparation creates a new instance of the process descriptor (Fig. 4-5) with p pointing to that example. The next two instructions create and assign a unique ID to the new technique. Subsequent instructions fill the individual fields of the descriptor using given parameters. We assume that any procedure is ready to attain the pointer to its own descriptor, either via an agreed-upon register or through a kernel call; the call self designates this pointer. Create adds p to self’s child listing and inserts p on the Ready List RL. The initial assets—here only essential memory—are generally shared assets for the new manner and, typically, must be a subset of those belonging to the parent technique. The discern might also proportion any of its assets with different child approaches in a similar manner. The created method, in turn, can share its sources with any youngsters it creates. At the end, the scheduler is called to choose the system to run subsequent.

Create(s0, m0, pi, pid) {

p = Get New PCB();

pid= Get New PID();

p -> ID = pid ;

p -> CPU State = s0;

p -> Memory = m0;

p -> Priority = pi;

p -> Status.Type = ‘ready s’;

p -> Status.List = RL;

p -> Creation Tree.Parent = self;

p -> Creation Tree.Child= NULL;

insert(self -> Creation Tree.Child, p);

insert(RL, p); Scheduler(); }

Destroy:

For destroying a method, identical alternatives square measure attainable as for the Suspend operation— we can either take away one method (a descendant) or take away that method and every one of its descendants. If the primary policy is chosen, the method hierarchy will simply fragment, potentially departure isolated processes within the system with no management over their behavior. We thus need that Destroy removes the named method and every one its descendants.The operate is invoked by the decision Destroy(pid), wherever PID is that the ID of the foundation process of the subtree to be removed. The procedure obtains the pointer to the current method and calls the routine Kill Tree(p), that recursively eliminates the complete tree. It calls Kill Tree(q) for every method Q on the present method kid list. for every method within the tree, Kill Tree take as follows. If the method is presently running, it's stopped by interrupting its computer hardware and marking it as free. The procedure then removes the method from the list pointed to by standing.List. this is often the prepared list if the method was running or ready, and otherwise a roster related to the resource upon that the method was blocked. Next, the procedure releases all resources presently allotted to the method and closes all files opened by the method. This doubtless unblocks alternative processes waiting for the free resources. Finally, the method descriptor is deleted and its area returned to the system. once the complete tree is eliminated and Kill Tree(p) returns to Destroy(pid), the method hardware is termed to work out that process(es) ought to be running next. this could embody the present process—the one World Health Organization issued the Destroy command—and any variety of processes which will became unblocked as a result of the Destroy operation.

Destroy(pid) { p = Get PCB(pid);

Kill Tree(p); Scheduler();

}

Kill Tree(p) { for (each q in p -> Creation Tree.Child) Kill Tree(q);

if (p -> Status.Type == ‘running’) { cpu = p -> Processor ID;

Interrupt(cpu); }

Remove(p -> Status.List, p); Release all(p -> Memory);

Release all(p -> Other Resources);

Close all(p -> Open Files); Delete PCB(p);

}