preemption

问题 In Kubernetes we can set the priority of a pod to Guaranteed , Burstable or Best-Effort base on requests and limits. Another method to assign priorities in Kubernetes is to define a priorityClass object and assign a priorityClassName to a pod. How are these methods different and when we have to choose one method over another? According to https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/#interactions-of-pod-priority-and-qos: The scheduler’s preemption logic does not

问题 Right now it seems that on every click tick, the running process is preempted and forced to yield the processor, I have thoroughly investigated the code-base and the only relevant part of the code to process preemption is below (in trap.c ): // Force process to give up CPU on clock tick. // If interrupts were on while locks held, would need to check nlock. if(myproc() && myproc() -> state == RUNNING && tf -> trapno == T_IRQ0 + IRQ_TIMER) yield(); I guess that timing is specified in T_IRQ0 +

问题 Right now it seems that on every click tick, the running process is preempted and forced to yield the processor, I have thoroughly investigated the code-base and the only relevant part of the code to process preemption is below (in trap.c ): // Force process to give up CPU on clock tick. // If interrupts were on while locks held, would need to check nlock. if(myproc() && myproc() -> state == RUNNING && tf -> trapno == T_IRQ0 + IRQ_TIMER) yield(); I guess that timing is specified in T_IRQ0 +

问题 I am working on a task scheduler and I would like to use EDF scheduling. The task set I need to schedule contains only tasks with deadlines equal to their periods and the tasks must be scheduled periodically. The problem I have is that the tasks cannot be interrupted once they have started execution. I know that the EDF is an optimal scheduling algorithm only when when tasks are scheduled on a single processor preemptively so I was wondering if there might be any tests or constraints I might

问题 I need to be able to save the state of a Centos-based Google Compute instance when it first receives a preemption signal. The documentation very clearly indicates that a "ACPI G2 Soft Off" signal is sent 30 seconds before a preemptible shutdown. Unfortunately, Google has given no examples to demonstrate how to capture this signal and I have not yet found a way to capture it. My initial attempts have all been focused around the ACPI Interface using the acpid daemon. Using it, I have been able

问题 Say I have this: public void foo(){ CompletableFuture.delayedExecutor(1, TimeUnit.MILLISECONDS).execute(() -> { doSomethingA(); }); doSomethingB(); } Is there any guarantee that doSomethingB(); will always run before doSomethingA();? Something tells me with thread pre-emption , it's possible, although unlikely, that doSomethingA() could be run first? 回答1: No, there is no guarantee, when on a machine which has multiple processors, that doSomethingB() would always execute before doSomethingA().

问题 I'm trying to simulate (very basic & simple) OS process manager subsystem, I have three "processes" (workers) writing something to console (this is an example): public class Message { public Message() { } public void Show() { while (true) { Console.WriteLine("Something"); Thread.Sleep(100); } } } Each worker is supposed to be run on a different thread. That's how I do it now: I have a Process class which constructor takes Action delegate and starts a thread from it and suspends it . public

问题 Similar to this question, I'd like to limit the execution time of a function--preferably with microsecond accuracy--in C. I imagine that C++ exceptions could be used to achieve a result similar to this Python solution. Though it's not ideal, such an approach is wholly unavailable in plain C. I wonder, then, how might I interrupt the execution of a function after a certain time interval in C on a Posix system? For relatively simple situations a bit of silly business works just fine, but that

问题 I'll soon start banging my head on the wall: It's very simple really, I want to measure the time a task spends between 2 points (in Linux - 1 core - 1 CPU). During this time the task must have total control over the CPU and NOT get interrupted by any other task or HW interrupts. To achieve this, I'v created a kernel module to make sure the above criterions are met. In this kernel module I've tried to: First, disable IRQs: I've used spin_lock_irqsave()/spin_lock_irqrestore() - Which i presume

问题 I'm wondering if it's possible to implement preemptive multitasking of native code within a single process in user space on Linux. (That is, externally pause some running native code, save the context, swap in a different context, and resume execution, all orchestrated by user space but using calls that may enter the kernel.) I was thinking this could be done using a signal handler for SIGALRM , and the *context() family but it turns out that the entire *context() family is async-signal