159 lines
3.2 KiB
C
159 lines
3.2 KiB
C
#include <socks/object.h>
|
|
#include <socks/sched.h>
|
|
#include <socks/clock.h>
|
|
#include <socks/cpu.h>
|
|
#include <socks/printk.h>
|
|
#include <socks/machine/thread.h>
|
|
|
|
extern kern_status_t setup_kernel_task(void);
|
|
extern kern_status_t setup_idle_task(void);
|
|
extern kern_status_t task_object_type_init(void);
|
|
extern kern_status_t thread_object_type_init(void);
|
|
|
|
static cycles_t __default_quantum = 0;
|
|
|
|
kern_status_t sched_init(void)
|
|
{
|
|
kern_status_t status = KERN_OK;
|
|
|
|
status = task_object_type_init();
|
|
if (status != KERN_OK) {
|
|
return status;
|
|
}
|
|
|
|
status = thread_object_type_init();
|
|
if (status != KERN_OK) {
|
|
return status;
|
|
}
|
|
|
|
status = setup_kernel_task();
|
|
if (status != KERN_OK) {
|
|
return status;
|
|
}
|
|
|
|
status = setup_idle_task();
|
|
if (status != KERN_OK) {
|
|
return status;
|
|
}
|
|
|
|
struct thread *this_thread = QUEUE_CONTAINER(struct thread, tr_threads, queue_first(&kernel_task()->t_threads));
|
|
struct thread *idle_thread = QUEUE_CONTAINER(struct thread, tr_threads, queue_first(&idle_task()->t_threads));
|
|
|
|
struct cpu_data *this_cpu = get_this_cpu();
|
|
rq_init(&this_cpu->c_rq);
|
|
this_cpu->c_rq.rq_cur = this_thread;
|
|
this_cpu->c_rq.rq_idle = idle_thread;
|
|
put_cpu(this_cpu);
|
|
|
|
start_charge_period();
|
|
|
|
return status;
|
|
}
|
|
|
|
static void expire_timers(struct cpu_data *cpu)
|
|
{
|
|
queue_foreach(struct timer, timer, &cpu->c_timers, t_entry) {
|
|
if (timer->t_expiry <= clock_ticks) {
|
|
timer->t_callback(timer);
|
|
}
|
|
}
|
|
}
|
|
|
|
void context_switch(struct thread *old, struct thread *new)
|
|
{
|
|
if (old->tr_parent->t_pmap != new->tr_parent->t_pmap) {
|
|
pmap_switch(new->tr_parent->t_pmap);
|
|
}
|
|
|
|
switch_to(old, new);
|
|
}
|
|
|
|
void __schedule(enum sched_mode mode)
|
|
{
|
|
struct cpu_data *this_cpu = get_this_cpu();
|
|
struct runqueue *rq = &this_cpu->c_rq;
|
|
|
|
expire_timers(this_cpu);
|
|
|
|
unsigned long flags;
|
|
rq_lock(rq, &flags);
|
|
|
|
put_cpu(this_cpu);
|
|
|
|
struct thread *prev = rq->rq_cur;
|
|
prev->tr_flags &= ~THREAD_F_NEED_RESCHED;
|
|
if (prev->tr_quantum_cycles >= prev->tr_quantum_target) {
|
|
prev->tr_quantum_cycles = 0;
|
|
}
|
|
|
|
enum thread_state prev_state = READ_ONCE(prev->tr_state);
|
|
|
|
if ((mode == SCHED_IRQ || prev_state == THREAD_READY) && prev != rq->rq_idle) {
|
|
rq_enqueue(rq, prev);
|
|
}
|
|
|
|
struct thread *next = rq_dequeue(rq);
|
|
|
|
if (!next) {
|
|
next = rq->rq_idle;
|
|
}
|
|
|
|
if (mode == SCHED_NORMAL) {
|
|
next->tr_state = THREAD_READY;
|
|
}
|
|
|
|
rq->rq_cur = next;
|
|
rq_unlock(rq, flags);
|
|
|
|
if (prev != next) {
|
|
context_switch(prev, next);
|
|
}
|
|
}
|
|
|
|
void schedule(enum sched_mode mode)
|
|
{
|
|
do {
|
|
__schedule(mode);
|
|
} while (need_resched());
|
|
}
|
|
|
|
void start_charge_period(void)
|
|
{
|
|
struct thread *self = current_thread();
|
|
if (!self) {
|
|
return;
|
|
}
|
|
|
|
self->tr_charge_period_start = get_cycles();
|
|
}
|
|
|
|
void end_charge_period(void)
|
|
{
|
|
preempt_disable();
|
|
struct thread *self = current_thread();
|
|
if (!self) {
|
|
return;
|
|
}
|
|
|
|
cycles_t end = get_cycles();
|
|
preempt_enable();
|
|
|
|
cycles_t charge = cycles_diff(self->tr_charge_period_start, end);
|
|
|
|
self->tr_quantum_cycles += charge;
|
|
self->tr_total_cycles += charge;
|
|
|
|
if (self->tr_quantum_cycles >= self->tr_quantum_target) {
|
|
self->tr_flags |= THREAD_F_NEED_RESCHED;
|
|
}
|
|
|
|
self->tr_charge_period_start = 0;
|
|
|
|
//printk("%llu cycles charged to %s/%u", charge, self->tr_parent->t_name, self->tr_parent->t_id);
|
|
}
|
|
|
|
cycles_t default_quantum(void)
|
|
{
|
|
return __default_quantum;
|
|
}
|