Subversion Repositories or1k

/* sched.h -- Abstract entities header file handling job scheduler

   Copyright (C) 2001 Marko Mlinar, markom@opencores.org

This file is part of OpenRISC 1000 Architectural Simulator.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

#ifndef _SCHED_H_

#define _SCHED_H_

/* Scheduler debug level */

#define SCHED_DEBUG     0

#define SCHED_HEAP_SIZE 128

#define SCHED_TIME_MAX  0x7fffffffffffffffLL

/* Structure for holding one job entry */

struct sched_entry {

  long long time;     /* Clock cycles before job starts */

  void *param;        /* Parameter to pass to the function */

  void (*func)(void *);  /* Function to call when time reaches 0 */

};

/* Heap of jobs */

struct scheduler_struct {

  int size;

  struct sched_entry heap[SCHED_HEAP_SIZE];

};

extern struct scheduler_struct scheduler;

/* Dummy function, representing a guard, which protects heap from

   emptying */

extern void sched_guard (void *);

/* Init scheduler -- clear the heap */

#define SCHED_INIT() {\

        scheduler.heap[1].func = sched_guard;\

        scheduler.heap[1].time = SCHED_TIME_MAX;\

        scheduler.size = 2;\

}

#if SCHED_DEBUG > 1

#define SCHED_PRINT_JOBS() {\

        int i;\

        for (i = 1; i < scheduler.size; i++) \

          PRINTF ("\t%i: %x $%i @ %i\n", i, scheduler.heap[i].func, scheduler.heap[i].param, scheduler.heap[i].time);\

}

#else

#define SCHED_PRINT_JOBS()

#endif

/* Adds new job to the queue */

static inline void sched_add(void (*job_func)(void *), void *job_param,

                             long long job_time, const char *func)

{

  int i;

  if (SCHED_DEBUG > 0)

    PRINTF ("%s@%lli:SCHED_ADD(func %p, param %p, time %lli)\n", func,

            runtime.sim.cycles, job_func, job_param, job_time);

  SCHED_PRINT_JOBS();

  if (SCHED_DEBUG > 1) PRINTF ("--------\n");\

  i = scheduler.size++;

  while (i > 1 && scheduler.heap[i / 2].time > job_time) {

    scheduler.heap[i] = scheduler.heap[i / 2];

    i /= 2;

  }

  scheduler.heap[i].func = job_func;

  scheduler.heap[i].param = job_param;

  scheduler.heap[i].time = job_time;

  SCHED_PRINT_JOBS();

}

#define SCHED_ADD(job_func, job_param, job_time) sched_add(job_func, job_param, job_time, __FUNCTION__)

/* Removes an item from the heap */

#define SCHED_REMOVE_ITEM(index) {\

        struct sched_entry *tmp;\

        int ___i = (index), ___j;\

        if (SCHED_DEBUG > 0) PRINTF ("%s@%i:SCHED_REMOVE%i(time %li)\n", __FUNCTION__, runtime.sim.cycles, (index), scheduler.heap[___i].time); \

        SCHED_PRINT_JOBS();\

        if (SCHED_DEBUG > 1) PRINTF ("--------\n");\

        tmp = &scheduler.heap[--scheduler.size];\

        while (___i <= scheduler.size / 2) {\

          ___j = 2 * ___i;\

          if (___j < scheduler.size && scheduler.heap[___j].time > scheduler.heap[___j + 1].time) ___j++;\

          if (scheduler.heap[___j].time >= tmp->time) break;\

          scheduler.heap[___i] = scheduler.heap[___j];\

          ___i = ___j;\

        }\

        scheduler.heap[___i] = *tmp;\

        SCHED_PRINT_JOBS();\

}

/* Removes first item from the heap */

#define SCHED_REMOVE() SCHED_REMOVE_ITEM(1)

/* Returns item with lowest time in the heap */

#define SCHED_PEEK() scheduler.heap[1]

/* Returns a job with specified function and param, NULL if not found */

#define SCHED_FIND(f, p) ({\

        int i;\

        struct sched_entry *t = NULL;\

        for (i = 1; i < scheduler.size; i++)\

          if (scheduler.heap[i].func == (f) && scheduler.heap[i].param == (p)) {\

            t = &scheduler.heap[i]; break;\

          }\

        tmp;\

})

/* Returns a index of the job with specified function and param, 0 if not found */

#define SCHED_FIND_INDEX(f, p) ({\

        int i, found = 0;\

        for (i = 1; i < scheduler.size; i++)\

          if (scheduler.heap[i].func == (f) && scheduler.heap[i].param == (p)) {\

            found = i; break;\

          }\

        found;\

})

/* Deletes job with specified function and param */

#define SCHED_FIND_REMOVE(f, p) {\

        int index;\

        index = SCHED_FIND_INDEX(f, p);\

        if (index) SCHED_REMOVE_ITEM(index);\

}

#endif /* _SCHED_H_ */