Subversion Repositories shark

Rev

Rev 1552 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1120 pj 1
/*
2
 * Project: S.Ha.R.K.
3
 *
4
 * Coordinators:
5
 *   Giorgio Buttazzo    <giorgio@sssup.it>
6
 *   Paolo Gai           <pj@gandalf.sssup.it>
7
 *
8
 * Authors     :
9
 *   Paolo Gai           <pj@gandalf.sssup.it>
10
 *   (see the web pages for full authors list)
11
 *
12
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
13
 *
14
 * http://www.sssup.it
15
 * http://retis.sssup.it
16
 * http://shark.sssup.it
17
 */
18
 
19
/*
20
 * Copyright (C) 2000 Giorgio Buttazzo, Paolo Gai, Massimiliano Giorgi
21
 *
22
 * This program is free software; you can redistribute it and/or modify
23
 * it under the terms of the GNU General Public License as published by
24
 * the Free Software Foundation; either version 2 of the License, or
25
 * (at your option) any later version.
26
 *
27
 * This program is distributed in the hope that it will be useful,
28
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30
 * GNU General Public License for more details.
31
 *
32
 * You should have received a copy of the GNU General Public License
33
 * along with this program; if not, write to the Free Software
34
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
35
 *
36
 *
1583 tullio 37
 * CVS :        $Id: aster7.c,v 1.7 2006-07-03 12:57:05 tullio Exp $
1120 pj 38
 
39
 this is a part of the classic Hartik demo Aster.
40
 
41
 it is based on test 10(A), and test the PS with RM.
42
 
43
 The JetControl is served by a dedicated Polling Server, too.
44
 
45
 There are APER_MAX tasks sleeping, and when an asteroide task finish
46
 the current activation, it activate also an aperiodic task chosen
47
 randomly (if the task chosen is already active, the task_activate do
48
 nothing!)
49
 
50
*/
51
 
52
#include "kernel/kern.h"
1552 pj 53
#include "edf/edf/edf.h"
1120 pj 54
 
1377 giacomo 55
#include <drivers/shark_linuxc26.h>
56
#include <drivers/shark_input26.h>
57
#include <drivers/shark_keyb26.h>
58
 
1120 pj 59
int num_aster = 0;
60
#define ASTER_LIM       60
61
#define DISPLAY_MAX     15
62
#define ASTER_MAX       70
63
#define STAT_Y           9
64
 
65
#define APER_MAX         8
66
 
67
/* Pentium 133 / Celeron 366 */
68
#define PER_WCET     25000 /* 7800 */
69
#define APER_WCET     5500 /* 1400 */
70
#define CLOCK_WCET     500 /* 200 */
71
#define ASTER_WCET     500 /* 200 */
72
 
73
#define APER_REP     2200
74
 
75
PID aper_table[APER_MAX];
76
 
77
TASK asteroide(void)
78
{
79
    int i;
80
    int y = rand() % 7 + 1;
81
 
82
    int load1,j;
83
 
84
    char s[2];
85
 
86
    s[0] = '*'; s[1] = 0;
87
 
88
    /*for (;;)*/ {
89
      i = 1;
90
      while (i < ASTER_LIM) {
91
        load1 = 10000; //8000 + rand()%2000;
92
        for (j=0; j<load1; j++) {
93
          s[0] = '*' + rand() % 100;
94
          puts_xy(i,y,rand()%15+1,s);
95
        }
96
 
97
        task_activate(aper_table[rand()%APER_MAX]);
98
        task_endcycle();
99
 
100
        puts_xy(i,y,WHITE," ");
101
        i++;
102
      }
103
    }
104
    num_aster--;
105
    return 0;
106
}
107
 
108
TASK aper_asteroid(void *a)
109
{
110
    int i;
111
    int y = rand() % 7 + 1;
112
 
113
    int load1,j;
114
    int c;
115
 
116
    char s[2];
117
 
118
    c = (int)a;
119
    s[0] = '*'; s[1] = 0;
120
 
121
    for (;;) {
122
      i = 1;
123
      while (i < ASTER_LIM) {
124
        load1 = APER_REP; //8000 + rand()%2000;
125
        for (j=0; j<load1; j++) {
126
          s[0] = '*' + rand() % 100;
127
          puts_xy(i,y,rand()%15+1,s);
128
        }
129
        s[0] = c;
130
        puts_xy(i,y,rand()%15+1,s);
131
 
132
        task_endcycle();
133
 
134
        puts_xy(i,y,WHITE," ");
135
        i++;
136
      }
137
    }
138
}
139
 
140
TASK aster()
141
{
142
    PID p;
143
 
144
    HARD_TASK_MODEL m;
145
    int r;
146
    int x; // adaptive bandwidth...
147
 
148
    hard_task_default_model(m);
149
    hard_task_def_wcet(m,PER_WCET);
150
    hard_task_def_ctrl_jet(m);
151
 
152
    x = 200;
153
 
154
    srand(7);
155
    while (1) {
156
        if (num_aster < ASTER_MAX) {
157
            r = (rand() % 200);
158
 
159
            hard_task_def_arg(m,(void *)((rand() % 7)+1));
160
            hard_task_def_mit(m, (x+r)*1000);
161
            p = task_create("aaa",asteroide,&m,NULL);
162
            if (p == -1)
163
            {
164
              if (x < 500 && errno != ENO_AVAIL_TASK)  x += 1;
165
              printf_xy(62,3,WHITE,"adapt=%3u err=%d",
166
                        iq_query_first(&freedesc),errno);
167
            }
168
            else {
169
              num_aster++;
170
              printf_xy(62,3,WHITE,"adapt=%3u           ",x);//,errno);
171
              task_activate(p);
172
              x /= 2;
173
              if (x<50) x = 50;
174
            }
175
        }
176
        task_endcycle();
177
    }
178
}
179
 
180
TASK clock()
181
{
182
    int s = 0, m = 0;
183
 
184
    while(1) {
185
        printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster);
1393 giacomo 186
        printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(1));
1120 pj 187
        task_endcycle();
188
 
189
        if (++s > 59) {
190
            s = 0;
191
            m++;
192
        }
193
        printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster);
1393 giacomo 194
        printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(1));
1120 pj 195
        task_endcycle();
196
    }
197
}
198
 
199
 
200
 
201
/* we consider the first ASTER_MAX + 2 tasks from the PID 2
202
   and plot on the screen the elapsed times... */
203
TASK jetcontrol()
204
{
205
  int i;  /* a counter */
206
  TIME sum, max, curr, last[5];
207
  int nact;
208
  int j; /* the elements set by jet_gettable */
209
  PID p;
210
 
211
 
212
  kern_cli();
213
  printf_xy(0,STAT_Y,WHITE,"PID  Mean T. Max T.  N.A.  Curr.    Last1  Last2  Last3  Last4  Last5");
214
  kern_sti();
215
 
216
  for (;;) {
217
    for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) {
218
       if (jet_getstat(p, &sum, &max, &nact, &curr) == -1) continue;
219
 
220
       for (j=0; j<5; j++) last[j] = 0;
221
       jet_gettable(p, &last[0], 5);
222
       kern_cli();
223
       printf_xy(0,STAT_Y+i+1,WHITE,"%-3d  %-6d  %-6d  %-4d  %-7d  %-5d  %-5d  %-5d  %-5d  %-5d",
224
                 p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)curr, (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]);
225
       kern_sti();
226
       i++;
227
    }
228
  }
229
}
230
 
231
 
232
void fine(KEY_EVT *e)
233
{
1547 pj 234
  exit(0);
1120 pj 235
}
236
 
237
 
238
int main(int argc, char **argv)
239
{
240
    PID p1,p2,p3; //,p4,p5,p6;
241
    HARD_TASK_MODEL m;
242
    NRT_TASK_MODEL m_nrt;
243
    SOFT_TASK_MODEL m_aper;
244
    int i;
245
 
246
    KEY_EVT emerg;
247
 
248
    clear();
249
 
1583 tullio 250
    cprintf("Press Ctrl-C to end the demo...");
1120 pj 251
 
1583 tullio 252
    emerg.ascii = 'c';
253
    emerg.scan = KEY_C;
254
    emerg.flag = CNTL_BIT;
1377 giacomo 255
    emerg.status = KEY_PRESSED;
256
    keyb_hook(emerg,fine,FALSE);
1583 tullio 257
 
258
          emerg.flag = CNTR_BIT;
259
    emerg.status = KEY_PRESSED;
260
    keyb_hook(emerg,fine,FALSE);
1120 pj 261
 
262
    hard_task_default_model(m);
263
    hard_task_def_wcet(m,ASTER_WCET);
264
    hard_task_def_mit(m,10000);
265
    hard_task_def_group(m,1);
266
    hard_task_def_ctrl_jet(m);
267
 
268
    nrt_task_default_model(m_nrt);
269
    nrt_task_def_group(m_nrt,1);
270
    nrt_task_def_ctrl_jet(m_nrt);
271
 
272
    p1 = task_create("Aster",aster,&m,NULL);
273
    if (p1 == -1) {
1377 giacomo 274
        sys_shutdown_message("test7.c(main): Could not create task <aster> ...");
1547 pj 275
        exit(1);
1120 pj 276
    }
277
 
278
    hard_task_def_mit(m,500000);
279
    hard_task_def_wcet(m,CLOCK_WCET);
280
    p2 = task_create("Clock",clock,&m,NULL);
281
    if (p2 == -1) {
1377 giacomo 282
        sys_shutdown_message("test7.c(main): Could not create task <Clock> ...");
1547 pj 283
        exit(1);
1120 pj 284
    }
285
 
286
    soft_task_default_model(m_aper);
287
    soft_task_def_ctrl_jet(m_aper);
1393 giacomo 288
    soft_task_def_level(m_aper, 2);
1120 pj 289
    soft_task_def_group(m_aper,1);
290
    soft_task_def_aperiodic(m_aper);
291
    p3 = task_create("JetControl",jetcontrol,&m_aper,NULL);
292
    if (p3 == -1) {
1377 giacomo 293
        sys_shutdown_message("test7.c(main): Could not create task <JetControl> ...");
1547 pj 294
        exit(1);
1120 pj 295
    }
296
 
297
    soft_task_def_wcet(m_aper,APER_WCET);
298
    soft_task_def_ctrl_jet(m_aper);
299
    soft_task_def_aperiodic(m_aper);
300
 
301
    for (i=0; i<APER_MAX; i++) {
1393 giacomo 302
      soft_task_def_level(m_aper, i/4 + 4);
1120 pj 303
      soft_task_def_arg(m_aper, (void *)(i/4 ? '' : ''));
304
      aper_table[i] = task_create("aper",aper_asteroid,&m_aper,NULL);
305
      if (aper_table[i] == -1) {
1377 giacomo 306
        sys_shutdown_message("test7.c(main): Could not create task <aper> ...");
1547 pj 307
        exit(1);
1120 pj 308
      }
309
    }
310
 
311
    group_activate(1);
312
    return 0;
313
}
314