Case 6

Processor Management

Memory management is concerned with managing the computer’s available pool of memory, allocating space to application routines and making sure that they do not interfere with each other. Some operating system routines directly support application programs as they run thus must be resident. Other transient routines are stored on disk and read into memory only when needed. To have a better allocation of jobs into memory, there is also a system that process the jobs as they arrived. This is what we call the processor manager.

            In the processor management, it is subdivided into two submanagers. The job-scheduler that manage and schedule the job processing and the process scheduler that schedules the processes and determines execution of the steps.

            In the processing of the jobs, there comes its five states. The Hold, Ready, Waiting, Running and Finished. These are the job status or the process status.

In this diagram, why is it that there is no transition from the READY to the WAITING ?

When the job enters the system and accepted, it would be place in the HOLD state. When the state changes from HOLD to READY, the job was waiting for the CPU to process it. As we all know, CPU or the central processing unit is the one who fetches instruction, interpret it, fetch data then process it and then write the data. And when the state changes from READY  to RUNNING, the CPU then process the requested job. During the processing of the job, there comes that page fault or interrupts. This thing occurs when the I/O request was not already stored in the memory. So, the state changes from RUNNING to WAITING. And after waiting, the job will now be ready to process and run for processing and then the job will be finished.

There is no transistion from Ready to Waiting since the job that is ready to be processed would never be interrupted. Interruptions only happen when the job is running. That is why we call them interrups because it interfere the processing of a certain job.

And why is it that there is also no transition from WAITING to RUNNING?

            When the state changes from Running to Waiting, it means that a page fault occurs or an I/O is requested during the process. There is no transition from Waiting to Running.  A wait state is a delay which is experienced by a computer processor when accessing external memory or another device. Computer microprocessors are very fast, while memory technology does not seem to be able to catch the processors. On the waiting state, the program would not run directly since it has to be ready first before it processed or wait for an I/O operation to complete, or a resource to become available. 

Case 5

Fixed Partitions

            Main memory is partitioned in a fixed partition. There should only one contiguous per job and its partition sizes remain static. Fixed partitions also require the protection of job’s memory space and it matches the job size with the applicable partition size. In this kind of memory management, there are three methods for free allocation. The best-fit, first-fit and the worst fit.

Case 4

Dynamic and Relocatable Partitions

            Management of memory is hard and is very critical. You have to consider many things before you could decide what to do with the system you are working on. By doing so, you have to consider how much memory is available in the system and the optimization of memory during the job processing. Memory allocation has four types : the single-user system, fixed partitions, dynamic partitions and the relocatable dynamic partition. The process of a dynamic partition goes like this :

Dynamic Partitions

a. Job1 (100k)             turnaround: 3            

b. Job2 (10k)               turnaround: 1

c. Job3 (35k)               turnaround: 2              the memory size is 220k with allocated OS for 15k

d. Job4 (15k)               turnaround: 1

e. Job5 (23k)               turnaround: 2

f. Job6 (6k)                  turnaround: 1

g. Job7 (25k)               turnaround: 1

h. Job8 (55k)               turnaround: 2

i. Job9 (88k)                turnaround: 3

j. Job10 (100k)            turnaround: 3

            In a dynamic partition, the main memory is partitioned. Jobs given memory requested when loaded. The method in allocating the job is first come, first serve. In this kind of memory management, the memory waste is comparatively small but the full memory utilization happens only on the first allocation of the jobs. And on the next allocation or at the second turnaround of the jobs, memory waste happens since the first jobs being allocated would be the basis of the second batch of jobs to be processed.

Snapshots of main memory as the jobs are submitted for processing and allocated space on the basis of the “first come, first serve”.

Relocatable Dynamic Partition

          

              In this kind of memory management, the memory manager relocates programs and gathers all the empty blocks. It makes one block of memory large enough to accommodate some or all of the jobs waiting to get in. This kind of method is called compaction. Snapshots for the jobs as it apply relocatable dynamic partition: