问题标签 [context-switching]

我需要为 ARM Cortex M3/M4 处理器实现一个带有 MPU 的多任务系统。

在该系统中，将有一个内核在特权模式下管理资源，在非特权模式下管理用户应用程序。我想将用户应用程序与其余部分和系统资源分开。

因此，当我切换到新任务时，我正在释放用户应用程序的堆栈和全局内存区域。它可以使用 ARM Cortex MPU 寄存器轻松完成。

但问题是，当发生上下文切换时，我还需要使用内核的一些全局变量。

例如，我在上下文切换期间调用一个函数来获取 PendSV 处理程序中的下一个 TCB，但任务池不在用户应用程序区域，并且它受到用户应用程序的保护。

所以，看起来应该是平衡的，对吧？有哪些安全有效的内存保护策略？

当调用 Yield 函数时，可以在上下文切换之前提升特权模式，但这似乎不是一个好的解决方案。

关于这个问题的一般策略是什么？

每当发生中断时，处理器将当前状态存储在 cpu 寄存器中。在https://en.wikipedia.org/wiki/Process_control_block中提到，当发生上下文切换时，内核会为中断保存 cpu 或硬件寄存器的内容进程在内核中。一种情况是cpu寄存器的当前值保存在cpu本身中，另一种情况是保存在内核中。是否正确？与正常中断相比，上下文切换是否被区别对待？归根结底，这也是一种中断……对吧？

Consider a very old single-core CPU that does not support hardware interrupts, and let's say I want to write a multi-tasked operating system. Using a hardware timer, one can poll an IRQ line in order to determine whether the timer has elapsed, and if so then switch threads/processes.

However, in order to be able to poll, the kernel has to have execution attention by the CPU. For a CPU that supports hardware interrupts, an ISR is called upon an interrupt and (correct me if I'm wrong) if the interrupt is by the context-switch timer, the appropriate ISR calls the kernel code that handles context switching.

If a CPU does not support hardware interrupts (again, correct me if I'm wrong), then the kernel has to repeatedly check for interrupts and the appropriate ISR is called in kernel space.

But, if a user thread is currently in execution on this hypothetical processor, the thread has to manually yield execution to the kernel for it to be able check whether the context-switch is due according to the timer through the appropriate IRQ line. This can be done by calling an appropriate kernel function.

Is there a way to implement non-cooperative multithreading on a single-core processor that only supports software interrupts? Are my thoughts correct, or am I missing something?

我正在研究linux内核。我读到这个，“Linux 的系统调用比许多其他操作系统快，原因是 linux 的快速上下文切换时间。进程的上下文切换非常简单，系统调用处理程序也很简单”。

这是什么意思？？为什么 linux'x 上下文切换比其他操作系统更快？为什么说linux的系统调用处理程序很简单？

我有一个 java 系统做很多 i/o 操作。我确实理解非 CPU 绑定的任务可以从线程数中受益，而不是从 #CPU 中受益。

由于 I/O 操作时间是不确定的（我不知道应该在池中初始化多少线程）。我想测量由于我在 java 程序中初始化的线程数而发生的上下文切换。

最后，由于上下文切换开销，我想调整线程池的大小。

当 CPU 接收到异常时，硬件预处理 将当前 PC 和 PSW 值保存在 RAM 中（或在快速中断的情况下保存在控制寄存器中）并读取向量 跳转到异常处理例程的开始。但是，在异常处理例程中使用的除 PC 和 PSW 之外的通用寄存器和控制寄存器必须在异常处理例程开始时由用户程序代码保存在堆栈中。从异常返回时，用户代码和硬件会重复反向操作。 （参考：瑞萨 Rx62n 硬件手册，第 297 页，章节：例外）

我的问题是这个用于上下文切换的用户代码在哪里以及它是如何被调用的？

我想并行运行 100 个网络（非 CPU 密集型）作业，并想了解最佳方法。

具体来说，是否可以使用 xargs 运行 100 多个作业，有哪些缺点？

我知道有一点需要进行更多的上下文切换，然后是实际的数据包处理。如何理解该点在哪里以及将其最小化的最佳方法是什么？

例如，是否有更好的工具可以使用 xargs 等？

我试图理解java中的内在锁。我有一个程序，我在其中启动 2 个线程，这些线程将循环并在同一个对象上调用同步方法。我希望两个线程并行执行，但看起来它是按顺序执行的。

如果我在循环中引入睡眠，那么它们会以随机顺序执行 [如我所料]

测试代码：

输出：

更新：原始问题已修复。即使在案例 1 中，它看起来也是随机的，但我只有在加载更多迭代（30K）时才会看到它。

那么线程切换在没有睡眠的 for 循环中发生得更少吗？Java-JVM 是否有什么特别之处，它试图让 for-loop 将其作为“某种”原子执行（不完全但尽可能多？）？

在特定 ISR 之后，是否有任何（肮脏的）方法可以引发上下文切换到特定进程？

在正常情况下，在 ISR 之后，被中断的进程将继续运行，我必须等待调度程序选择该特定进程。我想在 ISR 之后立即切换到具体流程。

任何建议都会很棒。谢谢！

我做了一个实验来模拟我们的服务器代码中发生的事情，我启动了 1024 个线程，每个线程都执行一个系统调用，这大约需要 2.8 秒才能在我的机器上完成执行。然后我在每个线程的函数中添加了usleep(1000000)，当我第二次运行相同的程序时，执行时间增加到16s，时间将减少到8s。我想这可能是由 cpu 缓存和 cpu 上下文切换引起的，但我不太清楚如何解释。

此外，避免这种情况发生的最佳实践是什么（稍微增加每个线程的运行时间会导致整个程序性能下降）。

我在这里附上了测试代码，非常感谢您的帮助。