Search by property

This page provides a simple browsing interface for finding entities described by a property and a named value. Other available search interfaces include the page property search, and the ask query builder.

List of results

Memory Mapping + (At its simplest, the (invisible) translation of the memory addresses a process wants to addresses of available, physical memory. I.e. this 'puts' the memory you bought in the places where you want to use it.)
Cacheability + (Caches are copies of data. This only works correctly under certain circumstances.)
Reentrancy + (Code is re-entrant if several threads can be running the same section of code at the same time. It should be clear that each thread's context is completely independent.)
Relocatable Code + (Code is relocatable if it can be moved to any address in memory and executed there successfully.)
Libraries + (Commonly used, probably optimised, application routines. Sometimes used to provide a more portable, user-friendly interface to an OS.)
Context Switching + (Context switching is changing from one running process to another. Typically this is done frequently to give the illusion of processes running concurrently)
Deadlock + (Deadlock is a problem in any multiprocessing system where there is a dependency cycle. At its simplest, process X is stuck waiting for process Y while process Y is also stuck waiting for process X.)
Starvation + (Deadlock or process blocking due to a resource shortage.)
Queues Extra + (Deeper explanation (and demonstration) of queue implementation.)
Caching + (Describes the principle as to why caches will (usually) give improved performance. Also gives some example applications from operating systems.)
Memory Management + (Details on the ways memory can be organised and, often shared amongst applications according to needs.)
Device Drivers + (Device drivers are a software abstraction of physical hardware interfaces.)
Memory Pages + (Dividing memory into pages - standard-size, interchangeable blocks - makes memory management practical.)
Power Management + (Electrical power management - battery life and cooling - are the limiting factors in modern computer systems. Applications programmers don't know (or care) much about this topic so it is up to the OS to maximise operation without melting the chips.)
Memory Barrier + (Enforcing the ordering of operations on the address space.)
Exceptions + (Exceptions are circumstances which are outside the normal application code path. Examples include some forms of error, wanting or needing a service from the hardware and the hardware needing some temporary assistance from software (interrupts).)
Processes Exercise + (Exercise in creating and destroying processes in Unix.)
Files Exercise + (Exercise on (Unix) file handling.)
Exceptions Exercise + (Exercise on Unix exceptions and how processes can intercept them. For example, how you can trap a ^C to tidy up state before stopping.)
Malloc Exercise + (Exercise on allocating (and deallocating) memory at run-time. Memory is managed by the O.S.)
Threads Exercise + (Exercise on multithreading: this time in Java.)
Synchronisation Exercise + (Exercise on synchronising Unix processes.)
Pipes Exercise + (Exercise on using pointers to retrieve arguments passed to a process.)
Arguments Exercise + (Exercise on using pointers to retrieve arguments passed to a process.)
Shared memory Exercise + (Exercise to illustrate that memory can be private to a process or shared between processes. This also illustrates memory mapping when a shared location may appear at different addresses in different processes.)

Structs Exercise + (Exercise to review data structures and build and destroy these in C.)

Files + (Files are a form of (usually persistent) memory which are not, generally, directly addressable by the processor hardware.)
Disks + (For many years the magnetic disk has been … For many years the magnetic disk has been the choice for backing store - i.e. ‘memory’ which is not directly addressable by a processor. This is typically, but not always exclusively, for files. Sometimes other technologies are (inaccurately) called “disks” too!ies are (inaccurately) called “disks” too!)
Fragmentation + (Fragmentation is when something - such as a file - which would be nice to have as one big item has been split into several smaller parts.)
Memory Mapped Files + (Gaining access to files by making them appear as arrays in the address space.)
SETUID + (Granting permission whilst maintaining security.)
Fork Unix + (How Unix processes can create more Unix processes.)
File Systems + (How files are organised.)
File Access + (How files may be written and read.)
Daemons + (In Unix, a daemon is a background process belonging to the system.)
Unix Signals + (In Unix, a set of “signals” allow system-level inter-process communication. For example, this allows one process to destroy another (permissions permitting). A target process can intercept and handle most signals in its own way.)
Shell + (In Unix, the software which provides a command line interface - and more.)
Links + (In this context, means of connecting a file tree structure into a directed graph.)
Memory Protection + (Increasing security by limiting access to various memory areas. This includes preventing one process from corrupting any others' spaces.)
Environment Variables + (Information about Unix command-line interfaces.)
Shared Memory + (Issues connected with memory made visible to more than one process.)
Memory + (Memory is the fundamental element in conventional contemporary computers, (apparently) containing all the code and data of executing programs. Its management as a resource is a fundamental task.)
Metadata + (Metadata provides information about the ‘main’ data.)
Using Peripherals + (Methods by which the software can communicate with the I/O devices.)
Mutual exclusion + (Mutual exclusion means “one at a time”. In this case it is largely about only allowing one of many possible threads to change some structure or I/O device.)
Pointers + (Not restricted to OS code, pointers are used in all computer programming. They are used extensively in (and around) an OS and a thorough understanding is important.)
System Calls + (OS provided calls that provide privileged, protected services using trusted code. Used to provide access to I/O devices, system variables etc.)
Virtual Machines + (One 'box' can apparently be several independent computers.)
Virtual Networks + (One wire can support several independent connections.)
Monitoring page behaviour + (Optimisations can require the collection of information about behaviour. This looks at some approaches to finding the information using limited hardware support.)
PATH + (Ordered lists of places to look for something.)