请注意，术语“过程”有时可以参考线程，因为线程有时称为“轻量级过程”，并且基本过程有时称为“重型过程”。对于重量和轻质过程（即线程和实际过程），过程甚至可能是一个通用术语。这是一个非常令人困惑的术语和对语言的滥用（例如，有时用于核心的“处理器”一词）。实际上，在特定上下文中，这通常不是问题，因为线程和过程可以互换使用（在这种情况下，人们应该使用诸如“任务”之类的通用术语）。

至于“ CPU时间切片的可计划单元”，这要复杂一些。一个简单而幼稚的答案是： thread （绝对不是单独处理）。话虽如此，线程是一个软件定义的概念（如过程）。它基本上是一个堆栈，很少的寄存器和父过程（可能有一些元信息和TLS空间）。 CPU不直接在此类数据结构上运行。例如，CPU没有线程堆栈的概念（它只是虚拟过程内存的一部分）。他们只需要由寄存器组成和过程配置组成的执行上下文（在 syultaneous multineReading （aka。 X86物理内核通常由两个可以执行软件线程的两个逻辑线程（即硬件线程）组成。

Clarification: my understanding of "a schedulable unit of CPU time slice" is "a unit that can be scheduled during a given CPU time slice" (since if "schedulable unit" would be a time then the question does not make much sense to me).

Based on this, put it shortly, "a schedulable unit of CPU time slice" for a given logical core can be seen as a software thread (more specifically its execution context composed of registers and process information).

Operating systems scheduler operates on tasks. Tasks can be threads, processes, or other unusual structure (eg. dataflows).

Modern mainstream operating system mainly schedule threads on processing units (typically hardware threads also called logical cores). You can get more information about how the Windows scheduler works in the Microsoft documentation. The documentation explicitly states:

A thread is the entity within a process that can be scheduled for execution

On Linux, the default scheduler, CFS, operates on task (ie. task_struct data structure). Tasks can be a thread, a group of threads or a process. This was done that way so to make the scheduler more generic and also because this scheduler was designed long ago, when processors had only 1 core and people focused on processes rather than thread. The multi-core era since caused applications to use a lot of threads so to use available cores. As a result, nowadays, it is generally threads that are actually scheduled AFAIK. This is explained in the famous research paper The Linux Scheduler: a Decade of Wasted Cores (which also explain a bit how the CFS operate regarding the target processor).

Note that the term "process" can sometime refer to a thread since threads are sometime called "lightweight processes" and basic processes are sometime called "heavy processes". Processes can even be a generic term for both heavy and lightweight processes (ie. threads and actual processes). This is a very confusing terminology and a misuse of language (like the term "processors" sometimes used for cores). In practice, this is often not a problem in a specific context since threads and processes may be used interchangeably though (in such a case, people should use a generic term like "tasks").

As for "a schedulable unit of CPU time slice" this is a bit more complex. A simple and naive answer is: a thread (it is definitively not processes alone). That being said, a thread is a software-defined concept (like processes). It is basically a stack, few registers, and a parent process (with possibly some meta-information and a TLS space). CPUs does not operate directly on such data structure. CPU does not have a concept of thread stack for example (it is just a section of the virtual process memory like any other). They just need an execution context which is composed of registers and a process configuration (in protected mode). For sake of simplicity, we can say that they execute threads. Mainstream modern x86 processors are very complex, and each core is often able to run multiple threads at the same time. This is called simultaneous multithreading (aka. Hyper-Threading for Intel processors). x86 physical cores are typically composed of two logical threads (ie. hardware threads) that can each execute a software threads.

回复收藏 0 原文

初见终念 2025-02-09 18:36:30

我认为您的误解实际上是对英语单词在这种情况下的含义的误解。

时间切片为时间。也许这是一秒钟的一小部分。也许几秒钟。

线程和过程有效地是计算机将要执行的任务。（我在这里简化。任务的概念即使在IT上下文中也具有多种含义。在现代操作系统上，一个过程实际上是共享相同虚拟内存地址空间的线程的集合。）

CPU ¹或处理器是将 run a（本机）线程的硬件。典型的计算机将具有多个CPU。但是，计算机中的每个CPU一次只能在一次上运行一个线程。

因此，操作系统需要安排它知道要在特定CPU上运行的每个线程。操作系统的一部分称为调度程序。

如果要运行的线程多于运行它们，则调度程序通常会将线程安排到CPU固定的时间段内；即时间切片。当线程的时间切片经过时，调度程序将暂停并将其放回队列，然后安排其他线程以在CPU上运行。

隐喻是我们正在“切片” CPU上的可用计算时间，并在需要它的线程之间共享切片。

^{1-关于“ CPU”的实际含义存在分歧。我认为它是指通常称为“核心”的内容。英特尔混乱地介绍了营销术语²“超线程”，该功能是指“核心”的物理硬件可以作为两个独立的指令执行者运行的功能。但是，在超线程模式下，操作系统调度程序通常会对待超线程，就像它们是不同的核心一样，因此这与您的问题无关。

2-超线程背后的实际概念可以追溯到1960年代，然后英特尔甚至作为一家公司就存在。参见 https://en.wikipedia.org/wiki/wiki/barrel_processor 。}

因此，您的问题的答案：

我想澄清“ CPU时间切片的可计划单元”是“过程”还是“线程”（内核托管线程）。

时间片是CPU时间的可计划单元。

时间切片既不是过程也不是线程。确实，这甚至没有意义，因为“过程”和“线程”不是时间。

我同意@Solomon Slow的评论。维基百科不是权威的。但是真正的问题是，随着时间的流逝，不同的人编写和编辑了不同的页面，并且他们经常不一致地使用术语。

我的建议是查找并阅读一本（现代）操作系统设计和建筑的好教科书。写得很好的教科书应该在使用术语方面是自以为是的。

I think your misunderstanding is actually a misunderstanding of what the English words mean in this context.

A time slice is a period of time. Maybe it is a fraction of a second. Maybe a few seconds.

Threads and processes are effectively tasks that the computer is going to perform. (I am simplifying here. The notion of a task has multiple meanings, even in the IT context. And on a modern OS, a process is actually a collection of threads that share the same virtual memory address space.)

The CPU¹ or processor is hardware that will run a (native) thread. A typical computer will have multiple CPUs. However, each CPU in a computer can only run one thread at a time.

The operating system therefore needs to schedule each of the threads it knows about to run on a specific CPU. The part of the operating system that does this is called the scheduler.

If there are more threads to run than CPUs to run them, the scheduler will typically schedule a thread to a CPU for a fixed period of time; i.e a time slice. When the thread's time slice has elapsed, the scheduler will suspend it and put it back into the queue, and then schedule a different thread to run on the CPU.

The metaphor is that we are "slicing up" the available compute time on the CPUs and sharing the slices between the threads that need it.

^{1 - There is some disagreement over what "CPU" actually means. I am taking the view that it refers to what it commonly called a "core". Intel confusingly introduced the marketing term² "hyperthread" which refers to a feature in which the physical hardware of a "core" can run as two independent instruction executors. However, in hyperthread mode, the OS scheduler will typically treat the hyperthreads as if they are distinct cores, so this is not pertinent to your question.

2 - The actual concept behind hyperthreads goes back to the 1960s, before Intel even existed as a company; see https://en.wikipedia.org/wiki/Barrel_processor.}

So the answer to your question:

I want to clarify whether "a schedulable unit of CPU time slice" is "process" or "thread" (kernel managed thread).

A time slice is a schedulable unit of CPU time.

A time slice is neither a process or a thread. Indeed that doesn't even make sense because "process" and "thread" are not time.

I concur with @Solomon Slow's comment. Wikipedia is not authoritative. But the real problem is that different pages are written and edited by different people over time, and they often use IT terminology inconsistently.

My advice would be to find and read One good textbook on (modern) operating system design and architecture. A well-written text book should be self-consistent in its use of terminology.

回复收藏 0 原文

倾城°AllureLove 2025-02-09 18:36:30

时间切片是时间单位，例如，在传统的Linux内核中使用Hz = 100（每秒100个计时器中断）。在CPU核心上运行了这么长时间的任务后，内核重新对该CPU进行了控制，并调用 schedule（）来决定下一步应运行的CPU核心任务；它已经运行的任务或另一个任务。

如果外部中断出现，调度程序也可以更早地运行，尤其是在当前时间的末端附近：如果现在有更高的优先级任务，现在正在等待CPU，例如等待I/O或 Sleep之后（）系统调用结束了，OS将其安排在此核心上是有意义的，而不是完成中断CPU结合任务的时间单板。

任务是调度程序必须从中选择的东西的有用词。不暗示过程中的单独过程或线程，也没有留出空间来完成诸如Linux中断处理程序“下半部”之类的内核任务，而不是线程或过程。

一个过程的每个线程都需要分别安排在CPU核心上执行（如果没有阻止）。

您发现有关调度过程的文章使用的是简化的假设，即每个过程都是单线程。

或者他们假设一个1：n线程模型，其中OS仅知道整个过程的一个任务，并且在用户空间中完成了多线程，” 绿色线程“而不是本机线程。如今，大多数主流OS都使用1：1线程模型，其中每个C ++或Java线程都是OS可见的单独可计划任务，尽管N：m型号在您执行了多个OSSSEDED任务的地方可能是可能的，但不是那么多您有高级语言线程。