Misplaced Pages

#62937

53-459: An iterative refresh of Raptor Lake-S desktop processors, called the 14th generation of Intel Core, was launched on October 17, 2023. CPUs in bold below feature ECC memory support only when paired with a motherboard based on the W680 chipset according to each respective Intel Ark product page. Processor An iterative refresh of Raptor Lake-HX mobile processors, called the 14th generation of Intel Core,

106-454: 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 . In many cases, a thread is a component of a process . The multiple threads of a given process may be executed concurrently (via multithreading capabilities), sharing resources such as memory , while different processes do not share these resources. In particular,

159-483: A 1:1 model. FreeBSD 5 implemented M:N model. FreeBSD 6 supported both 1:1 and M:N, users could choose which one should be used with a given program using /etc/libmap.conf. Starting with FreeBSD 7, the 1:1 became the default. FreeBSD 8 no longer supports the M:N model. In computer programming , single-threading is the processing of one command at a time. In the formal analysis of the variables' semantics and process state,

212-452: A context switch. On multi-processor systems, the thread may instead poll the mutex in a spinlock . Both of these may sap performance and force processors in symmetric multiprocessing (SMP) systems to contend for the memory bus, especially if the granularity of the locking is too fine. Other synchronization APIs include condition variables , critical sections , semaphores , and monitors . A popular programming pattern involving threads

265-508: A cooperatively multitasked thread blocks by waiting on a resource or if it starves other threads by not yielding control of execution during intensive computation. Until the early 2000s, most desktop computers had only one single-core CPU, with no support for hardware threads , although threads were still used on such computers because switching between threads was generally still quicker than full-process context switches . In 2002, Intel added support for simultaneous multithreading to

318-498: A limited form of preemptive multitasking was Windows/386 2.0 , which used the Intel 80386 's Virtual 8086 mode to run DOS applications in virtual 8086 machines , commonly known as "DOS boxes", which could be preempted. In Windows 95, 98 and Me , 32-bit applications were made preemptive by running each one in a separate address space, but 16-bit applications remained cooperative for backward compatibility. In Windows 3.1x (protected mode),

371-431: A running fiber must explicitly " yield " to allow another fiber to run, which makes their implementation much easier than kernel or user threads . A fiber can be scheduled to run in any thread in the same process. This permits applications to gain performance improvements by managing scheduling themselves, instead of relying on the kernel scheduler (which may not be tuned for the application). Some research implementations of

424-472: A useful abstraction of concurrent execution. Multithreading can also be applied to one process to enable parallel execution on a multiprocessing system. Multithreading libraries tend to provide a function call to create a new thread, which takes a function as a parameter. A concurrent thread is then created which starts running the passed function and ends when the function returns. The thread libraries also offer data synchronization functions. Threads in

477-513: Is a "heavyweight" unit of kernel scheduling, as creating, destroying, and switching processes is relatively expensive. Processes own resources allocated by the operating system. Resources include memory (for both code and data), file handles , sockets, device handles, windows, and a process control block . Processes are isolated by process isolation , and do not share address spaces or file resources except through explicit methods such as inheriting file handles or shared memory segments, or mapping

530-402: Is a "lightweight" unit of kernel scheduling. At least one kernel thread exists within each process. If multiple kernel threads exist within a process, then they share the same memory and file resources. Kernel threads are preemptively multitasked if the operating system's process scheduler is preemptive. Kernel threads do not own resources except for a stack , a copy of the registers including

583-477: Is initiated, a system call is made, and does not return until the I/O operation has been completed. In the intervening period, the entire process is "blocked" by the kernel and cannot run, which starves other user threads and fibers in the same process from executing. A common solution to this problem (used, in particular, by many green threads implementations) is providing an I/O API that implements an interface that blocks

SECTION 10

#1733085349063

636-593: Is more specific, referring instead to the class of scheduling policies known as time-shared scheduling , or time-sharing . Preemptive multitasking allows the computer system to more reliably guarantee each process a regular "slice" of operating time. It also allows the system to rapidly deal with important external events like incoming data, which might require the immediate attention of one or another process. At any specific time, processes can be grouped into two categories: those that are waiting for input or output (called " I/O bound "), and those that are fully utilizing

689-815: Is not so great a difference except in the cost of an address-space switch, which on some architectures (notably x86 ) results in a translation lookaside buffer (TLB) flush. Advantages and disadvantages of threads vs processes include: Operating systems schedule threads either preemptively or cooperatively . Multi-user operating systems generally favor preemptive multithreading for its finer-grained control over execution time via context switching . However, preemptive scheduling may context-switch threads at moments unanticipated by programmers, thus causing lock convoy , priority inversion , or other side-effects. In contrast, cooperative multithreading relies on threads to relinquish control of execution, thus ensuring that threads run to completion . This can cause problems if

742-405: Is that of thread pools where a set number of threads are created at startup that then wait for a task to be assigned. When a new task arrives, it wakes up, completes the task and goes back to waiting. This avoids the relatively expensive thread creation and destruction functions for every task performed and takes thread management out of the application developer's hand and leaves it to a library or

795-804: Is typically uniformly done preemptively or, less commonly, cooperatively. At the user level a process such as a runtime system can itself schedule multiple threads of execution. If these do not share data, as in Erlang, they are usually analogously called processes, while if they share data they are usually called (user) threads , particularly if preemptively scheduled. Cooperatively scheduled user threads are known as fibers ; different processes may schedule user threads differently. User threads may be executed by kernel threads in various ways (one-to-one, many-to-one, many-to-many). The term " light-weight process " variously refers to user threads or to kernel mechanisms for scheduling user threads onto kernel threads. A process

848-403: Is unaware of them, so they are managed and scheduled in userspace. Some implementations base their user threads on top of several kernel threads, to benefit from multi-processor machines ( M:N model ). User threads as implemented by virtual machines are also called green threads . As user thread implementations are typically entirely in userspace, context switching between user threads within

901-557: Is used to distinguish a multitasking operating system , which permits preemption of tasks, from a cooperative multitasking system wherein processes or tasks must be explicitly programmed to yield when they do not need system resources. In simple terms: Preemptive multitasking involves the use of an interrupt mechanism which suspends the currently executing process and invokes a scheduler to determine which process should execute next. Therefore, all processes will get some amount of CPU time at any given time. In preemptive multitasking,

954-478: The OS/360 control system, of which Multiprogramming with a Variable Number of Tasks (MVT) was one. Saltzer (1966) credits Victor A. Vyssotsky with the term "thread". The use of threads in software applications became more common in the early 2000s as CPUs began to utilize multiple cores. Applications wishing to take advantage of multiple cores for performance advantages were required to employ concurrency to utilize

1007-519: The OpenMP parallel programming model implement their tasks through fibers. Closely related to fibers are coroutines , with the distinction being that coroutines are a language-level construct, while fibers are a system-level construct. Threads differ from traditional multitasking operating-system processes in several ways: Systems such as Windows NT and OS/2 are said to have cheap threads and expensive processes; in other operating systems there

1060-507: The Pentium ;4 processor, under the name hyper-threading ; in 2005, they introduced the dual-core Pentium D processor and AMD introduced the dual-core Athlon 64 X2 processor. Systems with a single processor generally implement multithreading by time slicing : the central processing unit (CPU) switches between different software threads . This context switching usually occurs frequently enough that users perceive

1113-599: The classic Mac OS did not support multitasking at all, with cooperative multitasking becoming available via MultiFinder in System Software 5 and then standard in System 7 . Although there were plans to upgrade the cooperative multitasking found in the classic Mac OS to a preemptive model (and a preemptive API did exist in Mac OS 9 , although in a limited sense ), these were abandoned in favor of Mac OS X (now called macOS) that, as

SECTION 20

#1733085349063

1166-715: The program counter , and thread-local storage (if any), and are thus relatively cheap to create and destroy. Thread switching is also relatively cheap: it requires a context switch (saving and restoring registers and stack pointer), but does not change virtual memory and is thus cache-friendly (leaving TLB valid). The kernel can assign one or more software threads to each core in a CPU (it being able to assign itself multiple software threads depending on its support for multithreading), and can swap out threads that get blocked. However, kernel threads take much longer than user threads to be swapped. Threads are sometimes implemented in userspace libraries, thus called user threads . The kernel

1219-454: The CPU (" CPU bound "). In early systems, processes would often " poll " or " busy-wait " while waiting for requested input (such as disk, keyboard or network input). During this time, the process was not performing useful work, but still maintained complete control of the CPU. With the advent of interrupts and preemptive multitasking, these I/O bound processes could be "blocked", or put on hold, pending

1272-399: The M:N implementation, the threading library is responsible for scheduling user threads on the available schedulable entities; this makes context switching of threads very fast, as it avoids system calls. However, this increases complexity and the likelihood of priority inversion , as well as suboptimal scheduling without extensive (and expensive) coordination between the userland scheduler and

1325-571: The arrival of the necessary data, allowing other processes to utilize the CPU. As the arrival of the requested data would generate an interrupt, blocked processes could be guaranteed a timely return to execution. Although multitasking techniques were originally developed to allow multiple users to share a single machine, it became apparent that multitasking was useful regardless of the number of users. Many operating systems, from mainframes down to single-user personal computers and no-user control systems (like those in robotic spacecraft ), have recognized

1378-542: The calling thread, rather than the entire process, by using non-blocking I/O internally, and scheduling another user thread or fiber while the I/O operation is in progress. Similar solutions can be provided for other blocking system calls. Alternatively, the program can be written to avoid the use of synchronous I/O or other blocking system calls (in particular, using non-blocking I/O, including lambda continuations and/or async/ await primitives ). Fibers are an even lighter unit of scheduling which are cooperatively scheduled :

1431-467: The intention of resuming it at a later time. This interrupt is done by an external scheduler with no assistance or cooperation from the task. This preemptive scheduler usually runs in the most privileged protection ring , meaning that interruption and then resumption are considered highly secure actions. Such changes to the currently executing task of a processor are known as context switching . In any given system design, some operations performed by

1484-462: The kernel and virtual device drivers ran preemptively, but all 16-bit applications were non-preemptive and shared the same address space. Preemptive multitasking has always been supported by Windows NT (all versions), OS/2 (native applications), Unix and Unix-like systems (such as Linux , BSD and macOS ), VMS , OS/360 , and many other operating systems designed for use in the academic and medium-to-large business markets. Early versions of

1537-424: The kernel has no knowledge of the application threads. With this approach, context switching can be done very quickly and, in addition, it can be implemented even on simple kernels which do not support threading. One of the major drawbacks, however, is that it cannot benefit from the hardware acceleration on multithreaded processors or multi-processor computers: there is never more than one thread being scheduled at

1590-421: The kernel scheduler. SunOS 4.x implemented light-weight processes or LWPs. NetBSD 2.x+, and DragonFly BSD implement LWPs as kernel threads (1:1 model). SunOS 5.2 through SunOS 5.8 as well as NetBSD 2 to NetBSD 4 implemented a two level model, multiplexing one or more user level threads on each kernel thread (M:N model). SunOS 5.9 and later, as well as NetBSD 5 eliminated user threads support, returning to

1643-438: The multiple cores. Scheduling can be done at the kernel level or user level, and multitasking can be done preemptively or cooperatively . This yields a variety of related concepts. At the kernel level, a process contains one or more kernel threads , which share the process's resources, such as memory and file handles – a process is a unit of resources, while a thread is a unit of scheduling and execution. Kernel scheduling

List of Intel processors - Misplaced Pages Continue

1696-453: The next process to run. The length of each time slice can be critical to balancing system performance vs process responsiveness - if the time slice is too short then the scheduler will consume too much processing time, but if the time slice is too long, processes will take longer to respond to input. An interrupt is scheduled to allow the operating system kernel to switch between processes when their time slices expire, effectively allowing

1749-416: The operating system kernel can also initiate a context switch to satisfy the scheduling policy 's priority constraint, thus preempting the active task. In general, preemption means "prior seizure of". When the high-priority task at that instance seizes the currently running task, it is known as preemptive scheduling. The term "preemptive multitasking" is sometimes mistakenly used when the intended meaning

1802-413: The operating system that is better suited to optimize thread management. Multithreaded applications have the following advantages vs single-threaded ones: Multithreaded applications have the following drawbacks: Many programming languages support threading in some capacity. Preemption (computing) In computing , preemption is the act of temporarily interrupting an executing task , with

1855-480: The processor's time to be shared among a number of tasks, giving the illusion that it is dealing with these tasks in parallel (simultaneously). The operating system which controls such a design is called a multi-tasking system. Today, nearly all operating systems support preemptive multitasking, including the current versions of Windows , macOS , Linux (including Android ), iOS and iPadOS . An early microcomputer operating system providing preemptive multitasking

1908-452: The requirements of the program's workload. However, the use of blocking system calls in user threads (as opposed to kernel threads) can be problematic. If a user thread or a fiber performs a system call that blocks, the other user threads and fibers in the process are unable to run until the system call returns. A typical example of this problem is when performing I/O: most programs are written to perform I/O synchronously. When an I/O operation

1961-540: The same file in a shared way – see interprocess communication . Creating or destroying a process is relatively expensive, as resources must be acquired or released. Processes are typically preemptively multitasked, and process switching is relatively expensive, beyond basic cost of context switching , due to issues such as cache flushing (in particular, process switching changes virtual memory addressing, causing invalidation and thus flushing of an untagged translation lookaside buffer (TLB), notably on x86). A kernel thread

2014-766: The same flat address space. Early operating systems for IBM PC compatibles such as MS-DOS and PC DOS , did not support multitasking at all, however alternative operating systems such as MP/M-86 (1981) and Concurrent CP/M-86 did support preemptive multitasking. Other Unix-like systems including MINIX and Coherent provided preemptive multitasking on 1980s-era personal computers. Later MS-DOS compatible systems natively supporting preemptive multitasking/multithreading include Concurrent DOS , Multiuser DOS , Novell DOS (later called Caldera OpenDOS and DR-DOS 7.02 and higher). Since Concurrent DOS 386 , they could also run multiple DOS programs concurrently in virtual DOS machines . The earliest version of Windows to support

2067-405: The same process is extremely efficient because it does not require any interaction with the kernel at all: a context switch can be performed by locally saving the CPU registers used by the currently executing user thread or fiber and then loading the registers required by the user thread or fiber to be executed. Since scheduling occurs in userspace, the scheduling policy can be more easily tailored to

2120-406: The same process share the same address space. This allows concurrently running code to couple tightly and conveniently exchange data without the overhead or complexity of an IPC . When shared between threads, however, even simple data structures become prone to race conditions if they require more than one CPU instruction to update: two threads may end up attempting to update the data structure at

2173-407: The same time and find it unexpectedly changing underfoot. Bugs caused by race conditions can be very difficult to reproduce and isolate. To prevent this, threading application programming interfaces (APIs) offer synchronization primitives such as mutexes to lock data structures against concurrent access. On uniprocessor systems, a thread running into a locked mutex must sleep and hence trigger

List of Intel processors - Misplaced Pages Continue

2226-621: The same time. For example: If one of the threads needs to execute an I/O request, the whole process is blocked and the threading advantage cannot be used. The GNU Portable Threads uses User-level threading, as does State Threads . M : N maps some M number of application threads onto some N number of kernel entities, or "virtual processors." This is a compromise between kernel-level ("1:1") and user-level (" N :1") threading. In general, " M : N " threading systems are more complex to implement than either kernel or user threads, because changes to both kernel and user-space code are required . In

2279-469: The system may not be preemptable. This usually applies to kernel functions and service interrupts which, if not permitted to run to completion , would tend to produce race conditions resulting in deadlock . Barring the scheduler from preempting tasks while they are processing kernel functions simplifies the kernel design at the expense of system responsiveness . The distinction between user mode and kernel mode , which determines privilege level within

2332-428: The system, may also be used to distinguish whether a task is currently preemptable. Most modern operating systems have preemptive kernels , which are designed to permit tasks to be preempted even when in kernel mode. Examples of such operating systems are Solaris 2.0/SunOS 5.0, Windows NT , Linux kernel (2.5.4 and newer), AIX and some BSD systems ( NetBSD , since version 5). The term preemptive multitasking

2385-502: The term single threading can be used differently to mean "backtracking within a single thread", which is common in 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 process's resources, but are able to execute independently. The threaded programming model provides developers with

2438-1260: The third quarter of 1974, these bit-slicing components used bipolar Schottky transistors. Each component implemented two bits of a processor function; packages could be interconnected to build a processor with any desired word length. Members of the 3000 family: Bus width 2 n bits data/address (depending on number n of slices used) Pentium II Xeon (chronological entry) XScale (chronological entry – non-x86 architecture) Pentium 4 (not 4EE, 4E, 4F), Itanium, P4-based Xeon, Itanium 2 (chronological entries) Itanium (chronological entry – new non-x86 architecture) Itanium 2 (chronological entry – new non-x86 architecture) Westmere Not listed (yet) are several Broadwell-based CPU models: Note: this list does not say that all processors that match these patterns are Broadwell-based or fit into this scheme. The model numbers may have suffixes that are not shown here. Many Skylake-based processors are not yet listed in this section: mobile i3/i5/i7 processors (U, H, and M suffixes), embedded i3/i5/i7 processors (E suffix), certain i7-67nn/i7-68nn/i7-69nn. Skylake-based "Core X-series" processors (certain i7-78nn and i9-79nn models) can be found under current models. Intel discontinued

2491-479: The threads of a process share its executable code and the values of its dynamically allocated variables and non- thread-local global variables at any given time. The implementation of threads and processes differs between operating systems. Threads made an early appearance under the name of "tasks" in IBM's batch processing operating system, OS/360, in 1967. It provided users with three available configurations of

2544-510: The threads or tasks as running in parallel (for popular server/desktop operating systems, maximum time slice of a thread, when other threads are waiting, is often limited to 100–200ms). On a multiprocessor or multi-core system, multiple threads can execute in parallel , with every processor or core executing a separate thread simultaneously; on a processor or core with hardware threads , separate software threads can also be executed concurrently by separate hardware threads. Threads created by

2597-448: The use of part numbers such as 80486 in the marketing of mainstream x86-architecture processors with the introduction of the Pentium brand in 1993. However, numerical codes, in the 805xx range, continued to be assigned to these processors for internal and part numbering uses. The following is a list of such product codes in numerical order: Thread (computing) In computer science ,

2650-435: The usefulness of multitasking support for a variety of reasons. Multitasking makes it possible for a single user to run multiple applications at the same time, or to run "background" processes while retaining control of the computer. The period of time for which a process is allowed to run in a preemptive multitasking system is generally called the time slice or quantum . The scheduler is run once every time slice to choose

2703-558: The user in a 1:1 correspondence with schedulable entities in the kernel are the simplest possible threading implementation. OS/2 and Win32 used this approach from the start, while on Linux the GNU C Library implements this approach (via the NPTL or older LinuxThreads ). This approach is also used by Solaris , NetBSD , FreeBSD , macOS , and iOS . An M :1 model implies that all application-level threads map to one kernel-level scheduled entity;

SECTION 50

#1733085349063

2756-803: Was Microware 's OS-9 , available for computers based on the Motorola 6809 , including home computers such as the TRS-80 Color Computer 2 when configured with disk drives, with the operating system supplied by Tandy as an upgrade. Sinclair QDOS and AmigaOS on the Amiga were also microcomputer operating systems offering preemptive multitasking as a core feature. These both ran on Motorola 68000 -family microprocessors without memory management. Amiga OS used dynamic loading of relocatable code blocks (" hunks " in Amiga jargon) to multitask preemptively all processes in

2809-438: Was launched on Jan 9, 2024 family family family ( threads ) cache Turbo for 11th Gen Processors All processors are listed in chronological order. First microprocessor (single-chip IC processor) MCS-4 family: They are ICs with CPU, RAM, ROM (or PROM or EPROM), I/O Ports, Timers & Interrupts MCS-48 family: MCS-51 family: MCS-151 family: MCS-251 family: Introduced in

#62937