OSDev.org

ashishkumar4 wrote:Now the help I need is that as I said I have implemented MOST OF IT, I still haven't done much about this step in the algorithm:
"4.If the process voluntarily relinquishes control of the CPU, it leaves the queuing network, and when the process becomes ready again it is inserted at the tail of the same queue which it relinquished earlier."

I don't understand what it means? Please help me with it

ashishkumar4 wrote:With reference to the same on Wikipedia by MollenOS, I have implemented 'almost' most of the Multilevel Feedback queuing and it works as expected. I got 10 queues with highest queue getting smallest timeslice. The scheduler starts always from the top of the highest level queue and goes on searching and coming down until it gets a task in some queue. the the task is assigned the cpu and put at the last of the lower queue if it didn't completed in its timeslice. This is done until it reaches the last queue(base) where it just prempts in round robin fashion until its blocked for some io operation at which it jumps to higher queues thus getting immediate attention of the processor. A new task always arrives at the last of the highest queue and sinks down to the base then. This all works incredibly well with my new context switch algorithm which is less time consuming and simpler with less bugs.

Now the help I need is that as I said I have implemented MOST OF IT, I still haven't done much about this step in the algorithm:
"4.If the process voluntarily relinquishes control of the CPU, it leaves the queuing network, and when the process becomes ready again it is inserted at the tail of the same queue which it relinquished earlier."

I don't understand what it means? Please help me with it

ashishkumar4 wrote:Also in my algorithm, a separate timer keeps on incrementing a variable associated with every task in the BASE queue until it reaches a threshold upon which its put in a higher queue (which happens when the task was in lower priority for too long).
But here is a prob: I need atleast 2 independent timers (one for scheduler, one for this thing). I am currently on single processor systems, and had thought to use PIT as well as APIC separately. But my friend said, its not possible. Then what to do? Here are a few my ideas :generate 2 interrupts separately from a single timer at different points in time. But how? or some other solution?

void timer_IRQ_handler(void) {
    switch(soonest.type) {
        case END_OF_TIME_SLICE:
            handle_end_of_time_slice();
            break;
        case WAKE_SLEEPING_TASKS:
            wake_sleeping_tasks();
            break;
        case INCREASE_PRIORITY_OF_TASKS_THAT_HAVE_BEEN_WAITING_TOO_LONG:
            increase_priority_of_tasks_that_have_been_waiting_too_long();
            break;
    }
    soonest = soonest->next;            // Get "next soonest"
    set_timer_expiry( soonest.time );
}

void handle_end_of_time_slice(void) {
    switch_tasks();
    create_new_timer_event(END_OF_TIME_SLICE, now() + TIME_SLICE_LENGTH );
}

void wake_sleeping_tasks(void) {
    while( (head_of_sleeping_task_list != NULL) && ( head_of_sleeping_task_list->wakeTime <= now() ) ) {
        unblock_task( head_of_sleeping_task_list->taskID );
        head_of_sleeping_task_list = head_of_sleeping_task_list->next;
    }
    if( head_of_sleeping_task_list != NULL) {
        create_new_timer_event(WAKE_SLEEPING_TASKS, head_of_sleeping_task_list->wakeTime );
    }
}

void increase_priority_of_tasks_that_have_been_waiting_too_long(void) {
    for something {
        do stuff;
    }
    create_new_timer_event(INCREASE_PRIORITY_OF_TASKS_THAT_HAVE_BEEN_WAITING_TOO_LONG, now() + whatever );
}

ashishkumar4 wrote:timer_tasks_snippet__0000.html

that html link dosent seems to works. any ways Thanks Brenden and Unnamed for helping.

ashishkumar4 wrote:I have made such a thing called taskSleep() which just makes the task 'sleep' from which it was invoked, indefinitely until some I/o operation for it arrives. Like for example, I do this:
My func()
{
print some thing.
lock the keyboard input (MUTEX and iolock (a thing I made) )
sleep()
///**** from here the task ends for indefinite time, and other tasks are processed as the task gots removed from the queue***///
getline(something)
print it
}

as soon as I press a key, the interrupt Manager (for keyboard for example) puts the task which locked it to highest priority so as the task gets executed Immediately. Thus a Task like GUI app or something of high priority is removed from the queue until input arrives from the user if it required it, and wakes up almost instantly after the interrupt handling of the input interrupt (int 1 for keyboard, which writes to an input buffer)

Is everything right? it seems to work fine on qemu because :/
Thanks