/*! Timer interrupt for edf */
static void edf_period_alarm ( sigval_t sigev_value )
{
kthread_t *kthread = sigev_value.sival_ptr, *test;
ksched_t *ksched;
ASSERT ( kthread );
ksched = ksched2_get ( kthread_get_sched_policy (kthread) );
test = kthreadq_remove ( &ksched->params.edf.wait, kthread );
EDF_LOG ( "%x %x [Period alarm]", kthread, test );
if( test == kthread )
{
if ( !edf_check_deadline ( kthread ) )
{
EDF_LOG ( "%x [Waked, moved to edf.ready]", kthread );
kthread_enqueue ( kthread, &ksched->params.edf.ready );
edf_schedule (ksched);
}
/* else => missed deadline -- handle with deadline timer */
}
else {
/*
* thread is not in edf.wait queue, but might be running or its
* blocked - it is probable it missed its deadline, but that
* will be handled with different timer
*/
EDF_LOG ( "%x [Not in edf.wait. Missed deadline?]", kthread );
}
}
/*!
* Deactivate thread because:
* 1. higher priority thread becomes active
* 2. this thread blocks on some queue (not in edf_ready)
*/
static int edf_thread_deactivate ( ksched_t *ksched, kthread_t *kthread )
{
if ( kthread_is_alive (kthread) && !kthread_is_ready (kthread) &&
kthread_get_queue (kthread) != &ksched->params.edf.ready &&
kthread_get_queue (kthread) != &ksched->params.edf.wait )
{
/* if kthread is blocked, but not in edf.ready */
ksched->params.edf.active = NULL;
edf_schedule ( ksched );
}
return 0;
}
static int edf_thread_remove ( ksched_t *ksched, kthread_t *kthread )
{
kthread_sched2_t *tsched = kthread_get_sched2_param ( kthread );
if ( ksched->params.edf.active == kthread )
ksched->params.edf.active = NULL;
if ( tsched->params.edf.period_alarm )
{
ktimer_delete ( tsched->params.edf.period_alarm );
tsched->params.edf.period_alarm = NULL;
}
if ( tsched->params.edf.deadline_alarm )
{
ktimer_delete ( tsched->params.edf.deadline_alarm );
tsched->params.edf.deadline_alarm = NULL;
}
edf_schedule ( ksched );
return 0;
}
int main(int argc, char* argv[]) {
cout<<"beta ="<<beta<<endl;
if (argc < 6) {
cout
<< "invalid format: <tasksets><hyperperiod length><computation utilization><interval> <seed>"
<< endl;
exit(1);
}
#if(MATLAB_ENABLE)
ep =engOpen(NULL);
if(ep==0)
{
cout<<"connection with matlab engine failed"<<endl;
}
#endif
#if (RT_ENABLE)
struct sched_param param;
signal(SIGINT, int_handler);
freq_set(CORE,"performance");
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(1,&mask);
cout<<"setting affinity to processor "<<CORE<<endl;
if(sched_setaffinity(0,CPU_COUNT(&mask),&mask)==-1)
{
perror("sched_setscheduler failed");
exit(-1);
}
param.sched_priority = MY_PRIORITY; //priority for the scheduler
if (sched_setscheduler(0, SCHED_FIFO, ¶m) == -1) { //scheduler has cooporative scheduling
perror("sched_setscheduler failed");
exit(-1);
}
//lock memory
if(mlockall(MCL_CURRENT | MCL_FUTURE)==-1)
{
perror("mlockall failed");
exit(-2);
}
stack_prefault();
#endif
corrected_threshold = corrected_temperature(THRESHOLD);
cout<<"beta "<<beta<<" corrected threshold "<<corrected_threshold<<endl;
// exit(1);
int iter = atoi(argv[1]);
int hyperperiod = atoi(argv[2]);
int comp_util = atoi(argv[3]);
int sched_interval=atoi(argv[4]);
seed = atoi(argv[5]);
string task_file;
if (argc == 7) {
task_file = argv[6];
}
srand(seed);
vector<task> tasks;
vector<schedule> edf;
vector<task> scaled_tasks;
vector<double> speeds;
vector<schedule> edf2;
vector<task> discrete_scaled;
vector<schedule> edf3;
vector<schedule> edl2;
vector<schedule> i_schedule;
vector<schedule> opt;
vector<schedule> opt_exact;
vector<float> possible_speeds;
vector<double> h_speed;
vector<double> s_speed;
vector<double> m_speed;
vector<double> i_speed;
vector<double> i_speed_temp;
vector<slack> slacks;
vector<schedule> edl;
vector<task> scaled_max_first;
vector<task> scaled_static;
vector<task> scaled_matlab;
vector<schedule> edf_max_first;
vector<schedule> edf_static;
vector<schedule> edf_matlab;
for (int z = 0; z < iter; z++) {
thermal_optimal = 0;
// generate_tasksets(&tasks,1,hyperperiod,50,100);
if (argc == 6) {
// generate_tasksets(&tasks, 1, hyperperiod, comp_util, comp_util);
} else {
read_tasksets(&tasks, task_file);
}
int_pointer=&tasks;
#if(OPT_ENABLE)
call_gams();
store_opt(&tasks);
#endif
double t_util;
// edf_schedule(&tasks, &edf);
// consolidate_schedule(&edf, &tasks);
thermal_optimal = 1;
// compute_profile(&edf, &tasks, t_util);
// edl_schedule2(&edl2, &edf);
// consolidate_schedule(&edl2, &tasks);
// populate_slacks(&slacks, &edf);
// edl_schedule(&edl, &edf, &tasks, &slacks);
// consolidate_schedule(&edl, &tasks);
#if(INST_ENABLE)
cout<<"entering optimize instances"<<endl;
vector<int>slack;
optimize_instances(&i_speed,&tasks,&i_schedule,&edl, &edl2,MIN_SPEED,MAX_SPEED,&i_speed_temp,&slack);
cout<<"exiting optimize instances"<<endl;
cout<<"printing optimal schedule"<<endl;
for(unsigned int i=0;i<i_schedule.size();i++)
{
cout<<"task "<<i_schedule[i].task_id<<" start "<<i_schedule[i].start<<" end "<<i_schedule[i].end
<<" speed "<<i_speed[i]<<" power "<<tasks[i_schedule[i].task_id].power*pow(i_speed[i],3.0)<<
" slack "<<slack[i]<<" deadline "<<(i_schedule[i].start/tasks[i_schedule[i].task_id].period+1)*tasks[i_schedule[i].task_id].period<<endl;
}
verify(&i_schedule,&tasks,&i_speed);
#endif
#if(SLACK_ENABLE)
verify(&edl, &tasks);
opt_schedule_exact(&opt_exact, &tasks);
opt_schedule(&opt, &tasks, &edl);
#endif
#if(MAX_ENABLE)
vector<float_task>ft;
vector<long_task>ltasks;
vector<long_schedule>lschedule;
vector<long_schedule>lschedule2;
vector<long_schedule>lschedule3;
vector<float_schedule>wsch;
vector<float_schedule>wsch2;
vector<float_schedule>wsch3;
vector<float_schedule>fedf;
vector<schedule>o_sch;
vector<interval_s>intervals;
// cout<<"generating task set "<<endl;
float thermal_util=0.98;
float computation_util=1.0;
int num_tasks=rand() % (11) + 10;
// generate_taskset(&ft, 1000, num_tasks,computation_util, thermal_util);
// w2fq_task_convert(<asks, &ft);
// generate_intervals_gps(&intervals, <asks);/
// w2fq_schedule(&lschedule, <asks,&intervals,0);
// edf_schedule(&ft,&fedf);
// w2fq_schedule_convert(&wsch, &lschedule);
//cout<<" printing float schedule "<<endl;
// compute_profile(&wsch, &ft, 1);
// compute_profile(&fedf, &ft, 4);
// instance_override(&ft);
// dynamic_instance_schedule(&lschedule2, <asks,&intervals,1);
// w2fq_schedule_convert(&wsch2, &lschedule2);
// compute_profile(&wsch2, &ft, 2);
// dynamic_instance_schedule(&lschedule3, <asks,&intervals,2);
// w2fq_schedule_convert(&wsch3, &lschedule3);
// compute_profile(&wsch3, &ft, 3);
ft.clear();
ltasks.clear();
lschedule.clear();
fedf.clear();
wsch.clear();
float power;
power=rand()/(float)RAND_MAX*20.00;
power=power+18.00;
cout<<power<<endl;
float comp_util=1.5;//0.6;
ofstream taskfile("taskset_file");
int ** matrix;
matrix = new int *[20];
for(unsigned int i=0;i<20;i++)
{
matrix[i] =new int[20];
}
resource_matrix(matrix,20,0.5);
stringstream command;
generate_taskset_multi(&ft, 100, 15,2.0);
gams_include(&ft, matrix);
ofstream tasksetfile("taskset");
for(unsigned int i=0;i<ft.size();i++)
{
tasksetfile<<"task"<<i<<"\t"<<ft[i].computation_time<<"\t"<<ft[i].period<<"\t"<<ft[i].power<<endl;
}
tasksetfile.close();
vector<instance>inst;
vector<interval>speed_intervals;
vector<long_schedule>lsch;
generate_intervals_multi(&speed_intervals, "instanceassign_speed.put");
for(unsigned int i=0;i<speed_intervals.size();i++)
{
cout<<"start "<<speed_intervals[i].start<<" end "<<speed_intervals[i].end<<endl;
for(unsigned int j=0;j<speed_intervals[i].get_size();j++)
{
cout<<"task "<<speed_intervals[i].exec[j].task<<"|"<<speed_intervals[i].exec[j].exec<<"|"<<speed_intervals[i].exec[j].core<<endl;
}
}
//exit(1);
instance_override_speed(&ft, &inst);
w2fq_task_convert(<asks, &ft);
dynamic_instance_schedule_speed(&lsch, <asks, &speed_intervals, &inst,0);
// vector<long_schedule>lsch2;
// dynamic_instance_schedule_speed(&lsch2, <asks, &speed_intervals, &inst,0);
float scaled_power[CORE];
double avg_power;
generate_power_trace(&lsch, "power_profile_scaled", hyperperiod, scaled_power);
multi_simulate("power_profile_scaled", "multi.flp",0,avg_power);
// dynamic_instance_schedule
exit(1);
float comps[CORE];
for(unsigned int i=0;i<speed_intervals.size();i++)
{
for(unsigned int j=0;j<CORE;j++)
{
comps[j]=0;
}
for(unsigned int j=0;j<speed_intervals[i].get_size();j++)
{
comps[speed_intervals[i].exec[j].core]=comps[speed_intervals[i].exec[j].core]+
speed_intervals[i].exec[j].exec;
}
cout<<speed_intervals[i].start<<"|"<<speed_intervals[i].end<<"|"<<comps[0]<<"|"<<comps[1]<<"|"<<comps[2]<<endl;
}
exit(1);
float bins[BIN_LENGTH]={0.5,0.6,0.7,0.8,0.9,1.0,1.1};
int bin_count[BIN_LENGTH]={0,0,0,0,0,0,0};
int task_num=0;
bool tutil_incomplete=true;
while(comp_util<3.0)//1.0)
{
cout<<"generating for computil"<<comp_util<<endl;
tutil_incomplete=true;
for(unsigned int b=0;b<BIN_LENGTH;b++)
{
bin_count[b]=0;
}
while(tutil_incomplete)
{
//cout<<" task num "<<task_num<<endl;
//generate_taskset(&ft, 100, 10, comp_util);
generate_taskset_multi(&ft, 100, 15,comp_util);
float avg_power=0.00;
float real_cutil=0.00;
for(unsigned int i=0;i<ft.size();i++)
{
avg_power=avg_power+ft[i].computation_time/ft[i].period*ft[i].power;
real_cutil=real_cutil+ft[i].computation_time/ft[i].period;
}
float tutil=avg_power/(beta*corrected_threshold);//UTIL_POWER;
bool accept=false;
for(unsigned int b=0;b<BIN_LENGTH;b++)
{
if(tutil> bins[b] && tutil<(bins[b]+0.1) && bin_count[b]<10)
{
accept=true;
bin_count[b]=bin_count[b]+1;
}
}
if(accept)
{
/*if(tutil<0.6 && comp_util>0.75)
{
ofstream tasksetfile("taskset");
for(unsigned int i=0;i<ft.size();i++)
{
tasksetfile<<"task"<<i<<"\t"<<ft[i].computation_time<<"\t"<<ft[i].period<<"\t"<<ft[i].power<<endl;
}
taskfile<<real_cutil<<"\t"<<tutil<<endl;
//w2fq_task_convert(<asks, &ft);
//generate_intervals_gps(&intervals, <asks);
//w2fq_schedule(&lschedule, <asks,&intervals,0);
//edf_schedule(&ft,&fedf);
//w2fq_schedule_convert(&wsch, &lschedule);
//cout<<" printing float schedule "<<endl;
//compute_profile(&wsch, &ft, 1);
//compute_profile(&fedf, &ft, 4);
//command<<"mkdir results_uni/"<<task_num<<";";
//command<<"cp profile_float results_uni/"<<task_num<<"/.;";
//command<<"cp profile_default results_uni/"<<task_num<<"/.;";
//command<<"cp taskset results_uni/"<<task_num<<"/.";
//system(command.str().c_str());
//command.str("");
tasksetfile.close();
//exit(1);
}*/
//cout<<"checkpoint 1 "<<endl;
gams_include(&ft, matrix);
//cout<<"checkpoint 2 "<<endl;
system("cd gams_files; ~rehan/gams/gams lower_bound.gms");
system("cd gams_files; ~rehan/gams/gams task_assign.gms");
command<<"mkdir results/"<<task_num<<";";
command<<"cp gams_files/results.put results/"<<task_num<<"/.;";
command<<"cp gams_files/taskassign.put results/"<<task_num<<"/.;";
command<<"cp gams_files/taskassign_assign.put results/"<<task_num<<"/.;";
command<<"cp gams_files/task_assign.lst results/"<<task_num<<"/.;";
command<<"cp gams_files/lower_bound.lst results/"<<task_num<<"/.;";
command<<"cp gams_files/taskset.put results/"<<task_num<<"/.";
system(command.str().c_str());
command.str("");
//cin.get();
//exit(1);
task_num=task_num+1;
tutil_incomplete=false;
for(unsigned int b=0;b<BIN_LENGTH;b++)
{
if(bin_count[b]<10)
{
tutil_incomplete=true;
}
}
//exit(1);
}
intervals.clear();
lschedule.clear();
ltasks.clear();
fedf.clear();
wsch.clear();
ft.clear();//only ft needs to be cleared for multicore simulation
}
//comp_util=comp_util+0.0025;//0.01;
comp_util=comp_util+0.01;//0.01;
}
exit(1);
/*
int task_num=0;
while(comp_util<3.0)
{
for(unsigned int m=0;m<10;m++)
{
generate_taskset_multi(&ft, 100, 15,comp_util);
float avg_power=0.00;
float real_cutil=0.00;
for(unsigned int i=0;i<ft.size();i++)
{
avg_power=avg_power+ft[i].computation_time/ft[i].period*ft[i].power;
real_cutil=real_cutil+ft[i].computation_time/ft[i].period;
}
float tutil=avg_power/UTIL_POWER;
if(tutil>0.5 && tutil<1.2)
{
taskfile<<real_cutil<<"\t"<<tutil<<endl;
cout<<"checkpoint 1 "<<endl;
gams_include(&ft, matrix);
cout<<"checkpoint 2 "<<endl;
system("cd gams_files; ~rehan/gams/gams lower_bound.gms");
system("cd gams_files; ~rehan/gams/gams task_assign.gms");
command<<"mkdir results/"<<task_num<<";";
command<<"cp gams_files/results.put results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/taskassign.put results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/taskassign_assign.put results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/task_assign.lst results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/lower_bound.lst results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/taskset.put results/"<<atoi(argv[5])<<"/.";
system(command.str().c_str());
command.str("");
task_num=task_num+1;
}
ft.clear();
}
comp_util=comp_util+0.001;
}
/*
exit(1);
// generate_taskset_multi(&ft, 100, 8,2.5, power);
//read_taskset_multi(&ft, "gams_folder/taskset.put");
float cutil=0;
float tutil=0;
for(unsigned int i=0;i<ft.size();i++)
{
cout<<"task "<<i<<" computation time "<<ft[i].computation_time<<" period "
<<ft[i].period<<" power "<<ft[i].power<<" comp util "<<ft[i].computation_time/ft[i].period
<<" thermal util "<<ft[i].computation_time*ft[i].power/(ft[i].period*beta*corrected_threshold)<<endl;
cutil=cutil+ft[i].computation_time/ft[i].period;
tutil=tutil+ft[i].computation_time*ft[i].power/(ft[i].period*beta*corrected_threshold);
}
cout<<" computation utilization "<<cutil<<" thermal utilization "<<tutil<<endl;
int int_size=gams_include(&ft, matrix);
populate_beta();
for(unsigned int i=0;i<CORE;i++)
{
for(unsigned int j=0;j<CORE;j++)
{
cout<<beta_multi[i][j]<<"\t";
}
cout<<endl;
}
system("cd gams_files; ~rehan/gams/gams task_assign.gms");//
//system("cd gams_files; ~rehan/gams/gams instance_assign.gms");//
//vector<trace>ttrace;
// read_ttrace("hotspot_files/thermal_profile", &ttrace);
intervals.clear();
vector<mprofile>prof;
generate_intervals_multi(&intervals,"gams_files/taskassign.put", &ft);
vector<long_schedule>multi_sch;
ltasks.clear();
w2fq_task_convert(<asks, &ft);
multi_schedule(&multi_sch,&intervals, <asks);
long hyperperiod=compute_lcm(<asks);
float avg_power[CORE];
generate_power_trace(&multi_sch, "power_profile", hyperperiod, avg_power);
generate_power_profile(&prof,&multi_sch, hyperperiod);
cout<<"power profile length "<<prof.size()<<endl;
double average_power;
for(unsigned int i=0;i<ltasks.size();i++)
{
average_power=average_power+(((double)ltasks[i].computation_time)/((double)ltasks[i].period))*ltasks[i].power;
}
//compute_profile_multi(&multi_sch, <asks);
//exit(1);
// multi_simulate("power_profile", "multi.flp",0,average_power);
exit(1);
multi_sch.clear();
intervals.clear();
generate_intervals_multi(&intervals,"gams_files/instanceassign.put", &ft);
multi_schedule(&multi_sch,&intervals, <asks);
generate_power_trace(&multi_sch, "power_profile", hyperperiod, avg_power);
//multi_simulate("power_profile", "multi.flp",1);
// exit(1);
system(command.str().c_str());
for(unsigned int i=0;i<intervals.size();i++)
{
cout<<" start "<<intervals[i].start<<" end "<<intervals[i].end<<endl;
for(unsigned int k=0;k<CORE;k++)
{
cout<<" core"<<k<<": ";
int total=0;
float average_power=0;
for(unsigned int j=0;j<ft.size();j++)
{
cout<<intervals[i].computations[j][k]<<" ";
total=total+intervals[i].computations[j][k];
average_power=average_power+((float)intervals[i].computations[j][k])*ft[j].power/((float)(intervals[i].end-intervals[i].start));
}
assert(total<=(intervals[i].end-intervals[i].start));
cout<<" total "<<total<<" average power "<<average_power<< endl;
}
}
cout<<endl<<endl;
for(unsigned int i=0;i<multi_sch.size();i++)
{
// cout<<"task "<<multi_sch[i].task_id<<" start "<<multi_sch[i].start<<" end "<<multi_sch[i].end<<" core "<<multi_sch[i].core<<endl;
}
//avg_power=(float*)malloc(sizeof(float)*CORE);
cout<<" printing average power"<<endl;
for(unsigned int i=0;i<CORE;i++)
{
cout<<"core"<<i<<" average power "<<avg_power[i]<<endl;
}
total_comps(&multi_sch,<asks,&intervals);
// exit(1);
// void w2fq_schedule(vector<long_schedule>*sch, vector<long_task>*tasks, vector<interval>*intervals, int core)
/* while(computation_util<=1.0)
{
thermal_util=0.99;
while(thermal_util<=1.0)
{
generate_taskset(&ft, 1000, computation_util, thermal_util);
w2fq_task_convert(<asks, &ft);
w2fq_schedule(&lschedule, <asks);
edf_schedule(&ft,&fedf);
w2fq_schedule_convert(&wsch, &lschedule);
//cout<<" printing float schedule "<<endl;
compute_profile(&wsch, &ft, 1);
compute_profile(&fedf, &ft, 2);
ft.clear();
ltasks.clear();
lschedule.clear();
fedf.clear();
wsch.clear();
thermal_util=thermal_util+0.001;
}
computation_util=computation_util+0.01;
}
*/
/*
// t_util=optimize_maxfirst(&h_speed,&tasks,0.75,1.2);
timespec start_time,end_time;
clock_gettime(1,&start_time);
t_util=optimize_maxmin(&h_speed,&tasks,MIN_SPEED,MAX_SPEED);
clock_gettime(1,&end_time);
scale(&scaled_max_first,&tasks,&h_speed);
edf_schedule(&scaled_max_first,&edf_max_first);
thermal_optimal=4;
compute_profile(&edf_max_first, &scaled_max_first,t_util);
float max_first_time=time_diff(&start_time,&end_time);
slacks.clear();
opt.clear();
opt_exact.clear();
edl.clear();
populate_slacks(&slacks, &edf_max_first);
edl_schedule(&edl, &edf_max_first, &scaled_max_first, &slacks);
consolidate_schedule(&edl, &scaled_max_first);
clock_gettime(1,&start_time);
//opt_schedule(&opt, &scaled_max_first, &edl);
clock_gettime(1,&end_time);
// opt_schedule_exact(&opt_exact, &scaled_max_first);
// cout<<" schedule size "<<opt_exact.size()<<endl;
// run_schedule(&opt,&scaled_max_first);
// cout<<"TIME to find the optimal schedule "<<time_diff(&start_time,&end_time)<<"ms"<< " Maxfirst time" << max_first_time<<" Hyperperiod "<<tasksets[0].hyperperiod<<" tasks "<< tasks.size()<<endl;
float max_speeds[tasks.size()];
for(unsigned int i=0;i<tasks.size();i++)
{
max_speeds[i]=((float)tasks[i].computation_time)/((float)scaled_max_first[i].computation_time);
}
vector<schedule>o_sch2;
//run_dynamic(&scaled_max_first,max_speeds);
vector<instance>dyn_inst;
dynamic_instances(&scaled_max_first,max_speeds ,&dyn_inst);
vector<instance>dyn_inst2;
for(unsigned int i=0;i<dyn_inst.size();i++)
{
dyn_inst2.push_back(dyn_inst[i]);
}
double tutil=0;
scheduler(&o_sch,&scaled_max_first,&dyn_inst,max_speeds,sched_interval);
compute_profile_dynamic(&o_sch, &tasks,tutil,"");
scheduler2(&o_sch2,&scaled_max_first,&dyn_inst2, max_speeds, sched_interval);
compute_profile_dynamic(&o_sch2, &tasks,tutil,"window");
/* for(unsigned int i=0;i<o_sch2.size();i++)
{
cout<<"task "<<o_sch2[i].task_id<<" start "<<o_sch2[i].start<<" end "<<o_sch2[i].end<<" speed "<<o_sch2[i].speed<<endl;
}
*/
#endif
#if(STATIC_ENABLE)
t_util=optimize_static(&s_speed,&tasks,MIN_SPEED,MAX_SPEED);
scale(&scaled_static,&tasks,&s_speed);
edf_schedule(&scaled_static,&edf_static);
thermal_optimal=5;
compute_profile(&edf_static, &scaled_static,t_util);
#endif
#if(MATLAB_ENABLE)
t_util=optimize_matlab(&m_speed,&tasks,MIN_SPEED,MAX_SPEED);
scale(&scaled_matlab,&tasks,&m_speed);
edf_schedule(&scaled_matlab,&edf_matlab);
thermal_optimal=6;
compute_profile(&edf_matlab, &scaled_matlab,t_util);
#endif
#if(NOCONS_ENABLE)
speed_scale(&scaled_tasks,&speeds,&tasks,1.0);
edf_schedule(&scaled_tasks,&edf2);
thermal_optimal=7;
compute_profile(&edf2,&scaled_tasks,t_util);
#endif
#if(SPEED_DEBUG)
for(int i=0;i<tasks.size();i++)
{
cout<<"matlab: "<<m_speed[i]<<" max first:"<<h_speed[i]<<" static speed:<<"<<s_speed[i]<<" nocons speed:"<< speeds[i]<<endl;
}
#endif
#if(ENABLE_PRINTS)
cout<<"max first taskset"<<endl;
for(int i=0;i<scaled_max_first.size();i++)
{
cout<<"task "<<i<<" computation time:"<<scaled_max_first[i].computation_time<<" period:"<<scaled_max_first[i].period<<" power:"<<scaled_max_first[i].power<<endl;
}
cout<<"static speed taskset"<<endl;
for(int i=0;i<scaled_max_first.size();i++)
{
cout<<"task "<<i<<" computation time:"<<scaled_static[i].computation_time<<" period:"<<scaled_static[i].period<<" power:"<<scaled_static[i].power<<endl;
}
#endif
#if(ENABLE_PRINTS)
for(unsigned int i=0;i<speeds.size();i++)
{
cout<<"speed for task: "<<i<<"|"<<speeds[i]<<endl;
}
#endif
for (unsigned int i = 0; i < tasks.size(); i++) {
// tasks[i].stat_stream->clear();
// tasks[i].stat_stream->close();
// util1=util1+(float)tasks[i].computation_time/(float)tasks[i].period;
// util2=util2+(float)scaled_tasks[i].computation_time/(float)scaled_tasks[i].period;
// util3=util3+(float)discrete_scaled[i].computation_time/(float)discrete_scaled[i].period;
}
#if(ENABLE_PRINTS)
// cout<<"util "<<util1<<"|"<<util2<<"|"<<util3<<endl;
// cout<<"globally optimal power"<<g_power<<endl;
//cout<<"computed thermally optimal schedule"<<endl;
#endif
tasks.clear();
edf.clear();
scaled_tasks.clear();
speeds.clear();
edf2.clear();
discrete_scaled.clear();
edf3.clear();
possible_speeds.clear();
tasksets.clear();
opt.clear();
possible_speeds.clear();
slacks.clear();
h_speed.clear();
s_speed.clear();
m_speed.clear();
i_speed.clear();
i_speed_temp.clear();
scaled_max_first.clear();
scaled_static.clear();
scaled_matlab.clear();
edf_max_first.clear();
edf_static.clear();
edf_matlab.clear();
edl2.clear();
edl.clear();
i_schedule.clear();
o_sch.clear();
}
#if(MATLAB_ENABLE)
engClose(ep);
#endif
}
static void edf_deadline_alarm ( sigval_t sigev_value )
{
kthread_t *kthread = sigev_value.sival_ptr, *test;
kthread_sched2_t *tsched;
ksched_t *ksched;
itimerspec_t alarm;
ASSERT ( kthread );
ksched = ksched2_get ( kthread_get_sched_policy (kthread) );
tsched = kthread_get_sched2_param ( kthread );
test = kthreadq_remove ( &ksched->params.edf.wait, kthread );
EDF_LOG ( "%x %x [Deadline alarm]", kthread, test );
if( test == kthread )
{
EDF_LOG ( "%x [Waked, but too late]", kthread );
kthread_set_syscall_retval ( kthread, EXIT_FAILURE );
kthread_move_to_ready ( kthread, LAST );
if ( tsched->params.edf.flags & EDF_TERMINATE )
{
EDF_LOG ( "%x [EDF_TERMINATE]", kthread );
ktimer_delete ( tsched->params.edf.period_alarm );
tsched->params.edf.period_alarm = NULL;
ktimer_delete ( tsched->params.edf.deadline_alarm );
tsched->params.edf.deadline_alarm = NULL;
kthread_set_errno ( kthread, ETIMEDOUT );
kthread_exit ( kthread, NULL, TRUE );
}
else {
edf_schedule (ksched);
}
}
else {
/*
* thread is not in edf.wait queue, but might be running or its
* blocked - it is probable (almost certain) that it missed deadline
*/
EDF_LOG ( "%x [Not in edf.wait. Missed deadline?]", kthread );
if ( edf_check_deadline ( kthread ) )
{
/* what to do if its missed? kill thread? */
if ( tsched->params.edf.flags & EDF_TERMINATE )
{
EDF_LOG ( "%x [EDF_TERMINATE]", kthread );
ktimer_delete (tsched->params.edf.period_alarm);
tsched->params.edf.period_alarm = NULL;
ktimer_delete ( tsched->params.edf.deadline_alarm );
tsched->params.edf.deadline_alarm = NULL;
kthread_set_errno ( kthread, ETIMEDOUT );
kthread_exit ( kthread, NULL, TRUE );
}
else if ( tsched->params.edf.flags & EDF_CONTINUE )
{
/* continue as deadline is not missed */
EDF_LOG ( "%x [EDF_CONTINUE]", kthread );
}
else if ( tsched->params.edf.flags & EDF_SKIP )
{
/* skip deadline */
/* set times for next period */
EDF_LOG ( "%x [EDF_SKIP]", kthread );
time_add ( &tsched->params.edf.next_run,
&tsched->params.edf.period );
tsched->params.edf.active_deadline =
tsched->params.edf.next_run;
time_add ( &tsched->params.edf.active_deadline,
&tsched->params.edf.relative_deadline );
if ( kthread == ksched->params.edf.active )
ksched->params.edf.active = NULL;
TIME_RESET ( &alarm.it_interval );
alarm.it_value = tsched->params.edf.active_deadline;
ktimer_settime ( tsched->params.edf.deadline_alarm,
TIMER_ABSTIME, &alarm, NULL );
alarm.it_interval = tsched->params.edf.period;
alarm.it_value = tsched->params.edf.next_run;
ktimer_settime ( tsched->params.edf.period_alarm,
TIMER_ABSTIME, &alarm, NULL );
kthread_enqueue (kthread, &ksched->params.edf.ready);
edf_schedule (ksched);
}
} /* moved 1 tab left for readability */
}
}
static int edf_set_thread_sched_parameters ( ksched_t *ksched,
kthread_t *kthread,
sched_supp_t *params )
{
timespec_t now;
itimerspec_t alarm;
kthread_sched2_t *tsched = kthread_get_sched2_param ( kthread );
if ( ksched->params.edf.active == kthread )
ksched->params.edf.active = NULL;
kclock_gettime ( CLOCK_REALTIME, &now );
if ( params->edf.flags & EDF_SET )
{
tsched->params.edf.period = params->edf.period;
tsched->params.edf.relative_deadline = params->edf.deadline;
tsched->params.edf.flags = params->edf.flags ^ EDF_SET;
/* create and set periodic alarm */
edf_create_alarm ( kthread, edf_period_alarm,
&tsched->params.edf.period_alarm );
tsched->params.edf.next_run = now;
time_add ( &tsched->params.edf.next_run, ¶ms->edf.period );
alarm.it_interval = tsched->params.edf.period;
alarm.it_value = tsched->params.edf.next_run;
ktimer_settime ( tsched->params.edf.period_alarm, TIMER_ABSTIME,
&alarm, NULL );
/* adjust "next_run" and "deadline" for "0" period
* first "edf_wait" will set correct values for first period */
tsched->params.edf.next_run = now;
time_sub ( &tsched->params.edf.next_run, ¶ms->edf.period );
/* create and set deadline alarm */
edf_create_alarm ( kthread, edf_deadline_alarm,
&tsched->params.edf.deadline_alarm );
tsched->params.edf.active_deadline = now;
time_add ( &tsched->params.edf.active_deadline,
¶ms->edf.deadline );
TIME_RESET ( &alarm.it_interval );
alarm.it_value = tsched->params.edf.active_deadline;
ktimer_settime ( tsched->params.edf.deadline_alarm,
TIMER_ABSTIME, &alarm, NULL );
/* move thread to edf scheduler */
kthread_enqueue ( kthread, &ksched->params.edf.ready );
edf_schedule (ksched);
}
else if ( params->edf.flags & EDF_WAIT )
{
if ( edf_check_deadline ( kthread ) )
return EXIT_FAILURE;
/* set times for next period */
if ( time_cmp ( &now, &tsched->params.edf.next_run ) > 0 )
{
time_add ( &tsched->params.edf.next_run,
&tsched->params.edf.period );
tsched->params.edf.active_deadline =
tsched->params.edf.next_run;
time_add ( &tsched->params.edf.active_deadline,
&tsched->params.edf.relative_deadline );
if ( kthread == ksched->params.edf.active )
ksched->params.edf.active = NULL;
/* set (separate) alarm for deadline
* (periodic alarm is set only once as periodic) */
TIME_RESET ( &alarm.it_interval );
alarm.it_value = tsched->params.edf.active_deadline;
ktimer_settime ( tsched->params.edf.deadline_alarm,
TIMER_ABSTIME, &alarm, NULL );
}
/* is task ready for execution, or must wait until next period*/
if ( time_cmp ( &tsched->params.edf.next_run, &now ) > 0 )
{
/* wait till "next_run" */
EDF_LOG ( "%x [EDF WAIT]", kthread );
kthread_enqueue ( kthread, &ksched->params.edf.wait );
edf_schedule (ksched);
}
else {
/* "next_run" has already come,
* activate task => move it to "EDF ready tasks"
*/
EDF_LOG ( "%x [EDF READY]", kthread );
kthread_enqueue ( kthread, &ksched->params.edf.ready );
edf_schedule (ksched);
}
}
else if ( params->edf.flags & EDF_EXIT )
{
if ( kthread == ksched->params.edf.active )
ksched->params.edf.active = NULL;
if ( edf_check_deadline ( kthread ) )
{
EDF_LOG ( "%x [EXIT-error]", kthread );
return EXIT_FAILURE;
}
EDF_LOG ( "%x [EXIT-normal]", kthread );
if ( tsched->params.edf.period_alarm )
{
/* disarm timer */
TIME_RESET ( &alarm.it_interval );
TIME_RESET ( &alarm.it_value );
ktimer_settime ( tsched->params.edf.period_alarm, 0,
&alarm, NULL );
}
if ( tsched->params.edf.deadline_alarm )
{
/* disarm timer */
TIME_RESET ( &alarm.it_interval );
TIME_RESET ( &alarm.it_value );
ktimer_settime ( tsched->params.edf.deadline_alarm, 0,
&alarm, NULL );
}
kthread_setschedparam ( kthread, SCHED_FIFO, NULL );
}
return 0;
}
