Execution environment
An execution environment is the context in which a program runs. The following notable environment attributes are commonly-used. They are not strictly distinct as an environment may be described with multiple of these attributes.
Host-native
Host-native is a common scenario for execution, especially historically. It involves controlling a computer via the instructions of its central processing unit (CPU). The CPU interprets the program at the machine instruction level.
Context switch
Context switching, a feature of a multitasking operating system (OS), supports concurrent execution of multiple host-native executables. To swap out an executable (identified by a process-context identifier) from the execution environment, the OS saves its execution context data such as memory page addresses and register values. To swap it back in, the OS restores the data. [1] : 3.3 [2]
In a Linux-based OS, a set of data stored in registers is usually saved into a process descriptor in memory to implement a context switch. [1] PCIDs are also used.
Loading
When a program is started, a loader performs memory setup and links the program with any dynamically linked libraries it needs, and then execution begins at the program's entry point. In some cases, a language or implementation will have these tasks done by the language runtime instead, though this is unusual in mainstream languages on common consumer operating systems.
Runtime system
A runtime system is a software layer that provides services to an executable. It is a portion of an execution model.[ clarification needed ] Relatedly, a runtime environment (RTE) is everything that a program can interact with, including a runtime system.
Most programming languages include a runtime system. It may address issues including memory management, variable access, parameter passing mechanisms, operating system access, and more. The compiler makes assumptions depending on the specific runtime system to generate code. Typically, the runtime system has some responsibility for setting up and managing the stack and heap, and may include features such as garbage collection, threading or other dynamic features of the language. [3]
Instruction cycle
The instruction cycle is the cycle that the CPU follows from boot-up until the computer has shut down in order to process instructions. It is composed of three main stages: the fetch stage, the decode stage, and the execute stage.
In simpler CPUs, the instruction cycle is executed sequentially, each instruction being processed before the next one is started. In most modern CPUs, the instruction cycles are instead executed concurrently, and often in parallel, through an instruction pipeline: the next instruction starts being processed before the previous instruction has finished, which is possible because the cycle is broken up into separate steps. [4]
Virtual
A virtual machine (VM) provides the functionality of a physical computer that is either partially or fully implemented as a layer of software – instead of accessing the host system directly. Via virtualization, a VM provides a computer system that is logically independent from the host computer and other VMs on the host via a relatively thin software layer that allows for relatively high performance at the cost of being constrained by the host's technology. Via emulation, a VM provides a distinct computer that may differ significantly from the host computer system technology, but generally at the cost of relatively slow performance due to a relatively thick software layer.
A VM technology can differ by scope. A system VM (a.k.a. full virtualization VM) provides the functionality needed to execute an independent operating system. A hypervisor uses native execution to share and manage hardware, allowing for multiple environments which are isolated from one another, yet exist on the same physical machine. Modern hypervisors use hardware-assisted virtualization, virtualization-specific hardware, primarily from the host CPUs. In contrast, a process VM (such as the .NET, Java and Python runtimes) executes a computer program in a platform-independent environment.
Some emulators, such as QEMU and video game console emulators, are designed to also emulate (or "virtually imitate") different system architectures thus allowing execution of software applications and operating systems written for another CPU or architecture. OS-level virtualization allows the resources of a computer to be partitioned via the kernel. The terms are not universally interchangeable.
Interpreted
An interpreter executes code that is in a form that can be executed directly. Any preparation steps required for the environment have already been performed. An executable is directly executable by a CPU (including a virtual CPU). Source code can be executable in an environment that supports it. For example, JavaScript and Python are executed by interpreter software that does not require a compilation operation.