CPU Scheduling: Performance criteria

CPU scheduling is essential for the system’s performance and ensures that
processes are executed correctly and on time. Different CPU scheduling algorithms
have other properties and the choice of a particular algorithm depends on various
factors. Many criteria have been suggested for comparing CPU scheduling
algorithms.
What is CPU scheduling?

CPU Scheduling is a process that allows one process to use the CPU while another
process is delayed due to unavailability of any resources such as I / O etc, thus
making full use of the CPU. In short, CPU scheduling decides the order and priority
of the processes to run and allocates the CPU time based on various parameters
such as CPU usage, throughput, turnaround, waiting time, and response time. The
purpose of CPU Scheduling is to make the system more efficient, faster, and fairer.
Criteria of CPU Scheduling

CPU scheduling criteria, such as turnaround time, waiting time, and throughput, are
essential metrics used to evaluate the efficiency of scheduling algorithms.
1. CPU utilization

The main objective of any CPU scheduling algorithm is to keep the CPU as busy as
possible. Theoretically, CPU utilization can range from 0 to 100 but in a real-time
system, it varies from 40 to 90 percent depending on the load upon the system.
2. Throughput

A measure of the work done by the CPU is the number of processes being executed
and completed per unit of time. This is called throughput. The throughput may vary
depending on the length or duration of the processes.
CPU Scheduling Criteria
3. Turnaround Time

For a particular process, an important criterion is how long it takes to execute that
process. The time elapsed from the time of submission of a process to the time of
completion is known as the turnaround time. Turn-around time is the sum of times
spent waiting to get into memory, waiting in the ready queue, executing in CPU, and
waiting for I/O.

Turn Around Time = Completion Time – Arrival Time.

4. Waiting Time

A scheduling algorithm does not affect the time required to complete the process
once it starts execution. It only affects the waiting time of a process i.e. time spent by
a process waiting in the ready queue.

Waiting Time = Turnaround Time – Burst Time.

5. Response Time

In an interactive system, turn-around time is not the best criterion. A process may
produce some output fairly early and continue computing new results while previous
results are being output to the user. Thus another criterion is the time taken from
submission of the process of the request until the first response is produced. This
measure is called response time.

Response Time = CPU Allocation Time(when the CPU was allocated for the first) –
Arrival Time
6. Completion Time

The completion time is the time when the process stops executing, which means
that the process has completed its burst time and is completely executed.
7. Priority

If the operating system assigns priorities to processes, the scheduling mechanism

should favor the higher-priority processes.
8. Predictability

A given process always should run in about the same amount of time under a similar
system load.
Importance of Selecting the Right CPU Scheduling Algorithm for Specific
Situations

It is important to choose the correct CPU scheduling algorithm because different

algorithms have different priorities for different CPU scheduling criteria.Different
algorithms have different strengths and weaknesses. Choosing the wrong CPU
scheduling algorithm in a given situation can result in suboptimal performance of the
system.
Example: Here are some examples of CPU scheduling algorithms that work well in
different situations.

Round Robin scheduling algorithm works well in a time-sharing system where tasks
have to be completed in a short period of time. SJF scheduling algorithm works best
in a batch processing system where shorter jobs have to be completed first in order
to increase throughput.Priority scheduling algorithm works better in a real-time
system where certain tasks have to be prioritized so that they can be completed in a
timely manner.
Factors Influencing CPU Scheduling Algorithms

There are many factors that influence the choice of CPU scheduling algorithm. Some
of them are listed below.
 The number of processes.

 The processing time required.

 The urgency of tasks.

 The system requirements.

Selecting the correct algorithm will ensure that the system will use system resources
efficiently, increase productivity, and improve user satisfaction.
CPU Scheduling Algorithms

There are several CPU Scheduling Algorithms, that are listed below.

 First Come First Served (FCFS)

 Shortest Job First (SJF)

 Longest Job First (LJF)
 Priority Scheduling

 Round Robin (RR)

 Shortest Remaining Time First (SRTF)

 Longest Remaining Time First (LRTF)

Conclusion

In Conclusion, CPU scheduling criteria play an important role in improving system

performance. CPU scheduling techniques encourage efficient use of system
resource and effective task processing by analysing and prioritising criteria such as
CPU Utilization, Throughput, Turnaround Time, Waiting Time, and Response Time.
Selecting the appropriate algorithm for a given situation is crucial for increasing
system efficiency and production.
Question for Practice

Which of the following process scheduling algorithm may lead to starvation?

(A) FIFO

(B) Round Robin

(C) Shortest Job Next

(D) None of the above

Correct option is (C)

Explanation: Shortest job next may lead to process starvation for processes which
will require
a long time to complete if short processes are continually added.
Frequently Asked Question on CPU Scheduling Criteria – FAQs

How does CPU utilization affect scheduling algorithms?

CPU utilization indicates the efficiency of utilizing the CPU’s processing power.
Scheduling algorithms aim to keep the CPU as busy as possible to achieve high
utilization. However, excessively high CPU utilization can lead to poor system
responsiveness and potential resource contention.
What is throughput in the context of scheduling algorithms?

Throughput refers to the number of processes that are completed and leave the
system within a given time frame. Scheduling algorithms that maximize throughput
often prioritize short processes or those that require minimal CPU time, allowing
more processes to be completed in a given period.
Why is turnaround time an important criterion for scheduling algorithms?

Turnaround time measures the overall time a process takes to complete, from
submission to termination. Lower turnaround time indicates efficient process
execution. Scheduling algorithms that minimize turnaround time generally prioritize
processes with shorter burst times or high priority.
What trade-offs are involved in selecting a scheduling algorithm? Some trade-
off may include that the improving in throughput may lead to increment in waiting
time.
Deadlock System model

Overview :
A deadlock occurs when a set of processes is stalled because each process is
holding a resource and waiting for another process to acquire another resource. In
the diagram below, for example, Process 1 is holding Resource 1 while Process 2
acquires Resource 2, and Process 2 is waiting for Resource 1.

System Model :

 For the purposes of deadlock discussion, a system can be modelled as a

collection of limited resources that can be divided into different categories and
allocated to a variety of processes, each with different requirements.

 Memory, printers, CPUs, open files, tape drives, CD-ROMs, and other
resources are examples of resource categories.

 By definition, all resources within a category are equivalent, and any of the
resources within that category can equally satisfy a request from that
category. If this is not the case (i.e. if there is some difference between the
resources within a category), then that category must be subdivided further.
For example, the term “printers” may need to be subdivided into “laser
printers” and “colour inkjet printers.”

 Some categories may only have one resource.

 The kernel keeps track of which resources are free and which are allocated,
to which process they are allocated, and a queue of processes waiting for this
 resource to become available for all kernel-managed resources. Mutexes or
wait() and signal() calls can be used to control application-managed resources
(i.e. binary or counting semaphores. )

 When every process in a set is waiting for a resource that is currently

assigned to another process in the set, the set is said to be deadlocked.
Operations :
In normal operation, a process must request a resource before using it and release it
when finished, as shown below.
1. Request –
If the request cannot be granted immediately, the process must wait until the
resource(s) required to become available. The system, for example, uses the
functions open(), malloc(), new(), and request ().
2. Use –
The process makes use of the resource, such as printing to a printer or
reading from a file.
3. Release –
The process relinquishes the resource, allowing it to be used by other
processes.
Necessary Conditions :
There are four conditions that must be met in order to achieve deadlock as follows.
1. Mutual Exclusion –
At least one resource must be kept in a non-shareable state; if another
process requests it, it must wait for it to be released.

2. Hold and Wait –

A process must hold at least one resource while also waiting for at least one
resource that another process is currently holding.

3. No pre-emption –
Once a process holds a resource (i.e. after its request is granted), that
resource cannot be taken away from that process until the process voluntarily
releases it.

4. Circular Wait –
There must be a set of processes P0, P1, P2,…, PN such that every P[I] is
waiting for P[(I + 1) percent (N + 1)]. (It is important to note that this condition
implies the hold-and-wait condition, but dealing with the four conditions is
easier if they are considered separately).
Methods for Handling Deadlocks :
In general, there are three approaches to dealing with deadlocks as follows.

1. Preventing or avoiding deadlock by Avoid allowing the system to become

stuck in a loop.

2. Detection and recovery of deadlocks, When deadlocks are detected, abort the
process or preempt some resources.

3. Ignore the problem entirely.

4. To avoid deadlocks, the system requires more information about all

processes. The system, in particular, must understand what resources a
process will or may request in the future. ( Depending on the algorithm, this
can range from a simple worst-case maximum to a complete resource request
and release plan for each process. )

5. Deadlock detection is relatively simple, but deadlock recovery necessitates

either aborting processes or preempting resources, neither of which is an
appealing option.

6. If deadlocks are not avoided or detected, the system will gradually slow down
as more processes become stuck waiting for resources that the deadlock has
blocked and other waiting processes. Unfortunately, when the computing
requirements of a real-time process are high, this slowdown can be confused
with a general system slowdown.
Deadlock Prevention :
Deadlocks can be avoided by avoiding at least one of the four necessary conditions:
as follows.
Condition-1 :
Mutual Exclusion :

 Read-only files, for example, do not cause deadlocks.

 Unfortunately, some resources, such as printers and tape drives, require a

single process to have exclusive access to them.
Condition-2 :
Hold and Wait :
To avoid this condition, processes must be prevented from holding one or more
resources while also waiting for one or more others. There are a few possibilities
here:

 Make it a requirement that all processes request all resources at the same
time. This can be a waste of system resources if a process requires one
resource early in its execution but does not require another until much later.
  Processes that hold resources must release them prior to requesting new
ones, and then re-acquire the released resources alongside the new ones in a
single new request. This can be a problem if a process uses a resource to
partially complete an operation and then fails to re-allocate it after it is
released.

 If a process necessitates the use of one or more popular resources, either of

the methods described above can result in starvation.
Condition-3 :
No Preemption :
When possible, preemption of process resource allocations can help to avoid
deadlocks.

 One approach is that if a process is forced to wait when requesting a new

resource, all other resources previously held by this process are implicitly
released (preempted), forcing this process to re-acquire the old resources
alongside the new resources in a single request, as discussed previously.

 Another approach is that when a resource is requested, and it is not available,

the system looks to see what other processes are currently using those
resources and are themselves blocked while waiting for another resource. If
such a process is discovered, some of their resources may be preempted and
added to the list of resources that the process is looking for.

 Either of these approaches may be appropriate for resources whose states

can be easily saved and restored, such as registers and memory, but they are
generally inapplicable to other devices, such as printers and tape drives.
Condition-4 :
Circular Wait :

 To avoid circular waits, number all resources and insist that processes request
resources is strictly increasing ( or decreasing) order.

 To put it another way, before requesting resource Rj, a process must first
release all Ri such that I >= j.

 The relative ordering of the various resources is a significant challenge in this

scheme.
Deadlock Avoidance :

 The general idea behind deadlock avoidance is to avoid deadlocks by

avoiding at least one of the aforementioned conditions.

 This necessitates more information about each process AND results in low
device utilization. (This is a conservative approach.)
  The scheduler only needs to know the maximum number of each resource
that a process could potentially use in some algorithms. In more complex
algorithms, the scheduler can also use the schedule to determine which
resources are required and in what order.

 When a scheduler determines that starting a process or granting resource

requests will result in future deadlocks, the process is simply not started or the
request is denied.

 The number of available and allocated resources, as well as the maximum

requirements of all processes in the system, define a resource allocation
state.
Deadlock Detection :

 If deadlocks cannot be avoided, another approach is to detect them and

recover in some way.
 Aside from the performance hit of constantly checking for deadlocks, a
policy/algorithm for recovering from deadlocks must be in place, and when
processes must be aborted or have their resources preempted, there is the
possibility of lost work.
Recovery From Deadlock :
There are three basic approaches to getting out of a bind:

1. Inform the system operator and give him/her permission to intervene

manually.

2. Stop one or more of the processes involved in the deadlock.

3. Prevent the use of resources.

Approach of Recovery From Deadlock :
Here, we will discuss the approach of Recovery From Deadlock as follows.
Approach-1 :
Process Termination :
There are two basic approaches for recovering resources allocated to terminated
processes as follows.

1. Stop all processes that are involved in the deadlock. This does break the
deadlock, but at the expense of terminating more processes than are
absolutely necessary.
2. Processes should be terminated one at a time until the deadlock is broken.
This method is more conservative, but it necessitates performing deadlock
detection after each step.
In the latter case, many factors can influence which processes are terminated next
as follows.

1. Priorities in the process

2. How long has the process been running and how close it is to completion.

3. How many and what kind of resources does the process have? (Are they
simple to anticipate and restore? )

4. How many more resources are required for the process to be completed?

5. How many processes will have to be killed?

6. Whether the process is batch or interactive.

Approach-2 :
Resource Preemption :
When allocating resources to break the deadlock, three critical issues must be
addressed:
1. Selecting a victim –
Many of the decision criteria outlined above apply to determine which
resources to preempt from which processes.
2. Rollback –
A preempted process should ideally be rolled back to a safe state before the
point at which that resource was originally assigned to the process.
Unfortunately, determining such a safe state can be difficult or impossible, so
the only safe rollback is to start from the beginning. (In other words, halt and
restart the process.)
3. Starvation –
How do you ensure that a process does not go hungry because its resources
are constantly being preempted? One option is to use a priority system and
raise the priority of a process whenever its resources are preempted. It should
eventually gain a high enough priority that it will no longer be preempted.

Memory Management

Paged Segmentation and Segmented Paging

INTRODUCTION:

Paged Segmentation and Segmented Paging are two different memory management
techniques that combine the benefits of paging and segmentation.

1. Paged Segmentation is a memory management technique that divides a

process’s address space into segments and then divides each segment into
 pages. This allows for a flexible allocation of memory, where each segment
can have a different size, and each page can have a different size within a
segment.

2. Segmented Paging, on the other hand, is a memory management technique

that divides the physical memory into pages, and then maps each logical
address used by a process to a physical page. In this approach, segments are
used to map virtual memory addresses to physical memory addresses, rather
than dividing the virtual memory into pages.
3. Both Paged Segmentation and Segmented Paging provide the benefits of
paging, such as improved memory utilization, reduced fragmentation, and
increased performance. They also provide the benefits of segmentation, such
as increased flexibility in memory allocation, improved protection and security,
and reduced overhead in memory management.

However, both techniques can also introduce additional complexity and overhead in
the memory management process. The choice between Paged Segmentation and
Segmented Paging depends on the specific requirements and constraints of a
system, and often requires trade-offs between flexibility, performance, and overhead.
Major Limitation of Single Level Paging
A big challenge with single level paging is that if the logical address space is large,
then the page table may take up a lot of space in main memory. For instance,
consider that logical address is 32 bit and each page is 4 KB, the number of pages
will be 2^20 pages. The page table without additional bits will be of the size 20 bits *
220 or 2.5 MB. Since each process has its own page table, a lot of memory will be
consumed when single level paging is used. For a system with 64-bit logical address
even a page table of single process will not fit in main memory. For a process with a
large logical address space, a lot of its page table entries are invalid as a lot of the
logical address space goes unused.
Page table with invalid entries
Segmented Paging
A solution to the problem is to use segmentation along with paging to reduce the size
of page table. Traditionally, a program is divided into four segments, namely code
segment, data segment, stack segment and heap segment.

Segments of a process

The size of the page table can be reduced by creating a page table for each
segment. To accomplish this hardware support is required. The address provided by
CPU will now be partitioned into segment no., page no. and offset.
The memory management unit (MMU) will use the segment table which will contain
the address of page table(base) and limit. The page table will point to the page
frames of the segments in main memory.

Segmented Paging
Advantages of Segmented Paging

1. The page table size is reduced as pages are present only for data of
segments, hence reducing the memory requirements.
2. Gives a programmers view along with the advantages of paging.

3. Reduces external fragmentation in comparison with segmentation.

4. Since the entire segment need not be swapped out, the swapping out into
virtual memory becomes easier .
Disadvantages of Segmented Paging

1. Internal fragmentation still exists in pages.

 2. Extra hardware is required

3. Translation becomes more sequential increasing the memory access time.

4. External fragmentation occurs because of varying sizes of page tables and

varying sizes of segment tables in today’s systems.
Paged Segmentation

1. In segmented paging, not every process has the same number of segments
and the segment tables can be large in size which will cause external
fragmentation due to the varying segment table sizes. To solve this problem,
we use paged segmentation which requires the segment table to be paged.
The logical address generated by the CPU will now consist of page no #1,
segment no, page no #2 and offset.

2. The page table even with segmented paging can have a lot of invalid pages.
Instead of using multi level paging along with segmented paging, the problem
of larger page table can be solved by directly applying multi level paging
instead of segmented paging.
Paged Segmentation
Advantages of Paged Segmentation

1. No external fragmentation

2. Reduced memory requirements as no. of pages limited to segment size.

3. Page table size is smaller just like segmented paging,

4. Similar to segmented paging, the entire segment need not be swapped out.

5. Increased flexibility in memory allocation: Paged Segmentation allows for a

flexible allocation of memory, where each segment can have a different size,
and each page can have a different size within a segment.

6. Improved protection and security: Paged Segmentation provides better

protection and security by isolating each segment and its pages, preventing a
single segment from affecting the entire process’s memory.
Increased program structure: Paged Segmentation provides a natural
 program structure, with each segment representing a different logical part of a
program.

7. Improved error detection and recovery: Paged Segmentation enables the

detection of memory errors and the recovery of individual segments, rather
than the entire process’s memory.

8. Reduced overhead in memory management: Paged Segmentation reduces

the overhead in memory management by eliminating the need to maintain a
single, large page table for the entire process’s memory.

9. Improved memory utilization: Paged Segmentation can improve memory

utilization by reducing fragmentation and allowing for the allocation of larger
blocks of contiguous memory to each segment.
Disadvantages of Paged Segmentation

1. Internal fragmentation remains a problem.

2. Hardware is complexer than segmented paging.

3. Extra level of paging at first stage adds to the delay in memory access.

4. Increased complexity in memory management: Paged Segmentation

introduces additional complexity in the memory management process, as it
requires the maintenance of multiple page tables for each segment, rather
than a single page table for the entire process’s memory.

5. Increased overhead in memory access: Paged Segmentation introduces

additional overhead in memory access, as it requires multiple lookups in
multiple page tables to access a single memory location.

6. Reduced performance: Paged Segmentation can result in reduced

performance, as the additional overhead in memory management and access
can slow down the overall process.

7. Increased storage overhead: Paged Segmentation requires additional storage

overhead, as it requires additional data structures to store the multiple page
tables for each segment.

8. Increased code size: Paged Segmentation can result in increased code size,
as the additional code required to manage the multiple page tables can take
up valuable memory space.

9. Reduced address space: Paged Segmentation can result in a reduced

address space, as some of the available memory must be reserved for the
storage of the multiple page tables.
REFERENCE:
Some popular books on Operating Systems that discuss Paged Segmentation
include:

1. Operating System Concepts by Abraham Silberschatz, Peter Baer Galvin, and

Greg Gagne

2. Modern Operating Systems by Andrew S. Tanenbaum

3. Operating Systems: A Design-Oriented Approach by Charles Crowley

4. Understanding the Linux Kernel by Daniel P. Bovet and Marco Cesate

5. Operating Systems: Principles and Practice by Thomas Anderson and

Michael Dahlin.
These books provide a comprehensive discussion of Paged Segmentation
and its related concepts, as well as practical examples and implementation
details. They are considered essential reading for anyone interested in the
study of operating systems and memory management techniques.

Allocation of frames in Operating System

An important aspect of operating systems, virtual memory is implemented using

demand paging. Demand paging necessitates the development of a page-
replacement algorithm and a frame allocation algorithm. Frame allocation
algorithms are used if you have multiple processes; it helps decide how many frames
to allocate to each process.

There are various constraints to the strategies for the allocation of frames:

 You cannot allocate more than the total number of available frames.
 At least a minimum number of frames should be allocated to each process.
This constraint is supported by two reasons. The first reason is, as less
number of frames are allocated, there is an increase in the page fault ratio,
decreasing the performance of the execution of the process. Secondly, there
should be enough frames to hold all the different pages that any single
instruction can reference.
Frame allocation algorithms –
The two algorithms commonly used to allocate frames to a process are:
1. Equal allocation: In a system with x frames and y processes, each process
gets equal number of frames, i.e. x/y. For instance, if the system has 48
frames and 9 processes, each process will get 5 frames. The three frames
which are not allocated to any process can be used as a free-frame buffer
pool.
  Disadvantage: In systems with processes of varying sizes, it does not
make much sense to give each process equal frames. Allocation of a
large number of frames to a small process will eventually lead to the
wastage of a large number of allocated unused frames.
2. Proportional allocation: Frames are allocated to each process according to
the process size.
For a process pi of size si, the number of allocated frames is ai = (si/S)*m,
where S is the sum of the sizes of all the processes and m is the number of
frames in the system. For instance, in a system with 62 frames, if there is a
process of 10KB and another process of 127KB, then the first process will be
allocated (10/137)*62 = 4 frames and the other process will get (127/137)*62
= 57 frames.
 Advantage: All the processes share the available frames according to
their needs, rather than equally.
Global vs Local Allocation –
The number of frames allocated to a process can also dynamically change
depending on whether you have used global replacement or local replacement for
replacing pages in case of a page fault.
1. Local replacement: When a process needs a page which is not in the
memory, it can bring in the new page and allocate it a frame from its own set
of allocated frames only.
 Advantage: The pages in memory for a particular process and the
page fault ratio is affected by the paging behavior of only that process.
 Disadvantage: A low priority process may hinder a high priority
process by not making its frames available to the high priority process.
2. Global replacement: When a process needs a page which is not in the
memory, it can bring in the new page and allocate it a frame from the set of all
frames, even if that frame is currently allocated to some other process; that is,
one process can take a frame from another.
 Advantage: Does not hinder the performance of processes and hence
results in greater system throughput.
 Disadvantage: The page fault ratio of a process can not be solely
controlled by the process itself. The pages in memory for a process
depends on the paging behaviour of other processes as well.

Cache Memory
Cache memory is a special type of high-speed memory located close to the CPU in a
computer. It stores frequently used data and instructions, So that the CPU can
access them quickly, improving the overall speed and efficiency of the computer.

It is a faster and smaller segment of memory whose access time is as close as

registers. In a hierarchy of memory, cache memory has access time lesser than
primary memory. Generally, cache memory is used as a buffer.

In this article we will see cache memory in detail.

What is Cache Memory?

Data in primary memory can be accessed faster than secondary memory but still,
access times of primary memory are generally in a few microseconds, whereas the
CPU is capable of performing operations in nanoseconds. Due to the time lag
between accessing data and acting on data performance of the system decreases as
the CPU is not utilized properly, it may remain idle for some time. In order to
minimize this time gap new segment of memory is Introduced known as Cache
Memory.

It is based on principle of locality of reference, which refers to the observation that

program tries to access a relatively small portion of their address space at any given
time, and repeatedly tries to access some portion of the memory. For ex: In fees
department of your college, transactions are accessed frequently to check on the
dues.
Key Features of Cache Memory

1. Speed: Faster than the main memory (RAM), which helps the CPU retrieve
data more quickly.
2. Proximity: Located very close to the CPU, often on the CPU chip itself,
reducing data access time.
3. Function: Temporarily holds data and instructions that the CPU is likely to
use again soon, minimizing the need to access the slower main memory.
Role of Cache Memory

The role of cache memory is explained below,

 Cache memory plays a crucial role in computer systems.

 It provide faster access.

 It acts buffer between CPU and main memory(RAM).

 Primary role of it is to reduce average time taken to access data, thereby

improving overall system performance.
Benefits of Cache Memory
Various benefits of the cache memory are,
1. Faster access: Faster than main memory. It resides closer to CPU , typically
on same chip or in close proximity. Cache stores subset of data and
instruction.
2. Reducing memory latency: Memory access latency refers to time taken for
processes to retrieve data from memory. Caches are designed to exploit
principle of locality.
3. Lowering bus traffic: Accessing data from main memory involves
transferring it over system bus. Bus is shared resource and excessive traffic
can lead to congestion and slower data transfers. By utilizing cache memory ,
processor can reduce frequency of accessing main memory resulting in less
bus traffic and improves system efficiency.
4. Increasing effective CPU utilization: Cache memory allows CPU to operate
at a higher effective speed. CPU can spend more time executing instruction
rather than waiting for memory access. This leads to better utilization of
CPU’s processing capabilities and higher overall system performance.
5. Enhancing system scalability: Cache memory helps improve system
scalability by reducing impact of memory latency on overall system
performance.
Working of Cache Memory

In order to understand the working of cache we must understand few points:

 Cache memory is faster, they can be accessed very fast

 Cache memory is smaller, a large amount of data cannot be stored

Whenever CPU needs any data it searches for corresponding data in the cache (fast
process) if data is found, it processes the data according to instructions, however, if
data is not found in the cache CPU search for that data in primary memory(slower
process) and loads it into the cache. This ensures frequently accessed data are
always found in the cache and hence minimizes the time required to access the
data.
How does Cache Memory Improve CPU Performance?

Cache memory improves CPU performance by reducing the time it takes for the
CPU to access data. By storing frequently accessed data closer to the CPU, it
minimizes the need for the CPU to fetch data from the slower main memory.
What is a Cache Hit and a Cache Miss?

Cache Hit: When the CPU finds the required data in the cache memory, allowing for
quick access.On searching in the cache if data is found, a cache hit has occurred.
Cache Miss: When the required data is not found in the cache, forcing the CPU to
retrieve it from the slower main memory.On searching in the cache if data is not
found, a cache miss has occurred

Performance of cache is measured by the number of cache hits to the number of

searches. This parameter of measuring performance is known as the Hit Ratio.

Hit ratio=(Number of cache hits)/(Number of searches)

Types of Cache Memory

1. L1 or Level 1 Cache: It is the first level of cache memory that is present

inside the processor. It is present in a small amount inside every core of the
processor separately. The size of this memory ranges from 2KB to 64 KB.
2. L2 or Level 2 Cache: It is the second level of cache memory that may
present inside or outside the CPU. If not present inside the core, It can be
shared between two cores depending upon the architecture and is connected
to a processor with the high-speed bus. The size of memory ranges from 256
KB to 512 KB.
3. L3 or Level 3 Cache: It is the third level of cache memory that is present
outside the CPU and is shared by all the cores of the CPU. Some high
processors may have this cache. This cache is used to increase the
performance of the L2 and L1 cache. The size of this memory ranges from 1
MB to 8MB.
Difference Between Cache and RAM

Although Cache and RAM both are used to increase the performance of the system
there exists a lot of differences in which they operate to increase the efficiency of the
system.

RAM (Random Access

Feature Cache Memory Memory)

Connected to the CPU via the

Location Located close to the CPU.
memory bus.

Stores frequently accessed data Serves as the main working

Purpose
and instructions. memory for the CPU.
 RAM (Random Access
Feature Cache Memory Memory)

Fast, but slower than cache

Very fast, with access times in
Speed memory, with access times in
nanoseconds.
tens of nanoseconds.

Smaller in size, typically Larger in size, ranging from

Size measured in kilobytes (KB) to a gigabytes (GB) to terabytes
few megabytes (MB). (TB).

Uses SRAM (Static RAM), Uses DRAM (Dynamic RAM),

Type of
which is faster but more which is slower but more cost-
Memory
expensive. effective.

Extremely fast access times due Slightly slower access times

Accessibility
to proximity to the CPU. compared to cache memory.

More expensive per unit of Less expensive per unit of

Cost memory due to its speed and memory compared to cache
proximity to the CPU. memory.

Typically organized into multiple

Single level, serving as the
levels (L1, L2, L3), with each
Hierarchy primary working memory for
level increasing in size and
the CPU.
latency.

Acts as a buffer between the Used for storing data and

Usage CPU and main memory (RAM), instructions currently being
speeding up data access. processed by the CPU.

Larger capacity, providing

Limited capacity due to its small ample storage space for
Capacity
size and high-speed nature. running applications and
processes.
Conclusion

In conclusion, cache memory plays an important role in enhancing the speed and
efficiency of computer systems. By storing frequently accessed data and instructions
close to the CPU, cache memory minimizes the time required for the CPU to access
information, thereby reducing latency and improving overall system performance.
Frequently Asked Questions on Cache Memory – FAQ’s

Why is cache memory faster than main memory?

Cache memory is faster than main memory because it uses high-speed static RAM
(SRAM) rather than the slower dynamic RAM (DRAM) used in main memory. Its
proximity to the CPU also reduces the time needed to access data.
Can cache memory be upgraded?

Cache memory is typically built into the CPU and cannot be upgraded separately.
Upgrading the CPU can increase the amount and speed of cache memory available.
What happens if the cache memory is full?

When the cache memory is full, it uses algorithms like Least Recently Used (LRU) to
replace old data with new data. The least recently accessed data is removed to
make space for the new data.
Why is multi-level cache used in modern CPUs?

Multi-level caches are used to balance speed and cost. L1 cache is the f.astest and
most expensive per byte, so it’s small. L2 and L3 caches are progressively larger
and slower, providing a larger total cache size while managing costs and maintaining
reasonable speed.

Memory Management in Operating System

The term memory can be defined as a collection of data in a specific format. It is

used to store instructions and process data. The memory comprises a large array or
group of words or bytes, each with its own location. The primary purpose of a
computer system is to execute programs. These programs, along with the
information they access, should be in the main memory during execution. The CPU
fetches instructions from memory according to the value of the program counter.
To achieve a degree of multiprogramming and proper utilization of memory, memory
management is important. Many memory management methods exist, reflecting
various approaches, and the effectiveness of each algorithm depends on the
situation.
What is Main Memory?

The main memory is central to the operation of a Modern Computer. Main Memory is
a large array of words or bytes, ranging in size from hundreds of thousands to
billions. Main memory is a repository of rapidly available information shared by
the CPU and I/O devices. Main memory is the place where programs and
information are kept when the processor is effectively utilizing them. Main memory is
associated with the processor, so moving instructions and information into and out of
the processor is extremely fast. Main memory is also known as RAM (Random
Access Memory). This memory is volatile. RAM loses its data when a power
interruption occurs.

Main Memory
What is Memory Management?

Memory management mostly involves management of main memory. In a

multiprogramming computer, the Operating System resides in a part of the main
memory, and the rest is used by multiple processes. The task of subdividing the
memory among different processes is called Memory Management. Memory
management is a method in the operating system to manage operations between
main memory and disk during process execution. The main aim of memory
management is to achieve efficient utilization of memory.
Why Memory Management is Required?

 Allocate and de-allocate memory before and after process execution.

 To keep track of used memory space by processes.

 To minimize fragmentation issues.

 To proper utilization of main memory.

 To maintain data integrity while executing of process.

read more about – Requirements of Memory Management System

Now we are discussing the concept of Logical Address Space and Physical Address
Space
Logical and Physical Address Space

 Logical Address Space: An address generated by the CPU is known as a

“Logical Address”. It is also known as a Virtual address. Logical address
space can be defined as the size of the process. A logical address can be
changed.
 Physical Address Space: An address seen by the memory unit (i.e. the one
loaded into the memory address register of the memory) is commonly known
as a “Physical Address”. A Physical address is also known as a Real address.
The set of all physical addresses corresponding to these logical addresses is
known as Physical address space. A physical address is computed by MMU.
The run-time mapping from virtual to physical addresses is done by a
hardware device Memory Management Unit(MMU). The physical address
always remains constant.
Static and Dynamic Loading

Loading a process into the main memory is done by a loader. There are two different
types of loading :
 Static Loading: Static Loading is basically loading the entire program into a
fixed address. It requires more memory space.
 Dynamic Loading: The entire program and all data of a process must be in
physical memory for the process to execute. So, the size of a process is
limited to the size of physical memory. To gain proper memory utilization,
dynamic loading is used. In dynamic loading, a routine is not loaded until it is
called. All routines are residing on disk in a relocatable load format. One of the
advantages of dynamic loading is that the unused routine is never loaded.
 This loading is useful when a large amount of code is needed to handle it
efficiently.
Static and Dynamic Linking

To perform a linking task a linker is used. A linker is a program that takes one or
more object files generated by a compiler and combines them into a single
executable file.
 Static Linking: In static linking, the linker combines all necessary program
modules into a single executable program. So there is no runtime
dependency. Some operating systems support only static linking, in which
system language libraries are treated like any other object module.
 Dynamic Linking: The basic concept of dynamic linking is similar to dynamic
loading. In dynamic linking, “Stub” is included for each appropriate library
routine reference. A stub is a small piece of code. When the stub is executed,
it checks whether the needed routine is already in memory or not. If not
available then the program loads the routine into memory.
Swapping

When a process is executed it must have resided in memory. Swapping is a process

of swapping a process temporarily into a secondary memory from the main memory,
which is fast compared to secondary memory. A swapping allows more processes to
be run and can be fit into memory at one time. The main part of swapping is
transferred time and the total time is directly proportional to the amount of memory
swapped. Swapping is also known as roll-out, or roll because if a higher priority
process arrives and wants service, the memory manager can swap out the lower
priority process and then load and execute the higher priority process. After finishing
higher priority work, the lower priority process swapped back in memory and
continued to the execution process.
swapping in memory management
Memory Management Techniques

Memory management techniques are methods used by an operating system to

efficiently allocate, utilize, and manage memory resources for processes. These
techniques ensure smooth execution of programs and optimal use of system
memory

Different Memory Management techniques are:

Memory Management with Monoprogramming (Without Swapping)

This is the simplest memory management approach the memory is divided into two
sections:
  One part of the operating system

 The second part of the user program

Fence Register

operating system user program

 In this approach, the operating system keeps track of the first and last location
available for the allocation of the user program

 The operating system is loaded either at the bottom or at top

 Interrupt vectors are often loaded in low memory therefore, it makes sense to
load the operating system in low memory

 Sharing of data and code does not make much sense in a single process
environment

 The Operating system can be protected from user programs with the help of a
fence register.
Multiprogramming with Fixed Partitions (Without Swapping)

 A memory partition scheme with a fixed number of partitions was introduced

to support multiprogramming. this scheme is based on contiguous allocation

 Each partition is a block of contiguous memory

 Memory is partitioned into a fixed number of partitions.

 Each partition is of fixed size

Example: As shown in fig. memory is partitioned into 5 regions the region is
reserved for updating the system the remaining four partitions are for the user
program.
Fixed Size Partitioning

Operating System

p1

p2
Operating System

p3

p4

Partition Table

Once partitions are defined operating system keeps track of the status of memory
partitions it is done through a data structure called a partition table.
Sample Partition Table

Starting Address of Partition Size of Partition Status

0k 200k allocated

200k 100k free

300k 150k free

450k 250k allocated

Logical vs Physical Address

An address generated by the CPU is commonly referred to as a logical address. the

address seen by the memory unit is known as the physical address. The logical
address can be mapped to a physical address by hardware with the help of a base
register this is known as dynamic relocation of memory references.
Contiguous Memory Allocation

Contiguous memory allocation is a memory management method where each

process is given a single, continuous block of memory. This means all the data for a
process is stored in adjacent memory locations.
Partition Allocation Methods

To gain proper memory utilization, memory allocation must be allocated efficient

manner. One of the simplest methods for allocating memory is to divide memory into
several fixed-sized partitions and each partition contains exactly one process. Thus,
the degree of multiprogramming is obtained by the number of partitions.
 Fixed partition allocation: Memory is divided into fixed-sized partitions
during system initialization. Each partition can hold only one process.
 Dynamic Partition Allocation: In this allocation strategy, Memory is divided
into variable-sized partitions based on the size of the processes.

When it is time to load a process into the main memory and if there is more than one
free block of memory of sufficient size then the OS decides which free block to
allocate.

There are different Placement Algorithm:

1. First Fit

2. Best Fit

3. Worst Fit

4. Next Fit

 read more about – Fixed (or static) Partitioning in Operating System

 read more about – Variable (or Dynamic) Partitioning in Operating System

 read more about – Partition Allocation Methods in Memory Management

Non-Contiguous Memory Allocation
Non-contiguous memory allocation is a memory management method where a
process is divided into smaller parts, and these parts are stored in different, non-
adjacent memory locations. This means the entire process does not need to be
stored in one continuous block of memory.

Techniques of Non-Contiguous Memory Allocation are:

 Paging

 Segmentation

read more about – Non-Contiguous Memory Allocation

Fragmentation

Fragmentation is defined as when the process is loaded and removed after

execution from memory, it creates a small free hole. These holes can not be
assigned to new processes because holes are not combined or do not fulfill the
memory requirement of the process. In the operating systems two types of
fragmentation are:
 Internal fragmentation: Internal fragmentation occurs when memory blocks
are allocated to the process more than their requested size. Due to this some
unused space is left over and creating an internal fragmentation
problem. Example: Suppose there is a fixed partitioning used for memory
allocation and the different sizes of blocks 3MB, 6MB, and 7MB space in
memory. Now a new process p4 of size 2MB comes and demands a block of
memory. It gets a memory block of 3MB but 1MB block of memory is a waste,
and it can not be allocated to other processes too. This is called internal
fragmentation.
 External fragmentation: In External Fragmentation, we have a free memory
block, but we can not assign it to a process because blocks are not
contiguous. Example: Suppose (consider the above example) three
processes p1, p2, and p3 come with sizes 2MB, 4MB, and 7MB respectively.
Now they get memory blocks of size 3MB, 6MB, and 7MB allocated
respectively. After allocating the process p1 process and the p2 process left
1MB and 2MB. Suppose a new process p4 comes and demands a 3MB block
of memory, which is available, but we can not assign it because free memory
space is not contiguous. This is called external fragmentation.

read more about – Fragmentation

Frequently asked Questions on Memory Management in Operating System –
FAQ

What is a memory leak, and how does it affect system performance?

A memory leak occurs when a program fails to release memory that it no longer
needs, resulting in wasted memory resources. Over time, if memory leaks
accumulate, the system’s available memory diminishes, leading to reduced
performance and possibly system crashes.
Can memory fragmentation be prevented in an operating system?

While it is challenging to completely eliminate memory fragmentation, certain

techniques can help minimize its impact. One approach is to use memory allocation
algorithms that focus on reducing external fragmentation, such as buddy systems or
slab allocation. Additionally, techniques like compaction can be employed to reduce
internal fragmentation.
What are the advantages and disadvantages of using virtual memory?

Virtual memory provides several benefits, including the ability to run larger programs
than the available physical memory, increased security through memory isolation,
and simplified memory management for applications. However, using virtual memory
also introduces additional overhead due to page table lookups and potential
performance degradation if excessive swapping occurs.
Real Storage

Real storage in an operating system is the physical memory of a computer that

stores data. It's also known as central storage or processor storage.

Explanation
 Internal and external storage: Computers have two types of physical
storage: internal and external.
 Volatile and non-volatile storage: Volatile storage loses its contents when
the power is removed, while non-volatile storage does not.
 Primary storage: This is where documents, images, and other files are
stored on a hard drive or external drive.
 Mass storage: This includes devices with removable and non-removable
media, such as smartphones, computers, enterprise servers, and data
centres.
 Optical storage: This includes compact disks (CDs) and digital versatile disks
(DVDs).

Bare Machine and Resident Monitor

The Bare Machine and Resident Monitor are not directly related to the operating
system but while we study about memory management these components are really
important to study, so let’s study them one by one and then their working. In this
article, we are going to talk about two important part of the computer system, that is
Bare machine and Resident monitor.
What is Bare Machine?

Bare machine is logical hardware which is used to execute the program in the
processor without using the operating system. As of now, we have studied that we
can’t execute any process without the Operating system. But yes with the help of the
Bare machine we can do that.

Initially, when the operating systems are not developed, the execution of an
instruction is done by directly on hardware without using any interfering hardware, at
that time the only drawback was that the Bare machines accepting the instruction in
only machine language, due to this those person who has sufficient knowledge about
Computer field are able to operate a computer. so after the development of the
operating system Bare machine is referred to as inefficient.
What is Resident Monitor?

The Resident Monitor is a code that runs on Bare Machines. The resident monitor
works like an operating system that controls the instructions and performs all
necessary functions. It also works like job sequencer because it also sequences the
job and sends them to the processor.

After scheduling the job Resident monitors loads the programs one by one into the
main memory according to their sequences. One most important factor about the
resident monitor is that when the program execution occurred there is no gap
between the program execution and the processing is going to be faster.

The Resident monitors are divided into 4 parts as:

1. Control Language Interpreter

2. Loader

3. Device Driver

4. Interrupt Processing
Parts of Resident Monitor
 Control Language Interpreter: The first part of the Resident monitor is
control language interpreter which is used to read and carry out the instruction
from one level to the next level.
 Loader: The second part of the Resident monitor which is the main part of the
Resident Monitor is Loader which Loads all the necessary system and
application programs into the main memory.
 Device Driver: The third part of the Resident monitor is Device Driver which
is used to manage the connecting input-output devices to the system. So
basically it is the interface between the user and the system. it works as an
interface between the request and response. request which user made,
Device driver responds that the system produces to fulfill these requests.
 Interrupt Processing: The fourth part as the name suggests, it processes the
all occurred interrupt to the system.
Conclusion
In conclusion, a Bare machine is a basic model of a computer that focuses on its
essential components and operations, like memory and simple instructions. It helps
us understand fundamental computing concepts without any extra features. On the
other hand, a resident monitor is a more advanced system that manages the
computer’s resources and allows multiple programs to run efficiently. It handles tasks
like memory allocation and input/output operations, making it easier for users to
interact with the computer.
Frequently Asked Questions on Bare Machine and Resident Monitor – FAQs
Why is the Bare Machine Important?

The bare machine is important for understanding the fundamental concepts of

computing, like how data is processed and stored, without distractions from modern
features.
What are the Benefits of a Resident Monitor?
A resident monitor allows for efficient multitasking, better resource management, and
smoother user experiences by handling multiple programs simultaneously.
Are They Used in Real Computers?

The bare machine is mostly a theoretical concept for learning, while resident
monitors are used in operating systems to help manage computer functions and
resources.
Can I Run Programs on a Bare Machine?

No, a bare machine doesn’t support running complex programs directly. It only
shows basic operations. In contrast, a resident monitor allows you to run and
manage multiple programs effectively.

Fixed (or static) Partitioning in Operating System

Fixed partitioning, also known as static partitioning, is one of the earliest memory
management techniques used in operating systems. In this method, the main
memory is divided into a fixed number of partitions at system startup, and each
partition is allocated to a process. These partitions remain unchanged throughout
system operation, ensuring a simple, predictable memory allocation process. Despite
its simplicity, fixed partitioning has several limitations, such as internal fragmentation
and inflexible handling of varying process sizes. This article delves into the
advantages, disadvantages, and applications of fixed partitioning in modern
operating systems.
What is Fixed (or static) Partitioning in the Operating System?

Fixed (or static) partitioning is one of the earliest and simplest memory management
techniques used in operating systems. It involves dividing the main memory into a
fixed number of partitions at system startup, with each partition being assigned to a
process. These partitions remain unchanged throughout the system’s operation,
providing each process with a designated memory space. This method was widely
used in early operating systems and remains relevant in specific contexts like
embedded systems and real-time applications. However, while fixed partitioning is
simple to implement, it has significant limitations, including inefficiencies caused by
internal fragmentation.

1. In fixed partitioning, the memory is divided into fixed-size chunks, with each
chunk being reserved for a specific process. When a process requests
memory, the operating system assigns it to the appropriate partition. Each
partition is of the same size, and the memory allocation is done at system
boot time.

2. Fixed partitioning has several advantages over other memory allocation

techniques. First, it is simple and easy to implement. Second, it is predictable,
meaning the operating system can ensure a minimum amount of memory for
each process. Third, it can prevent processes from interfering with each
other’s memory space, improving the security and stability of the system.

3. However, fixed partitioning also has some disadvantages. It can lead to

internal fragmentation, where memory in a partition remains unused. This can
happen when the process’s memory requirements are smaller than the
partition size, leaving some memory unused. Additionally, fixed partitioning
limits the number of processes that can run concurrently, as each process
requires a dedicated partition.

Overall, fixed partitioning is a useful memory allocation technique in situations where

the number of processes is fixed, and the memory requirements for each process
are known in advance. It is commonly used in embedded systems, real-time
systems, and systems with limited memory resources.

In operating systems, Memory Management is the function responsible for allocating

and managing a computer’s main memory. Memory Management function keeps
track of the status of each memory location, either allocated or free to ensure
effective and efficient use of Primary Memory.

There are two Memory Management Techniques:

1. Contiguous

2. Non-Contiguous
Contiguous Memory Allocation:
In contiguous memory allocation, each process is assigned a single continuous block
of memory in the main memory. The entire process is loaded into one contiguous
memory region.

In Contiguous Technique, executing process must be loaded entirely in the main

memory.
Contiguous Technique can be divided into:

 Fixed (or static) partitioning

 Variable (or dynamic) partitioning

Fixed Partitioning:
This is the oldest and simplest technique used to put more than one process in the
main memory. In this partitioning, the number of partitions (non-overlapping)
in RAM is fixed but the size of each partition may or may not be the same. As it is
a contiguous allocation, hence no spanning is allowed. Here partitions are made
before execution or during system configure.

As illustrated in above figure, first process is only consuming 1MB out of 4MB in the
main memory.
Hence, Internal Fragmentation in first block is (4-1) = 3MB.
Sum of Internal Fragmentation in every block = (4-1)+(8-7)+(8-7)+(16-14)= 3+1+1+2
= 7MB.

Suppose process P5 of size 7MB comes. But this process cannot be accommodated
in spite of available free space because of contiguous allocation (as spanning is not
allowed). Hence, 7MB becomes part of External Fragmentation.
Advantages of Fixed Partitioning
 Easy to implement: The algorithms required are simple and straightforward.

 Low overhead: Requires minimal system resources to manage, ideal for

resource-constrained systems.
 Predictable: Memory allocation is predictable, with each process receiving a
fixed partition.
 No external fragmentation: Since the memory is divided into fixed partitions
and no spanning is allowed, external fragmentation is avoided.
 Suitable for systems with a fixed number of processes: Ideal for systems
where the number of processes and their memory requirements are known in
advance.
 Prevents process interference: Ensures that processes do not interfere with
each other’s memory, improving system stability.
 Efficient memory use: Particularly in systems with fixed, known processes
and batch processing scenarios.
 Good for batch processing: Works well in environments where the number
of processes remains constant over time.
 Better control over memory allocation: The operating system has clear
control over how memory is allocated and managed.
 Easy to debug: Fixed Partitioning is easy to debug since the size and
location of each process are predetermined.
Disadvantages of Fixed Partitioning

1. Internal Fragmentation: Main memory use is inefficient. Any program, no

matter how small, occupies an entire partition. This can cause internal
fragmentation.

2. Limit process size: Process of size greater than the size of the partition in
Main Memory cannot be accommodated. The partition size cannot be varied
according to the size of the incoming process size. Hence, the process size of
32MB in the above-stated example is invalid.

3. Limitation on Degree of Multiprogramming: Partitions in Main Memory are

made before execution or during system configure. Main Memory is divided
into a fixed number of partitions. Suppose if there are partitions in RAM
 and are the number of processes, then n2<=n1 n2<=n1 condition must be
fulfilled. Number of processes greater than the number of partitions in RAM is
invalid in Fixed Partitioning.
Clarification:

Internal fragmentation is a notable disadvantage in fixed partitioning, whereas

external fragmentation is not applicable because processes cannot span across
multiple partitions, and memory is allocated in fixed blocks.
Non-Contiguous Memory Allocation:

In non-contiguous memory allocation, a process is divided into multiple blocks or

segments that can be loaded into different parts of the memory, rather than requiring
a single continuous block.
Key Features:

Divided memory blocks: A process is divided into smaller chunks (pages,

segments) and placed in available memory blocks, which can be located anywhere
in the memory.
Paging and Segmentation:

 Paging: Divides memory into fixed-size blocks called pages. Pages of a

process can be placed in any available memory frames.
 Segmentation: Divides memory into variable-sized segments based on
logical sections of a program, like code, data, and stack.
Conclusion

Fixed partitioning, though straightforward and easy to manage, presents several

challenges, particularly in the form of internal fragmentation and limited flexibility in
handling varying process sizes. This memory allocation technique works well in
environments where memory requirements are predictable and stable. However, for
modern systems with dynamic workloads and varying memory demands, more
flexible techniques like dynamic partitioning or non-contiguous allocation methods
have become preferable. Nonetheless, understanding fixed partitioning is crucial for
grasping the evolution of memory management in operating systems and its
applications in specialized environments.
Frequently Asked Questions on Fixed Partitioning in OS -FAQs

How does internal fragmentation occur in Fixed Partitioning?

Internal fragmentation occurs when a process’s size is smaller than the allocated
partition. The unused memory within the partition is wasted, leading to inefficient
memory usage.
Why is Fixed Partitioning not widely used in modern systems?
Due to its inflexibility in handling varying process sizes and the inefficiency caused
by internal fragmentation, fixed partitioning is not suitable for modern systems with
dynamic workloads.
How is internal fragmentation different from external fragmentation in memory
management?

Internal fragmentation occurs when allocated memory exceeds the memory required
by a process, leaving unused space within a partition. External fragmentation, on the
other hand, refers to the wasted space outside of allocated partitions, which is not
applicable in fixed partitioning since partitions are predetermined and cannot span.
Can processes larger than the partition size be accommodated in Fixed
Partitioning?

No, in fixed partitioning, a process larger than the partition size cannot be
accommodated because partitions are of fixed size and cannot dynamically adjust to
a process’s memory requirements.
What types of systems benefit from Fixed Partitioning?

Systems with a fixed number of processes and predictable memory requirements,

such as embedded systems, real-time systems, and batch processing systems,
benefit from fixed partitioning due to its simplicity and low overhead.
Why does Fixed Partitioning limit the degree of multiprogramming?

Since the number of partitions in memory is fixed, only a limited number of

processes can be loaded into memory simultaneously. This restricts the degree of
multiprogramming, as processes are confined to the number of available partitions.
Is Fixed Partitioning still used in modern systems?

While fixed partitioning is not commonly used in modern general-purpose systems, it

still finds use in specialized environments such as embedded systems, where
predictable and stable memory allocation is crucial.
What alternatives to Fixed Partitioning exist for memory management?

Alternatives include dynamic partitioning, where partition sizes can adjust to process
requirements, and non-contiguous memory allocation methods like paging and
segmentation, which allow processes to be loaded into non-contiguous memory
blocks, reducing fragmentation.

Variable (or Dynamic) Partitioning in Operating System

In operating systems, Memory Management is the function responsible for allocating
and managing a computer’s main memory. The memory Management function keeps
track of the status of each memory location, either allocated or free to ensure
effective and efficient use of Primary Memory.

Below are Memory Management Techniques.

 Contiguous

 Non-Contiguous

In the Contiguous Technique, the executing process must be loaded entirely in the
main memory. The contiguous Technique can be divided into.

 Fixed (static) partitioning

 Variable (dynamic) partitioning

What is Variable (Dynamic) Partitioning?

It is a part of the Contiguous allocation technique. It is used to alleviate the problem

faced by Fixed Partitioning. In contrast with fixed partitioning, partitions are not made
before the execution or during system configuration. Various features associated
with variable Partitioning-

 Initially, RAM is empty and partitions are made during the run-time according
to the process’s need instead of partitioning during system configuration.

 The size of the partition will be equal to the incoming process.

 The partition size varies according to the need of the process so that internal
fragmentation can be avoided to ensure efficient utilization of RAM.

 The number of partitions in RAM is not fixed and depends on the number of
incoming processes and the Main Memory’s size.
Advantages of Variable(Dynamic) Partitioning

 No Internal Fragmentation: In variable Partitioning, space in the main

memory is allocated strictly according to the need of the process, hence there
is no case of internal fragmentation. There will be no unused space left in the
partition.
 No restriction on the Degree of Multiprogramming: More processes can
be accommodated due to the absence of internal fragmentation. A process
can be loaded until the memory is empty.
 No Limitation on the Size of the Process: In Fixed partitioning, the process
with a size greater than the size of the largest partition could not be loaded
and the process can not be divided as it is invalid in the contiguous allocation
technique. Here, In variable partitioning, the process size can’t be restricted
since the partition size is decided according to the process size.
Disadvantages of Variable(Dynamic) Partitioning

 Difficult Implementation: Implementing variable Partitioning is difficult as

compared to Fixed Partitioning as it involves the allocation of memory during
run-time rather than during system configuration.
 External Fragmentation: There will be external fragmentation despite the
absence of internal fragmentation. For example, suppose in the above
example- process P1(2MB) and process P3(1MB) completed their execution.
Hence two spaces are left i.e. 2MB and 1MB. Let’s suppose process P5 of
size 3MB comes. The space in memory cannot be allocated as no spanning is
allowed in contiguous allocation. The rule says that the process must be
 continuously present in the main memory to get executed. Hence it results in
External Fragmentation.

No Internal Fragmentation

Now P5 of size 3 MB cannot be accommodated despite the required available space

because in contiguous no spanning is allowed.
Key Points On Variable (Dynamic) Partitioning in Operating Systems

 Variable (or dynamic) partitioning is a memory allocation technique that allows

memory partitions to be created and resized dynamically as needed.

 The operating system maintains a table of free memory blocks or holes, each
of which represents a potential partition. When a process requests memory,
the operating system searches the table for a suitable hole that can
accommodate the requested amount of memory.

 Dynamic partitioning reduces internal fragmentation by allocating memory

more efficiently, allows multiple processes to share the same memory space,
and is flexible in accommodating processes with varying memory
requirements.

 However, dynamic partitioning can also lead to external fragmentation and

requires more complex memory management algorithms, which can make it
slower than fixed partitioning.

 Understanding dynamic partitioning is essential for operating system design

and implementation, as well as for system-level programming.
FAQs on Dynamic (Variable) Partitioning
Q.1: What is the basic difference between Fixed Partitioning and Variable
Partitioning?

Answer:

Fixed Partitioning helps in creating memory of identical sizes whereas dynamic

partitioning helps in creating memory of variable sizes.
Q.2: Which algorithms work best for Dynamic Partitioning?

Answer:

The Worst Fit Algorithm works best for Dynamic Partitioning.

Q.3: What is Data Partitioning?

Answer:

The process of dividing up data among several tables, drives, or locations in order to
enhance database manageability or query processing speed is known as data
partitioning.

Memory Allocation Techniques | Mapping Virtual Addresses to Physical

Addresses

Memory Allocation Techniques:

To store the data and to manage the processes, we need a large-sized memory and,
at the same time, we need to access the data as fast as possible. But if we increase
the size of memory, the access time will also increase and, as we know, the CPU
always generates addresses for secondary memory, i.e. logical addresses. But we
want to access the main memory, so we need Address translation of logical address
into physical address.
The main memory interacts with both the user processes and the operating system.
So we need to efficiently use the main memory. Main memory is divided into non-
overlapping memory regions called partitions.
The main memory can be broadly allocated in two ways –

1. Contiguous memory allocation

2. Non-Contiguous memory allocation

Contiguous memory allocation can be categorized into two ways :

1. Fixed partition scheme

2. Variable partition scheme.

Different Partition Allocation methods are used in Contiguous memory
allocations –

1. First Fit
2. Best Fit

3. Worst Fit

4. Next Fit
Non-Contiguous memory allocation can be categorized into many ways :

1. Paging

2. Multilevel paging

3. Inverted paging

4. Segmentation

5. Segmented paging
MMU(Memory Management Unit) :
The run time mapping between Virtual address and Physical Address is done by a
hardware device known as MMU.
In memory management, the Operating System will handle the processes and move
the processes between disk and memory for execution . It keeps track of available
and used memory.
MMU scheme :

CPU------- MMU------Memory
Dynamic relocation using a relocation register.

1. CPU will generate logical address for eg: 346

2. MMU will generate a relocation register (base register) for eg: 14000

3. In memory, the physical address is located eg:(346+14000= 14346)

The value in the relocation register is added to every address generated by a user
process at the time the address is sent to memory. The user program never sees the
real physical addresses. The program can create a pointer to location 346, store it in
memory, manipulate it, and compare it with other addresses—all like the number
346.
The user program generates only logical addresses. However, these logical
addresses must be mapped to physical addresses before they are used.
Address binding :
Address binding is the process of mapping from one address space to another
address space. Logical address is an address generated by the CPU during
execution, whereas Physical Address refers to the location in the memory unit(the
one that is loaded into memory).The logical address undergoes translation by the
MMU or address translation unit in particular. The output of this process is the
appropriate physical address or the location of code/data in RAM.

An address binding can be done in three different ways :

Compile Time –
If you know that during compile time, where process will reside in memory, then an
absolute address is generated. i.e The physical address is embedded to the
executable of the program during compilation. Loading the executable as a process
in memory is very fast. But if the generated address space is preoccupied by other
processes, then the program crashes and it becomes necessary to recompile the
program to change the address space.
Load time –
If it is not known at the compile time where the process will reside, then a relocatable
address will be generated. The loader translates the relocatable address to an
absolute address. The base address of the process in main memory is added to all
logical addresses by the loader to generate an absolute address. In this, if the base
address of the process changes, then we need to reload the process again.
Execution time –
The instructions are in memory and are being processed by the CPU. Additional
memory may be allocated and/or deallocated at this time. This is used if a process
can be moved from one memory to another during execution(dynamic linking-Linking
that is done during load or run time). e.g – Compaction.
Mapping Virtual Addresses to Physical Addresses :
In Contiguous memory allocation mapping from virtual addresses to physical
addresses is not a difficult task, because if we take a process from secondary
memory and copy it to the main memory, the addresses will be stored in a
contiguous manner, so if we know the base address of the process, we can find out
the next addresses.

The Memory Management Unit is a combination of 2 registers –

1. Base Register (Relocation Register)

2. Limit Register.
Base Register – contains the starting physical address of the process.
Limit Register -mentions the limit relative to the base address on the region
occupied by the process.

The logical address generated by the CPU is first checked by the limit register, If the
value of the logical address generated is less than the value of the limit register, the
base address stored in the relocation register is added to the logical address to get
the physical address of the memory location.
If the logical address value is greater than the limit register, then the CPU traps to
the OS, and the OS terminates the program by giving fatal error.

In Non Contiguous Memory allocation, processes can be allocated anywhere in

available space. The address translation in non-contiguous memory allocation is
difficult.
There are several techniques used for address translation in non contiguous memory
allocation like Paging, Multilevel paging, Inverted paging, Segmentation, Segmented
paging. Different data structures and hardware support like TLB are required in these
techniques.