Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1219 → Rev 1218

/demos/trunk/mpegstar/mpegstar.c
36,7 → 36,6
#include "kernel/kern.h"
 
#include "fsf_contract.h"
#include "fsf_server.h"
 
#include "stdlib.h"
#include "unistd.h"
47,13 → 46,12
#include "drivers/keyb.h"
#include "drivers/glib.h"
 
/*Init Server Parameters */
#define SERVER_I_PERIOD 50000
#define SERVER_I_PERIOD 40000
#define SERVER_I_BUDGET 10000
#define SERVER_P_PERIOD 50000
#define SERVER_P_PERIOD 40000
#define SERVER_P_BUDGET 10000
#define SERVER_B_PERIOD 50000
#define SERVER_B_BUDGET 10000
#define SERVER_B_PERIOD 40000
#define SERVER_B_BUDGET 1000
 
struct timespec server_I_period = {0,SERVER_I_PERIOD*1000};
struct timespec server_I_budget = {0,SERVER_I_BUDGET*1000};
65,49 → 63,21
fsf_server_id_t server_I, server_P, server_B;
fsf_contract_parameters_t contract_I, contract_P, contract_B;
 
/* Decoder PID */
pthread_t pI,pP,pB;
 
#define FRAME_I 0
#define FRAME_P 1
#define FRAME_B 2
 
struct decoder_arg {
 
int frame_number;
int frame_type;
void *input_buffer;
void *output_buffer;
int server_id;
 
};
 
typedef struct decoder_arg *decoder_arg_ptr;
 
#define MAX_DECODER_NUMBER 10
 
/* Table of pointer to decoder_ard struct */
decoder_arg_ptr decoder_arg_table[MAX_DECODER_NUMBER];
 
/* Decoder TASK */
TASK decoder(void *arg)
{
 
decoder_arg_ptr darg = (decoder_arg_ptr)(arg);
int i;
 
while(1) {
cprintf("Decoder Start %d\n",exec_shadow);
 
cprintf("Decoder Start %d Frame %d\n",exec_shadow,darg->frame_number);
for (i=0;i<100000;i++);
 
for (i=0;i<100000;i++);
cprintf("Decoder End %d\n",exec_shadow);
 
cprintf("Decoder End %d\n",exec_shadow);
task_endcycle();
 
task_endcycle();
 
}
 
return NULL;
 
}
138,77 → 108,41
 
hard_task_default_model(ht);
 
decoder_arg_table[server_I] = (decoder_arg_ptr)malloc(sizeof(struct decoder_arg));
decoder_arg_table[server_I]->server_id = server_I;
fsf_create_thread(server_I, &pI, NULL, decoder, decoder_arg_table[server_I], &ht);
cprintf("Decoder I PID %d\n",pI);
fsf_create_thread(server_I, &pI, NULL, decoder, NULL, &ht);
cprintf("Server I %d\n",pI);
 
decoder_arg_table[server_P] = (decoder_arg_ptr)malloc(sizeof(struct decoder_arg));
decoder_arg_table[server_P]->server_id = server_P;
fsf_create_thread(server_P, &pP, NULL, decoder, decoder_arg_table[server_P], &ht);
cprintf("Decoder P PID %d\n",pP);
decoder_arg_table[server_B] = (decoder_arg_ptr)malloc(sizeof(struct decoder_arg));
decoder_arg_table[server_B]->server_id = server_B;
fsf_create_thread(server_B, &pB, NULL, decoder, decoder_arg_table[server_B], &ht);
cprintf("Decoder B PID %d\n",pB);
fsf_create_thread(server_P, &pP, NULL, decoder, NULL, &ht);
cprintf("Server P %d\n",pP);
 
fsf_create_thread(server_B, &pB, NULL, decoder, NULL, &ht);
cprintf("Server B %d\n",pB);
 
return 0;
}
 
/* Decoder Manager TASK */
TASK decoder_manager(void *arg) {
int main () {
 
init_mpeg_server();
TIME T,Q;
 
T = 50000;
T = 40000;
Q = 10000;
MPEGSTAR_rescale(server_I,Q,T);
decoder_arg_table[server_I]->frame_number = 0;
decoder_arg_table[server_I]->frame_type = FRAME_I;
task_activate(pI);
T = 100000;
T = 80000;
Q = 10000;
MPEGSTAR_rescale(server_P,Q,T);
decoder_arg_table[server_P]->frame_number = 1;
decoder_arg_table[server_P]->frame_type = FRAME_P;
task_activate(pP);
T = 150000;
Q = 10000;
 
T = 120000;
Q = 1000;
MPEGSTAR_rescale(server_B,Q,T);
decoder_arg_table[server_B]->frame_number = 2;
decoder_arg_table[server_B]->frame_type = FRAME_B;
task_activate(pB);
 
return 0;
}
 
int main () {
 
HARD_TASK_MODEL ht_manager;
PID dm;
 
init_mpeg_server();
 
hard_task_default_model(ht_manager);
hard_task_def_mit(ht_manager,10000);
hard_task_def_wcet(ht_manager,5000);
hard_task_def_arg(ht_manager,NULL);
dm = task_create("Manager", decoder_manager, &ht_manager, NULL);
if (dm == NIL) {
cprintf("Error creating decoder manager\n");
sys_end();
}
 
task_activate(dm);
 
while(1);
 
return 0;
 
}