Subversion Repositories shark

Rev

Rev 1120 | Rev 1377 | 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
 *
1123 pj 37
 * CVS :        $Id: aster7.c,v 1.2 2003-01-07 17:10:15 pj 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"
53
#include "modules//edf.h"
54
#include "drivers/keyb.h"
55
 
56
int num_aster = 0;
57
#define ASTER_LIM       60
58
#define DISPLAY_MAX     15
59
#define ASTER_MAX       70
60
#define STAT_Y           9
61
 
62
#define APER_MAX         8
63
 
64
/* Pentium 133 / Celeron 366 */
65
#define PER_WCET     25000 /* 7800 */
66
#define APER_WCET     5500 /* 1400 */
67
#define CLOCK_WCET     500 /* 200 */
68
#define ASTER_WCET     500 /* 200 */
69
 
70
#define APER_REP     2200
71
 
72
PID aper_table[APER_MAX];
73
 
74
TASK asteroide(void)
75
{
76
    int i;
77
    int y = rand() % 7 + 1;
78
 
79
    int load1,j;
80
 
81
    char s[2];
82
 
83
    s[0] = '*'; s[1] = 0;
84
 
85
    /*for (;;)*/ {
86
      i = 1;
87
      while (i < ASTER_LIM) {
88
        load1 = 10000; //8000 + rand()%2000;
89
        for (j=0; j<load1; j++) {
90
          s[0] = '*' + rand() % 100;
91
          puts_xy(i,y,rand()%15+1,s);
92
        }
93
 
94
        task_activate(aper_table[rand()%APER_MAX]);
95
        task_endcycle();
96
 
97
        puts_xy(i,y,WHITE," ");
98
        i++;
99
      }
100
    }
101
    num_aster--;
102
    return 0;
103
}
104
 
105
TASK aper_asteroid(void *a)
106
{
107
    int i;
108
    int y = rand() % 7 + 1;
109
 
110
    int load1,j;
111
    int c;
112
 
113
    char s[2];
114
 
115
    c = (int)a;
116
    s[0] = '*'; s[1] = 0;
117
 
118
    for (;;) {
119
      i = 1;
120
      while (i < ASTER_LIM) {
121
        load1 = APER_REP; //8000 + rand()%2000;
122
        for (j=0; j<load1; j++) {
123
          s[0] = '*' + rand() % 100;
124
          puts_xy(i,y,rand()%15+1,s);
125
        }
126
        s[0] = c;
127
        puts_xy(i,y,rand()%15+1,s);
128
 
129
        task_endcycle();
130
 
131
        puts_xy(i,y,WHITE," ");
132
        i++;
133
      }
134
    }
135
}
136
 
137
TASK aster()
138
{
139
    PID p;
140
 
141
    HARD_TASK_MODEL m;
142
    int r;
143
    int x; // adaptive bandwidth...
144
 
145
    hard_task_default_model(m);
146
    hard_task_def_wcet(m,PER_WCET);
147
    hard_task_def_ctrl_jet(m);
148
 
149
    x = 200;
150
 
151
    srand(7);
152
    while (1) {
153
        if (num_aster < ASTER_MAX) {
154
            r = (rand() % 200);
155
 
156
            hard_task_def_arg(m,(void *)((rand() % 7)+1));
157
            hard_task_def_mit(m, (x+r)*1000);
158
            p = task_create("aaa",asteroide,&m,NULL);
159
            if (p == -1)
160
            {
161
              if (x < 500 && errno != ENO_AVAIL_TASK)  x += 1;
162
              printf_xy(62,3,WHITE,"adapt=%3u err=%d",
163
                        iq_query_first(&freedesc),errno);
164
            }
165
            else {
166
              num_aster++;
167
              printf_xy(62,3,WHITE,"adapt=%3u           ",x);//,errno);
168
              task_activate(p);
169
              x /= 2;
170
              if (x<50) x = 50;
171
            }
172
        }
173
        task_endcycle();
174
    }
175
}
176
 
177
TASK clock()
178
{
179
    int s = 0, m = 0;
180
 
181
    while(1) {
182
        printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster);
183
        printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(0));
184
        task_endcycle();
185
 
186
        if (++s > 59) {
187
            s = 0;
188
            m++;
189
        }
190
        printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster);
191
        printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(0));
192
        task_endcycle();
193
    }
194
}
195
 
196
 
197
 
198
/* we consider the first ASTER_MAX + 2 tasks from the PID 2
199
   and plot on the screen the elapsed times... */
200
TASK jetcontrol()
201
{
202
  int i;  /* a counter */
203
  TIME sum, max, curr, last[5];
204
  int nact;
205
  int j; /* the elements set by jet_gettable */
206
  PID p;
207
 
208
 
209
  kern_cli();
210
  printf_xy(0,STAT_Y,WHITE,"PID  Mean T. Max T.  N.A.  Curr.    Last1  Last2  Last3  Last4  Last5");
211
  kern_sti();
212
 
213
  for (;;) {
214
    for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) {
215
       if (jet_getstat(p, &sum, &max, &nact, &curr) == -1) continue;
216
 
217
       for (j=0; j<5; j++) last[j] = 0;
218
       jet_gettable(p, &last[0], 5);
219
       kern_cli();
220
       printf_xy(0,STAT_Y+i+1,WHITE,"%-3d  %-6d  %-6d  %-4d  %-7d  %-5d  %-5d  %-5d  %-5d  %-5d",
221
                 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]);
222
       kern_sti();
223
       i++;
224
    }
225
  }
226
}
227
 
228
 
229
void fine(KEY_EVT *e)
230
{
231
  sys_end();
232
}
233
 
234
 
235
int main(int argc, char **argv)
236
{
237
    PID p1,p2,p3; //,p4,p5,p6;
238
    HARD_TASK_MODEL m;
239
    NRT_TASK_MODEL m_nrt;
240
    SOFT_TASK_MODEL m_aper;
241
    int i;
242
 
243
    KEY_EVT emerg;
244
 
245
    clear();
246
 
247
    cprintf("Press Alt-x to end the demo...");
248
 
249
    //keyb_set_map(itaMap);
250
    emerg.ascii = 'x';
251
    emerg.scan = KEY_X;
252
    emerg.flag = ALTL_BIT;
253
    keyb_hook(emerg,fine);
254
 
255
    hard_task_default_model(m);
256
    hard_task_def_wcet(m,ASTER_WCET);
257
    hard_task_def_mit(m,10000);
258
    hard_task_def_group(m,1);
259
    hard_task_def_ctrl_jet(m);
260
 
261
    nrt_task_default_model(m_nrt);
262
    nrt_task_def_group(m_nrt,1);
263
    nrt_task_def_ctrl_jet(m_nrt);
264
 
265
    p1 = task_create("Aster",aster,&m,NULL);
266
    if (p1 == -1) {
267
        perror("test7.c(main): Could not create task <aster> ...");
268
        sys_end();
269
    }
270
 
271
    hard_task_def_mit(m,500000);
272
    hard_task_def_wcet(m,CLOCK_WCET);
273
    p2 = task_create("Clock",clock,&m,NULL);
274
    if (p2 == -1) {
275
        perror("test7.c(main): Could not create task <Clock> ...");
276
        sys_end();
277
    }
278
 
279
    soft_task_default_model(m_aper);
280
    soft_task_def_ctrl_jet(m_aper);
281
    soft_task_def_level(m_aper, 1);
282
    soft_task_def_group(m_aper,1);
283
    soft_task_def_aperiodic(m_aper);
284
    p3 = task_create("JetControl",jetcontrol,&m_aper,NULL);
285
    if (p3 == -1) {
286
        perror("test7.c(main): Could not create task <JetControl> ...");
287
        sys_end();
288
    }
289
 
290
    soft_task_def_wcet(m_aper,APER_WCET);
291
    soft_task_def_ctrl_jet(m_aper);
292
    soft_task_def_aperiodic(m_aper);
293
 
294
    for (i=0; i<APER_MAX; i++) {
295
      soft_task_def_level(m_aper, i/4 + 3);
296
      soft_task_def_arg(m_aper, (void *)(i/4 ? '' : ''));
297
      aper_table[i] = task_create("aper",aper_asteroid,&m_aper,NULL);
298
      if (aper_table[i] == -1) {
299
        perror("test7.c(main): Could not create task <aper> ...");
300
        sys_end();
301
      }
302
    }
303
 
304
    group_activate(1);
305
    return 0;
306
}
307