Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1303 → Rev 1304

/demos/trunk/newtrace/utils/udpdump.c
38,11 → 38,15
 
FILE *output_file;
 
int miss;
 
void close_and_exit()
{
 
printf("Closing...\n");
 
if (miss == 1) printf("Possible error receiving packets !\n");
 
fclose(output_file);
 
exit(0);
51,7 → 55,7
 
int main(int argc, char *argv[])
{
int sd, rc, n, cliLen;
int sd, rc, n, cliLen,count;
struct sockaddr_in cliAddr, servAddr;
char msg[MAX_MSG];
 
90,6 → 94,9
 
signal(SIGINT, close_and_exit);
 
count = 1;
miss = 0;
 
while(1) {
 
printf("Wait packet...\n");
101,6 → 108,13
printf("Received %d, length %d(%d), %d tracer events.\n",
pkt_head->pkt_number, n, pkt_head->size, pkt_head->events);
if (pkt_head->pkt_number != count) {
printf("Miss Packet !!!\n");
miss = 1;
}
 
count++;
 
if(n < 0) {
printf("%s: cannot receive data \n",argv[0]);
continue;
/demos/trunk/newtrace/utils/isolation.c
106,6 → 106,10
 
}
 
if (e->type == 0x25) {
printf("Inheritance S %d E %d A %d\n",e->par[0],e->par[1],e->par[2]);
}
 
//Context Switch
if (e->type == 0x15) {
 
/demos/trunk/loader/loadfile/load.fsf
41,7 → 41,7
# ACT_MEAN(START_TIME, MEAN, DELTA)
#
# CRITICAL SESSION
# CRIT(RES NUMBER, MEAN_START, DELTA_START, MEAN_LEN, DELTA_LEN)
# CRIT(RES NUMBER, BLOCKING_TIME)
# NO_CRIT
#
 
53,7 → 53,7
[0]:[0][3000]:[0][10000]:[0][3000]:[0][10000]:[0]:POSIX;
[1]:[0][6000]:[0][30000]:[0][6000]:[0][30000]:[0]:POSIX;
[2]:[0][3000]:[0][30000]:[0][3000]:[0][30000]:[0]:POSIX;
[3]:[0][6000]:[0][30000]:[0][6000]:[0][30000]:[0]:POSIX;
[3]:[0][3000]:[0][20000]:[0][3000]:[0][20000]:[0]:POSIX;
 
END
 
60,7 → 60,7
TASK SECTION
 
BT:[0]:POSIX:[1]:[0][0]:[0][0]:ACT_SINGLE([1][0]):
:EXEC_CONST([0][16000]):NO_CRIT;
:EXEC_CONST([0][25000]):NO_CRIT;
 
BT:[1]:POSIX:[1]:[0][0]:[0][0]:ACT_SINGLE([2][0]):
:EXEC_CONST([0][16000]):NO_CRIT;
68,8 → 68,8
OS:[2]:POSIX:[1]:[0][0]:[0][0]:ACT_SINGLE([3][0]):
:EXEC_CONST([1][0]):NO_CRIT;
 
BT:[3]:POSIX:[10]:[0][0]:[0][0]:ACT_SINGLE([4][0]):
:EXEC_CONST([0][20000]):NO_CRIT;
BT:[3]:POSIX:[5]:[0][0]:[0][0]:ACT_SINGLE([4][0]):
:EXEC_CONST([0][10000]):NO_CRIT;
 
END
 
/demos/trunk/loader/common/nload.h
19,8 → 19,12
int act_number; //Number of activations precalcolated
int act_current; //Actual activation number
 
int resource;
int muxstatus;
 
struct timespec *act; //Activation list
struct timespec *exec; //Execution time list
struct timespec *block; //Blocking time
 
};
 
/demos/trunk/loader/common/nload.c
79,7 → 79,7
*/
void *periodic_task(void *arg)
{
long long i,exec_cycles = 0;
long long i,exec_cycles = 0,block_cycles = 0;
int act = 0;
struct loader_task *l = (struct loader_task *)(arg);
 
105,13 → 105,38
#endif
exec_cycles = (long long)(TIMESPEC2USEC(&l->exec[l->act_current-1])) * CALIBRATION_DELTA / cal_cycles;
block_cycles = (long long)(TIMESPEC2USEC(&l->block[l->act_current-1])) * CALIBRATION_DELTA / cal_cycles;
 
/* Execution delay */
for (i=0;i<exec_cycles;i++)
__asm__ __volatile__ ("xorl %%eax,%%eax\n\t"
"cpuid\n\t"
:::"eax","ebx","ecx","edx");
if (l->muxstatus == 2) {
#ifdef TASK_OUTPUT
#ifdef OS_SHARK
sprintf(tmp,"C[LOCK%02d]",l->resource);
printf_xy((get_current_exec_task() % 5) * 9 + 34,get_current_exec_task() / 5 + 5, RED, tmp);
#endif
#endif
 
generic_lock_mutex(l->resource);
for (i=0;i<block_cycles;i++)
__asm__ __volatile__ ("xorl %%eax,%%eax\n\t"
"cpuid\n\t"
:::"eax","ebx","ecx","edx");
generic_unlock_mutex(l->resource);
#ifdef TASK_OUTPUT
#ifdef OS_SHARK
sprintf(tmp,"C[FREE%02d]",l->resource);
printf_xy((get_current_exec_task() % 5) * 9 + 34,get_current_exec_task() / 5 + 5, GREEN, tmp);
#endif
#endif
 
}
 
end_job_periodic_task();
 
generic_task_endcycle();
142,7 → 167,7
*/
void *back_task(void *arg)
{
long long i,exec_cycles = 0;
long long i,exec_cycles = 0,block_cycles = 0;
int act = 0;
struct loader_task *l = (struct loader_task *)(arg);
#ifdef TASK_OUTPUT
167,13 → 192,38
#endif
exec_cycles = (long long)(TIMESPEC2USEC(&l->exec[l->act_current-1])) * CALIBRATION_DELTA / cal_cycles;
block_cycles = (long long)(TIMESPEC2USEC(&l->block[l->act_current-1])) * CALIBRATION_DELTA / cal_cycles;
/* Execution delay */
for (i=0;i<exec_cycles;i++)
__asm__ __volatile__ ("xorl %%eax,%%eax\n\t"
"cpuid\n\t"
:::"eax","ebx","ecx","edx");
if (l->muxstatus == 2) {
 
#ifdef TASK_OUTPUT
#ifdef OS_SHARK
sprintf(tmp,"B[LOCK%02d]",l->resource);
printf_xy((get_current_exec_task() % 5) * 9 + 34,get_current_exec_task() / 5 + 5, RED, tmp);
#endif
#endif
 
generic_lock_mutex(l->resource);
for (i=0;i<block_cycles;i++)
__asm__ __volatile__ ("xorl %%eax,%%eax\n\t"
"cpuid\n\t"
:::"eax","ebx","ecx","edx");
generic_unlock_mutex(l->resource);
 
#ifdef TASK_OUTPUT
#ifdef OS_SHARK
sprintf(tmp,"C[FREE%02d]",l->resource);
printf_xy((get_current_exec_task() % 5) * 9 + 34,get_current_exec_task() / 5 + 5, GREEN, tmp);
#endif
#endif
 
}
 
end_job_back_task();
 
act++;
/demos/trunk/loader/shark/func.h
82,6 → 82,19
#define printf cprintf
/* Printf standard function */
 
/* Mutex */
extern __inline__ void generic_lock_mutex(int res) {
extern mutex_t mutex_table[MAX_MUTEX];
 
mutex_lock(&mutex_table[res]);
}
 
extern __inline__ void generic_unlock_mutex(int res) {
extern mutex_t mutex_table[MAX_MUTEX];
mutex_unlock(&mutex_table[res]);
}
 
/* TASK RUNTIME FUNCTIONS */
 
extern __inline__ void start_oneshot_task(void) {}
/demos/trunk/loader/shark/shark.c
9,6 → 9,8
extern int total_loader_task;
extern int total_loader_contract;
 
mutex_t mutex_table[MAX_MUTEX];
 
/* Runtime Calibration */
int calibrate_cycle()
{
103,7 → 105,9
unsigned int k;
SYS_FLAGS f;
sleep(1);
tracer_init_udp(1,"192.168.1.10","192.168.1.1");
 
tracer_create_udp_task(NULL,80);
130,6 → 134,7
 
int i;
struct loader_task *l = loader_task_list;
extern __volatile__ unsigned int TracerEventsPresent;
 
NRT_TASK_MODEL nrt;
 
137,6 → 142,8
 
tracer_disable();
 
cprintf("Total Events Present %d\n",TracerEventsPresent);
 
i = 0;
while (i < total_loader_task) {
167,7 → 174,10
int i;
struct loader_task *l = loader_task_list;
struct timespec end_time;
PI_mutexattr_t a;
 
PI_mutexattr_default(a);
 
i = 0;
 
tracer_initialize(10000000);
180,6 → 190,11
while (i < total_loader_task) {
if (l->muxstatus == 1) {
mutex_init(&mutex_table[l->resource],&a);
l->muxstatus = 2;
}
 
if (l->act_number > 0) {
ADDTIMESPEC(&zero_time, &l->act[0], &end_time);
l->act_current++;
/demos/trunk/loader/shark/shark.h
4,6 → 4,8
#include "nload.h"
#include "lconst.h"
 
#define MAX_MUTEX 20
 
int calibrate_cycle();
void start_simulation();
void *get_task_model(struct loader_task *current);
/demos/trunk/loader/generators/lparser.c
363,30 → 363,8
#ifdef PARSER_DEBUG
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000);
#endif
TIMESPEC_ASSIGN(&ld->crit_par_1,&time);
TIMESPEC_ASSIGN(&ld->crit_par,&time);
} else par_error(line_num);
res = find_break(pbuf,PAR_TIME, &time, &val);
if (res == PAR_FOUND) {
#ifdef PARSER_DEBUG
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000);
#endif
TIMESPEC_ASSIGN(&ld->crit_par_2,&time);
} else par_error(line_num);
res = find_break(pbuf,PAR_TIME, &time, &val);
if (res == PAR_FOUND) {
#ifdef PARSER_DEBUG
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000);
#endif
TIMESPEC_ASSIGN(&ld->crit_par_3,&time);
} else par_error(line_num);
res = find_break(pbuf,PAR_TIME, &time, &val);
if (res == PAR_FOUND) {
#ifdef PARSER_DEBUG
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000);
#endif
TIMESPEC_ASSIGN(&ld->crit_par_4,&time);
} else par_error(line_num);
 
}
#ifdef PARSER_DEBUG
/demos/trunk/loader/generators/event_gen.c
68,15 → 68,25
{
 
FILE *file_event_header;
int muxpres;
char muxtemp[30];
 
file_event_header = fopen(EVENT_DEFINE,"a+");
if (file_event_header == NULL) return 1;
fprintf(file_event_header, " {\"%s\",%d,%d,%d,%d,%d,{%d,%d},{%d,%d},%d,0,act_%s,exec_%s},\n",
if (c->crit_type == PAR_CRIT) {
muxpres = 1;
sprintf(muxtemp,"block_%s",c->name);
} else {
muxpres = 0;
sprintf(muxtemp,"NULL");
}
fprintf(file_event_header, " {\"%s\",%d,%d,%d,%d,%d,{%d,%d},{%d,%d},%d,0,%d,%d,act_%s,exec_%s,%s},\n",
c->name,(int)c->task_type,(int)c->server,(int)c->local_scheduler,(int)c->number,(int)c->group,
(int)c->deadline.tv_sec, (int)c->deadline.tv_nsec,
(int)c->wcet.tv_sec, (int)c->wcet.tv_nsec,
(int)c->act_number, c->name, c->name);
(int)c->act_number, (int)c->resource, muxpres, c->name, c->name, muxtemp);
 
fclose(file_event_header);
 
243,6 → 253,30
}
 
int write_block_const(struct loader_task *c)
{
FILE *file_block_header;
int i;
file_block_header = fopen(ACT_LIST,"a+");
if (file_block_header == NULL) return 1;
fprintf(file_block_header,"struct timespec block_%s[] = {{%d,%d},\n",c->name,
(int)c->crit_par.tv_sec,(int)c->crit_par.tv_nsec);
for (i=0; i< c->act_number-1; i++)
fprintf(file_block_header," {%d,%d},\n",
(int)c->crit_par.tv_sec,(int)c->crit_par.tv_nsec);
fprintf(file_block_header," };\n\n");
fclose(file_block_header);
return 0;
}
 
int write_exec_const(struct loader_task *c)
{
 
385,6 → 419,16
break;
}
 
switch (current_t->crit_type) {
case PAR_CRIT:
err = write_block_const(current_t);
if (err != 0) {
printf("Error writing block header\n");
exit(1);
}
break;
}
 
current_t = current_t->next;
 
}
/demos/trunk/loader/generators/lparser.h
29,10 → 29,7
 
int crit_type;
int resource;
struct timespec crit_par_1;
struct timespec crit_par_2;
struct timespec crit_par_3;
struct timespec crit_par_4;
struct timespec crit_par;
struct loader_task *next;