# data[].attributes.body
External fragmentation. Compaction takes all of the free memory and puts it all in one place so as to be usable for the next process which are waiting for memory. This is only done with dynamic and relocatable dynamic memory system.

# data[].attributes.body
Single user operating is that in which one user works on one interface. In these systems no other operating system is interrupting with the processing. Single user operating systems work on processing that require less resources. Today we will discuss some of advantages and disadvantages of these systems.

# data[].attributes.body
External fragmentation. One way is to suffle memory content to place all free memory together in one large block

# data[].attributes.body
1) number of partitions is predefined and limits the total number of active processes in the system
2) partition sizes are preset and small jobs do not run efficiently
3) arbitrary partition sizes lead to undesired results
4) a partition size too small results in having longer turnaround time
5) a partition sizs too large results in internal fragmentation

# data[].attributes.body
No cost effective

# data[].attributes.body
•Full memory utilization only during loading of first job
•Subsequent allocation cause memory waste

# data[].attributes.body
Hazim (66721)

The type of fragmentation which is reduced by compaction is external fragmentation. Compaction takes all of the free memory and put it all in one place for the next process which are waiting for memory.

# data[].attributes.body
Number of partitions is predefined and limits the total number of active processes in the system

Partition sizes are preset and small jobs do not run efficiently

Too small a partition size results in large jobs having longer turnaround time

Too large a partition size results in internal fragmentation

# data[].attributes.body
Multiprogramming is executing a few job at a time on a system. It is used because it is efficient and less time needed which single use scheme do not have.

# data[].attributes.body
Full memory utilization only during loading of first jobs.
Subsequence allocation causes memory waste and external fragmentation occurs.

# data[].attributes.body
Multiprogramming is a task to execute multiple jobs by the same computer. It is use to overcome the problem of underutilization of CPU & main memory. It provide serving several jobs to share the time of CPU. But multiprogramming is not defined to be execution of jobs at the same instance of time.

# data[].attributes.body
No support for multiprogramming or networking

# data[].attributes.body
No support for multiprogramming and no cost effective.

# data[].attributes.body
external fragmentation. It can be reduce by shuffle memory content to place all free memory together in one large block

# data[].attributes.body
-Partition sizes are preset and small jobs do not run efficiently.
-Too small a partition size results in large jobs having longer turnaround time
-Sized of partitions could only be designated when the machine was powered on

# data[].attributes.body
This memory scheme operates on the first come, first serve basis : meaning that as newer jobs enter the system that are not the same size as those just vacated memory, they are fit into available spaces on the priority basis.

# data[].attributes.body
Multiprogramming is
1. The capability of an operation system to run multiple task in the same time.
2. Used to shorten the time for the operation system to finish the task compared to a single task system

# data[].attributes.body
Multiprogramming is the allocation of more than one concurrent program on a computer system and its resources. Multiprogramming allow using the CPU effectively by allowing various users to use the CPU and I/O devices effectively

# data[].attributes.body
67857 Syaiffudin bin Salleh

- Ability of an OS to execute more than one job/program on a single processor
- it increases CPU utilization
- maximize total job throughput of a computer

# data[].attributes.body
Rachel (67526)

The type of fragmentation which is reduced by compaction is external fragmentation. Compaction takes all the free memory and puts it all in one place so as to be usable for next processes which are waiting for memory. This is only done with dynamic and relocatable dynamic memory systems.

# data[].attributes.body
External fragmentation. Because compaction takes all free memory and compacts all of the in one so it will be usable for next process which are waiting for memory

# data[].attributes.body
- Does not support multiprogramming or networking
- Program size must be less than memory size to execute.

# data[].attributes.body
External fragmentation. Compaction takes all of the free memory and puts it all in one place so as to be usable for the next process(es) which are waiting for memory.

# data[].attributes.body
This memory scheme operates on the first come, first serve basis; meaning that as newer jobs enter the system that are not the same size as those that just vacated memory, they are fit into available spaces on a priority basis.

# data[].attributes.body
67049

One of the first problems with this type of memory allocation scheme is that it doesn't support multiprogramming or networking, it can only handle one job at a time.

# data[].attributes.body
(68083)
Internal fragmentation - The memory must be partitioned into variable sized blocks and assign the best fit block to process
External fragmentation -compaction, paging and segmentation

# data[].attributes.body
-Requires contiguous loading of entire program.
-in order to reconfigure a partition size, the machine had to be shut down, reconfigured and powered back on.

# data[].attributes.body
65834
External fragmentation

# data[].attributes.body
66874 Zulhaziq😉

Tasks take longer time to complete

# data[].attributes.body
Compaction is the reclaiming fragmented section of memory space.
Compaction helps to solve the problem of fragmentation. It moves all the occupied areas to store to one end and leaves one large free space for incoming jobs, instead of numerous small ones

# data[].attributes.body
Compaction is a process in which the free space is collected in a large memory chunk to make some space available for processes. In memory management, swapping creates multiple fragments in the memory because of the processes moving in and out. Compaction refers to combining all the empty spaces together and processes. Compaction helps to solve the problem of fragmentation, but it requires too much of CPU time. It moves all the occupied areas of store to one end and leaves are large free space for incoming jobs, instead of numerous small area. In compaction, the system also maintains relocation information and it must be performed on each new allocation at job to the memory or completion of job from memory.

# data[].attributes.body
Compaction is reclaiming fragmented sections of memory space. Compaction is used in order to process the information using fewer bits by using encoding schemes.

# data[].attributes.body
Disadvantage of relocatable dynamic partition is time consumption is very high due to compaction. Every program in memory must relocated so they are contiguous

# data[].attributes.body
64887
Can concentrate on one task at a time.

# data[].attributes.body
65351
-Doesn't support multiprogramming.
-Program must be less than memory block size to be able to execute

# data[].attributes.body
Multiprogramming is the allocation of more than one concurrent programs on a computer system and its resources. Multiprogramming allows usage of cpu effectively by allowing various users to use the cpu and I/O devices effectively.

# data[].attributes.body
68641

Internal fragmentation-wasted space within each allocated block because of roundung up from the actual requested allocation
External fragmentation- various spaced holes that are generated in either your memory or disk space

# data[].attributes.body
-Internal fragmentation is the wasted space within each allocated block because of rounding up from the actual requested allocation to the allocation granularity.
-External fragmentation is the various free spaced holes that are generated in either your memory or disk space.

# data[].attributes.body
67557
Internal Fragmentation block assigned to process is in fixed-sized memory while external fragmentation is in variable-sized memory. Internal fragmentation occurred when the process is larger than memory while external fragmentation occurred when the process is removed.

# data[].attributes.body
1)Time consumption is very high.

2)Due to compaction Every program in memory must be relocated so they are contiguous

3)Operating system must distinguish between addresses and data values which consumes a lot of time

# data[].attributes.body
External fragmentation.
Compaction moves memory around until it is all placed together in one big block.

66642 Midori.

# data[].attributes.body
65881

due to compaction, every program in memory must be relocated, so they are contiguous.

# data[].attributes.body
Internal fragmentation is the wasted space when each allocated block because of rounding up from the actual requested allocation to the allocation granularity.
External fragmentation is the various free spaced holes that are generated in either memory or disk space.

# data[].attributes.body
66304 Jong

In this dynamic partition technique, the partition size is not declared initially. It is declared at the time of process loading.this improve the internal fragmentation but in other hand it still have disadvantage on external fragmentation

# data[].attributes.body
67557
When there is no job can access the memory contiguous lu.

# data[].attributes.body
Internal fragmentation occurs when the amount of main memory requested by a program is less than the size of the fixed partition allocated. While external fragmentation is the development of unusable portions of memory in a dynamic partition memory management schemes

# data[].attributes.body
A form of parallel processing where multiple programs are running at the same time in a uniprocessor.
It is used to utilize the CPU during downtime such as waiting for an I/O to finish.

# data[].attributes.body
68641
Compiler or assemblef typically generate the execute with zero as lower most starting address, before amexecution of obje t code, these addresses should be adjusted so that they denote the correct runtime addresses.
Reallocation should be performed before the running of any program.

# data[].attributes.body
Relocation is done by adjusting the addresses used by the processes. It should be performed before the running of any problem.

# data[].attributes.body
Rellocation should be performed before the running of any program. Compilers or assembles typically generate the executable with zero as the lower-most, starting address. Before the execution of object code, these addresses should be adjusted so that they denote correct runtime addresses.

# data[].attributes.body
Relocation occur when operating system adjusts the addresses in a process to reflect the memory position in memory or the hardware adds relocation register(base) to virtual address to get a physical address.
Reallocation should be performed before the running of any program as the compilers or assembles typically generate executable with zero at the lower-most. Therefore, the address be adjusted so they denote the correct runtime address

# data[].attributes.body
Hazim (66721)

Relocation is the process of assigning load addresses for position-dependent code and data of a program and adjusting the code and data to reflect the assigned addresses. Relocation should be performed before the running of any program.

# data[].attributes.body
64887
Prevent data loss during power outage or software failure and increase the chances of data recovery in critical situation.

# data[].attributes.body
Relocation is the process of assigning load addresses for position-dependent code and data of a program and adjusting the code and data to reflect the assigned addresses.It should be done before running any program

# data[].attributes.body
Relocation is the adjusting of addresses so that they denote the correct runtime addresses. This should be done before running any programme

# data[].attributes.body
Relocation is the process by which program are reposition in main memory to allow compaction of free memory areas. Reallocation should be performed before the running of any program.

# data[].attributes.body
Relocation is the process of assigning loaded address for position, dependent code and data of the program and adjusting the code and the data to reflect the assigned addresses. Reallocation should be performed before the running of any program.

# data[].attributes.body
-Time consumption is very high.
-Due to compaction, every program in memory must be relocated so they are contigous.
-Operating system must distinguish between addresses and data values which consumes a lot of time.

# data[].attributes.body
66840 Muhd Nasharuddin bin Sufiyan
Can prevent data loss during software failure or power outages.

# data[].attributes.body
Relocation is the process of assigning loaded address for position-dependent code and data of program and adjusting the code and data to reflect the assigned addresses. Reallocation should be performed before the running of any program.Compilers or assemblers typically generate the executable with zero as the lower-most , starting address. Before the execution of object code,these addresses should be adjusted so that they denote the correct runtime addresses.

# data[].attributes.body
Relocation move a program from one area of memory to another. It often performed before the running of any program.

# data[].attributes.body
Relocation moves a program from one area of memory to another.

- it should be performed before running any program

66642 Midori

# data[].attributes.body
Relocation is the work that collect all external fragmentation and put it into one memory cache to be used by the future task.It should be done when the memory has been used by more than 50%.

# data[].attributes.body
Relocation moves programmes from one area of memory to another and should be performed before running any programme. It is done when unacceptable fragmentation characteristics are to be resolved.

# data[].attributes.body
Relocation is move a program from one area of memory to another. Performed before running any program.

# data[].attributes.body
A process where a job/program has to be moved from its current address to a new one to create space for new jobs to be run.
When there are jobs in waiting list,  a certain time had passed or certain percentage of memory is busy.

# data[].attributes.body
easy to maintain=These systems uses less resources and complexity of them is less so it is easy to maintain and debug.

# data[].attributes.body
68680
Internal fragmentation - Occurs when a fixed sized memory allocation technique is used
External fragmentation - Occurs when dynamic memory allocation technique is used

# data[].attributes.body
Reallocation should be performed before the running of any program.Compilers or assemblers typically generate the executed with zero as the lower-most,starting address.Before the execution of object code, these addresses should be adjusted so that they denote the correct runtime addresses.

# data[].attributes.body
66840 - Muhd Nasharuddin bin Sufiyan
Relocation is the action of moving free spaces in a memory and group them together so that it can accomodate to jobs that needed it. It should be performed everytime before a program started to run.

# data[].attributes.body
Reallocation should be performed before the running of any program.Compilers or assemblers typically generate the executable with zero as the lower most, starting address. Before the execution of object code, these addresses should be adjusted so that they denote the correct runtime addresses.

# data[].attributes.body
Relocation is the process to gather all the empty & wasted block and compact it into a memory block to accomodate some of all the jobs waiting to get in. The relocation of memory is low or when there are the jobs waiting to get in.

# data[].attributes.body
Internal fragmentation - Memory waste when the partition is too large.
External fragmentation - Memory waste at the fragments between blocks.

# data[].attributes.body
Relocation process start before running the program. This process done by the linker during compile time. Compiler generate the executable with zero as the lower-most.

# data[].attributes.body
67526 - Rachel

Reallocation is the process of assigning load addresses for position- dependent code and data of a program and adjusting the code and data to reflect the assigned addresses. Reallocation should be perform before running of any program.

# data[].attributes.body
Relocation means moving program from one place to another. Relocation should be performed before any program running .

# data[].attributes.body
Relocation process must be performed before running the program. This process is typically done by the linker during compilation, although it can be done at runtime by a relocating loader. Compilers or assemblers typically generate the executable with zero as the lower-most, starting address. Before the execution of the object code, these addresses should be adjusted so that they denote the correct runtime addresses.

# data[].attributes.body
Reallocation should be performed before the running of any program.

Compilers or assemblers typically generate the executable with zero as the

lower-most, starting address. Before the execution of object code, these addresses should be adjusted so that they denote the correct runtime addresses.

# data[].attributes.body
Relocation should be performed before running any program. Compilers or assemblers typically generate the executable with zero, as the lower-most, starting address. Before the execution of object code, these address should be adjusted so that they denote the correct runtime addresses.

# data[].attributes.body
This is the oldest and simplest technique used to put more than one processes in the main memory. In this partitioning, number of partitions (non-overlapping) in RAM are fixed but size of each partition may or may not be same. As it is contiguous allocation, hence no spanning is allowed.

# data[].attributes.body
68680
Relocation of memory is the process of reserving a partial or complete portion of computer memory for the execution of a program
Relocation should be performed before the running of program

# data[].attributes.body
-the number of partitions is predefined and limits the total number of active processes in the system

-partition sizes are preset and small jobs do not run efficiently

-arbitrary partition sizes lead to undesired results

-too small a partition size results in large jobs having longer turnaround time

-too large a partition size results in memory waste or internal fragmentation

# data[].attributes.body
Relocation moves a program from one area of memory to another, it should be performed before running any program, this has to be done when unacceptable fragmentation characteristics are to be resolved. This way the empty blocks gathered together and compacted to make one block of memory large enough to accommodate some or all of the jobs waiting to get in.

# data[].attributes.body
relocation is an act that gathers all empty block so that it is large enough to accomodate some or all of the waiting jobs.
Relocation should be performed before running any program

# data[].attributes.body
68078
1.requires contiguous loading of programs.
2.to work well all jobs must be same size and memory size known ahead of time.
3.arbitrary partition size leads to undesired results. If the partition too small, large jobs have longer turnaround time. If the partition too large, memory will be wasted.

# data[].attributes.body
Relocation is the process of assigning load addresses for position-dependent code and data of program and adjusting the code and data to reflect the assigned addresses. Reallocation should be performed before the running of any program

# data[].attributes.body
relocation moves a program from one area of memory to another, it should be performed before running any program. this has to be done when unacceptable

fragmentations characteristics are to be resolved.

# data[].attributes.body
64895 ridhwan
Advantages to single-user, single-tasking operating systems are, the computer is dedicated to one particular task at a time.

# data[].attributes.body
Reallocation should be performed before the running of any program. Compilers or assemblers typically generate the executable with zero as the most lower-most, starting address. Before the execution of  the object code these address should be adjusted so that they denote the correct runtime address

# data[].attributes.body
66214

Concentrate on one task                                               In modern operating system there are running multiple tasks at a time. Like many applications and tasks are running at a time but in single user OS only one task run at a time. So these systems are sometimes give less output result at a time.

# data[].attributes.body
Time consumption is very high. Due to compaction Every program in memory must be relocated so they are contiguous.

# data[].attributes.body
Memory manager relocates programs, gather together all empty blocks.
Compact the empty blocks: make one block of memory large to some or all jobs waiting.
It Should be performed before running of any program.

# data[].attributes.body
Supports one user at a time

-In these systems one user is only active at a time. So there will be no other user interfering with the applications. And in these systems all computer resources are used by a user requests.

# data[].attributes.body
Support for multi –programming

• The jobs in other partitions are prevented from overriding the boundaries of other jobs. The partition intrusion does not exist in Single User Partition scheme as there is only one job present and executing at any point of time.

# data[].attributes.body
Reallocation should be performed before the running of any program.

Compilers or assemblers typically generate the executable with zero as the

lower-most, starting address. Before the execution of object code, these addresses should be adjusted so that they denote the correct runtime addresses.

# data[].attributes.body
Easy to maintain=Algorithms needed to implement Fixed Partitioning are easy to implement.

# data[].attributes.body
Relocation is the process of assigning load addresses for position-dependent code and data of a program and adjusting the code and data to reflect the assigned addresses.

Relocation moves a program from one area of memory to another, it should be performed before running any program; this has to be done when unacceptable fragmentations characteristics are to be resolved. This way, the empty blocks are gathered together and compacted to make one block of memory large enough to accommodate some or all of the jobs waiting to get in.