/*
 * Copyright (C) 1998 by the Board of Trustees
 *    of Leland Stanford Junior University.
 * Copyright (C) 1998 Digital Equipment Corporation
 *
 * This file is part of the SimOS distribution.
 * See LICENSE file for terms of the license.
 *
 */


/*
 * Routines for creating and scheduling tasks
 */

#include <stdio.h>

#include "icode.h"
#include "globals.h"
#include "wheel.h"
#include "symtab.h"
#include "hash.h"
#include "aint.h"

/* This is the queue on which blocked tasks are put */
static qnode_t block_q;

task_ptr task_free;
int num_tasks;			/* to help find mem leaks */
task_t active_tasks;		/* head node of list of allocated tasks */
extern hash_tab_ptr func_hash_tab;

/* This is the counter that holds the virtual time */
aint_time_t virtual_time;

/* function prototypes */

void sched_loop ();
int next_event (task_ptr ptask);
int return_advance (task_ptr ptask);
task_ptr unblock_proc (int pid, aint_time_t simtime);
task_ptr pri_sched_task (task_ptr ptask, PFTASK ufunc, aint_time_t simtime,
			 int priority);

void
execute ()
{
    int pid;

    wheel_init ();

    pid = 0;

    /* create a task for the first process to start at time 0 */
    /* need to set its runstate to R_SLEEP to satisfy the consistency check */
    threads[pid].runstate = R_SLEEP;
    unblock_proc (pid, (aint_time_t) 0);

    /* initialize the head node for the blocked queue */
    INLINE_INIT_Q (&block_q);

    sched_loop ();

}

void
sched_loop ()
{
    int advance_thread;
    task_ptr ptask, pnew;

    /* Get the first task */
    INLINE_TASK_EXTRACT (ptask);

    while (1) {
	virtual_time = ptask->time;
	advance_thread = (*ptask->ufunc) (ptask);
	if (advance_thread == T_ADVANCE) {
	    /*
	     * All tasks for this event have completed,
	     * so advance the thread to the next event
	     */
	    if (virtual_time == ptask->time) {
		/*
		 * If the current time is the same, call next_event()
		 * directly, thereby avoiding extra calls to task_insert()
		 * and task_extract()
		 */
		next_event (ptask);

		/* This reschedules the task, so dont free it */

		INLINE_TASK_EXTRACT (ptask);
	    }
	    else {
		/*
		 * The simulator changed the time of ptask so schedule
		 * the next_event() call for that time in the future.
		 */
		ptask->ufunc = next_event;

		/* put this on the time wheel */
		INLINE_TASK_INSERT (ptask);

		/* get the next task */
		INLINE_TASK_EXTRACT (ptask);
	    }
	}
	else if (advance_thread == T_CONTINUE) {
	    /*
	     * If there is a task on the task stack, then schedule it.
	     * otherwise, treat this is a T_ADVANCE, and call next_event().
	     */
	    if (virtual_time == ptask->time) {
		/*
		 * If the current time is the same, call next_event()
		 * directly. First though check the task stack for
		 * pending tasks 
		 */
		pnew = ptask->tstack;
		if (pnew) {
		    /* there are more tasks to execute before the next event */
		    FREE_ITEM (task_free, ptask);
		    pnew->time = virtual_time;
		    INLINE_TASK_INSERT (pnew);

		    INLINE_TASK_EXTRACT (ptask);
		}
		else {
		    /* there are no tasks on the task stack */
		    next_event (ptask);

		    INLINE_TASK_EXTRACT (ptask);
		}
	    }
	    else {
		/*
		 * The simulator changed the time of ptask so schedule 
		 * the next_event() call for that time in the future.
		 */

		/* First, though, check the task stack for pending tasks. */
		pnew = ptask->tstack;
		if (pnew) {
		    /* There are more tasks to execute before the next event */
		    pnew->time = ptask->time;
		    FREE_ITEM (task_free, ptask);
		    ptask = pnew;
		} else {
		    /* there are no tasks on the task stack */
		    ptask->ufunc = next_event;
		}
		INLINE_TASK_INSERT (ptask);

		INLINE_TASK_EXTRACT (ptask);
	    }
	} else /* == T_YIELD */ {
	    /* This was not the task that advances the thread */

	    /* If the last task terminated the last thread, then we're done. */

	    if (nprocs == 0)
		break;

	    if (advance_thread == T_NO_ADVANCE) {
		/* free this task */
		FREE_ITEM (task_free, ptask);
	    }
	    else if (advance_thread >= T_MAX) {
		fatal ("Unexpected return value from back end: %d\n",
		       advance_thread);
	    }
	    /* Get the next task with the minimum time */

	    INLINE_TASK_EXTRACT (ptask);
	}
    }
    if (!wheel_empty ())
	warning ("all processes terminated but not all tasks have"
		 " executed.\n"); 
}



task_ptr
unblock_proc (int pid, aint_time_t simtime)
{
    task_ptr pnew;

    /* Check that the unblocked process is in a consistent state */
    if (threads[pid].runstate != R_SLEEP)
	fatal ("unblock_proc: process %d runstate is %d, not R_SLEEP.\n",
	       pid, threads[pid].runstate);

    /* Create a temporary new task */
    NEW_ITEM (task_free, sizeof (task_t), pnew, "unblock_proc");

    pnew->pevent = threads[pid].pevent;
    pnew->pid = pid;
    pnew->tstack = NULL;
    pnew->ufunc = next_event;
    pnew->time = simtime;
    pnew->priority = DEF_PRIORITY;

    INLINE_TASK_INSERT (pnew);
    return (pnew);
}


/*
 * Create a new task to execute function "ufunc" at time "time",
 * with the specified priority
 */

task_ptr
pri_sched_task (task_ptr ptask, PFTASK ufunc, aint_time_t simtime, 
		int priority) 
{
    task_ptr pnew;

    /* create a temprary new task */
    NEW_ITEM (task_free, sizeof (task_t), pnew, "pri_sched_task");
    pnew->pevent = ptask->pevent;
    pnew->pid = ptask->pid;
    pnew->tstack = ptask->tstack;
    pnew->ufunc = ufunc;
    pnew->time = simtime;
    pnew->priority = priority;

    INLINE_TASK_INSERT (pnew);
    return (pnew);
}


/*
 * Create a new task to execute function "ufunc" at time "simtime",
 * with a default priority.
 */

task_ptr
sched_task (task_ptr ptask, PFTASK ufunc, aint_time_t simtime)
{
    task_ptr pnew;

    /* create a temporary new task */
    NEW_ITEM (task_free, sizeof (task_t), pnew, "sched_task");
    pnew->pevent = ptask->pevent;
    pnew->pid = ptask->pid;
    pnew->tstack = ptask->tstack;
    pnew->ufunc = ufunc;
    pnew->time = simtime;
    pnew->priority = DEF_PRIORITY;

    INLINE_TASK_INSERT (pnew);
    return pnew;
}

/*
 * This function is similar to task_unblock() except that a list of
 * tasks are unblocked instead of a single task. The sim_unblock()
 * fuction is called for each unblocked task with a pointer to that
 * task. The unblocking task continues execution.
 *
 * Thanks to tina@concave.cs.wits.ac.za for finding a bug in this
 * routine.
 */
int
task_unblock_list (task_ptr ptask)
{
    event_ptr pevent, ptmp, next;
    task_ptr unblocked;

    pevent = ptask->pevent;

    /* the events are linked through the next field */
    for (ptmp = pevent->next; ptmp; ptmp = next) {
	next = ptmp->next;

	/* reset the pointer to NULL for the next call to event_unblock_list */
	ptmp->next = NULL;

	unblocked = (task_ptr) ptmp->sptr;

	/* reset the task's time */
	unblocked->time = ptask->time;

	/* take the unblocked task off the blocked queue */
	INLINE_REMOVE (unblocked);

	/* change the event type in case sim_unblock() needs it */
	unblocked->pevent->type = E_UNBLOCK;
	sim_unblock (unblocked);

	/* schedule the newly unblocked task */
	INLINE_TASK_INSERT (unblocked);
    }

    /* reset the pointer to NULL for the next call to event_unblock_list */
    pevent->next = NULL;

    /* advance the unblocking thread */
    return T_ADVANCE;
}


int
task_yield (task_ptr ptask)
{
    return T_ADVANCE;
}

int
task_exit (task_ptr ptask)
{
    return sim_exit (ptask);
}

int
task_terminate (task_ptr ptask)
{
    stack_task (ptask, sim_terminate);
    return task_cleanup (ptask);
}


/*
 * Create a new task to execute whenever ptask returns T_CONTINUE.
 * If ptask does not return T_CONTINUE, then it must have scheduled
 * a task that will eventually return T_CONTINUE. Only one task in a
 * subree of related tasks may return T_CONTINUE. When that occurs, the
 * task stack is popped, and the next task is scheduled. If the stack is
 * empty, then next_event is called.
 */
task_ptr
stack_task (task_ptr ptask, PFTASK ufunc)
{
    task_ptr pnew;

    /* create a temporary new task */
    NEW_ITEM (task_free, sizeof (task_t), pnew, "sched_task");
    pnew->pevent = ptask->pevent;
    pnew->pid = ptask->pid;
    pnew->tstack = ptask->tstack;
    ptask->tstack = pnew;
    pnew->ufunc = ufunc;
    pnew->priority = DEF_PRIORITY;
    return pnew;
}

/*
 * This is called when a thread blocks
 */
int
task_block (task_ptr ptask)
{
    event_ptr pevent;

    sim_block (ptask);

    /*
     * Save the ptask pointer in the pevent structure
     * so that we can find it quickly when we unblock ptask.
     */
    pevent = ptask->pevent;
    pevent->sptr = (void *) ptask;

    /* Change the event to a yield so we don't re-execute this function. */
    ptask->ufunc = task_yield;

    /* Put this task on the blocked queue. */
    INLINE_ENQUEUE ((task_ptr) & block_q, ptask);

    /* return T_YIELD so that the execute_loop doesn't free this task */
    return T_YIELD;
}


/*
 * This is called when a thread blocks for a specified time
 */
int
task_timed_block (task_ptr ptask)
{
    event_ptr pevent;

    sim_block (ptask);
    pevent = ptask->pevent;
    
    /* Schedule the task to run after the specified time */
    ptask->ufunc = next_event;
    ptask->time += pevent->arg1;
    INLINE_TASK_INSERT (ptask);   

    /* return T_YIELD so that the execute_loop doesn't free this task */
    return T_YIELD;
}

/*
 * This function unblocks a task and schedules it. The sim_unblock()
 * function is called with a pointer to the unblocked task. The unblocking
 * task continues execution.
 */
int
task_unblock (task_ptr ptask)
{
    event_ptr pevent;
    task_ptr unblocked;

    pevent = ptask->pevent;
    unblocked = (task_ptr) pevent->pevent->sptr;

    /* reset the task's time */
    unblocked->time = ptask->time;

    /* take the unblocked task off the blocked queue */
    INLINE_REMOVE (unblocked);

    /* change the event type in case sim_unblock() needs it */
    unblocked->pevent->type = E_UNBLOCK;

    /* tell the backend that a task has been unblocked */
    sim_unblock (unblocked);

    /* change the ufunc of the of the unblocked task to next_event */
    unblocked->ufunc = next_event;
    
    /* schedule the newly unblocked task */
    INLINE_TASK_INSERT (unblocked);

    /* advance the unblocking thread */
    return T_ADVANCE;
}

int
task_done (task_ptr ptask)
{
    nprocs--;
    return T_NO_ADVANCE;
}

int 
task_fork (task_ptr ptask)
{
    event_ptr pevent, child_event;
    task_ptr child_task;

    sim_fork (ptask);

    pevent = ptask->pevent;

    /* get a pointer to the child event */
    child_event = pevent->pevent;

    /* allocate and initialize a task for the child */
    NEW_ITEM (task_free, sizeof (task_t), child_task, "task_fork");

    /* use the thread time rather than the task time */
    child_task->time = ptask->time;

    /*
     * This is an oracle specific modification to AINT. Trying to give a
     * larger timeslice to the child
     */
#ifdef ORACLE
    ptask->time += (CLOCKS_PER_SECOND * 2000);
#endif
    
    child_task->priority = 0;
    child_task->pid = child_event->pid;
    child_task->pevent = child_event;

    /* Change the parent's task function so we dont re-execute E_FORK */
    ptask->ufunc = task_yield;

    /* Give the child a yield event since it has no event yet. */
    child_task->ufunc = task_yield;

    /* insert the child task in the task queue */
    INLINE_TASK_INSERT (child_task);

    /* advance the parent */
    return T_ADVANCE;
}


task_ptr
schedule_task (task_ptr pnew)
{
    INLINE_TASK_INSERT (pnew);
    return pnew;
}

/*
 * This function creates a new task and initializes the fields.
 * The function pointer field is also copied. This function may be used
 * by simulators that need to create a task without scheduling it.
 */
task_ptr
new_task (task_ptr ptask)
{
    task_ptr pnew;

    NEW_ITEM (task_free, sizeof (task_t), pnew, "new_task");
    pnew->pevent = ptask->pevent;
    pnew->pid = ptask->pid;
    pnew->ufunc = ptask->ufunc;
    pnew->priority = DEF_PRIORITY;
    pnew->tstack = ptask->tstack;
    return pnew;
}

/*
 * This function creates a new task but does not initialize any fields.
 * The intended use of this function is for creating tasks that are
 * not associated with any process or event and do not return T_ADVANCE.
 */
task_ptr
newtask ()
{
    task_ptr pnew;

    NEW_ITEM (task_free, sizeof (task_t), pnew, "new_task");
    return pnew;
}

void
free_task (task_ptr ptask)
{
    FREE_ITEM (task_free, ptask);
}