Subversion Repositories shark

/*
 * Project: S.Ha.R.K.
 *
 * Coordinators:
 *   Giorgio Buttazzo    <giorgio@sssup.it>
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *
 * Authors     :
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *   (see the web pages for full authors list)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://shark.sssup.it
 */

/**
 ------------
 CVS :        $Id: mymod.c,v 1.1 2004-07-05 14:17:12 pj Exp $

 File:        $File$
 Revision:    $Revision: 1.1 $
 Last update: $Date: 2004-07-05 14:17:12 $
 ------------
**/

/*
 * Copyright (C) 2001 by Paolo Gai
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#include "mymod.h"
#include <ll/string.h>
#include <kernel/model.h>
#include <kernel/descr.h>
#include <kernel/var.h>
#include <kernel/func.h>

// other include files if needed

// NOTE: NO GLOBAL OR STATIC VARIABLES!!!
// (put them inside the level descriptor!)

/* Statuses used in the level */
#define MYMOD_READY         MODULE_STATUS_BASE    
#define MYMOD_WAIT          MODULE_STATUS_BASE+3  
#define MYMOD_IDLE          MODULE_STATUS_BASE+4  

/* the level redefinition for the Module */
typedef struct {
  level_des l;     /* the standard level descriptor          */

  int myvar[100];  /* other local (private) variables of the module */

} MYMOD_level_des;

// example of OSLib event
static void MYMOD_timer_deadline(void *par)
{
  // usually the void *par is a pointer to a structure or a PID
  // if it is a PID, you can do that to retrieve it and the correspondent
  // level descriptor
  PID p = (PID) par;
  MYMOD_level_des *lev;

  lev = (MYMOD_level_des *)level_table[proc_table[p].task_level];

  // now you know the PID of the task and the level descriptor
  // ... so, you know all the things you need
}

static int MYMOD_level_accept_task_model(LEVEL l, TASK_MODEL *m)
{
  // your code here
  return 0; // dummy number
}

static int MYMOD_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
{
  // your code here
  return 0; // dummy number
}

static void MYMOD_level_status(LEVEL l)
{
}

/* The scheduler only gets the first task in the queue */
static PID MYMOD_level_scheduler(LEVEL l)
{
  return 0; // dummy number
}

/* The on-line guarantee is enabled only if the appropriate flag is set... */
static int MYMOD_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
{
  return 0; // dummy number
}

static int MYMOD_task_create(LEVEL l, PID p, TASK_MODEL *m)
{
  return 0; // dummy number
}

static void MYMOD_task_detach(LEVEL l, PID p)
{
}

static int MYMOD_task_eligible(LEVEL l, PID p)
{
  return 0; // dummy number
}

static void MYMOD_task_dispatch(LEVEL l, PID p, int nostop)
{
}

static void MYMOD_task_epilogue(LEVEL l, PID p)
{
}

static void MYMOD_task_activate(LEVEL l, PID p)
{
}

static void MYMOD_task_insert(LEVEL l, PID p)
{
}

static void MYMOD_task_extract(LEVEL l, PID p)
{
}

static void MYMOD_task_endcycle(LEVEL l, PID p)
{
}

static void MYMOD_task_end(LEVEL l, PID p)
{
}

static void MYMOD_task_sleep(LEVEL l, PID p)
{
}

static void MYMOD_task_delay(LEVEL l, PID p, TIME usdelay)
{
}

static int MYMOD_guest_create(LEVEL l, PID p, TASK_MODEL *m)
{
  return 0; // dummy number
}

static void MYMOD_guest_detach(LEVEL l, PID p)
{
}

static void MYMOD_guest_dispatch(LEVEL l, PID p, int nostop)
{
}

static void MYMOD_guest_epilogue(LEVEL l, PID p)
{
}

static void MYMOD_guest_activate(LEVEL l, PID p)
{
}

static void MYMOD_guest_insert(LEVEL l, PID p)
{
}

static void MYMOD_guest_extract(LEVEL l, PID p)
{
}

static void MYMOD_guest_endcycle(LEVEL l, PID p)
{
}

static void MYMOD_guest_end(LEVEL l, PID p)
{
}

static void MYMOD_guest_sleep(LEVEL l, PID p)
{
}

static void MYMOD_guest_delay(LEVEL l, PID p, TIME usdelay)
{
}




/* Registration functions */

/*+ Registration function:
    int flags                 the init flags ... see MYMOD.h +*/
void MYMOD_register_level(int flags)
{
  LEVEL l;            /* the level that we register */
  MYMOD_level_des *lev;  /* for readableness only */
  PID i;              /* a counter */

  /* request an entry in the level_table */
  l = level_alloc_descriptor();

  /* alloc the space needed for the MYMOD_level_des */
  lev = (MYMOD_level_des *)kern_alloc(sizeof(MYMOD_level_des));

  /* update the level_table with the new entry */
  level_table[l] = (level_des *)lev;

  /* fill the standard descriptor */
  strncpy(lev->l.level_name,  MYMOD_LEVELNAME, MAX_LEVELNAME);
  lev->l.level_code               = MYMOD_LEVEL_CODE;
  lev->l.level_version            = MYMOD_LEVEL_VERSION;

  lev->l.level_accept_task_model  = MYMOD_level_accept_task_model;
  lev->l.level_accept_guest_model = MYMOD_level_accept_guest_model;
  lev->l.level_status             = MYMOD_level_status;
  lev->l.level_scheduler          = MYMOD_level_scheduler;
  lev->l.level_guarantee          = MYMOD_level_guarantee;

  lev->l.task_create              = MYMOD_task_create;
  lev->l.task_detach              = MYMOD_task_detach;
  lev->l.task_eligible            = MYMOD_task_eligible;
  lev->l.task_dispatch            = MYMOD_task_dispatch;
  lev->l.task_epilogue            = MYMOD_task_epilogue;
  lev->l.task_activate            = MYMOD_task_activate;
  lev->l.task_insert              = MYMOD_task_insert;
  lev->l.task_extract             = MYMOD_task_extract;
  lev->l.task_endcycle            = MYMOD_task_endcycle;
  lev->l.task_end                 = MYMOD_task_end;
  lev->l.task_sleep               = MYMOD_task_sleep;
  lev->l.task_delay               = MYMOD_task_delay;

  lev->l.guest_create             = MYMOD_guest_create;
  lev->l.guest_detach             = MYMOD_guest_detach;
  lev->l.guest_dispatch           = MYMOD_guest_dispatch;
  lev->l.guest_epilogue           = MYMOD_guest_epilogue;
  lev->l.guest_activate           = MYMOD_guest_activate;
  lev->l.guest_insert             = MYMOD_guest_insert;
  lev->l.guest_extract            = MYMOD_guest_extract;
  lev->l.guest_endcycle           = MYMOD_guest_endcycle;
  lev->l.guest_end                = MYMOD_guest_end;
  lev->l.guest_sleep              = MYMOD_guest_sleep;
  lev->l.guest_delay              = MYMOD_guest_delay;

  /* fill the MYMOD descriptor part */
  for (i=0; i<100; i++)
    lev->myvar[i] = 0;
}

/*+ this function will accept or reject tasks during group creation +*/
int MYMOD_taskaccepted(PID p)
{
}

/*+ returns the current total value +*/
int MYMOD_getvalue(LEVEL l)
{
}


// put here the other interface functions added




/* Interface with the crunch application */

void crunch_register_models(struct multiboot_info *mb);
{
  // here you can register your scheduling modules
}

int crunch_taskaccepted(PID p);
{
  // here maybe you can call MYMOD_taskaccepted()!!!
}

int crunch_getvalue()
{
  // here just return the accumulated value by the modules you used
}