https://homeostasis.scs.carleton.ca/wiki/api.php?action=feedcontributions&feedformat=atom&user=Dmiyusov 2026-05-02T19:08:54Z User contributions MediaWiki 1.42.1 https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1705 2007-11-20T23:22:56Z

<p>Dmiyusov: /* Overlays */</p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.[3]<br /> <br /> ==Swapping==<br /> A technique that enables computer to execute programs and manipulate data files larger than main memory. An operating system copies as much data as possible into main memory leaving the rest on disk. When it needs data from disk , thsi data exchanges a portion of data (page or segment) in main memory with a portion of data on disk [1] <br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (R1/R2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. [3]<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation [2]<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume [2]<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> A memory allocation strategy using fixed-length pages as opposed to variable-length segments. Every process’s virtual address space is logically divided into pages.<br /> Main function of paging are performed when a program tries to access pages that do not currently reside in RAM, this is a situation which causes page fault.<br /> The main functions of paging are:<br /> <br /> 1. Handles the page fault, in a manner invisible to the causing program, and takes control. <br /> <br /> 2. Determines the location of the data in auxiliary storage. <br /> <br /> 3. Determines the page frame in RAM to use as a container for the data. <br /> <br /> 4. If a page currently residing in chosen frame has been modified since loading (if it is dirty), writes the page to auxiliary storage. <br /> <br /> 5. Loads the requested data into the available page. <br /> <br /> 6. Returns control to the program, transparently retrying the instruction that caused page fault. <br /> [3]<br /> <br /> <br /> <br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''<br /> <br /> Rerefeces:<br /> <br /> [1] http://www.ptdd.com/datarecovery/swap.htm<br /> <br /> [2] Nutt, Gary (2004). Operating systems. Boulder Colorado. <br /> <br /> [3] http://wikipedia.org/</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1704 2007-11-20T23:22:15Z

<p>Dmiyusov: /* Dynamic Paging algorithms */</p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.[3]<br /> <br /> ==Swapping==<br /> A technique that enables computer to execute programs and manipulate data files larger than main memory. An operating system copies as much data as possible into main memory leaving the rest on disk. When it needs data from disk , thsi data exchanges a portion of data (page or segment) in main memory with a portion of data on disk [1] <br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. [3]<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation [2]<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume [2]<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> A memory allocation strategy using fixed-length pages as opposed to variable-length segments. Every process’s virtual address space is logically divided into pages.<br /> Main function of paging are performed when a program tries to access pages that do not currently reside in RAM, this is a situation which causes page fault.<br /> The main functions of paging are:<br /> <br /> 1. Handles the page fault, in a manner invisible to the causing program, and takes control. <br /> <br /> 2. Determines the location of the data in auxiliary storage. <br /> <br /> 3. Determines the page frame in RAM to use as a container for the data. <br /> <br /> 4. If a page currently residing in chosen frame has been modified since loading (if it is dirty), writes the page to auxiliary storage. <br /> <br /> 5. Loads the requested data into the available page. <br /> <br /> 6. Returns control to the program, transparently retrying the instruction that caused page fault. <br /> [3]<br /> <br /> <br /> <br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''<br /> <br /> Rerefeces:<br /> <br /> [1] http://www.ptdd.com/datarecovery/swap.htm<br /> <br /> [2] Nutt, Gary (2004). Operating systems. Boulder Colorado. <br /> <br /> [3] http://wikipedia.org/</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1703 2007-11-20T23:19:51Z

<p>Dmiyusov: /* Paging */</p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.[3]<br /> <br /> ==Swapping==<br /> A technique that enables computer to execute programs and manipulate data files larger than main memory. An operating system copies as much data as possible into main memory leaving the rest on disk. When it needs data from disk , thsi data exchanges a portion of data (page or segment) in main memory with a portion of data on disk [1] <br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. [3]<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation [2]<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume [2]<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> A memory allocation strategy using fixed-length pages as opposed to variable-length segments. Every process’s virtual address space is logically divided into pages.<br /> Main function of paging are performed when a program tries to access pages that do not currently reside in RAM, this is a situation which causes page fault.<br /> The main functions of paging are:<br /> <br /> 1. Handles the page fault, in a manner invisible to the causing program, and takes control. <br /> <br /> 2. Determines the location of the data in auxiliary storage. <br /> <br /> 3. Determines the page frame in RAM to use as a container for the data. <br /> <br /> 4. If a page currently residing in chosen frame has been modified since loading (if it is dirty), writes the page to auxiliary storage. <br /> <br /> 5. Loads the requested data into the available page. <br /> <br /> 6. Returns control to the program, transparently retrying the instruction that caused page fault. <br /> [3]<br /> <br /> <br /> <br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''<br /> <br /> Rerefeces:<br /> <br /> [1] http://www.ptdd.com/datarecovery/swap.htm<br /> <br /> [2] Nutt, Gary. Operating systems 2004. Boulder Colorado. <br /> <br /> [3] http://wikipedia.org/</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1702 2007-11-20T23:19:30Z

<p>Dmiyusov: /* Paging */</p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.[3]<br /> <br /> ==Swapping==<br /> A technique that enables computer to execute programs and manipulate data files larger than main memory. An operating system copies as much data as possible into main memory leaving the rest on disk. When it needs data from disk , thsi data exchanges a portion of data (page or segment) in main memory with a portion of data on disk [1] <br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. [3]<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation [2]<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume [2]<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> A memory allocation strategy using fixed-length pages as opposed to variable-length segments. Every process’s virtual address space is logically divided into pages.<br /> Main function of paging are performed when a program tries to access pages that do not currently reside in RAM, this is a situation which causes page fault.<br /> The main functions of paging are:<br /> <br /> 1. Handles the page fault, in a manner invisible to the causing program, and takes control. <br /> <br /> 2. Determines the location of the data in auxiliary storage. <br /> <br /> 3. Determines the page frame in RAM to use as a container for the data. <br /> <br /> 4. If a page currently residing in chosen frame has been modified since loading (if it is dirty), writes the page to auxiliary storage. <br /> <br /> 5. Loads the requested data into the available page. <br /> <br /> 6.Returns control to the program, transparently retrying the instruction that caused page fault. <br /> [3]<br /> <br /> <br /> <br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''<br /> <br /> Rerefeces:<br /> <br /> [1] http://www.ptdd.com/datarecovery/swap.htm<br /> <br /> [2] Nutt, Gary. Operating systems 2004. Boulder Colorado. <br /> <br /> [3] http://wikipedia.org/</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1701 2007-11-20T23:19:03Z

<p>Dmiyusov: </p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.[3]<br /> <br /> ==Swapping==<br /> A technique that enables computer to execute programs and manipulate data files larger than main memory. An operating system copies as much data as possible into main memory leaving the rest on disk. When it needs data from disk , thsi data exchanges a portion of data (page or segment) in main memory with a portion of data on disk [1] <br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. [3]<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation [2]<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume [2]<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> A memory allocation strategy using fixed-length pages as opposed to variable-length segments. Every process’s virtual address space is logically divided into pages.<br /> Main function of paging are performed when a program tries to access pages that do not currently reside in RAM, this is a situation which causes page fault.<br /> The main functions of paging are:<br /> <br /> 1. Handles the page fault, in a manner invisible to the causing program, and takes control. <br /> 2. Determines the location of the data in auxiliary storage. <br /> 3. Determines the page frame in RAM to use as a container for the data. <br /> 4. If a page currently residing in chosen frame has been modified since loading (if it is dirty), writes the page to auxiliary storage. <br /> 5. Loads the requested data into the available page. <br /> 6.Returns control to the program, transparently retrying the instruction that caused page fault. <br /> [3]<br /> <br /> <br /> <br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''<br /> <br /> Rerefeces:<br /> <br /> [1] http://www.ptdd.com/datarecovery/swap.htm<br /> <br /> [2] Nutt, Gary. Operating systems 2004. Boulder Colorado. <br /> <br /> [3] http://wikipedia.org/</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1700 2007-11-20T23:16:21Z

<p>Dmiyusov: /* Paging */</p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.[3]<br /> <br /> ==Swapping==<br /> A technique that enables computer to execute programs and manipulate data files larger than main memory. An operating system copies as much data as possible into main memory leaving the rest on disk. When it needs data from disk , thsi data exchanges a portion of data (page or segment) in main memory with a portion of data on disk [1] <br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. [3]<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation [2]<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume [2]<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> A memory allocation strategy using fixed-length pages as opposed to variable-length segments. Every process’s virtual address space is logically divided into pages.<br /> Main function of paging are performed when a program tries to access pages that do not currently reside in RAM, this is a situation which causes page fault.<br /> The main functions of paging are:<br /> <br /> <br /> <br /> <br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''<br /> <br /> Rerefeces:<br /> <br /> [1] http://www.ptdd.com/datarecovery/swap.htm<br /> <br /> [2] Nutt, Gary. Operating systems 2004. Boulder Colorado. <br /> <br /> [3] http://wikipedia.org/</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1699 2007-11-20T22:56:02Z

<p>Dmiyusov: /* Dynamic Paging algorithms */</p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.[3]<br /> <br /> ==Swapping==<br /> A technique that enables computer to execute programs and manipulate data files larger than main memory. An operating system copies as much data as possible into main memory leaving the rest on disk. When it needs data from disk , thsi data exchanges a portion of data (page or segment) in main memory with a portion of data on disk [1] <br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. [3]<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation [2]<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume [2]<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)[2]<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. [2]<br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j) [2]<br /> <br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''<br /> <br /> Rerefeces:<br /> <br /> [1] http://www.ptdd.com/datarecovery/swap.htm<br /> <br /> [2] Nutt, Gary. Operating systems 2004. Boulder Colorado. <br /> <br /> [3] http://wikipedia.org/</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1698 2007-11-20T22:55:47Z

<p>Dmiyusov: </p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.[3]<br /> <br /> ==Swapping==<br /> A technique that enables computer to execute programs and manipulate data files larger than main memory. An operating system copies as much data as possible into main memory leaving the rest on disk. When it needs data from disk , thsi data exchanges a portion of data (page or segment) in main memory with a portion of data on disk [1] <br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. [3]<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation [2]<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume [2]<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)[2]<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. [2]<br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j) [2]<br /> <br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''<br /> <br /> Rerefeces:<br /> <br /> [1] http://www.ptdd.com/datarecovery/swap.htm<br /> [2] Nutt, Gary. Operating systems 2004. Boulder Colorado. <br /> [3] http://wikipedia.org/</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1697 2007-11-20T22:45:41Z

<p>Dmiyusov: </p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. <br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> '''Fragmentation''' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1696 2007-11-20T22:43:14Z

<p>Dmiyusov: </p> <hr /> <div>'''Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. <br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> ''Fragmentation'' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1695 2007-11-20T22:42:41Z

<p>Dmiyusov: </p> <hr /> <div>'''Memory Management &amp; Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram). These regions can be of a different size. An overlay manager, such as an operating system loads the required overlay from external memory into this region. <br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is 'when exactly do you load x, y or z?'. Developers need to think carefully what they put in these modules. <br /> Another problem is that x, y, and z can’t talk to each other, they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> x,y and z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> ''Fragmentation'' - difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1694 2007-11-20T21:47:44Z

<p>Dmiyusov: </p> <hr /> <div>'''Memory Management &amp; Virtual Memory Lecture 10'''<br /> <br /> ==Virtual Memory== <br /> Virtual mermory is system memory which is simulated by the hard drive. In the case that all of the RAM is used up, the computer can simulate extra memory by swapping data to the hard drive and back, giving an impression that there is more memory. Extending memory can be done by other ways including overlays and swapping.<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> This technique allows programs to be larger than the CPU's main memory. In this method a program is divided into self-contained object code blocks called overlays where the size of the overlay is limited according to memory constraints. The place where overlays are loaded are refered to as 'regions' (r1/r2 in the diagram)<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1693 2007-11-20T21:20:06Z

<p>Dmiyusov: /* Dynamic Paging algorithms */</p> <hr /> <div>'''Memory Management &amp; Virtual Memory Lecture 10'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.<br /> <br /> <br /> ''Edited by Dmitrii Miyusov ''</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1692 2007-11-20T21:17:37Z

<p>Dmiyusov: </p> <hr /> <div></div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Virtual_Memory&diff=1691 2007-11-20T21:16:49Z

<p>Dmiyusov: </p> <hr /> <div>'''Memory Management &amp; Virtual Memory Lecture 10'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Main_Page&diff=1690 2007-11-20T21:16:04Z

<p>Dmiyusov: </p> <hr /> <div>Welcome to the Carleton University COMP 3000: Operating Systems (Fall 2007) wiki.<br /> <br /> ==Course Outline==<br /> <br /> The course outline can be found [http://www.scs.carleton.ca/%7Ecourses/course_outline.php?number=COMP%203000A&amp;amp;term=Fall&amp;amp;year=2007 here]. A backup copy is [http://www.scs.carleton.ca/~soma/os-2007f/course_outline_printable.php.html here].<br /> <br /> ==Running Linux at Home==<br /> <br /> To give you an opportunity to become more familiar with Linux and UNIX, consider running a Linux distribution on your own machine if you can. I suggest looking at [http://www.ubuntu.com Ubuntu] or [http://www.debian.org Debian] (the distribution used in the lab).<br /> <br /> If you don't want to dual boot from Windows/MacOS X or you just don't want to worry about repartitioning, you can run Linux in a virtual machine.<br /> See [[Running Linux in a Virtual Machine]] for more information.<br /> <br /> ==Proposal Meetings==<br /> <br /> Feedback on draft proposals will be given though in-person meetings with Prof. Somayaji. Please add yourself to the [[Proposal Meeting Schedule]] page.<br /> <br /> ==Lectures and Deadlines==<br /> <br /> &lt;table style=&quot;width: 100%;&quot; border=&quot;1&quot; cellpadding=&quot;4&quot; cellspacing=&quot;0&quot;&gt;<br /> &lt;tr valign=&quot;top&quot;&gt;<br /> &lt;th&gt;<br /> &lt;p align=&quot;left&quot;&gt;Date&lt;/p&gt;<br /> &lt;/th&gt;<br /> &lt;th&gt;<br /> &lt;p align=&quot;left&quot;&gt;Due/In Class<br /> &lt;/p&gt;<br /> &lt;/th&gt;<br /> &lt;th&gt;<br /> &lt;p align=&quot;left&quot;&gt;Topics&lt;/p&gt;<br /> &lt;/th&gt;<br /> &lt;th&gt;<br /> &lt;p align=&quot;left&quot;&gt;Readings&lt;/p&gt;<br /> &lt;/th&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;<br /> &lt;p&gt;Sept. 10th<br /> &lt;/p&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt; &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;p&gt;[[Class Outline]]<br /> &lt;/p&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;p&gt;<br /> &lt;/p&gt;<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Sept. 12th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#1: [[Introduction]]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 1<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Sept. 17th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#2: [[Using the Operating System]], [http://www.scs.carleton.ca/~soma/os-2007f/labs/comp3000-2007F-lab1.pdf Lab 1 introduction]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 2<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Sept. 19th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#3: [[Operating System Organization]] (Glenn)<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 3<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Sept. 24th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#4: [[Computer Organization]]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 4<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Sept. 26th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#5: [[Device Management]]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 5<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 1st<br /> &lt;/td&gt;<br /> &lt;td&gt;[http://www.scs.carleton.ca/~soma/os-2007f/labs/comp3000-2007F-lab1-solution.pdf Lab 1]&lt;/td&gt;<br /> &lt;td&gt;#6: [[Implementing Processes, Threads, and Resources]], [http://www.scs.carleton.ca/~soma/os-2007f/labs/lab2 Lab 2 introduction]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 6<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 3rd<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#7: [[Basic Synchronization Principles]]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 8<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 8th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;Thanksgiving<br /> &lt;/td&gt;<br /> &lt;td&gt;[http://www.cryptonomicon.com/beginning.html In the Beginning was the Command Line].<br /> Prettier version [http://www.csn.ul.ie/%7Ecaolan/Texts/stephenson.html here] (optional)&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 10th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#8: [[High-level Synchronization and IPC]]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 9<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 15th<br /> &lt;/td&gt;<br /> &lt;td&gt;[http://www.scs.carleton.ca/~soma/os-2007f/labs/lab2/comp3000-2007F-lab2-sol.pdf Lab 2] (10pm on WebCT)<br /> <br /> &lt;/td&gt;<br /> &lt;td&gt;[[Test 1 Review]]<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 17th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;[[Test 1 Review]] (cont.)<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 22nd<br /> &lt;/td&gt;<br /> &lt;td&gt;[http://homeostasis.scs.carleton.ca/~soma/os-2007f/comp3000-test1-2007F-sol.pdf Test 1]<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 24th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#9: [[Scheduling]], [http://homeostasis.scs.carleton.ca/~soma/os-2007f/labs/lab3/ Lab 3 Introduction]&lt;/td&gt;<br /> &lt;td&gt;Chap. 7 &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 29th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#10: [[Virtual Memory]] &lt;/td&gt;<br /> &lt;td&gt;Chap. 10 &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Oct. 31st<br /> &lt;/td&gt;<br /> &lt;td&gt;&lt;/td&gt;<br /> &lt;td&gt;#11: [[Memory Management]]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 11<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Nov. 5th<br /> &lt;/td&gt;<br /> &lt;td&gt;[http://www.scs.carleton.ca/~soma/os-2007f/labs/lab3/lab3-sol.pdf Lab 3]<br /> &lt;/td&gt;<br /> &lt;td&gt;#12: [[Deadlock]], [http://homeostasis.scs.carleton.ca/~soma/os-2007f/labs/lab4/ Lab 4 Introduction]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 12<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Nov. 7th<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#13: [[File Management]]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 13<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Nov. 12th<br /> &lt;/td&gt;<br /> &lt;td&gt; <br /> &lt;/td&gt;<br /> &lt;td&gt;#14: [[Networks]] &lt;/td&gt;<br /> &lt;td&gt;Chap. 15<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Nov. 14th<br /> &lt;/td&gt;<br /> &lt;td&gt;Paper Outline<br /> &lt;/td&gt;<br /> &lt;td&gt;#15: [[Protection and Security]] (Glenn)<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 14<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Nov. 19th<br /> &lt;/td&gt;<br /> &lt;td&gt; <br /> &lt;/td&gt;<br /> &lt;td&gt;#16: [[Remote Files]]<br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 16<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Nov. 21st<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;td&gt;#17: [[Security 2]]<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Nov. 26th<br /> &lt;/td&gt;<br /> &lt;td&gt;Lab 4<br /> &lt;/td&gt;<br /> &lt;td&gt;[[Test 2 Review]]<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Nov. 28th<br /> &lt;/td&gt;<br /> &lt;td&gt;Test 2<br /> &lt;/td&gt;<br /> &lt;td&gt; <br /> &lt;/td&gt;<br /> &lt;td&gt;Chap. 17 &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;Dec. 3rd<br /> &lt;/td&gt;<br /> &lt;td&gt;Paper Final Draft<br /> &lt;/td&gt;<br /> &lt;td&gt;#21: [[The Future of Operating Systems]]<br /> &lt;/td&gt;<br /> &lt;td&gt;<br /> &lt;/td&gt;<br /> &lt;/tr&gt; <br /> &lt;/table&gt;</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1689 2007-11-20T21:14:37Z

<p>Dmiyusov: </p> <hr /> <div>'''Memory Management &amp; Virtual Memory Lecture 10'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1688 2007-11-20T21:13:49Z

<p>Dmiyusov: </p> <hr /> <div>'''Memory Management &amp; Virtual Memory Lecture 11'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1683 2007-11-18T20:40:26Z

<p>Dmiyusov: </p> <hr /> <div><br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines how these page frames will be loaded and unloaded by the virtual memory system.<br /> <br /> Three basic policies in defining paging algorithm are<br /> <br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1682 2007-11-13T12:16:59Z

<p>Dmiyusov: </p> <hr /> <div><br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1681 2007-11-13T03:21:13Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c3.jpeg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1680 2007-11-13T03:08:36Z

<p>Dmiyusov: /* Static Paging algorithms */</p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> '''fetch policy:'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy:'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy:'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1679 2007-11-13T03:08:16Z

<p>Dmiyusov: /* Static Paging algorithms */</p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> '''fetch policy'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy'''<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1678 2007-11-13T03:07:56Z

<p>Dmiyusov: /* Static Paging algorithms */</p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> '''fetch policy'''<br /> when a page should be loaded into memory<br /> <br /> '''replacement policy'''<br /> determines which page should be removed from primary memory if all page frames are full<br /> <br /> '''placement policy'''<br /> <br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1677 2007-11-13T03:07:07Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> '''fetch policy'''<br /> <br /> when a page should be loaded into memory<br /> '''replacement policy'''<br /> <br /> determines which page should be removed from primary memory if all page frames are full<br /> '''placement policy'''<br /> <br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1676 2007-11-13T03:04:21Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> <br /> <br /> ===Static Paging algorithms===<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> 1) fetch policy<br /> when a page should be loaded into memory<br /> 2) replacement policy<br /> determines which page should be removed from primary memory if all page frames are full<br /> 3) placement policy<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> ===Dynamic Paging algorithms===<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1675 2007-11-13T03:03:39Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> === Headline text ===<br /> <br /> '''Static Paging algorithms'''<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> 1) fetch policy<br /> when a page should be loaded into memory<br /> 2) replacement policy<br /> determines which page should be removed from primary memory if all page frames are full<br /> 3) placement policy<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> '''Dynamic Paging algorithms'''<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1674 2007-11-13T03:03:10Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> = Headline text =<br /> <br /> '''Static Paging algorithms'''<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> 1) fetch policy<br /> when a page should be loaded into memory<br /> 2) replacement policy<br /> determines which page should be removed from primary memory if all page frames are full<br /> 3) placement policy<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> '''Dynamic Paging algorithms'''<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1673 2007-11-13T03:02:04Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> '''Static Paging algorithms'''<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> 1) fetch policy<br /> when a page should be loaded into memory<br /> 2) replacement policy<br /> determines which page should be removed from primary memory if all page frames are full<br /> 3) placement policy<br /> determines where the fetched page whould be loaded into primary memory<br /> <br /> '''Dynamic Paging algorithms'''<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1672 2007-11-13T03:01:10Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]<br /> <br /> <br /> ==Paging Algorithms==<br /> There are two basic types of pagig algorithms: static and dynamic allocation<br /> <br /> '''Static Paging algorithms'''<br /> allocates a fixed number of page frames to a process when it is created. The paging policy defines hwo tehse page frames will be loaded and unloaded by the virtual memory system<br /> three basic policies in defining paging algorithm are<br /> - fetch policy<br /> - when a page should be loaded into memory<br /> - replacement policy<br /> - determines which page should be removed from primary memory if all page frames are full<br /> - placement policy<br /> - determines where the fetched page whould be loaded into primary memory<br /> <br /> '''Dynamic Paging algorithms'''<br /> Dynamic paging algorithms adjust the memory allocation to match the process's needs as they change.</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=File:Diagram3_c3.jpeg&diff=1671 2007-11-13T02:33:22Z

<p>Dmiyusov: </p> <hr /> <div></div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=File:Diagram3_c2.jpg&diff=1670 2007-11-13T01:58:22Z

<p>Dmiyusov: </p> <hr /> <div></div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1669 2007-11-13T01:57:17Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1668 2007-11-13T01:51:06Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Memory Management &amp; Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1666 2007-11-12T20:55:20Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:Diagram3_c2.JPG‎]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=File:Diagram3_c2.JPG&diff=1665 2007-11-12T20:52:03Z

<p>Dmiyusov: </p> <hr /> <div></div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1664 2007-11-12T20:50:38Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The_address_space_and_pages.JPG]]</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=File:The_address_space_and_pages.JPG&diff=1663 2007-11-12T20:49:38Z

<p>Dmiyusov: </p> <hr /> <div></div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=File:The_address_space_and_pages.jpg&diff=1662 2007-11-12T20:49:01Z

<p>Dmiyusov: </p> <hr /> <div></div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1661 2007-11-12T20:48:00Z

<p>Dmiyusov: /* Paging */</p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)<br /> <br /> [[Image:The address space and pages.bmp]]</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=File:Diagram1_c2.jpg&diff=1659 2007-11-10T17:52:39Z

<p>Dmiyusov: </p> <hr /> <div></div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1658 2007-11-10T17:48:31Z

<p>Dmiyusov: </p> <hr /> <div>'''(Currently UNDER CONSTRUCTION!)'''<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1657 2007-11-10T17:47:55Z

<p>Dmiyusov: </p> <hr /> <div>(Currently UNDER CONSTRUCTION!)<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1656 2007-11-10T17:47:22Z

<p>Dmiyusov: /* Paging */</p> <hr /> <div>(currently under construction!)<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> Thisis an allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space(page) whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1655 2007-11-10T17:39:50Z

<p>Dmiyusov: /* Memory Segmentation */</p> <hr /> <div>(currently under construction!)<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> Technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger than pages, and can be of a variable size.<br /> <br /> ==Paging==<br /> allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space-a page- whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> reference ( text) <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1654 2007-11-10T17:38:11Z

<p>Dmiyusov: /* Fragmentation */</p> <hr /> <div>(currently under construction!)<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. An example is that many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger then pages, and can be of a variable size. <br /> <br /> ==Paging==<br /> allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space-a page- whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> reference ( text) <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1653 2007-11-10T17:36:17Z

<p>Dmiyusov: /* Overlays */</p> <hr /> <div>(currently under construction!)<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays is when exactly do you load x, y or z. We have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t talk to each other , they need some sort of cut / paste buffer. The problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> Fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many? <br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive because programming manually has to manage memory in addition to being inefficient. How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. Ex in many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger then pages, and can be of a variable size. <br /> <br /> ==Paging==<br /> allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space-a page- whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> reference ( text) <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1652 2007-11-10T17:32:46Z

<p>Dmiyusov: /* Swapping */</p> <hr /> <div>(currently under construction!)<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and (hence is using some resources) but is inactive for relatively long periods ( and hence not using the CPU). <br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays , when do you load x, y or z, we have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t now talk to each other , they need some sort of cut / paste buffer. <br /> Problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> One problem: fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many?<br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive b/c programming manually has to manually manage memory plus, it’s is inefficient How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. Ex in many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger then pages, and can be of a variable size. <br /> <br /> ==Paging==<br /> allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space-a page- whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> reference ( text) <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)</div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=File:Diagram4.jpg&diff=1651 2007-11-09T22:10:33Z

<p>Dmiyusov: </p> <hr /> <div></div>

Dmiyusov https://homeostasis.scs.carleton.ca/wiki/index.php?title=Deadlock&diff=1650 2007-11-09T22:10:06Z

<p>Dmiyusov: /* Overlays */</p> <hr /> <div>(currently under construction!)<br /> <br /> '''Virtual Memory'''<br /> <br /> ==Swapping==<br /> A memory management technique where a process may periodically have its primary memory space deallocated. This forces the swapped-out process to compete for memory before it can once again compete for the processor<br /> <br /> Swapping is especially well suited to timesharing systems since such systems often have times when a user logs onto the machine and hence is using some resources, but is inactive for relatively long periods ( and hence not using the CPU). A swapping memory manager accommodates the timesharing scenario by allocating memory to a process while the user is requesting service at a relatively high rate but deallocating memory.<br /> <br /> <br /> [[Image:Diagram1.jpg]]<br /> <br /> ==Overlays==<br /> <br /> [[Image:diagram2.jpg]]<br /> <br /> <br /> <br /> Significant problem with overlays , when do you load x, y or z, we have to make sure they are there. Developers need to think carefully what they put in these modules. <br /> Another problem with swapping is that x, y, and z can’t now talk to each other , they need some sort of cut / paste buffer. <br /> Problem is that x, y and z are different sizes and we need to fit the biggest one in the overlay area.<br /> <br /> X,Y and Z are all desired to be loaded in the same area of RAM. In traditional overlay schemes this would be an index.<br /> <br /> Classic problem of memory management:<br /> One problem: fragmentation, difference between size of overlay area and size of the overlays<br /> <br /> Instead of having one overlay area what if we had many?<br /> <br /> [[Image:diagram3.jpg]]<br /> <br /> This is primitive b/c programming manually has to manually manage memory plus, it’s is inefficient How do you deal with the situation so that you don’t need to deal with it every again?<br /> First step is to change this and to add relocation. To do that we need to have some sort of indirection<br /> <br /> <br /> [[Image:diagram4.jpg]]<br /> <br /> ==Fragmentation==<br /> <br /> ;'''Data fragmentation'''<br /> Reduces the amount of fragmentation in file systems. Occurs when a piece of data in memory is broken up into many pieces. Two types of fragmentation which exist are internal fragmentation and external fragmentation<br /> <br /> ;'''Internal Fragmentation'''<br /> Space is wasted in return for increased efficiency or simplicity. Ex in many file systems files always start at the beginning of a sector, which simplifies organization and makes it easier to grow files. Any space that is left over between the last byte of the file and the first byte of the next sector is internal fragmentation. Internal fragmentation occurs when the index pages are not being used to their maximum volume<br /> <br /> ;'''External Fragmentation'''<br /> In such a fragmentation, the free space which is available for storage is divided into many small pieces. The storage space is of many different sizes. <br /> <br /> ;'''Page'''<br /> fixed-length block of main memory, that is contiguous in both physical addressing and virtual memory addressing.<br /> <br /> ==Memory Segmentation==<br /> technique used to divide memory into smaller units. It is an extension of the ideas suggested by the use of relocation-limit registers for relocating and bound checking blocks of memory. Memory contents are referenced using a two-component virtual address &lt;segmentNumber, offset&gt; .<br /> Segment number identifies the particular logical block of memory and offset is a linear offset from the beginning of the segment. <br /> Segmentation provides more programmer control over the units of transfer in the memory system than paging does. Memory segments are distinct from memory pages because the segments are usually much larger then pages, and can be of a variable size. <br /> <br /> ==Paging==<br /> allocation strategy in a paging system to reduce external fragmentation by transferring a fixed-size unit of virtual address space-a page- whenever a virtual address in it is needed to execute the program. Every process’s virtual address space is logically divided into pages, with each page having the same number of location.<br /> <br /> The program translation image is constructed to fit in a set of G continguous memory locations, with virtual addresses ranging between 0 and G-1. When the process executes it is allocated enough primary memory to store the contents of H memory locations where H&lt;G (that is the process has fewer physical memory locations than virtual addresses)<br /> reference ( text) <br /> In a binary computer the paging system maps the virtual addressees in the absolute module (0-G) into a set of n = 2^g pages, each of size c = 2^h. If G is not an integer multiple of the page size then part of the last page will be lost to internal fragmentation; the paging system will adjust G upward to hold the entire virtual address space. <br /> <br /> Physical address space is the portion of the primary memory allocated to the process. The units of allocation are page frames and these are blocks of primary memory which are the same size as the page. The physical address space can be though of as a set of m = 2^j page frames each of size c = 2^h, so the amount of primary memory allocated to the process is H = 2^(h+j)</div>

Dmiyusov