Solution

• Compile time: Address binding is done when the program is compiled.
• Load time: Address binding is done when the program is loaded into memory.
• Execution time: Address binding is done during the execution of the program.
• Initialization time: This is not a standard stage in the context of address binding.

Dynamic linking typically involves address binding at execution time, as the linking occurs when the process is executing, allowing for the use of shared libraries and memory.

Solution

• Address generated by the CPU: This is correct as the logical address is generated by the CPU during program execution.
• Address seen by the memory unit: This describes the physical address.
• Address used by the operating system: The operating system uses both logical and physical addresses.
• Address mapped to the hard disk: This does not describe a logical address.

The logical address is the address generated by the CPU and used within the program. The memory management unit (MMU) translates logical addresses into physical addresses.

Solution

• Must be a power of 2: This is correct because page sizes are typically powers of 2 for alignment and addressing efficiency.
• Always equal to the size of physical memory: This is incorrect; the page size is much smaller.
• Can vary for different processes: All processes use the same page size defined by the system.
• Determines the number of logical addresses: The number of logical addresses is determined by the address space, not the page size.

Page sizes are generally a power of 2 to simplify the translation process and manage memory efficiently.

Solution

• Dividing memory into fixed-sized blocks: This describes paging.
• Dividing memory into variable-sized segments based on logical divisions: This correctly describes segmentation.
• Mapping logical addresses to physical addresses using fixed-size pages: This describes paging.
• Combining pages into a single large memory block: This is not a standard memory management technique.

Segmentation divides memory into segments that correspond to logical divisions of a program, such as functions, objects, and data structures.

Solution

• Simpler implementation: Contiguous allocation is simpler.
• Better utilization of memory: Non-contiguous allocation generally allows for better memory utilization by reducing fragmentation.
• Faster access times: Contiguous allocation typically provides faster access times.
• Easier address translation: Contiguous allocation has simpler address translation.

Non-contiguous memory allocation can reduce fragmentation and improve memory utilization, allowing the system to manage memory more flexibly.

Solution

First, calculate the page number and offset for the logical address 8196.

• Page size = 4 KB = 4096 bytes
• Logical address = 8196

Page number = 8196 / 4096 = 2

Offset = 8196 % 4096 = 4

Look up the frame number for page 2:

• Frame number = 7

Calculate the physical address:

• Physical address = (7 * 4096) + 4 = 28676

Solution

Logical address is given as (segment number, offset) = (1, 300).

From the segment table, for segment number 1:

• Base = 2000
• Limit = 400

Since the offset (300) is within the limit (400), we can calculate the physical address:

Physical address = base + offset = 2000+300=23002000 + 300 = 23002000+300=2300

Solution

Using the first-fit algorithm:

• 212 KB will be placed in the first partition that is big enough: 500 KB
• 417 KB will be placed in the first partition that is big enough: 600 KB
• 112 KB will be placed in the first partition that is big enough: 200 KB
• 426 KB cannot be placed as no remaining partitions are large enough

Solution

Using the best-fit algorithm:

• 212 KB will be placed in the smallest partition that is big enough: 300 KB
• 417 KB will be placed in the smallest partition that is big enough: 500 KB
• 112 KB will be placed in the smallest partition that is big enough: 200 KB
• 426 KB will be placed in the smallest partition that is big enough: 600 KB

Solution

Using the worst-fit algorithm:

212 KB will be placed in the largest partition: 600 KB

417 KB will be placed in the largest partition: 500 KB

112 KB will be placed in the largest remaining partition: 300 KB

426 KB cannot be placed as no remaining partitions are large enough

Solution

The process of 700 KB cannot be allocated to any of the available partitions:

600 KB is too small

400 KB is too small

200 KB is too small

External fragmentation is the total size of all the free memory partitions:

Total external fragmentation = 600 KB + 400 KB + 200 KB = 1200 KB

Solution

The virtual address space is 32 bits, which means there are 2322^{32}232 addresses. With a page size of 4 KB (2^12 bytes), the number of pages is:

Number of pages = 2^32/2^12=220\frac{2^{32}}{2^{12}} ==2^20 entries.

Solution

First, split the logical address 0x00401000 into parts:

• First-level page number: bits 22-31
• Second-level page number: bits 12-21
• Offset: bits 0-11

Logical address: 0x00401000 in binary: 0000 0000 0100 0000 0001 0000 0000 0000

• First-level index (bits 22-31): 0x1 (0000 0000 01)
• Second-level index (bits 12-21): 0x0 (0000 0000 00)
• Offset (bits 0-11): 0x1000 (0001 0000 0000)

From the first-level page table, index 1 maps to address 0x2000. From the second-level page table at 0x2000, index 0 maps to frame number 7.

Physical address base = frame number * page size = 7 * 4096 = 0x1C000 Physical address = base + offset = 0x1C000 + 0x1000 = 0x1D000

Solution

First, calculate the number of frames in physical memory:

• Physical memory size = 64 MB = 64 * 2^20 bytes
• Page size = 4 KB = 2^12 bytes

Number of frames = 64×2^20/2^12​=2^16

So, the inverted page table will have 2^16 entries = 16384

Solution

The virtual address space is 32 bits, so there are 2^32 addresses. With a page size of 4 KB (2^12 bytes), the number of pages is:

Number of pages = = 2^32/2^12​=2^20

If the first-level page table has 1024 entries, it covers 2^10 pages (since 1024 = 2^10). Therefore, the number of second-level page tables needed is:

Number of second-level page tables = 2^20/2^10​ = 2^10 entries.