Provide provide constructive feedback and ask some meaningful questions about this comment: The physical memory addresses are actual addresses located on the main memory $($RAM$),$ which they are loaded into the memory register. Physical addresses can not be seen by the program user but they are only seen by the kernel. The logical addresses are virtual addresses that physically don$$t exist. The CPU creates logical addresses for the processes so the CPU can fetch the content of the called$/$running process from the main memory. In other words, the logical addresses enable the CPU to have access to the main memory. Logical addresses are unique for each running process in the operating system and they don$$t represent the physical location in RAM. The logical address doesn$$t have a direct access to the RAM but with the use of a memory management unit $($MMU$),$ which is a hardware that interfaces between the CPU and RAM, The logical addresses get translated to physical memory. This translation process is known as mapping because the logical address, for each process, is mapped into a physical address in RAM.

Swapping, in the context of operating system memory, is a memory management technique that temporarily swaps out the blocked or not used or less frequently used process from the main memory to the secondary storage $($hard disk$),$ temporarily removing the some processes from RAM to HD$,$ to make full use of memory utilization and also to ensure enough memory availability for the process that are in ready status to execute. Example, assume that we have a scenario that several process like P$1,$ P$2,$ P$3$ and P$4$ are ready for execution but let us assume that P$1$ & P$2$ consumes too much memory when in they go in running mode so there might be not enough memory to cover the P$3$ and P$4$ as well due to limited amount of RAM. What will happen here, the operating system will move the P$3$ & P$4$ temporarily to HD until being called again and being swapped by P$1$ & P$2.$

Another memory management technique is a segmentation where the process virtual address is divided into variable sized segments and each segment represents a different process part $($such as data, code, head$).$ Segmentation is more flexible in the memory allocation compared to the contiguous memory allocation. In segmentation technique, the operating system generates a segment table that has entries to store the details for each segment in the process and also to map the logical addresses to the physical addresses. The table entries specify base address and length for each segment.

In regard to the page fault which is a situation when the CPU in the operating system accesses a page in the RAM but that page doesn$$t exist. Simply if the page is not loaded into the RAM the page fault occurs and the operating system will require to bring the required page from the hard disk to overcome this problem.

Fragmentation are blocks in the memory that can be not utilized. In contiguous memory allocation, the operating system allocates the blocks of the process, which are also called pages, next to each other in the memory which is efficient and allows the CPU to access the memory address directly. The fragmentation issue arises when the OS wastes pieces in the memory allocation. Let us assume that a request with a size of $3$ MB process is made by the CPU to the RAM but RAM has partitions of $4$MB & $8$MB$,$ the request will most likely get fit into one of the $4$MB partition but as you can see here the request is going to cause an unused block of $1$MB size.

When many small processes get fit into RAM partitions that are bigger than their size will eventually lead to a situation to have many scattered unused blocks in the RAM, therefore when a time come for a memory request with, let us say $5$MB$,$ the MMU may not find contiguous blocks allocation that satisfy the request of $5$MB in the memory which leads either to break up the process $($request of $5$MB$)$ into smaller pieces and shatter them into the opening blocks in the memory or refuse the allocation. When the processes can not be assigned to the memory blocks due to their small size $($small size of the blocks$),$ these blocks stay unused.

Fragmentation occurs due to loading and deleting programs from memory which generates free holes and these holes can not be allotted to newly arrived processes and results in inefficient memory use.