| 0,0 → 1,275 |
|---|
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Giacomo Guidi <giacomo@gandalf.sssup.it> |
| * Mauro Marinoni |
| * Anton Cervin |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| |
| /* |
| * 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 <kernel/model.h> |
| #include <kernel/descr.h> |
| #include <kernel/var.h> |
| #include <kernel/func.h> |
| |
| #include <stdlib.h> |
| |
| #include <modules/elastic.h> |
| |
| #include <tracer.h> |
| |
| #define ELASTIC_EMPTY_SLOT 0 |
| |
| typedef struct { |
| |
| struct timespec dline; |
| |
| TIME Tmin; |
| TIME Tmax; |
| |
| TIME period; |
| TIME wcet; |
| |
| int kelastic; |
| int beta; |
| |
| int nact; |
| |
| int flags; |
| |
| } ELASTIC_task_descr; |
| |
| typedef struct { |
| level_des l; /*+ the standard level descriptor +*/ |
| |
| bandwidth_t U; /*+ the used bandwidth by the server +*/ |
| |
| ELASTIC_task_descr *elist; |
| |
| LEVEL scheduling_level; |
| |
| LEVEL current_level; |
| |
| int flags; |
| |
| } ELASTIC_level_des; |
| |
| static void ELASTIC_activation(ELASTIC_level_des *lev, |
| PID p, |
| struct timespec *acttime) |
| { |
| JOB_TASK_MODEL job; |
| |
| /* |
| job_task_default_model(job, lev->cbs_dline[p]); |
| job_task_def_noexc(job); |
| level_table[ lev->scheduling_level ]-> |
| private_insert(lev->scheduling_level, p, (TASK_MODEL *)&job); |
| |
| */ |
| |
| } |
| |
| /* The on-line guarantee is enabled only if the appropriate flag is set... */ |
| static int ELASTIC_public_guarantee(LEVEL l, bandwidth_t *freebandwidth) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| |
| if (*freebandwidth >= lev->U) { |
| *freebandwidth -= lev->U; |
| return 1; |
| } |
| else |
| return 0; |
| } |
| |
| static int ELASTIC_public_create(LEVEL l, PID p, TASK_MODEL *m) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| ELASTIC_TASK_MODEL *elastic; |
| |
| if (m->pclass != ELASTIC_PCLASS) return -1; |
| if (m->level != 0 && m->level != l) return -1; |
| elastic = (ELASTIC_TASK_MODEL *)m; |
| |
| return 0; /* OK, also if the task cannot be guaranteed... */ |
| |
| } |
| |
| static void ELASTIC_public_detach(LEVEL l, PID p) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| |
| } |
| |
| static int ELASTIC_public_eligible(LEVEL l, PID p) |
| { |
| |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| JOB_TASK_MODEL job; |
| |
| return 0; |
| |
| } |
| |
| static void ELASTIC_public_dispatch(LEVEL l, PID p, int nostop) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| level_table[ lev->scheduling_level ]-> |
| private_dispatch(lev->scheduling_level,p,nostop); |
| } |
| |
| static void ELASTIC_public_epilogue(LEVEL l, PID p) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| JOB_TASK_MODEL job; |
| |
| } |
| |
| static void ELASTIC_public_activate(LEVEL l, PID p, struct timespec *t) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| |
| } |
| |
| static void ELASTIC_public_unblock(LEVEL l, PID p) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| struct timespec acttime; |
| |
| kern_gettime(&acttime); |
| |
| ELASTIC_activation(lev,p,&acttime); |
| |
| } |
| |
| static void ELASTIC_public_block(LEVEL l, PID p) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| |
| level_table[ lev->scheduling_level ]-> |
| private_extract(lev->scheduling_level,p); |
| |
| } |
| |
| static int ELASTIC_public_message(LEVEL l, PID p, void *m) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| |
| switch((long)(m)) { |
| |
| case (long)(NULL): |
| |
| jet_update_endcycle(); /* Update the Jet data... */ |
| TRACER_LOGEVENT(FTrace_EVT_task_end_cycle,(unsigned short int)proc_table[p].context,(unsigned int)l); |
| |
| break; |
| |
| case 1: |
| |
| TRACER_LOGEVENT(FTrace_EVT_task_disable,(unsigned short int)proc_table[p].context,(unsigned int)l); |
| |
| break; |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| static void ELASTIC_public_end(LEVEL l, PID p) |
| { |
| ELASTIC_level_des *lev = (ELASTIC_level_des *)(level_table[l]); |
| |
| level_table[ lev->scheduling_level ]-> |
| private_extract(lev->scheduling_level,p); |
| |
| } |
| |
| /*+ Registration function +*/ |
| LEVEL ELASTIC_register_level(int flags, LEVEL master) |
| { |
| LEVEL l; /* the level that we register */ |
| ELASTIC_level_des *lev; /* for readableness only */ |
| PID i; |
| |
| printk("ELASTIC_register_level\n"); |
| |
| /* request an entry in the level_table */ |
| l = level_alloc_descriptor(sizeof(ELASTIC_level_des)); |
| |
| lev = (ELASTIC_level_des *)level_table[l]; |
| |
| /* fill the standard descriptor */ |
| if (flags & ELASTIC_ENABLE_GUARANTEE) |
| lev->l.public_guarantee = ELASTIC_public_guarantee; |
| else |
| lev->l.public_guarantee = NULL; |
| lev->l.public_create = ELASTIC_public_create; |
| lev->l.public_detach = ELASTIC_public_detach; |
| lev->l.public_end = ELASTIC_public_end; |
| lev->l.public_eligible = ELASTIC_public_eligible; |
| lev->l.public_dispatch = ELASTIC_public_dispatch; |
| lev->l.public_epilogue = ELASTIC_public_epilogue; |
| lev->l.public_activate = ELASTIC_public_activate; |
| lev->l.public_unblock = ELASTIC_public_unblock; |
| lev->l.public_block = ELASTIC_public_block; |
| lev->l.public_message = ELASTIC_public_message; |
| |
| lev->elist = malloc(MAX_PROC * sizeof(ELASTIC_task_descr)); |
| if (lev->elist == NULL) { |
| printk("ELASTIC: Error allocating elastic task decriptor table\n"); |
| sys_end(); |
| } |
| |
| /* fill the CBS descriptor part */ |
| for (i=0; i<MAX_PROC; i++) { |
| NULL_TIMESPEC(&(lev->elist[i].dline)); |
| lev->elist[i].Tmin = 0; |
| lev->elist[i].Tmax = 0; |
| lev->elist[i].period = 0; |
| lev->elist[i].wcet = 0; |
| lev->elist[i].kelastic = 0; |
| lev->elist[i].beta = 0; |
| lev->elist[i].nact = 0; |
| lev->elist[i].flags = ELASTIC_EMPTY_SLOT; |
| } |
| |
| lev->U = 0; |
| |
| lev->scheduling_level = master; |
| |
| lev->current_level = l; |
| |
| lev->flags = flags; |
| |
| return l; |
| } |
| |