Skip to content

Memory Schemes

Jump to bottomEditNew page
Sharad Khanna edited this page Oct 5, 2024 · 4 revisions

Physical Memory

The most basic and unconstrained scheme is that of physical memory. In physical memory, the address corresponds to the byte that you trying to access.

This is to say that suppose you have 1 KiB (1024 bytes) of memory/RAM. Then if you access address 0 then you get the 0th byte of RAM. Likewise, if you access address 0x200 then you get 512th byte of RAM.

The main issue with this scheme arises when you start to have multiple processes. Suppose you have 1 KiB of memory and process A occupies the address range 0x0..0xff and process B occupies the address range 0x100..0x1ff. In this scheme, process A can simply access process B's memory and vice versa without any problem at all. The main reason for this is that physical memory has no permission schemes or any way to partition memory between two processes. The only hope is that process A nor B are not malicious/buggy and won't access each other's memory.

Segmentation

The first solution to this scheme is segmentation. Segmentation involves defining a base and a limit for each process that defines what they can access. If a process accesses outside its segment, it is delivered a general-protection (#GP) fault that kills it.

In the previous scheme, if process A exists between the range 0x0..0xff then its base would be 0x0 and its limit would be 0xff. Likewise, if process B exists between the range 0x100..0x1ff then its base would be 0x100 and its limit would be 0xff. The valid access range for a segment would be base..base+limit as an inclusive range.

The main issue with segmentation arises with fragmentation.

Consider we have our 1024 (0x400) bytes of memory with process A occupying 0x0..0xff, process B occupying 0x100..0x17f, process C occupying 0x200..0x2ff and process D occupying 0x300..0x37f. Suppose we want to introduce some process E that needs 0x100contiguous bytes. In this scheme of segmentation, this is not possible. Even though we have 0x100 bytes of memory total remaining on our system (0x180..0x1ff and 0x380..0x3ff), we cannot accommodate 0x100 bytes of contiguous memory and thus we cannot run process E on the system. This problem is common in segmentation and is known as fragmentation.

Virtual Memory/Paging

The modern scheme used is virtual memory/paging. This system was devised to solve the fragmentation problem

Add a custom footer
Add a custom sidebar

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Memory Schemes · VRIG-RITSEC/Resources Wiki · GitHub
Skip to content
Memory Schemes
Jump to bottomEditNew page

Sharad Khanna edited this page Oct 5, 2024
·
4 revisions
Physical Memory
The most basic and unconstrained scheme is that of physical memory. In physical memory, the address corresponds to the byte that you trying to access.
This is to say that suppose you have 1 KiB (1024 bytes) of memory/RAM. Then if you access address 0 then you get the 0th byte of RAM. Likewise, if you access address 0x200 then you get 512th byte of RAM.
The main issue with this scheme arises when you start to have multiple processes. Suppose you have 1 KiB of memory and process A occupies the address range 0x0..0xff and process B occupies the address range 0x100..0x1ff. In this scheme, process A can simply access process B's memory and vice versa without any problem at all. The main reason for this is that physical memory has no permission schemes or any way to partition memory between two processes. The only hope is that process A nor B are not malicious/buggy and won't access each other's memory.
Segmentation
The first solution to this scheme is segmentation. Segmentation involves defining a base and a limit for each process that defines what they can access. If a process accesses outside its segment, it is delivered a general-protection (#GP) fault that kills it.
In the previous scheme, if process A exists between the range 0x0..0xff then its base would be 0x0 and its limit would be 0xff. Likewise, if process B exists between the range 0x100..0x1ff then its base would be 0x100 and its limit would be 0xff. The valid access range for a segment would be base..base+limit as an inclusive range.
The main issue with segmentation arises with fragmentation.
Consider we have our 1024 (0x400) bytes of memory with process A occupying 0x0..0xff, process B occupying 0x100..0x17f, process C occupying 0x200..0x2ff and process D occupying 0x300..0x37f. Suppose we want to introduce some process E that needs 0x100contiguous bytes. In this scheme of segmentation, this is not possible. Even though we have 0x100 bytes of memory total remaining on our system (0x180..0x1ff and 0x380..0x3ff), we cannot accommodate 0x100 bytes of contiguous memory and thus we cannot run process E on the system. This problem is common in segmentation and is known as fragmentation.
Virtual Memory/Paging
The modern scheme used is virtual memory/paging. This system was devised to solve the fragmentation problem
 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Memory Schemes · VRIG-RITSEC/Resources Wiki · GitHub
Skip to content
Memory Schemes
Jump to bottomEditNew page

Sharad Khanna edited this page Oct 5, 2024
·
4 revisions
Physical Memory
The most basic and unconstrained scheme is that of physical memory. In physical memory, the address corresponds to the byte that you trying to access.
This is to say that suppose you have 1 KiB (1024 bytes) of memory/RAM. Then if you access address 0 then you get the 0th byte of RAM. Likewise, if you access address 0x200 then you get 512th byte of RAM.
The main issue with this scheme arises when you start to have multiple processes. Suppose you have 1 KiB of memory and process A occupies the address range 0x0..0xff and process B occupies the address range 0x100..0x1ff. In this scheme, process A can simply access process B's memory and vice versa without any problem at all. The main reason for this is that physical memory has no permission schemes or any way to partition memory between two processes. The only hope is that process A nor B are not malicious/buggy and won't access each other's memory.
Segmentation
The first solution to this scheme is segmentation. Segmentation involves defining a base and a limit for each process that defines what they can access. If a process accesses outside its segment, it is delivered a general-protection (#GP) fault that kills it.
In the previous scheme, if process A exists between the range 0x0..0xff then its base would be 0x0 and its limit would be 0xff. Likewise, if process B exists between the range 0x100..0x1ff then its base would be 0x100 and its limit would be 0xff. The valid access range for a segment would be base..base+limit as an inclusive range.
The main issue with segmentation arises with fragmentation.
Consider we have our 1024 (0x400) bytes of memory with process A occupying 0x0..0xff, process B occupying 0x100..0x17f, process C occupying 0x200..0x2ff and process D occupying 0x300..0x37f. Suppose we want to introduce some process E that needs 0x100contiguous bytes. In this scheme of segmentation, this is not possible. Even though we have 0x100 bytes of memory total remaining on our system (0x180..0x1ff and 0x380..0x3ff), we cannot accommodate 0x100 bytes of contiguous memory and thus we cannot run process E on the system. This problem is common in segmentation and is known as fragmentation.
Virtual Memory/Paging
The modern scheme used is virtual memory/paging. This system was devised to solve the fragmentation problem
 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Memory Schemes · VRIG-RITSEC/Resources Wiki · GitHub
Skip to content
Memory Schemes
Jump to bottomEditNew page

Sharad Khanna edited this page Oct 5, 2024
·
4 revisions
Physical Memory
The most basic and unconstrained scheme is that of physical memory. In physical memory, the address corresponds to the byte that you trying to access.
This is to say that suppose you have 1 KiB (1024 bytes) of memory/RAM. Then if you access address 0 then you get the 0th byte of RAM. Likewise, if you access address 0x200 then you get 512th byte of RAM.
The main issue with this scheme arises when you start to have multiple processes. Suppose you have 1 KiB of memory and process A occupies the address range 0x0..0xff and process B occupies the address range 0x100..0x1ff. In this scheme, process A can simply access process B's memory and vice versa without any problem at all. The main reason for this is that physical memory has no permission schemes or any way to partition memory between two processes. The only hope is that process A nor B are not malicious/buggy and won't access each other's memory.
Segmentation
The first solution to this scheme is segmentation. Segmentation involves defining a base and a limit for each process that defines what they can access. If a process accesses outside its segment, it is delivered a general-protection (#GP) fault that kills it.
In the previous scheme, if process A exists between the range 0x0..0xff then its base would be 0x0 and its limit would be 0xff. Likewise, if process B exists between the range 0x100..0x1ff then its base would be 0x100 and its limit would be 0xff. The valid access range for a segment would be base..base+limit as an inclusive range.
The main issue with segmentation arises with fragmentation.
Consider we have our 1024 (0x400) bytes of memory with process A occupying 0x0..0xff, process B occupying 0x100..0x17f, process C occupying 0x200..0x2ff and process D occupying 0x300..0x37f. Suppose we want to introduce some process E that needs 0x100contiguous bytes. In this scheme of segmentation, this is not possible. Even though we have 0x100 bytes of memory total remaining on our system (0x180..0x1ff and 0x380..0x3ff), we cannot accommodate 0x100 bytes of contiguous memory and thus we cannot run process E on the system. This problem is common in segmentation and is known as fragmentation.
Virtual Memory/Paging
The modern scheme used is virtual memory/paging. This system was devised to solve the fragmentation problem
 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
Memory Schemes · VRIG-RITSEC/Resources Wiki · GitHub
Skip to content
Memory Schemes
Jump to bottomEditNew page

Sharad Khanna edited this page Oct 5, 2024
·
4 revisions
Physical Memory
The most basic and unconstrained scheme is that of physical memory. In physical memory, the address corresponds to the byte that you trying to access.
This is to say that suppose you have 1 KiB (1024 bytes) of memory/RAM. Then if you access address 0 then you get the 0th byte of RAM. Likewise, if you access address 0x200 then you get 512th byte of RAM.
The main issue with this scheme arises when you start to have multiple processes. Suppose you have 1 KiB of memory and process A occupies the address range 0x0..0xff and process B occupies the address range 0x100..0x1ff. In this scheme, process A can simply access process B's memory and vice versa without any problem at all. The main reason for this is that physical memory has no permission schemes or any way to partition memory between two processes. The only hope is that process A nor B are not malicious/buggy and won't access each other's memory.
Segmentation
The first solution to this scheme is segmentation. Segmentation involves defining a base and a limit for each process that defines what they can access. If a process accesses outside its segment, it is delivered a general-protection (#GP) fault that kills it.
In the previous scheme, if process A exists between the range 0x0..0xff then its base would be 0x0 and its limit would be 0xff. Likewise, if process B exists between the range 0x100..0x1ff then its base would be 0x100 and its limit would be 0xff. The valid access range for a segment would be base..base+limit as an inclusive range.
The main issue with segmentation arises with fragmentation.
Consider we have our 1024 (0x400) bytes of memory with process A occupying 0x0..0xff, process B occupying 0x100..0x17f, process C occupying 0x200..0x2ff and process D occupying 0x300..0x37f. Suppose we want to introduce some process E that needs 0x100contiguous bytes. In this scheme of segmentation, this is not possible. Even though we have 0x100 bytes of memory total remaining on our system (0x180..0x1ff and 0x380..0x3ff), we cannot accommodate 0x100 bytes of contiguous memory and thus we cannot run process E on the system. This problem is common in segmentation and is known as fragmentation.
Virtual Memory/Paging
The modern scheme used is virtual memory/paging. This system was devised to solve the fragmentation problem
 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Memory Schemes · VRIG-RITSEC/Resources Wiki · GitHub
Skip to content
Memory Schemes
Jump to bottomEditNew page

Sharad Khanna edited this page Oct 5, 2024
·
4 revisions
Physical Memory
The most basic and unconstrained scheme is that of physical memory. In physical memory, the address corresponds to the byte that you trying to access.
This is to say that suppose you have 1 KiB (1024 bytes) of memory/RAM. Then if you access address 0 then you get the 0th byte of RAM. Likewise, if you access address 0x200 then you get 512th byte of RAM.
The main issue with this scheme arises when you start to have multiple processes. Suppose you have 1 KiB of memory and process A occupies the address range 0x0..0xff and process B occupies the address range 0x100..0x1ff. In this scheme, process A can simply access process B's memory and vice versa without any problem at all. The main reason for this is that physical memory has no permission schemes or any way to partition memory between two processes. The only hope is that process A nor B are not malicious/buggy and won't access each other's memory.
Segmentation
The first solution to this scheme is segmentation. Segmentation involves defining a base and a limit for each process that defines what they can access. If a process accesses outside its segment, it is delivered a general-protection (#GP) fault that kills it.
In the previous scheme, if process A exists between the range 0x0..0xff then its base would be 0x0 and its limit would be 0xff. Likewise, if process B exists between the range 0x100..0x1ff then its base would be 0x100 and its limit would be 0xff. The valid access range for a segment would be base..base+limit as an inclusive range.
The main issue with segmentation arises with fragmentation.
Consider we have our 1024 (0x400) bytes of memory with process A occupying 0x0..0xff, process B occupying 0x100..0x17f, process C occupying 0x200..0x2ff and process D occupying 0x300..0x37f. Suppose we want to introduce some process E that needs 0x100contiguous bytes. In this scheme of segmentation, this is not possible. Even though we have 0x100 bytes of memory total remaining on our system (0x180..0x1ff and 0x380..0x3ff), we cannot accommodate 0x100 bytes of contiguous memory and thus we cannot run process E on the system. This problem is common in segmentation and is known as fragmentation.
Virtual Memory/Paging
The modern scheme used is virtual memory/paging. This system was devised to solve the fragmentation problem
 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Memory Schemes · VRIG-RITSEC/Resources Wiki · GitHub
Skip to content
Memory Schemes
Jump to bottomEditNew page

Sharad Khanna edited this page Oct 5, 2024
·
4 revisions
Physical Memory
The most basic and unconstrained scheme is that of physical memory. In physical memory, the address corresponds to the byte that you trying to access.
This is to say that suppose you have 1 KiB (1024 bytes) of memory/RAM. Then if you access address 0 then you get the 0th byte of RAM. Likewise, if you access address 0x200 then you get 512th byte of RAM.
The main issue with this scheme arises when you start to have multiple processes. Suppose you have 1 KiB of memory and process A occupies the address range 0x0..0xff and process B occupies the address range 0x100..0x1ff. In this scheme, process A can simply access process B's memory and vice versa without any problem at all. The main reason for this is that physical memory has no permission schemes or any way to partition memory between two processes. The only hope is that process A nor B are not malicious/buggy and won't access each other's memory.
Segmentation
The first solution to this scheme is segmentation. Segmentation involves defining a base and a limit for each process that defines what they can access. If a process accesses outside its segment, it is delivered a general-protection (#GP) fault that kills it.
In the previous scheme, if process A exists between the range 0x0..0xff then its base would be 0x0 and its limit would be 0xff. Likewise, if process B exists between the range 0x100..0x1ff then its base would be 0x100 and its limit would be 0xff. The valid access range for a segment would be base..base+limit as an inclusive range.
The main issue with segmentation arises with fragmentation.
Consider we have our 1024 (0x400) bytes of memory with process A occupying 0x0..0xff, process B occupying 0x100..0x17f, process C occupying 0x200..0x2ff and process D occupying 0x300..0x37f. Suppose we want to introduce some process E that needs 0x100contiguous bytes. In this scheme of segmentation, this is not possible. Even though we have 0x100 bytes of memory total remaining on our system (0x180..0x1ff and 0x380..0x3ff), we cannot accommodate 0x100 bytes of contiguous memory and thus we cannot run process E on the system. This problem is common in segmentation and is known as fragmentation.
Virtual Memory/Paging
The modern scheme used is virtual memory/paging. This system was devised to solve the fragmentation problem
 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
Memory Schemes · VRIG-RITSEC/Resources Wiki · GitHub
Skip to content
Memory Schemes
Jump to bottomEditNew page

Sharad Khanna edited this page Oct 5, 2024
·
4 revisions
Physical Memory
The most basic and unconstrained scheme is that of physical memory. In physical memory, the address corresponds to the byte that you trying to access.
This is to say that suppose you have 1 KiB (1024 bytes) of memory/RAM. Then if you access address 0 then you get the 0th byte of RAM. Likewise, if you access address 0x200 then you get 512th byte of RAM.
The main issue with this scheme arises when you start to have multiple processes. Suppose you have 1 KiB of memory and process A occupies the address range 0x0..0xff and process B occupies the address range 0x100..0x1ff. In this scheme, process A can simply access process B's memory and vice versa without any problem at all. The main reason for this is that physical memory has no permission schemes or any way to partition memory between two processes. The only hope is that process A nor B are not malicious/buggy and won't access each other's memory.
Segmentation
The first solution to this scheme is segmentation. Segmentation involves defining a base and a limit for each process that defines what they can access. If a process accesses outside its segment, it is delivered a general-protection (#GP) fault that kills it.
In the previous scheme, if process A exists between the range 0x0..0xff then its base would be 0x0 and its limit would be 0xff. Likewise, if process B exists between the range 0x100..0x1ff then its base would be 0x100 and its limit would be 0xff. The valid access range for a segment would be base..base+limit as an inclusive range.
The main issue with segmentation arises with fragmentation.
Consider we have our 1024 (0x400) bytes of memory with process A occupying 0x0..0xff, process B occupying 0x100..0x17f, process C occupying 0x200..0x2ff and process D occupying 0x300..0x37f. Suppose we want to introduce some process E that needs 0x100contiguous bytes. In this scheme of segmentation, this is not possible. Even though we have 0x100 bytes of memory total remaining on our system (0x180..0x1ff and 0x380..0x3ff), we cannot accommodate 0x100 bytes of contiguous memory and thus we cannot run process E on the system. This problem is common in segmentation and is known as fragmentation.
Virtual Memory/Paging
The modern scheme used is virtual memory/paging. This system was devised to solve the fragmentation problem
 Add a custom footer

 Add a custom sidebar

Clone this wiki locally