1.
Htop
–
Htop is an interactive system-monitor process-viewer. It is designed as an alternative to the Unix program top and it shows a frequently updated list of the processes running on a computer, normally ordered by the amount of CPU usage. Unlike top, htop provides a full list of processes running, htop uses color and gives visual information about processor, swap and memory status. Users often deploy htop in cases where Unix top does not provide information about the systems processes. Htop is also popularly used interactively as a system monitor, compared to top, it provides a more convenient, visual, cursor-controlled interface for sending signals to processes. Htop is written in the C programming language using the ncurses library and its name is derived from the original authors first name, as a nod to pinfo, an info-replacement program that does the same. Because system monitoring interfaces are not standardized among Unix-like operating systems, cross-platform support was added in htop 2.0
2.
Computer program
–
A computer program is a collection of instructions that performs a specific task when executed by a computer. A computer requires programs to function, and typically executes the programs instructions in a processing unit. A computer program is written by a computer programmer in a programming language. From the program in its form of source code, a compiler can derive machine code—a form consisting of instructions that the computer can directly execute. Alternatively, a program may be executed with the aid of an interpreter. A part of a program that performs a well-defined task is known as an algorithm. A collection of programs, libraries and related data are referred to as software. Computer programs may be categorized along functional lines, such as software or system software. The earliest programmable machines preceded the invention of the digital computer, in 1801, Joseph-Marie Jacquard devised a loom that would weave a pattern by following a series of perforated cards. Patterns could be weaved and repeated by arranging the cards, in 1837, Charles Babbage was inspired by Jacquards loom to attempt to build the Analytical Engine. The names of the components of the device were borrowed from the textile industry. In the textile industry, yarn was brought from the store to be milled, the device would have had a store—memory to hold 1,000 numbers of 40 decimal digits each. Numbers from the store would then have then transferred to the mill. It was programmed using two sets of perforated cards—one to direct the operation and the other for the input variables, however, after more than 17,000 pounds of the British governments money, the thousands of cogged wheels and gears never fully worked together. During a nine-month period in 1842–43, Ada Lovelace translated the memoir of Italian mathematician Luigi Menabrea, the memoir covered the Analytical Engine. The translation contained Note G which completely detailed a method for calculating Bernoulli numbers using the Analytical Engine and this note is recognized by some historians as the worlds first written computer program. In 1936, Alan Turing introduced the Universal Turing machine—a theoretical device that can model every computation that can be performed on a Turing complete computing machine and it is a finite-state machine that has an infinitely long read/write tape. The machine can move the back and forth, changing its contents as it performs an algorithm
3.
Operating system
–
An operating system is system software that manages computer hardware and software resources and provides common services for computer programs. All computer programs, excluding firmware, require a system to function. Operating systems are found on many devices that contain a computer – from cellular phones, the dominant desktop operating system is Microsoft Windows with a market share of around 83. 3%. MacOS by Apple Inc. is in place, and the varieties of Linux is in third position. Linux distributions are dominant in the server and supercomputing sectors, other specialized classes of operating systems, such as embedded and real-time systems, exist for many applications. A single-tasking system can run one program at a time. Multi-tasking may be characterized in preemptive and co-operative types, in preemptive multitasking, the operating system slices the CPU time and dedicates a slot to each of the programs. Unix-like operating systems, e. g. Solaris, Linux, cooperative multitasking is achieved by relying on each process to provide time to the other processes in a defined manner. 16-bit versions of Microsoft Windows used cooperative multi-tasking, 32-bit versions of both Windows NT and Win9x, used preemptive multi-tasking. Single-user operating systems have no facilities to distinguish users, but may allow multiple programs to run in tandem, a distributed operating system manages a group of distinct computers and makes them appear to be a single computer. The development of networked computers that could be linked and communicate with each other gave rise to distributed computing, distributed computations are carried out on more than one machine. When computers in a work in cooperation, they form a distributed system. The technique is used both in virtualization and cloud computing management, and is common in large server warehouses, embedded operating systems are designed to be used in embedded computer systems. They are designed to operate on small machines like PDAs with less autonomy and they are able to operate with a limited number of resources. They are very compact and extremely efficient by design, Windows CE and Minix 3 are some examples of embedded operating systems. A real-time operating system is a system that guarantees to process events or data by a specific moment in time. A real-time operating system may be single- or multi-tasking, but when multitasking, early computers were built to perform a series of single tasks, like a calculator. Basic operating system features were developed in the 1950s, such as resident monitor functions that could run different programs in succession to speed up processing
4.
Thread (computing)
–
In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. The implementation of threads and processes differs between operating systems, but in most cases a thread is a component of a process, multiple threads can exist within one process, executing concurrently and sharing resources such as memory, while different processes do not share these resources. In particular, the threads of a process share its executable code, systems with a single processor generally implement multithreading by time slicing, the central processing unit switches between different software threads. This context switching generally happens very often and rapidly enough that users perceive the threads or tasks as running in parallel, Threads made an early appearance in OS/360 Multiprogramming with a Variable Number of Tasks in 1967, in which context they were called tasks. The term thread has been attributed to Victor A. Vyssotsky, some threading implementations are called kernel threads, whereas light-weight processes are a specific type of kernel thread that share the same state and information. Furthermore, programs can have user-space threads when threading with timers, signals, or other methods to interrupt their own execution, in computer programming, single-threading is the processing of one command at a time. The opposite of single-threading is multithreading, while it has been suggested that the term single-threading is misleading, the term has been widely accepted within the functional programming community. Multithreading is mainly found in multitasking operating systems, multithreading is a widespread programming and execution model that allows multiple threads to exist within the context of one process. These threads share the resources, but are able to execute independently. The threaded programming model provides developers with an abstraction of concurrent execution. Multithreading can also be applied to one process to enable parallel execution on a multiprocessing system, multithreaded applications have the following advantages, Responsiveness, multithreading can allow an application to remain responsive to input. In a one-thread program, if the main execution thread blocks on a long-running task, on the other hand, in most cases multithreading is not the only way to keep a program responsive, with non-blocking I/O and/or Unix signals being available for gaining similar results. Lower resource consumption, using threads, an application can serve multiple clients concurrently using fewer resources than it would need when using multiple copies of itself. For example, the Apache HTTP server uses thread pools, a pool of threads for listening to incoming requests. GPU computing environments like CUDA and OpenCL use the model where dozens to hundreds of threads run in parallel across data on a large number of cores. Multithreading has the drawbacks, Synchronization, since threads share the same address space. In order for data to be manipulated, threads will often need to rendezvous in time in order to process the data in the correct order. Threads may also require mutually exclusive operations in order to prevent common data from being simultaneously modified or read while in the process of being modified, careless use of such primitives can lead to deadlocks
5.
Concurrency (computer science)
–
In computer science, concurrency is the decomposability property of a program, algorithm, or problem into order-independent or partially-ordered components or units. This means that if the concurrent units of the program, algorithm, or problem are executed out-of-order or in partial order. This allows for execution of the concurrent units, which can significantly improve overall speed of the execution in multi-processor. The ensuing decades have seen a growth of interest in concurrency—particularly in distributed systems. Looking back at the origins of the field, what stands out is the role played by Edsger Dijkstra. Concurrent use of shared resources can be a source of indeterminacy leading to such as deadlocks. Concurrency theory has been a field of research in theoretical computer science. One of the first proposals was Carl Adam Petris seminal work on Petri Nets in the early 1960s, in the years since, a wide variety of formalisms have been developed for modeling and reasoning about concurrency. g. Some of these are based on passing, while others have different mechanisms for concurrency. The proliferation of different models of concurrency has motivated some researchers to develop ways to unify these different theoretical models, various types of temporal logic can be used to help reason about concurrent systems. Some of these logics, such as linear temporal logic and computational tree logic, others, such as action computational tree logic, Hennessy-Milner logic, and Lamports temporal logic of actions, build their assertions from sequences of actions. The principal application of these logics is in writing specifications for concurrent systems, concurrent programming encompasses programming languages and algorithms used to implement concurrent systems. The base goals of concurrent programming include correctness, performance and robustness, concurrent systems such as Operating systems and Database management systems are generally designed to operate indefinitely, including automatic recovery from failure, and not terminate unexpectedly. Because they use shared resources, concurrent systems in general require the inclusion of some kind of arbiter somewhere in their implementation, the use of arbiters introduces the possibility of indeterminacy in concurrent computation which has major implications for practice including correctness and performance. Some concurrent programming models include coprocesses and deterministic concurrency, in these models, threads of control explicitly yield their timeslices, either to the system or to another process. Tanenbaum, Andrew S. Van Steen, Maarten, a Practical Theory of Reactive Systems. Concurrency, State Models and Java Programming, concurrent Systems at The WWW Virtual Library Concurrency patterns presentation given at scaleconf
6.
Instruction set architecture
–
An ISA includes a specification of the set of opcodes, and the native commands implemented by a particular processor. An instruction set architecture is distinguished from a microarchitecture, which is the set of design techniques used, in a particular processor. Processors with different microarchitectures can share a common instruction set, for example, the Intel Pentium and the AMD Athlon implement nearly identical versions of the x86 instruction set, but have radically different internal designs. The concept of an architecture, distinct from the design of a machine, was developed by Fred Brooks at IBM during the design phase of System/360. Prior to NPL, the companys computer designers had been free to honor cost objectives not only by selecting technologies, the SPREAD compatibility objective, in contrast, postulated a single architecture for a series of five processors spanning a wide range of cost and performance. In addition, these virtual machines execute less frequently used code paths by interpretation, transmeta implemented the x86 instruction set atop VLIW processors in this fashion. A complex instruction set computer has many specialized instructions, some of which may only be used in practical programs. Theoretically important types are the instruction set computer and the one instruction set computer. Another variation is the very long instruction word where the processor receives many instructions encoded and retrieved in one instruction word, machine language is built up from discrete statements or instructions. Examples of operations common to many instruction sets include, Set a register to a constant value. Copy data from a location to a register, or vice versa. Used to store the contents of a register, result of a computation, often called load and store operations. Read and write data from hardware devices, add, subtract, multiply, or divide the values of two registers, placing the result in a register, possibly setting one or more condition codes in a status register. Increment, decrement in some ISAs, saving operand fetch in trivial cases, perform bitwise operations, e. g. taking the conjunction and disjunction of corresponding bits in a pair of registers, taking the negation of each bit in a register. Floating-point instructions for arithmetic on floating-point numbers, branch to another location in the program and execute instructions there. Conditionally branch to another if a certain condition holds. Call another block of code, while saving the location of the instruction as a point to return to. Load/store data to and from a coprocessor, or exchanging with CPU registers, processors may include complex instructions in their instruction set
7.
Computer multitasking
–
In computing, multitasking is a concept of performing multiple tasks over a certain period of time by executing them concurrently. As a result, a computer executes segments of multiple tasks in a manner, while the tasks share common processing resources such as central processing units. Multitasking does not necessarily mean that multiple tasks are executing at exactly the same time, even on multiprocessor or multicore computers, which have multiple CPUs/cores so more than one task can be executed at once, multitasking allows many more tasks to be run than there are CPUs. In the case of a computer with a single CPU, only one task is said to be running at any point in time, multitasking solves the problem by scheduling which task may be the one running at any given time, and when another waiting task gets a turn. The act of reassigning a CPU from one task to one is called a context switch. Multiprogramming systems are designed to maximize CPU usage, in time-sharing systems, the running task is required to relinquish the CPU, either voluntarily or by an external event such as a hardware interrupt. Time sharing systems are designed to allow programs to execute apparently simultaneously. In real-time systems, some waiting tasks are guaranteed to be given the CPU when an event occurs. Real time systems are designed to control devices such as industrial robots. The term multitasking has become a term, as the same word is used in many other languages such as German, Italian, Dutch, Danish. In the early days of computing, CPU time was expensive, when the computer ran a program that needed access to a peripheral, the central processing unit would have to stop executing program instructions while the peripheral processed the data. The first computer using a system was the British Leo III owned by J. Lyons. During batch processing, several different programs were loaded in the memory. When the first program reached an instruction waiting for a peripheral, the context of program was stored away. The process continued until all programs finished running, multiprogramming doesnt give any guarantee that a program will run in a timely manner. Indeed, the very first program may very well run for hours without needing access to a peripheral. As there were no users waiting at a terminal, this was no problem, users handed in a deck of punched cards to an operator. Multiprogramming greatly reduced wait times when multiple batches were being processed, the expression time sharing usually designated computers shared by interactive users at terminals, such as IBMs TSO, and VM/CMS
8.
Central processing unit
–
The computer industry has used the term central processing unit at least since the early 1960s. The form, design and implementation of CPUs have changed over the course of their history, most modern CPUs are microprocessors, meaning they are contained on a single integrated circuit chip. An IC that contains a CPU may also contain memory, peripheral interfaces, some computers employ a multi-core processor, which is a single chip containing two or more CPUs called cores, in that context, one can speak of such single chips as sockets. Array processors or vector processors have multiple processors that operate in parallel, there also exists the concept of virtual CPUs which are an abstraction of dynamical aggregated computational resources. Early computers such as the ENIAC had to be rewired to perform different tasks. Since the term CPU is generally defined as a device for software execution, the idea of a stored-program computer was already present in the design of J. Presper Eckert and John William Mauchlys ENIAC, but was initially omitted so that it could be finished sooner. On June 30,1945, before ENIAC was made, mathematician John von Neumann distributed the paper entitled First Draft of a Report on the EDVAC and it was the outline of a stored-program computer that would eventually be completed in August 1949. EDVAC was designed to perform a number of instructions of various types. Significantly, the programs written for EDVAC were to be stored in high-speed computer memory rather than specified by the wiring of the computer. This overcame a severe limitation of ENIAC, which was the considerable time, with von Neumanns design, the program that EDVAC ran could be changed simply by changing the contents of the memory. Early CPUs were custom designs used as part of a larger, however, this method of designing custom CPUs for a particular application has largely given way to the development of multi-purpose processors produced in large quantities. This standardization began in the era of discrete transistor mainframes and minicomputers and has accelerated with the popularization of the integrated circuit. The IC has allowed increasingly complex CPUs to be designed and manufactured to tolerances on the order of nanometers, both the miniaturization and standardization of CPUs have increased the presence of digital devices in modern life far beyond the limited application of dedicated computing machines. Modern microprocessors appear in electronic devices ranging from automobiles to cellphones, the so-called Harvard architecture of the Harvard Mark I, which was completed before EDVAC, also utilized a stored-program design using punched paper tape rather than electronic memory. Relays and vacuum tubes were used as switching elements, a useful computer requires thousands or tens of thousands of switching devices. The overall speed of a system is dependent on the speed of the switches, tube computers like EDVAC tended to average eight hours between failures, whereas relay computers like the Harvard Mark I failed very rarely. In the end, tube-based CPUs became dominant because the significant speed advantages afforded generally outweighed the reliability problems, most of these early synchronous CPUs ran at low clock rates compared to modern microelectronic designs. Clock signal frequencies ranging from 100 kHz to 4 MHz were very common at this time, the design complexity of CPUs increased as various technologies facilitated building smaller and more reliable electronic devices
9.
Interrupt
–
In system programming, an interrupt is a signal to the processor emitted by hardware or software indicating an event that needs immediate attention. An interrupt alerts the processor to a high-priority condition requiring the interruption of the current code the processor is executing, the processor responds by suspending its current activities, saving its state, and executing a function called an interrupt handler to deal with the event. This interruption is temporary, and, after the interrupt handler finishes, there are two types of interrupts, hardware interrupts and software interrupts. Hardware interrupts are used by devices to communicate that they require attention from the operating system, for example, pressing a key on the keyboard or moving the mouse triggers hardware interrupts that cause the processor to read the keystroke or mouse position. Unlike the software type, hardware interrupts are asynchronous and can occur in the middle of instruction execution, the act of initiating a hardware interrupt is referred to as an interrupt request. A software interrupt is caused either by a condition in the processor itself. The former is called a trap or exception and is used for errors or events occurring during program execution that are exceptional enough that they cannot be handled within the program itself. For example, an exception will be thrown if the processors arithmetic logic unit is commanded to divide a number by zero as this instruction is in error. The operating system will catch this exception, and can choose to abort the instruction, each interrupt has its own interrupt handler. The number of interrupts is limited by the number of interrupt request lines to the processor. Interrupts are a commonly used technique for computer multitasking, especially in real-time computing, such a system is said to be interrupt-driven. Hardware interrupts were introduced as an optimization, eliminating unproductive waiting time in polling loops and they may be implemented in hardware as a distinct system with control lines, or they may be integrated into the memory subsystem. If implemented as part of the controller, interrupts are mapped into the systems memory address space. Interrupts can be categorized into different types, Maskable interrupt. Non-maskable interrupt, an interrupt that lacks an associated bit-mask. NMIs are used for the highest priority tasks such as timers, inter-processor interrupt, a special case of interrupt that is generated by one processor to interrupt another processor in a multiprocessor system. Software interrupt, an interrupt generated within a processor by executing an instruction, software interrupts are often used to implement system calls because they result in a subroutine call with a CPU ring level change. Spurious interrupt, an interrupt that is unwanted
10.
Time-sharing
–
In computing, time-sharing is the sharing of a computing resource among many users by means of multiprogramming and multi-tasking at the same time. Its introduction in the 1960s and emergence as the prominent model of computing in the 1970s represented a major shift in the history of computing. The earliest computers were expensive devices, and very slow in comparison to later models. These programs might take hours, or even weeks, to run, as computers grew in speed, run times dropped, and soon the time taken to start up the next program became a concern. Batch processing methodologies evolved to decrease these dead periods by queuing up programs so that as soon as one program completed, to support a batch processing operation, a number of comparatively inexpensive card punch or paper tape writers were used by programmers to write their programs offline. When typing was complete, the programs were submitted to the operations team, important programs were started quickly, how long before less important programs were started was unpredictable. When the program run was completed, the output was returned to the programmer. The complete process might take days, during which time the programmer might never see the computer, the alternative of allowing the user to operate the computer directly was generally far too expensive to consider. This was because users might have long periods of entering code while the computer remained idle and this situation limited interactive development to those organizations that could afford to waste computing cycles, large universities for the most part. Programmers at the universities decried the behaviors that batch processing imposed and they experimented with new ways to interact directly with the computer, a field today known as human–computer interaction. Time-sharing was developed out of the realization that any single user would make inefficient use of a computer. Given an optimal size, the overall process could be very efficient. Similarly, small slices of time spent waiting for disk, tape, in a paper published in December 1958 by W. F. Bauer, he wrote that The computers would handle a number of problems concurrently. Implementing a system able to take advantage of this was initially difficult, batch processing was effectively a methodological development on top of the earliest systems. Since computers still ran single programs for single users at any time, developing a system that supported multiple users at the same time was a completely different concept. The state of each user and their programs would have to be kept in the machine and this would take up computer cycles, and on the slow machines of the era this was a concern. However, as computers rapidly improved in speed, and especially in size of memory in which users states were retained. The first project to implement a system was initiated by John McCarthy at MIT in 1959, initially planned on a modified IBM704
11.
Inter-process communication
–
In computer science, inter-process communication or interprocess communication refers specifically to the mechanisms an operating system provides to allow processes it manages to share data. Typically, applications can use IPC, categorized as clients and servers, where the client requests data, many applications are both clients and servers, as commonly seen in distributed computing. IPC is very important to the process for microkernels and nanokernels. Microkernels reduce the number of functionalities provided by the kernel and those functionalities are then obtained by communicating with servers via IPC, increasing drastically the number of IPC compared to a regular monolithic kernel. Depending on solution IPC mechanism may provide synchronization or leave it up to processes, while synchronization includes some information it is not primarily information passing communication mechanism per se. Examples of synchronization primitives are, Semaphore Spinlock Barrier Mutual exclusion Javas Remote Method Invocation ONC RPC XML-RPC or SOAP JSON-RPC Message Bus, UNIX Network Programming, Volume 2, Second Edition, Interprocess Communications. Ramachandran, M. Solomon, M. Vernon Hardware support for interprocess communication Proceedings of the 14th annual international symposium on Computer architecture, year of Publication,1987 ISBN 0-8186-0776-9 Crovella, M. Bianchini, R. LeBlanc, T. Markatos, E. Wisniewski, R. Using communication-to-computation ratio in parallel program designand performance prediction 1–4 December 1992, pp. 238–245 ISBN 0-8186-3200-3 Linux ipc man page describing System V IPC Windows IPC Beejs Guide to Unix IPC Unix Network Programming by W. Richard Stevens Interprocess Communication and Pipes in C
12.
Machine code
–
Machine code or machine language is a set of instructions executed directly by a computers central processing unit. Each instruction performs a specific task, such as a load. Every program directly executed by a CPU is made up of a series of such instructions, numerical machine code may be regarded as the lowest-level representation of a compiled or assembled computer program or as a primitive and hardware-dependent programming language. While it is possible to write directly in numerical machine code, it is tedious and error prone to manage individual bits and calculate numerical addresses. For this reason machine code is almost never used to programs in modern contexts. Almost all practical programs today are written in languages or assembly language. However, the interpreter itself, which may be seen as an executor or processor, performing the instructions of the source code, every processor or processor family has its own machine code instruction set. Instructions are patterns of bits that by physical design correspond to different commands to the machine, thus, the instruction set is specific to a class of processors using the same architecture. Successor or derivative processor designs often include all the instructions of a predecessor, systems may also differ in other details, such as memory arrangement, operating systems, or peripheral devices. Because a program normally relies on such factors, different systems will not run the same machine code. A machine code instruction set may have all instructions of the same length, how the patterns are organized varies strongly with the particular architecture and often also with the type of instruction. Not all machines or individual instructions have explicit operands, an accumulator machine has a combined left operand and result in an implicit accumulator for most arithmetic instructions. Other architectures have accumulator versions of common instructions, with the accumulator regarded as one of the general registers by longer instructions, a stack machine has most or all of its operands on an implicit stack. Special purpose instructions also often lack explicit operands and this distinction between explicit and implicit operands is important in machine code generators, especially in the register allocation and live range tracking parts. A good code optimizer can track implicit as well as explicit operands which may allow more frequent constant propagation, constant folding of registers, a computer program is a sequence of instructions that are executed by a CPU. While simple processors execute instructions one after another, superscalar processors are capable of executing several instructions at once, program flow may be influenced by special jump instructions that transfer execution to an instruction other than the numerically following one. Conditional jumps are taken or not depending on some condition, a much more readable rendition of machine language, called assembly language, uses mnemonic codes to refer to machine code instructions, rather than using the instructions numeric values directly. For example, on the Zilog Z80 processor, the machine code 00000101, the MIPS instruction set provides a specific example for a machine code whose instructions are always 32 bits long
13.
Virtual memory
–
In computing, virtual memory is a memory management technique that is implemented using both hardware and software. It maps memory addresses used by a program, called virtual addresses, main storage as seen by a process or task appears as a contiguous address space or collection of contiguous segments. The operating system virtual address spaces and the assignment of real memory to virtual memory. Address translation hardware in the CPU, often referred to as a management unit or MMU. Memory virtualization can be considered a generalization of the concept of virtual memory, virtual memory is an integral part of a modern computer architecture, implementations usually require hardware support, typically in the form of a memory management unit built into the CPU. While not necessary, emulators and virtual machines can employ hardware support to increase performance of their virtual memory implementations, during the 1960s and early 70s, computer memory was very expensive. The introduction of virtual memory provided an ability for software systems with large memory demands to run on computers with less real memory, the savings from this provided a strong incentive to switch to virtual memory for all systems. The additional capability of providing virtual address spaces added another level of security and reliability, most modern operating systems that support virtual memory also run each process in its own dedicated address space. Each program thus appears to have access to the virtual memory. However, some operating systems and even modern ones are single address space operating systems that run all processes in a single address space composed of virtualized memory. This is because embedded hardware costs are kept low by implementing all such operations with software rather than with dedicated hardware. In the 1940s and 1950s, all larger programs had to contain logic for managing primary and secondary storage, virtual memory was therefore introduced not only to extend primary memory, but to make such an extension as easy as possible for programmers to use. To allow for multiprogramming and multitasking, many early systems divided memory between multiple programs without virtual memory, such as models of the PDP-10 via registers. The first Atlas was commissioned in 1962 but working prototypes of paging had been developed by 1959, in 1961, the Burroughs Corporation independently released the first commercial computer with virtual memory, the B5000, with segmentation rather than paging. Before virtual memory could be implemented in operating systems, many problems had to be addressed. Dynamic address translation required expensive and difficult to build specialized hardware, there were worries that new system-wide algorithms utilizing secondary storage would be less effective than previously used application-specific algorithms. The first minicomputer to introduce virtual memory was the Norwegian NORD-1, during the 1970s, other minicomputers implemented virtual memory, virtual memory was introduced to the x86 architecture with the protected mode of the Intel 80286 processor, but its segment swapping technique scaled poorly to larger segment sizes. The Intel 80386 introduced paging support underneath the existing segmentation layer, however, loading segment descriptors was an expensive operation, causing operating system designers to rely strictly on paging rather than a combination of paging and segmentation
14.
Call stack
–
In computer science, a call stack is a stack data structure that stores information about the active subroutines of a computer program. This kind of stack is also known as a stack, program stack, control stack, run-time stack, or machine stack. Although maintenance of the stack is important for the proper functioning of most software. Many computer instruction sets provide special instructions for manipulating stacks, a call stack is used for several related purposes, but the main reason for having one is to keep track of the point to which each active subroutine should return control when it finishes executing. An active subroutine is one that has been called but is yet to complete execution after which control should be handed back to the point of call, such activations of subroutines may be nested to any level, hence the stack structure. If, for example, a subroutine DrawSquare calls a subroutine DrawLine from four different places, to accomplish this, the address following the call instruction, the return address, is pushed onto the call stack with each call. If a called subroutine calls on yet another subroutine, it will push another return address onto the call stack, if the pushing consumes all of the space allocated for the call stack, an error called a stack overflow occurs, generally causing the program to crash. Adding a subroutines entry to the stack is sometimes called winding, conversely. There is usually exactly one call stack associated with a running program, in high-level programming languages, the specifics of the call stack are usually hidden from the programmer. They are given only to a set of functions. This is an example of abstraction, most assembly languages, on the other hand, require programmers to be involved with manipulating the stack. The actual details of the stack in a language depend upon the compiler, operating system. As noted above, the purpose of a call stack is to store the return addresses. When a subroutine is called, the location of the instruction at which it can later resume needs to be saved somewhere, using a stack to save the return address has important advantages over alternative calling conventions. One is that each task can have its own stack, and thus the subroutine can be reentrant, another benefit is that recursion is automatically supported. When a function calls itself recursively, a return address needs to be stored for each activation of the function so that it can later be used to return from the function activation, stack structures provide this capability automatically. It is often convenient to allocate space for use by simply moving the top of the stack by enough to provide the space. This is very fast when compared to dynamic memory allocation, which uses the heap space, note that each separate activation of a subroutine gets its own separate space in the stack for locals
15.
Memory management
–
Memory management is a form of resource management applied to computer memory. The essential requirement of memory management is to provide ways to dynamically allocate portions of memory to programs at their request and this is critical to any advanced computer system where more than a single process might be underway at any time. Several methods have been devised that increase the effectiveness of memory management, the quality of the virtual memory manager can have an extensive effect on overall system performance. Modern general-purpose computer systems manage memory at two levels, operating system level, and application level, application-level memory management is generally categorized as either automatic memory management, usually involving garbage collection, or manual memory management. The task of fulfilling an allocation request consists of locating a block of unused memory of sufficient size, Memory requests are satisfied by allocating portions from a large pool of memory called the heap or free store. At any given time, some parts of the heap are in use, while some are free, the allocators metadata can also inflate the size of small allocations. This is often managed by chunking, the memory management system must track outstanding allocations to ensure that they do not overlap and that no memory is ever lost as a memory leak. The specific dynamic memory allocation algorithm implemented can impact performance significantly, a study conducted in 1994 by Digital Equipment Corporation illustrates the overheads involved for a variety of allocators. The lowest average instruction path length required to allocate a single memory slot was 52, since the precise location of the allocation is not known in advance, the memory is accessed indirectly, usually through a pointer reference. This works well for simple embedded systems where no large objects need to be allocated, however, due to the significantly reduced overhead this method can substantially improve performance for objects that need frequent allocation / de-allocation and is often used in video games. All blocks of a particular size are kept in a linked list or tree. If a smaller size is requested than is available, the smallest available size is selected, one of the resulting parts is selected, and the process repeats until the request is complete. When a block is allocated, the allocator will start with the smallest sufficiently large block to avoid needlessly breaking blocks, when a block is freed, it is compared to its buddy. If they are free, they are combined and placed in the correspondingly larger-sized buddy-block list. Virtual memory is a method of decoupling the memory organization from the physical hardware, the applications operate memory via virtual addresses. Each time an attempt to access stored data is made, virtual memory data orders translate the virtual address to a physical address, in this way addition of virtual memory enables granular control over memory systems and methods of access. In virtual memory systems the system limits how a process can access the memory. Even though the memory allocated for specific processes is normally isolated, shared memory is one of the fastest techniques for inter-process communication
16.
File descriptor
–
In Unix and related computer operating systems, a file descriptor is an abstract indicator used to access a file or other input/output resource, such as a pipe or network socket. File descriptors form part of the POSIX application programming interface, a file descriptor is a non-negative integer, generally represented in the C programming language as the type int. This table records the mode with which the file has been opened, for reading, writing, appending and it also indexes into a third table called the inode table that describes the actual underlying files. To perform input or output, the passes the file descriptor to the kernel through a system call. The process does not have access to the file or inode tables. On Linux, the set of file descriptors open in a process can be accessed under the path /proc/PID/fd/, in Unix-like systems, file descriptors can refer to any Unix file type named in a file system. As well as files, this includes directories, block and character devices, Unix domain sockets. File descriptors can refer to other objects that do not normally exist in the file system, such as anonymous pipes. The FILE data structure in the C standard I/O library usually includes a low level file descriptor for the object in question on Unix-like systems, the overall data structure provides additional abstraction and is instead known as a file handle. The following lists typical operations on file descriptors on modern Unix-like systems, most of these functions are declared in the <unistd. h> header, but some are in the <fcntl. h> header instead. The fcntl function is used to various operations on a file descriptor. There are commands to get and set attributes associated with a descriptor, including F_GETFD, F_SETFD. The purpose of new operations is to defend against a certain class of TOCTTOU attacks. Openat faccessat fchmodat fchownat fstatat futimesat linkat mkdirat mknodat readlinkat renameat symlinkat unlinkat mkfifoat fdopendir Unix file descriptors behave in ways as capabilities. They can be passed between processes across Unix domain sockets using the system call. Note, however, that what is actually passed is a reference to an open file description that has mutable state, in operating systems that are specifically designed as capability systems, there is very rarely any mutable state associated with a capability itself. A Unix process file descriptor table is an example of a C-list
17.
Unix
–
Among these is Apples macOS, which is the Unix version with the largest installed base as of 2014. Many Unix-like operating systems have arisen over the years, of which Linux is the most popular, Unix was originally meant to be a convenient platform for programmers developing software to be run on it and on other systems, rather than for non-programmer users. The system grew larger as the system started spreading in academic circles, as users added their own tools to the system. Unix was designed to be portable, multi-tasking and multi-user in a time-sharing configuration and these concepts are collectively known as the Unix philosophy. By the early 1980s users began seeing Unix as a universal operating system. Under Unix, the system consists of many utilities along with the master control program. To mediate such access, the kernel has special rights, reflected in the division between user space and kernel space, the microkernel concept was introduced in an effort to reverse the trend towards larger kernels and return to a system in which most tasks were completed by smaller utilities. In an era when a standard computer consisted of a disk for storage and a data terminal for input and output. However, modern systems include networking and other new devices, as graphical user interfaces developed, the file model proved inadequate to the task of handling asynchronous events such as those generated by a mouse. In the 1980s, non-blocking I/O and the set of inter-process communication mechanisms were augmented with Unix domain sockets, shared memory, message queues, and semaphores. In microkernel implementations, functions such as network protocols could be moved out of the kernel, Multics introduced many innovations, but had many problems. Frustrated by the size and complexity of Multics but not by the aims and their last researchers to leave Multics, Ken Thompson, Dennis Ritchie, M. D. McIlroy, and J. F. Ossanna, decided to redo the work on a much smaller scale. The name Unics, a pun on Multics, was suggested for the project in 1970. Peter H. Salus credits Peter Neumann with the pun, while Brian Kernighan claims the coining for himself, in 1972, Unix was rewritten in the C programming language. Bell Labs produced several versions of Unix that are referred to as Research Unix. In 1975, the first source license for UNIX was sold to faculty at the University of Illinois Department of Computer Science, UIUC graduate student Greg Chesson was instrumental in negotiating the terms of this license. During the late 1970s and early 1980s, the influence of Unix in academic circles led to adoption of Unix by commercial startups, including Sequent, HP-UX, Solaris, AIX. In the late 1980s, AT&T Unix System Laboratories and Sun Microsystems developed System V Release 4, in the 1990s, Unix-like systems grew in popularity as Linux and BSD distributions were developed through collaboration by a worldwide network of programmers
18.
Microsoft Windows
–
Microsoft Windows is a metafamily of graphical operating systems developed, marketed, and sold by Microsoft. It consists of families of operating systems, each of which cater to a certain sector of the computing industry with the OS typically associated with IBM PC compatible architecture. Active Windows families include Windows NT, Windows Embedded and Windows Phone, defunct Windows families include Windows 9x, Windows 10 Mobile is an active product, unrelated to the defunct family Windows Mobile. Microsoft introduced an operating environment named Windows on November 20,1985, Microsoft Windows came to dominate the worlds personal computer market with over 90% market share, overtaking Mac OS, which had been introduced in 1984. Apple came to see Windows as an encroachment on their innovation in GUI development as implemented on products such as the Lisa. On PCs, Windows is still the most popular operating system, however, in 2014, Microsoft admitted losing the majority of the overall operating system market to Android, because of the massive growth in sales of Android smartphones. In 2014, the number of Windows devices sold was less than 25% that of Android devices sold and this comparison however may not be fully relevant, as the two operating systems traditionally target different platforms. As of September 2016, the most recent version of Windows for PCs, tablets, smartphones, the most recent versions for server computers is Windows Server 2016. A specialized version of Windows runs on the Xbox One game console, Microsoft, the developer of Windows, has registered several trademarks each of which denote a family of Windows operating systems that target a specific sector of the computing industry. It now consists of three operating system subfamilies that are released almost at the time and share the same kernel. Windows, The operating system for personal computers, tablets. The latest version is Windows 10, the main competitor of this family is macOS by Apple Inc. for personal computers and Android for mobile devices. Windows Server, The operating system for server computers, the latest version is Windows Server 2016. Unlike its clients sibling, it has adopted a strong naming scheme, the main competitor of this family is Linux. Windows PE, A lightweight version of its Windows sibling meant to operate as an operating system, used for installing Windows on bare-metal computers. The latest version is Windows PE10.0.10586.0, Windows Embedded, Initially, Microsoft developed Windows CE as a general-purpose operating system for every device that was too resource-limited to be called a full-fledged computer. The following Windows families are no longer being developed, Windows 9x, Microsoft now caters to the consumers market with Windows NT. Windows Mobile, The predecessor to Windows Phone, it was a mobile operating system
19.
Computer security
–
A vulnerability is a system susceptibility or flaw. Many vulnerabilities are documented in the Common Vulnerabilities and Exposures database, an exploitable vulnerability is one for which at least one working attack or exploit exists. They may exist for a number of reasons, including by original design or from poor configuration, denial of service attacks are designed to make a machine or network resource unavailable to its intended users. An unauthorized user gaining physical access to a computer is most likely able to copy data from it. They may also compromise security by making operating system modifications, installing software worms, keyloggers, even when the system is protected by standard security measures, these may be able to be by-passed by booting another operating system or tool from a CD-ROM or other bootable media. Disk encryption and Trusted Platform Module are designed to prevent these attacks, eavesdropping is the act of surreptitiously listening to a private conversation, typically between hosts on a network. For instance, programs such as Carnivore and NarusInsight have been used by the FBI, spoofing, in general, is a fraudulent or malicious practice in which communication is sent from an unknown source disguised as a source known to the receiver. Spoofing is most prevalent in communication mechanisms lack a high level of security. Tampering describes a malicious modification of products, so-called Evil Maid attacks and security services planting of surveillance capability into routers are examples. Privilege escalation describes a situation where an attacker with some level of restricted access is able to, without authorization, elevate their privileges or access level. So for example a computer user may be able to fool the system into giving them access to restricted data. Phishing is the attempt to acquire sensitive information such as usernames, passwords, phishing is typically carried out by email spoofing or instant messaging, and it often directs users to enter details at a fake website whose look and feel are almost identical to the legitimate one. Preying on a victims trust, phishing can be classified as a form of social engineering and this is done using multiple transparent or opaque layers. The attacker is basically hijacking the clicks meant for the top level page and routing them to some other irrelevant page, a similar technique can be used to hijack keystrokes. Social engineering aims to convince a user to disclose secrets such as passwords, card numbers, etc. by, for example, impersonating a bank, a common scam involves fake CEO emails sent to accounting and finance departments. In early 2016, the FBI reported that the scam has cost US businesses more than $2bn in about two years, Computer security is critical in almost any industry which uses computers. However, computers can be protected through well built software and hardware, by having strong internal interactions of properties, software complexity can prevent software crash and security failure. In-store payment systems and ATMs have also been tampered with in order to gather customer account data, computers control functions at many utilities, including coordination of telecommunications, the power grid, nuclear power plants, and valve opening and closing in water and gas networks
20.
Deadlock
–
In concurrent computing, a deadlock is a state in which each member of a group of actions, is waiting for some other member to release a lock. If a process is unable to change its state indefinitely because the resources requested by it are being used by another waiting process, in a communications system, deadlocks occur mainly due to lost or corrupt signals rather than resource contention. Only one process can use the resource at any instant of time. Hold and wait or resource holding, a process is currently holding at least one resource, no preemption, a resource can be released only voluntarily by the process holding it. Circular wait, each process must be waiting for a resource which is being held by another process and these four conditions are known as the Coffman conditions from their first description in a 1971 article by Edward G. Coffman, Jr. Most current operating systems cannot prevent deadlocks, when a deadlock occurs, different operating systems respond to them in different non-standard manners. Most approaches work by preventing one of the four Coffman conditions from occurring, in this approach, it is assumed that a deadlock will never occur. This is also an application of the Ostrich algorithm and this approach was initially used by MINIX and UNIX. This is used when the intervals between occurrences of deadlocks are large and the data loss incurred each time is tolerable. Under the deadlock detection, deadlocks are allowed to occur, then the state of the system is examined to detect that a deadlock has occurred and subsequently it is corrected. An algorithm is employed that tracks resource allocation and process states, it rolls back, after a deadlock is detected, it can be corrected by using one of the following methods, Process termination, one or more processes involved in the deadlock may be aborted. One could choose to all competing processes involved in the deadlock. This ensures that deadlock is resolved with certainty and speed, but the expense is high as partial computations will be lost. Or, one could choose to one process at a time until the deadlock is resolved. This approach has high overhead because after each abort an algorithm must determine whether the system is still in deadlock, several factors must be considered while choosing a candidate for termination, such as priority and age of the process. Resource preemption, resources allocated to various processes may be successively preempted and allocated to other processes until the deadlock is broken, Deadlock prevention works by preventing one of the four Coffman conditions from occurring. Removing the mutual exclusion condition means that no process will have access to a resource. This proves impossible for resources that cannot be spooled, but even with spooled resources, deadlock could still occur
21.
Process management (computing)
–
Process management is an integral part of any modern-day operating system. The OS must allocate resources to processes, enable processes to share and exchange information, protect the resources of each process from other processes and enable synchronization among processes. With some programs, it is possible to have one copy loaded into memory, such a program is said to be re-entrant. A number of processes being executed over a period of time instead of at the time is called concurrent execution. A multiprogramming or multitasking OS is a system executing many processes concurrently, Multiprogramming requires that the processor be allocated to each process for a period of time and de-allocated at an appropriate moment. If the processor is de-allocated during the execution of a process, a hardware interrupt occurs, for example, a key was pressed on the keyboard, or a timer runs out. The stopping of one process and starting of another process is called a switch or context change. In many modern operating systems, processes can consist of many sub-processes and this introduces the concept of a thread. A thread may be viewed as a sub-process, that is, threads are becoming increasingly important in the design of distributed and client–server systems and in software run on multi-processor systems. A common trait observed among processes associated with most computer programs, is that they alternate between CPU cycles and I/O cycles, for the portion of the time required for CPU cycles, the process is being executed, i. e. is occupying the CPU. During the time required for I/O cycles, the process is not using the processor, instead, it is either waiting to perform Input/Output, or is actually performing Input/Output. An example of this is the reading from or writing to a file on disk, prior to the advent of multiprogramming, computers operated as single-user systems. Computer scientists observed that overall performance of the machine could be improved by letting a different process use the processor whenever one process was waiting for input/output, in a uni-programming system, if N users were to execute programs with individual execution times of t1, t2. TN, then the time, tuni, to service the N processes of all N users would be. However, because each process consumes both CPU cycles and I/O cycles, the time each process actually uses the CPU is a very small fraction of the total execution time for the process. To overcome this inefficiency, multiprogramming is now implemented in operating systems such as Linux, UNIX. This enables the processor to switch from one process, X, to another, Y, in a very simple system designed for running only a single application, it may be possible to have all the processes that will ever be needed be present when the system comes up. In general-purpose systems, however, some way is needed to create and terminate processes as needed during operation, there are four principal events that cause a process to be created, System initialization
22.
Parallel computing
–
Parallel computing is a type of computation in which many calculations or the execution of processes are carried out simultaneously. Large problems can often be divided into smaller ones, which can then be solved at the same time, there are several different forms of parallel computing, bit-level, instruction-level, data, and task parallelism. Parallelism has been employed for years, mainly in high-performance computing. As power consumption by computers has become a concern in recent years, parallel computing has become the dominant paradigm in computer architecture, specialized parallel computer architectures are sometimes used alongside traditional processors, for accelerating specific tasks. Communication and synchronization between the different subtasks are typically some of the greatest obstacles to getting good parallel program performance, a theoretical upper bound on the speed-up of a single program as a result of parallelization is given by Amdahls law. Traditionally, computer software has been written for serial computation, to solve a problem, an algorithm is constructed and implemented as a serial stream of instructions. These instructions are executed on a central processing unit on one computer, only one instruction may execute at a time—after that instruction is finished, the next one is executed. Parallel computing, on the hand, uses multiple processing elements simultaneously to solve a problem. This is accomplished by breaking the problem into independent parts so that each processing element can execute its part of the algorithm simultaneously with the others. The processing elements can be diverse and include such as a single computer with multiple processors, several networked computers, specialized hardware. Frequency scaling was the dominant reason for improvements in performance from the mid-1980s until 2004. The runtime of a program is equal to the number of instructions multiplied by the time per instruction. Maintaining everything else constant, increasing the frequency decreases the average time it takes to execute an instruction. An increase in frequency thus decreases runtime for all compute-bound programs. However, power consumption P by a chip is given by the equation P = C × V2 × F, where C is the capacitance being switched per clock cycle, V is voltage, increases in frequency increase the amount of power used in a processor. Moores law is the observation that the number of transistors in a microprocessor doubles every 18 to 24 months. Despite power consumption issues, and repeated predictions of its end, with the end of frequency scaling, these additional transistors can be used to add extra hardware for parallel computing. Optimally, the speedup from parallelization would be linear—doubling the number of processing elements should halve the runtime, however, very few parallel algorithms achieve optimal speedup
23.
Embedded system
–
An embedded system is a computer system with a dedicated function within a larger mechanical or electrical system, often with real-time computing constraints. It is embedded as part of a device often including hardware. Embedded systems control many devices in use today. Ninety-eight percent of all microprocessors are manufactured as components of embedded systems, examples of properties of typically embedded computers when compared with general-purpose counterparts are low power consumption, small size, rugged operating ranges, and low per-unit cost. This comes at the price of limited processing resources, which make them more difficult to program. For example, intelligent techniques can be designed to power consumption of embedded systems. Modern embedded systems are based on microcontrollers, but ordinary microprocessors are also common. In either case, the processor used may be ranging from general purpose to those specialised in certain class of computations. A common standard class of dedicated processors is the signal processor. Since the embedded system is dedicated to tasks, design engineers can optimize it to reduce the size and cost of the product and increase the reliability. Some embedded systems are mass-produced, benefiting from economies of scale, complexity varies from low, with a single microcontroller chip, to very high with multiple units, peripherals and networks mounted inside a large chassis or enclosure. One of the very first recognizably modern embedded systems was the Apollo Guidance Computer, an early mass-produced embedded system was the Autonetics D-17 guidance computer for the Minuteman missile, released in 1961. When the Minuteman II went into production in 1966, the D-17 was replaced with a new computer that was the first high-volume use of integrated circuits. Since these early applications in the 1960s, embedded systems have come down in price and there has been a rise in processing power. An early microprocessor for example, the Intel 4004, was designed for calculators and other systems but still required external memory. By the early 1980s, memory, input and output system components had been integrated into the chip as the processor forming a microcontroller. Microcontrollers find applications where a computer would be too costly. A comparatively low-cost microcontroller may be programmed to fulfill the role as a large number of separate components
24.
Process state
–
In a multitasking computer system, processes may occupy a variety of states. These distinct states may not be recognized as such by the system kernel. However, they are an abstraction for the understanding of processes. The following typical process states are possible on computer systems of all kinds, in most of these states, processes are stored on main memory. When a process is first created, it occupies the created or new state, in this state, the process awaits admission to the ready state. Admission will be approved or delayed by a long-term, or admission, typically in most desktop computer systems, this admission will be approved automatically. However, for operating systems this admission may be delayed. In a real system, admitting too many processes to the ready state may lead to oversaturation and overcontention for the systems resources. A ready or waiting process has been loaded into memory and is awaiting execution on a CPU. A ready queue or run queue is used in computer scheduling, modern computers are capable of running many different programs or processes at the same time. However, the CPU is only capable of handling one process at a time, processes that are ready for the CPU are kept in a queue for ready processes. Other processes that are waiting for an event to occur, such as loading information from a drive or waiting on an internet connection, are not in the ready queue. A process moves into the state when it is chosen for execution. The processs instructions are executed by one of the CPUs of the system, There is at most one running process per CPU or core. A process can run in either of the two modes, namely kernel mode or user mode, processes in kernel mode can access both, kernel and user addresses. Kernel mode allows unrestricted access to hardware including execution of privileged instructions, various instructions are privileged and can be executed only in kernel mode. A system call from a user program leads to a switch to kernel mode, processes in user mode can access their own instructions and data but not kernel instructions and data. When the computer system is executing on behalf of a user application, however, when a user application requests a service from the operating system, the system must transition from user to kernel mode to fulfill the request
25.
Computer data storage
–
Computer data storage, often called storage or memory, is a technology consisting of computer components and recording media used to retain digital data. It is a function and fundamental component of computers. The central processing unit of a computer is what manipulates data by performing computations, in practice, almost all computers use a storage hierarchy, which puts fast but expensive and small storage options close to the CPU and slower but larger and cheaper options farther away. In the Von Neumann architecture, the CPU consists of two parts, The control unit and the arithmetic logic unit. The former controls the flow of data between the CPU and memory, while the latter performs arithmetic and logical operations on data, without a significant amount of memory, a computer would merely be able to perform fixed operations and immediately output the result. It would have to be reconfigured to change its behavior and this is acceptable for devices such as desk calculators, digital signal processors, and other specialized devices. Von Neumann machines differ in having a memory in which they store their operating instructions, most modern computers are von Neumann machines. A modern digital computer represents data using the numeral system. Text, numbers, pictures, audio, and nearly any form of information can be converted into a string of bits, or binary digits. The most common unit of storage is the byte, equal to 8 bits, a piece of information can be handled by any computer or device whose storage space is large enough to accommodate the binary representation of the piece of information, or simply data. For example, the works of Shakespeare, about 1250 pages in print. Data is encoded by assigning a bit pattern to each character, digit, by adding bits to each encoded unit, redundancy allows the computer to both detect errors in coded data and correct them based on mathematical algorithms. A random bit flip is typically corrected upon detection, the cyclic redundancy check method is typically used in communications and storage for error detection. A detected error is then retried, data compression methods allow in many cases to represent a string of bits by a shorter bit string and reconstruct the original string when needed. This utilizes substantially less storage for many types of data at the cost of more computation, analysis of trade-off between storage cost saving and costs of related computations and possible delays in data availability is done before deciding whether to keep certain data compressed or not. For security reasons certain types of data may be encrypted in storage to prevent the possibility of unauthorized information reconstruction from chunks of storage snapshots. Generally, the lower a storage is in the hierarchy, the lesser its bandwidth and this traditional division of storage to primary, secondary, tertiary and off-line storage is also guided by cost per bit. In contemporary usage, memory is usually semiconductor storage read-write random-access memory, typically DRAM or other forms of fast but temporary storage
26.
State diagram
–
A state diagram is a type of diagram used in computer science and related fields to describe the behavior of systems. State diagrams require that the system described is composed of a number of states, sometimes. Many forms of state diagrams exist, which differ slightly and have different semantics, State diagrams are used to give an abstract description of the behavior of a system. This behavior is analyzed and represented as a series of events that can occur in one or more possible states, hereby each diagram usually represents objects of a single class and track the different states of its objects through the system. State diagrams can be used to graphically represent finite state machines and this was introduced by C. E. Shannon and W. Weaver in their 1949 book The Mathematical Theory of Communication. Another source is Taylor Booth in his 1967 book Sequential Machines, another possible representation is the State transition table. Edges δ, represent transitions from one state to another as caused by the input, an edge is usually drawn as an arrow directed from the present state to the next state. This mapping describes the transition that is to occur on input of a particular symbol. Item δ= p in the definition of the FA means that from the state named q under input symbol a, in the diagram representing this FA, this is represented by an edge labeled by a pointing from the vertex labeled by q to the vertex labeled by p. The start state q0 ∈ Q is usually represented by an arrow with no origin pointing to the state, in older texts, the start state is not shown and must be inferred from the text. Accepting state F, If used, for example for accepting automata and it is usually drawn as a double circle. Sometimes the accept state function as Final states, for a deterministic finite automaton, nondeterministic finite automaton, generalized nondeterministic finite automaton, or Moore machine, the input is denoted on each edge. For a Mealy machine, input and output are signified on each edge, separated with a slash /, for a Moore machine the states output is usually written inside the states circle, also separated from the states designator with a slash /. There are also variants that combine these two notations, for example, if a state has a number of outputs the diagram should reflect this, e. g. q5/1,0 designates state q5 with outputs a=1, b=0. This designator will be written inside the states circle, S1 and S2 are states and S1 is an accepting state or a final state. Each edge is labeled with the input and this example shows an acceptor for strings over that contain an even number of zeros. S0, S1, and S2 are states, each edge is labeled with j / k where j is the input and k is the output. Harel statecharts are gaining widespread usage since a variant has become part of the Unified Modeling Language, the diagram type allows the modeling of superstates, orthogonal regions, and activities as part of a state
27.
Kernel (operating system)
–
The kernel is a computer program that is the core of a computers operating system, with complete control over everything in the system. It is the first program loaded on start-up and it handles the rest of start-up as well as input/output requests from software, translating them into data-processing instructions for the central processing unit. It handles memory and peripherals like keyboards, monitors, printers, the critical code of the kernel is usually loaded into a protected area of memory, which prevents it from being overwritten by applications or other, more minor parts of the operating system. The kernel performs its tasks, such as running processes and handling interrupts, in contrast, everything a user does is in user space, writing text in a text editor, running programs in a GUI, etc. This separation prevents user data and kernel data from interfering with other and causing instability. The kernels interface is an abstraction layer. When a process makes requests of the kernel, it is called a system call, Kernel designs differ in how they manage these system calls and resources. A monolithic kernel runs all the operating instructions in the same address space. A microkernel runs most processes in space, for modularity. The kernel takes responsibility for deciding at any time which of the running programs should be allocated to the processor or processors. Random-access memory Random-access memory is used to both program instructions and data. Typically, both need to be present in memory in order for a program to execute, often multiple programs will want access to memory, frequently demanding more memory than the computer has available. The kernel is responsible for deciding which memory each process can use, input/output devices I/O devices include such peripherals as keyboards, mice, disk drives, printers, network adapters, and display devices. The kernel allocates requests from applications to perform I/O to an appropriate device, key aspects necessary in resource management are the definition of an execution domain and the protection mechanism used to mediate the accesses to the resources within a domain. Kernels also usually provide methods for synchronization and communication between processes called inter-process communication, finally, a kernel must provide running programs with a method to make requests to access these facilities. The kernel has full access to the memory and must allow processes to safely access this memory as they require it. Often the first step in doing this is virtual addressing, usually achieved by paging and/or segmentation, virtual addressing allows the kernel to make a given physical address appear to be another address, the virtual address. This allows every program to behave as if it is the one running
28.
Auxiliary memory
–
In RAM devices data can be directly deleted or changed. It is used to store a large amount of data at lesser cost per byte than primary memory, secondary storage is two orders of magnitude less expensive than primary storage, the most common forms of auxiliary memory are flash memory, optical discs, magnetic disks and magnetic tape. The latest addition to the auxiliary memory family is flash memory and this form is much faster as compared to its predecessors, as this form of auxiliary memory does not involve any moving parts. In some laptops, this type of memory is referred to as a solid state drive. Flash memory, An electronic non-volatile computer storage device that can be erased and reprogrammed. Examples of this are flash drives, memory cards and solid state drives, a version of this is implemented in many notebook and some desktop computers. Optical disc, A storage medium from which data is read, optical disks can store much more data — up to 6 gigabytes more than most portable magnetic media, such as floppies. There are three types of optical disks, CD/DVD/BD-ROM, WORM & EO. Magnetic Disk, A magnetic disk is a circular plate constructed of metal or plastic coated with magnetized material, both sides of the disk are used and several disks may be stacked on one spindle with read/write heads available on each surface. Bits are stored on the surface in spots along concentric circles called tracks. Tracks are commonly divided into sections called sectors, Disk that are permanently attached and cannot be removed by the occasional user are called hard disks. A disk drive with removable disks is called a disk drive. Magnetic tapes, A magnetic tape transport consists of electric, mechanical and electronic components to provide the parts, the tape itself is a strip of plastic coated with a magnetic recording medium. Bits are recorded as magnetic spots on tape along several tracks, seven or nine bits are recorded to form a character together with a parity bit. R/W heads are mounted in each track so that data can be recorded, Computer data storage Secondary storage on the Computer data storage article Data storage device External storage Mass storage
29.
Hard disk drive
–
The platters are paired with magnetic heads, usually arranged on a moving actuator arm, which read and write data to the platter surfaces. Data is accessed in a manner, meaning that individual blocks of data can be stored or retrieved in any order. HDDs are a type of storage, retaining stored data even when powered off. Introduced by IBM in 1956, HDDs became the dominant secondary storage device for computers by the early 1960s. Continuously improved, HDDs have maintained this position into the era of servers. More than 200 companies have produced HDDs historically, though after extensive industry consolidation most current units are manufactured by Seagate, Toshiba, as of 2016, HDD production is growing, although unit shipments and sales revenues are declining. While SSDs have higher cost per bit, SSDs are replacing HDDs where speed, power consumption, small size, the primary characteristics of an HDD are its capacity and performance. Capacity is specified in unit prefixes corresponding to powers of 1000, the two most common form factors for modern HDDs are 3. 5-inch, for desktop computers, and 2. 5-inch, primarily for laptops. HDDs are connected to systems by standard interface cables such as PATA, SATA, Hard disk drives were introduced in 1956, as data storage for an IBM real-time transaction processing computer and were developed for use with general-purpose mainframe and minicomputers. The first IBM drive, the 350 RAMAC in 1956, was approximately the size of two medium-sized refrigerators and stored five million six-bit characters on a stack of 50 disks. In 1962 the IBM350 RAMAC disk storage unit was superseded by the IBM1301 disk storage unit, cylinder-mode read/write operations were supported, and the heads flew about 250 micro-inches above the platter surface. Motion of the head array depended upon a binary system of hydraulic actuators which assured repeatable positioning. The 1301 cabinet was about the size of three home refrigerators placed side by side, storing the equivalent of about 21 million eight-bit bytes, access time was about a quarter of a second. Also in 1962, IBM introduced the model 1311 disk drive, users could buy additional packs and interchange them as needed, much like reels of magnetic tape. Later models of removable pack drives, from IBM and others, became the norm in most computer installations, non-removable HDDs were called fixed disk drives. Some high-performance HDDs were manufactured with one head per track so that no time was lost physically moving the heads to a track, known as fixed-head or head-per-track disk drives they were very expensive and are no longer in production. In 1973, IBM introduced a new type of HDD code-named Winchester and its primary distinguishing feature was that the disk heads were not withdrawn completely from the stack of disk platters when the drive was powered down. Instead, the heads were allowed to land on an area of the disk surface upon spin-down
30.
CD-ROM
–
A CD-ROM /ˌsiːˌdiːˈrɒm/ is a pre-pressed optical compact disc which contains data. The name is an acronym which stands for Compact Disc Read-Only Memory, computers can read CD-ROMs, but cannot write to CD-ROMs which are not writable or erasable. From the mid-1990s until the mid-2000s, CD-ROMs were popularly used to distribute software for computers, some CDs, called enhanced CDs, hold both computer data and audio with the latter capable of being played on a CD player, while data is only usable on a computer. An early CD-ROM format was developed by Sony and Denon, introduced at a Japanese computer show in 1984 and it was an extension of Compact Disc Digital Audio, and adapted the format to hold any form of digital data, with a capacity of 540 MiB. The Yellow Book is the standard that defines the format of CD-ROMs. One of a set of books that contain the technical specifications for all CD formats. CD-ROMs are identical in appearance to audio CDs, and data are stored and retrieved in a similar manner. Discs are made from a 1.2 mm thick disc of polycarbonate plastic, data is stored on the disc as a series of microscopic indentations. A laser is shone onto the surface of the disc to read the pattern of pits. This pattern of changing intensity of the beam is converted into binary data. Several formats are used for data stored on discs, known as the Rainbow Books. The Yellow Book, published in 1988, defines the specifications for CD-ROMs, the CD-ROM standard builds on top of the original Red Book CD-DA standard for CD audio. Other standards, such as the White Book for Video CDs, the Yellow Book itself is not freely available, but the standards with the corresponding content can be downloaded for free from ISO or ECMA. There are several standards that define how to structure data files on a CD-ROM, ISO9660 defines the standard file system for a CD-ROM. ISO13490 is an improvement on this standard which adds support for non-sequential write-once and re-writeable discs such as CD-R and CD-RW, as well as multiple sessions. The ISO13346 standard was designed to address most of the shortcomings of ISO9660, and a subset of it evolved into the UDF format, which was adopted for DVDs. The bootable CD specification was issued in January 1995, to make a CD emulate a hard disk or floppy disk, is called El Torito, data stored on CD-ROMs follows the standard CD data encoding techniques described in the Red Book specification. This includes cross-interleaved Reed–Solomon coding, eight-to-fourteen modulation, and the use of pits, the structures used to group data on a CD-ROM are also derived from the Red Book
31.
Communications protocol
–
These are the rules or standard that defines the syntax, semantics and synchronization of communication and possible error recovery methods. Protocols may be implemented by hardware, software, or a combination of both, Communicating systems use well-defined formats for exchanging various messages. Each message has a meaning intended to elicit a response from a range of possible responses pre-determined for that particular situation. The specified behavior is independent of how it is to be implemented. Communications protocols have to be agreed upon by the parties involved, to reach agreement, a protocol may be developed into a technical standard. Multiple protocols often describe different aspects of a single communication, a group of protocols designed to work together are known as a protocol suite, when implemented in software they are a protocol stack. Most recent protocols are assigned by the IETF for Internet communication, the ITU-T handles telecommunications protocols and formats for the PSTN. As the PSTN and Internet converge, the two sets of standards are also being driven towards convergence, the nature of a communication, the actual data exchanged and any state-dependent behaviors, is defined by these specifications. In digital computing systems, the rules can be expressed by algorithms, expressing the algorithms in a portable programming language makes the protocol software operating-system independent. Operating systems usually contain a set of cooperating processes that manipulate shared data to communicate each other. This communication is governed by protocols, which can be embedded in the process code itself. In contrast, because there is no memory, communicating systems have to communicate with each other using a shared transmission medium. Transmission is not necessarily reliable, and individual systems may use different hardware or operating systems, to implement a networking protocol, the protocol software modules are interfaced with a framework implemented on the machines operating system. This framework implements the functionality of the operating system. The best known frameworks are the TCP/IP model and the OSI model and this gave rise to the concept of layered protocols which nowadays forms the basis of protocol design. Systems typically do not use a protocol to handle a transmission. Instead they use a set of cooperating protocols, sometimes called a family or protocol suite. Some of the best known protocol suites are TCP/IP, IPX/SPX, X.25, AX.25, the protocols can be arranged based on functionality in groups, for instance there is a group of transport protocols
Media related to 