0,0 → 1,856 |
//package first_filter; |
|
import java.io.*; |
import java.net.*; |
import java.util.List; |
import java.util.ArrayList; |
import java.util.Iterator; |
import org.jdom.*; |
import org.jdom.input.SAXBuilder; |
import org.jdom.output.XMLOutputter; |
import java.util.regex.*; |
import java.util.Random; |
|
/** |
* <p>Title: First XML filter</p> |
* <p>Description: </p> |
* <p>Copyright: Copyright (c) 2003</p> |
* <p>Company: Retis Lab</p> |
* @author not attributable |
* @version 1.0 |
*/ |
|
public class Application { |
private int numElements = 0; |
final String LOADFILE_DIR="../loadfile/"; |
final String EVENT_DEFINE="event.c"; |
final String ACT_LIST="event.c"; |
private int servernumber=0; |
private timespec simulation_time=new timespec(); |
ArrayList local_scheduler=new ArrayList(); |
ArrayList Task_Section=new ArrayList(); |
private int task_group=0; |
private int task_server=0; |
private int current_scheduler=0; |
|
|
|
//Construct the frame |
public Application() { |
try { |
jbInit(); |
} |
catch(Exception e) { |
e.printStackTrace(); |
} |
} |
//Component initialization |
private void jbInit() throws Exception { |
} |
|
public void process (String url) throws MalformedURLException { |
try { |
// Use SAXBuilder |
SAXBuilder builder = new SAXBuilder("org.apache.xerces.parsers.SAXParser", true); |
builder.setFeature("http://apache.org/xml/features/validation/schema", true); |
|
|
Document doc = builder.build(url); |
Element root = doc.getRootElement(); |
|
try { |
// Funzione per il salvataggio del file XML |
OutputStream fout = new FileOutputStream(EVENT_DEFINE); |
OutputStream bout = new BufferedOutputStream(fout); |
OutputStreamWriter out = new OutputStreamWriter(bout, "8859_1"); |
out.write("\n#include \"func.h\"\n"); |
|
processElement (root,out); |
out.flush(); |
out.close(); |
} catch (UnsupportedEncodingException e) { |
System.out.println("Non sono supportati i caratteri latini"); |
System.exit(1); |
|
} catch (IOException e){ |
System.out.println("Salvatagio fallito"); |
System.exit(1); |
} |
|
|
|
System.out.println ("Total Number of Elements Processed: " |
+numElements); |
} catch (JDOMException e) { |
System.out.println ("JDOM Exception: "+e.getMessage()); |
} catch (java.io.IOException e) { |
System.out.println ("File Exception: "+e.getMessage()); |
|
} |
} |
|
// Recursive Function to Process Elements |
// Prints the Element Name and keeps a running count |
// out total number of elements. |
private void processElement(Element element, OutputStreamWriter out) { |
numElements++; |
String elementName = element.getName(); |
|
System.out.println(elementName); |
List servers = element.getChildren(); |
Iterator iterator = servers.iterator(); |
/* get simulation parameter */ |
Element SimulationInfo = (Element) iterator.next(); |
|
Pattern pattern = Pattern.compile("[us\\s]+"); |
try { |
/*simulation time */ |
|
String[] stime = pattern.split(SimulationInfo.getChild("time").getText()); |
out.write("struct timespec total_time={" + stime[0] + "," + stime[1] + |
"};\n\n"); |
simulation_time.tv_sec = Long.valueOf(stime[0].trim()).longValue(); |
simulation_time.tv_nsec = Long.valueOf(stime[1].trim()).longValue() / |
1000; |
//float f = Float.valueOf(s.trim()).floatValue(); |
/* server section start */ |
out.write("struct loader_contract loader_contract_list[] = {\n"); |
int total_server=0; |
while (iterator.hasNext()) { |
/* get server */ |
Element server = (Element) iterator.next(); |
process_server_section(server, out); |
total_server++; |
} |
|
out.write("};\n\n"); |
|
out.write("int total_loader_contract="+total_server+";\n\n"); |
iterator = local_scheduler.iterator(); |
while (iterator.hasNext()) { |
/* get server */ |
Element loc_sched = (Element) iterator.next(); |
process_scheduler_section(loc_sched, out); |
task_server++; |
} |
|
iterator = Task_Section.iterator(); |
int total_task_section=0; |
out.write("\nstruct loader_task loader_task_list[] = {\n"); |
while (iterator.hasNext()) { |
/* get server */ |
task_class tsk_sec = (task_class) iterator.next(); |
out.write(" {\"" + tsk_sec.name + "\"," + tsk_sec.task_type + "," + |
tsk_sec.contract + |
"," + tsk_sec.localscheduler + "," + tsk_sec.number + "," |
+ tsk_sec.group + ",{" + tsk_sec.deadline.tv_sec + |
"," + |
tsk_sec.deadline.tv_nsec + "}," + "{" + |
tsk_sec.wcet.tv_sec + "," + |
tsk_sec.wcet.tv_nsec + "}," + tsk_sec.act_number + |
",0,act_" + tsk_sec.name + |
",exec_" + tsk_sec.name + "},\n"); |
total_task_section++; |
} |
out.write("};\n\n"); |
out.write("int total_loader_task="+total_task_section+";\n\n"); |
|
|
} |
catch (java.io.IOException e) { |
System.out.println("File Exception: " + e.getMessage()); |
|
} |
|
} |
|
void process_scheduler_section(Element e, OutputStreamWriter out) { |
Attribute t; |
t=e.getAttribute("type"); |
|
List localpars = e.getChildren(); |
Iterator iterator = localpars.iterator(); |
while (iterator.hasNext()) { |
/* get task section */ |
Element loc_task = (Element) iterator.next(); |
process_task_section(loc_task, out, t); |
|
} |
|
} |
|
void process_task_section(Element e, OutputStreamWriter out, Attribute loc) { |
Attribute t; |
int act; |
act=1; |
int task_type=0; |
int localscheduler=0; |
timespec time = new timespec(); |
Pattern pattern = Pattern.compile("[us\\s]+"); |
String scheduler=loc.getValue(); |
if (scheduler.equals("POSIX")) { |
localscheduler=30; |
} |
else if (scheduler.equals("EDF")) { |
localscheduler=31; |
} |
else if (scheduler.equals("RM")) { |
localscheduler=32; |
} |
|
/* get task section */ |
t=e.getAttribute("type"); |
|
if (t.getValue().equals("BackTask")) { |
process_back_task(e, out); |
task_type=23; |
} else if (t.getValue().equals("OneShot")) { |
process_oneshot_task(e, out); |
task_type=21; |
} else if (t.getValue().equals("CyclicalTask")) { |
task_type=22; |
act=process_cyclical_task(e, out); |
} |
|
task_class section=new task_class(); |
section.deadline=new timespec(); |
section.wcet=new timespec(); |
section.name="task"+task_group; |
section.contract=task_server; |
section.group=task_group; |
section.act_number=act; |
section.task_type=task_type; |
section.localscheduler=localscheduler; |
section.number=Integer.valueOf(e.getChild("number").getText()).intValue(); |
|
Element dl = e.getChild("dline"); |
if (dl != null) { |
|
String[] dline=pattern.split(dl.getText()); |
time.tv_sec = Long.valueOf(dline[0]).longValue(); |
time.tv_nsec = Long.valueOf(dline[1]).longValue() * 1000; |
|
section.deadline.tv_sec=time.tv_sec; |
section.deadline.tv_nsec=time.tv_nsec; |
|
} |
|
|
Element wc = e.getChild("wcet"); |
if (wc != null) { |
|
String[] wcet=pattern.split(e.getChild("wcet").getText()); |
time.tv_sec = Long.valueOf(wcet[0]).longValue(); |
time.tv_nsec = Long.valueOf(wcet[1]).longValue() * 1000; |
|
section.wcet.tv_sec=time.tv_sec; |
section.wcet.tv_nsec=time.tv_nsec; |
|
} |
|
Task_Section.add(section); |
task_group++; |
|
} |
|
void process_back_task(Element e, OutputStreamWriter out) { |
|
Pattern pattern = Pattern.compile("[us\\s]+"); |
|
Element act_section=e.getChild("act_section"); |
String[] start_time=pattern.split(act_section.getChild("start_time").getText()); |
Element exec_section=e.getChild("exec_section"); |
|
String[] exec_const=pattern.split(exec_section.getChild("exec_time").getText()); |
try { |
out.write("struct timespec act_task"+task_group+"[]={{"+start_time[0]+","+start_time[1]+"},};\n\n"); |
out.write("struct timespec exec_task"+task_group+"[]={{"+exec_const[0]+","+exec_const[1]+"},};\n\n"); |
|
} |
catch (java.io.IOException ex) { |
System.out.println("File Exception: " + ex.getMessage()); |
|
} |
} |
void process_oneshot_task(Element e, OutputStreamWriter out) { |
Pattern pattern = Pattern.compile("[us\\s]+"); |
|
Element act_section=e.getChild("act_section"); |
String[] start_time=pattern.split(act_section.getChild("start_time").getText()); |
|
Element exec_section=e.getChild("exec_section"); |
String[] exec_const=pattern.split(exec_section.getChild("exec_time").getText()); |
|
try { |
out.write("struct timespec act_task"+task_group+"[]={{"+start_time[0]+","+start_time[1]+"},};\n\n"); |
out.write("struct timespec exec_task"+task_group+"[]={{"+exec_const[0]+","+exec_const[1]+"},};\n\n"); |
} |
catch (java.io.IOException ex) { |
System.out.println("File Exception: " + ex.getMessage()); |
} |
} |
|
int process_cyclical_task(Element e, OutputStreamWriter out) { |
|
int activated=1; |
Pattern pattern = Pattern.compile("[us\\s]+"); |
Element act_section=e.getChild("act_section"); |
String[] start_time=pattern.split(act_section.getChild("start_time").getText()); |
String[] period=pattern.split(act_section.getChild("period_time").getText()); |
Element deltatime=act_section.getChild("delta_time"); |
String[] delta_time; |
|
long act_delta=0; |
timespec delta_act_ts = new timespec(); |
|
if (deltatime != null) { |
delta_time = pattern.split(deltatime.getText()); |
delta_act_ts.tv_sec = Long.valueOf(delta_time[0]).longValue(); |
delta_act_ts.tv_nsec = Long.valueOf(delta_time[1]).longValue() * 1000; |
act_delta = delta_act_ts.TIMESPEC2USEC(); |
} |
|
Element exec_section=e.getChild("exec_section"); |
String[] exec_const=pattern.split(exec_section.getChild("exec_time").getText()); |
Element execdelta=exec_section.getChild("delta_time"); |
String[] exec_delta; |
|
long exec_delta_long = 0; |
timespec exec_delta_ts = new timespec(); |
|
if (execdelta != null) { |
exec_delta=pattern.split(execdelta.getText()); |
exec_delta_ts.tv_sec = Long.valueOf(exec_delta[0]).longValue(); |
exec_delta_ts.tv_nsec = Long.valueOf(exec_delta[1]).longValue() * 1000; |
exec_delta_long = exec_delta_ts.TIMESPEC2USEC(); |
} |
|
try { |
out.write("struct timespec act_task"+task_group+"[]={{"+ |
start_time[0]+","+start_time[1]+"},\n"); |
|
timespec time = new timespec(); |
time.tv_sec = Long.valueOf(period[0]).longValue(); |
time.tv_nsec = Long.valueOf(period[1]).longValue() * 1000; |
|
long usecperiod = time.TIMESPEC2USEC(); |
timespec nextact = new timespec(); |
|
time.tv_sec = Long.valueOf(start_time[0]).longValue(); |
time.tv_nsec = Long.valueOf(start_time[1]).longValue() * 1000; |
|
Random rd = new Random(); |
|
while (simulation_time.TIMESPEC_A_GT_B(time)) { |
|
nextact.tv_sec = Long.valueOf(period[0]).longValue(); |
nextact.tv_nsec = Long.valueOf(period[1]).longValue() * 1000; |
|
if (act_delta != 0) { |
nextact.ADDUSEC2TIMESPEC((rd.nextInt() & Integer.MAX_VALUE) % act_delta - act_delta/2); |
} |
|
time.ADDUSEC2TIMESPEC(usecperiod); |
out.write(" {"+nextact.tv_sec+","+nextact.tv_nsec/1000+"},\n"); |
activated++; |
} |
out.write("};\n"); |
|
out.write("struct timespec exec_task"+task_group+"[]={\n"); |
|
timespec nextexec = new timespec(); |
|
for (int i=0; i<activated; i++) { |
|
nextexec.tv_sec = Long.valueOf(exec_const[0]).longValue(); |
nextexec.tv_nsec = Long.valueOf(exec_const[1]).longValue() * 1000; |
|
if (exec_delta_long != 0) { |
nextexec.ADDUSEC2TIMESPEC((rd.nextInt() & Integer.MAX_VALUE) % exec_delta_long - exec_delta_long/2); |
} |
|
out.write(" {"+nextexec.tv_sec+","+nextexec.tv_nsec/1000+"},\n"); |
|
} |
out.write("};\n"); |
} |
catch (java.io.IOException ex) { |
System.out.println("File Exception: " + ex.getMessage()); |
} |
|
return activated; |
} |
|
void process_server_section(Element e, OutputStreamWriter out) { |
|
|
List serverpars = e.getChildren(); |
Iterator iterator = serverpars.iterator(); |
Element serverpar = (Element) iterator.next(); |
String current_value; |
current_value=serverpar.getText(); |
try { |
out.write("{" + servernumber + ",{"); |
servernumber++; |
|
Pattern pattern = Pattern.compile("[us\\s]+"); |
/* cmin */ |
String[] cmin = pattern.split(current_value); |
out.write(cmin[0] + "," + Long.valueOf(cmin[1]).longValue()*1000+"},{"); |
|
/* tmax */ |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getText(); |
String[] tmax = pattern.split(current_value); |
out.write(tmax[0] + "," + Long.valueOf(tmax[1]).longValue()*1000+"},{"); |
|
/* cmax */ |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getText(); |
String[] cmax = pattern.split(current_value); |
out.write(cmax[0] + "," + Long.valueOf(cmax[1]).longValue()*1000+"},{"); |
|
/* tmin */ |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getText(); |
String[] tmin = pattern.split(current_value); |
out.write(tmin[0] + "," + Long.valueOf(tmin[1]).longValue()*1000+"},"); |
|
/*work load */ |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getText(); |
out.write(current_value+","); |
|
serverpar = (Element) iterator.next(); |
current_value=serverpar.getName(); |
Attribute loc_type=serverpar.getAttribute("type"); |
String scheduler=loc_type.getValue(); |
if (scheduler.equals("POSIX")) { |
out.write("30"); |
} |
else if (scheduler.equals("EDF")) { |
out.write("31"); |
} |
else if (scheduler.equals("RM")) { |
out.write("32"); |
} |
out.write(",-1},\n"); |
local_scheduler.add(servernumber-1,serverpar); |
|
} catch (java.io.IOException ex) { |
System.out.println ("File Exception: "+ex.getMessage()); |
} |
|
/* |
fprintf(file_event_header, " {%d,{%d,%d},{%d,%d},{%d,%d},{%d,%d},%d,%d,-1},\n", |
(int)c->number,(int)c->cmin.tv_sec,(int)c->cmin.tv_nsec, |
(int)c->tmax.tv_sec,(int)c->tmax.tv_nsec, |
(int)c->cmax.tv_sec,(int)c->cmax.tv_nsec, |
(int)c->tmin.tv_sec,(int)c->tmin.tv_nsec, |
(int)c->workload,(int)c->local_scheduler); |
|
*/ |
//processElement (kid); |
} |
|
|
|
public static void main(String[] args) throws Exception { |
System.out.println("Parser Versione 1.0"); |
Application app = new Application(); |
if (args.length > 0) |
app.process(args[0]); |
} |
|
/* Event Generator |
* |
* Giacomo Guidi |
*/ |
|
|
|
|
|
/* |
int write_basic_par_start(void) |
{ |
|
FILE *file_event_header; |
|
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
|
fprintf(file_event_header, "struct loader_task loader_task_list[] = {\n"); |
|
fclose(file_event_header); |
|
return 0; |
|
} |
|
|
int write_basic_par(struct loader_task *c) |
{ |
|
FILE *file_event_header; |
|
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", |
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); |
|
fclose(file_event_header); |
|
return 0; |
|
} |
|
int write_contract(struct loader_contract *c) |
{ |
|
FILE *file_event_header; |
|
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
|
fprintf(file_event_header, " {%d,{%d,%d},{%d,%d},{%d,%d},{%d,%d},%d,%d,-1},\n", |
(int)c->number,(int)c->cmin.tv_sec,(int)c->cmin.tv_nsec, |
(int)c->tmax.tv_sec,(int)c->tmax.tv_nsec, |
(int)c->cmax.tv_sec,(int)c->cmax.tv_nsec, |
(int)c->tmin.tv_sec,(int)c->tmin.tv_nsec, |
(int)c->workload,(int)c->local_scheduler); |
|
fclose(file_event_header); |
|
return 0; |
|
} |
|
int close_loader_task(int total_task_number) |
{ |
|
FILE *file_event_header; |
|
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
|
fprintf(file_event_header,"};\n\n"); |
|
fprintf(file_event_header,"int total_loader_task = %d;\n\n",total_task_number); |
|
fclose(file_event_header); |
|
return 0; |
|
} |
|
int close_loader_contract(int total_contract_number) |
{ |
|
FILE *file_event_header; |
|
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
|
fprintf(file_event_header,"};\n\n"); |
|
fprintf(file_event_header,"int total_loader_contract = %d;\n\n",total_contract_number); |
|
fclose(file_event_header); |
|
return 0; |
|
} |
|
int write_simulation_time(struct timespec *total) |
{ |
|
FILE *file_event_header; |
|
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
|
fprintf(file_event_header,"struct timespec total_time = {%d,%d};\n\n",(int)total->tv_sec,(int)total->tv_nsec); |
|
fclose(file_event_header); |
|
return 0; |
|
|
} |
|
int write_single_act(struct timespec *t, struct loader_task *c) |
{ |
|
FILE *file_act_header; |
|
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
|
if (TIMESPEC_A_GT_B(t,&c->act_par_1)) { |
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d}};\n\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
c->act_number = 1; |
} else { |
fprintf(file_act_header,"struct timespec act_%s[] = {{0,0}};\n\n",c->name); |
c->act_number = 0; |
} |
|
fclose(file_act_header); |
|
return 0; |
|
} |
|
int write_periodic_act(struct timespec *t, struct loader_task *c) |
{ |
|
FILE *file_act_header; |
struct timespec tot_time; |
int period; |
|
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
|
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d},\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
|
c->act_number = 1; |
TIMESPEC_ASSIGN(&tot_time,&c->act_par_1); |
period = TIMESPEC2USEC(&c->act_par_2); |
while (TIMESPEC_A_GT_B(t, &tot_time)) { |
c->act_number++; |
ADDUSEC2TIMESPEC(period,&tot_time); |
fprintf(file_act_header," {%d,%d},\n", |
(int)c->act_par_2.tv_sec,(int)c->act_par_2.tv_nsec); |
} |
|
fprintf(file_act_header," };\n\n"); |
|
fclose(file_act_header); |
|
return 0; |
|
} |
|
int write_mean_act(struct timespec *t,struct loader_task *c) |
{ |
|
FILE *file_act_header; |
struct timespec tot_time; |
int next_act; |
|
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
|
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d},\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
|
c->act_number = 1; |
TIMESPEC_ASSIGN(&tot_time,&c->act_par_1); |
while (TIMESPEC_A_GT_B(t, &tot_time)) { |
c->act_number++; |
next_act = TIMESPEC2USEC(&c->act_par_2) + random() % TIMESPEC2USEC(&c->act_par_3) - TIMESPEC2USEC(&c->act_par_3) / 2; |
ADDUSEC2TIMESPEC(next_act,&tot_time); |
fprintf(file_act_header," {%d,%d},\n", |
next_act / 1000000, next_act % 1000000 * 1000); |
} |
|
fprintf(file_act_header," };\n\n"); |
|
fclose(file_act_header); |
|
return 0; |
|
} |
|
int write_exec_const(struct loader_task *c) |
{ |
|
FILE *file_exec_header; |
int i; |
|
file_exec_header = fopen(ACT_LIST,"a+"); |
if (file_exec_header == NULL) return 1; |
|
fprintf(file_exec_header,"struct timespec exec_%s[] = {{%d,%d},\n",c->name, |
(int)c->exec_par_1.tv_sec,(int)c->exec_par_1.tv_nsec); |
|
for (i=0; i< c->act_number-1; i++) |
fprintf(file_exec_header," {%d,%d},\n", |
(int)c->exec_par_1.tv_sec,(int)c->exec_par_1.tv_nsec); |
|
fprintf(file_exec_header," };\n\n"); |
|
fclose(file_exec_header); |
|
return 0; |
|
} |
|
int write_exec_mean(struct loader_task *c) |
{ |
|
FILE *file_exec_header; |
int exec_time_usec; |
int i; |
|
file_exec_header = fopen(ACT_LIST,"a+"); |
if (file_exec_header == NULL) return 1; |
|
exec_time_usec = TIMESPEC2USEC(&c->exec_par_1) |
+ random() % TIMESPEC2USEC(&c->exec_par_2) - TIMESPEC2USEC(&c->exec_par_2) / 2; |
fprintf(file_exec_header,"struct timespec exec_%s[] = {{%d,%d},\n",c->name, |
exec_time_usec / 1000000, exec_time_usec % 1000000 * 1000); |
|
for (i=0; i< c->act_number-1; i++) { |
exec_time_usec = TIMESPEC2USEC(&c->exec_par_1) |
+ random() % TIMESPEC2USEC(&c->exec_par_2) - TIMESPEC2USEC(&c->exec_par_2) / 2; |
fprintf(file_exec_header," {%d,%d},\n", |
exec_time_usec / 1000000, exec_time_usec % 1000000 * 1000); |
} |
|
fprintf(file_exec_header," };\n\n"); |
|
fclose(file_exec_header); |
|
return 0; |
|
} |
|
void *start; |
void *end; |
|
int main(int argc, char **argv) { |
|
char loadfile[100]; |
struct timespec total_time; |
struct loader_task *start_loader_task = NULL, *current_t; |
struct loader_contract *start_loader_contract = NULL, *current_c; |
int err,ldnum; |
int total_task_number; |
int total_contract_number; |
|
printf("\nEvent Generator\n"); |
|
if (argc < 2) { |
printf("Error: event_gen loadfile.fsf\n"); |
exit(1); |
} |
|
printf("Read loader file %s\n",argv[1]); |
|
sprintf(loadfile,"%s%s",LOADFILE_DIR,argv[1]); |
err = dos_preload(loadfile,100000,&start,&end); |
|
if (err != 0) { |
printf("Error: File not found\n"); |
exit(1); |
} |
|
printf("Parsing file\n"); |
|
line_reader(start, end, &total_time, &start_loader_task, &start_loader_contract); |
|
srandom(time(NULL)); |
|
write_struct(); |
|
current_t = start_loader_task; |
ldnum = 1; |
|
while(current_t != NULL) { |
|
sprintf(current_t->name,"ltask%d",ldnum); |
current_t->group = ldnum; |
ldnum++; |
|
switch (current_t->act_type) { |
case PAR_ACT_SINGLE: |
err = write_single_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
case PAR_ACT_PERIODIC: |
err = write_periodic_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
case PAR_ACT_MEAN: |
err = write_mean_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
} |
|
switch (current_t->exec_type) { |
case PAR_EXEC_CONST: |
err = write_exec_const(current_t); |
if (err != 0) { |
printf("Error writing exec header\n"); |
exit(1); |
} |
break; |
case PAR_EXEC_MEAN: |
err = write_exec_mean(current_t); |
if (err != 0) { |
printf("Error writing exec header\n"); |
exit(1); |
} |
break; |
} |
|
current_t = current_t->next; |
|
} |
|
write_basic_par_start(); |
|
total_task_number = 0; |
current_t = start_loader_task; |
while(current_t != NULL) { |
|
write_basic_par(current_t); |
|
current_t = current_t->next; |
|
total_task_number++; |
|
} |
|
close_loader_task(total_task_number); |
|
write_contract_start(); |
|
total_contract_number = 0; |
current_c = start_loader_contract; |
while(current_c != NULL) { |
|
write_contract(current_c); |
|
current_c = current_c->next; |
|
total_contract_number++; |
|
} |
|
close_loader_contract(total_contract_number); |
|
write_simulation_time(&total_time); |
|
return 0; |
|
} |
|
*/ |
} |