int main(int argc, char *argv[])
{
sigset_t allsigs;
int cur_val = 0;
int s32CPUNo = 0;
int s32CHDNo = 0;
int s32i = 0;
int s32pid = 0;
if(argc != 3)
{
printf("Error!\n");
exit(EXIT_FAILURE);
}
s32CPUNo = atoi(argv[1]);
s32CHDNo = atoi(argv[2]) - 1;
if(s32CPUNo < 0 || s32CPUNo > MAX_CORE_NO)
{
printf("OUT of Range\n");
exit(EXIT_FAILURE);
}
printf("CPU bind: %d\n", s32CPUNo);
set_cpu(s32CPUNo);
printf("Set Sched:RR\n");
set_sched();
for(s32i = 0; s32i < s32CHDNo; s32i++)
{
s32pid = fork();
if(0 == s32pid)
{
/* Child */
break;
}
else
{
/* Parent */
}
}
for(s32i = 0; s32i < IRT_NUM; s32i++)
{
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct sigaction sa;
sigset_t allsigs;
struct itimerspec timerspec;
struct timespec now;
timer_t timer;
struct sigevent timer_event;
if(argc != 5)
{
fprintf(stderr, "Argu ERROR! ./calib_stage1 period count priority taskId\n");
exit(EXIT_FAILURE);
}
/* We do not need a Wcet this time */
/* wcet = atoi(argv[1]); */
period = atoi(argv[1]);
count = atoi(argv[2]);
priority = atoi(argv[3]);
gu16RefID = atoi(argv[4]);
printf("Task[%d] period[%d] count[%d] priority[%d]\n",
gu16RefID, period, count, priority);
sprintf(gacFileName, "Task%04d.trace", gu16RefID);
/* Set SCHED_FIFO */
set_sched();
/* INIT Tracing */
init_tracing();
gs32PID = getpid();
/* Bind a sighandler, using SIGRTMIN */
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_SIGINFO;
sa.sa_sigaction = work;
if (sigaction(SIGRTMIN, &sa, NULL) < 0) {
perror("sigaction error");
exit(EXIT_FAILURE);
}
/* Bind another sighander, using SIGINT */
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_SIGINFO;
sa.sa_sigaction = exit_dump;
if (sigaction(SIGINT, &sa, NULL) < 0) {
perror("sigaction error");
exit(EXIT_FAILURE);
}
/* We don't need an external trigger */
/* raise(SIGSTOP); */
/* the timer */
timerspec.it_interval.tv_sec = period / 1000;
/* Correct the Timer Interval Error Regardless of rdtsc*/
timerspec.it_interval.tv_nsec = (period % 1000) * 1000000;
/* the start time */
/* if(clock_gettime(CLOCK_MONOTONIC, &now) < 0) { */
if(clock_gettime(CLOCK_REALTIME, &now) < 0) {
perror("clock_gettime");
exit(EXIT_FAILURE);
}
// Start one second from now.
/* add_record_task(TASK_EVENT_SET_TIMER, gu16RefID, gs32PID, 0); */
timerspec.it_value.tv_sec = now.tv_sec + 1;
/* Correct the Timer Start Error Regardless of rdtsc*/
timerspec.it_value.tv_nsec = now.tv_nsec;
timer_event.sigev_notify = SIGEV_SIGNAL;
timer_event.sigev_signo = SIGRTMIN;
timer_event.sigev_value.sival_ptr = (void *)&timer;
if (timer_create(CLOCK_REALTIME, &timer_event, &timer) < 0) {
perror("timer_create");
exit(EXIT_FAILURE);
}
if (timer_settime(timer, TIMER_ABSTIME, &timerspec, NULL) < 0) {
perror("timer_settime");
exit(EXIT_FAILURE);
}
sigemptyset(&allsigs);
while(1) {
sigsuspend(&allsigs);
}
exit(EXIT_SUCCESS);
}
static int set_sched_one(struct chrt_ctl *ctl, pid_t pid)
{
struct sched_param sp = { .sched_priority = ctl->priority };
int policy = ctl->policy;
# ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork)
policy |= SCHED_RESET_ON_FORK;
# endif
return sched_setscheduler(pid, policy, &sp);
}
#else /* !HAVE_SCHED_SETATTR */
static int set_sched_one(struct chrt_ctl *ctl, pid_t pid)
{
/* use main() to check if the setting makes sense */
struct sched_attr sa = {
.size = sizeof(struct sched_attr),
.sched_policy = ctl->policy,
.sched_priority = ctl->priority,
.sched_runtime = ctl->runtime,
.sched_period = ctl->period,
.sched_deadline = ctl->deadline
};
# ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork)
sa.sched_flags |= SCHED_RESET_ON_FORK;
# endif
return sched_setattr(pid, &sa, 0);
}
#endif /* HAVE_SCHED_SETATTR */
static void set_sched(struct chrt_ctl *ctl)
{
if (ctl->all_tasks) {
pid_t tid;
struct proc_tasks *ts = proc_open_tasks(ctl->pid);
if (!ts)
err(EXIT_FAILURE, _("cannot obtain the list of tasks"));
while (!proc_next_tid(ts, &tid))
if (set_sched_one(ctl, tid) == -1)
err(EXIT_FAILURE, _("failed to set tid %d's policy"), tid);
proc_close_tasks(ts);
} else if (set_sched_one(ctl, ctl->pid) == -1)
err(EXIT_FAILURE, _("failed to set pid %d's policy"), ctl->pid);
ctl->altered = 1;
}
int main(int argc, char **argv)
{
struct chrt_ctl _ctl = { .pid = -1 }, *ctl = &_ctl;
int c;
static const struct option longopts[] = {
{ "all-tasks", no_argument, NULL, 'a' },
{ "batch", no_argument, NULL, 'b' },
{ "deadline", no_argument, NULL, 'd' },
{ "fifo", no_argument, NULL, 'f' },
{ "idle", no_argument, NULL, 'i' },
{ "pid", no_argument, NULL, 'p' },
{ "help", no_argument, NULL, 'h' },
{ "max", no_argument, NULL, 'm' },
{ "other", no_argument, NULL, 'o' },
{ "rr", no_argument, NULL, 'r' },
{ "sched-runtime", required_argument, NULL, 'T' },
{ "sched-period", required_argument, NULL, 'P' },
{ "sched-deadline", required_argument, NULL, 'D' },
{ "reset-on-fork", no_argument, NULL, 'R' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ NULL, no_argument, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while((c = getopt_long(argc, argv, "+abdDfiphmoPTrRvV", longopts, NULL)) != -1)
{
int ret = EXIT_FAILURE;
switch (c) {
case 'a':
ctl->all_tasks = 1;
break;
case 'b':
#ifdef SCHED_BATCH
ctl->policy = SCHED_BATCH;
#endif
break;
case 'd':
#ifdef SCHED_DEADLINE
ctl->policy = SCHED_DEADLINE;
#endif
break;
case 'f':
ctl->policy = SCHED_FIFO;
break;
case 'R':
ctl->reset_on_fork = 1;
break;
case 'i':
#ifdef SCHED_IDLE
ctl->policy = SCHED_IDLE;
#endif
break;
case 'm':
show_min_max();
return EXIT_SUCCESS;
case 'o':
ctl->policy = SCHED_OTHER;
break;
case 'p':
errno = 0;
ctl->pid = strtos32_or_err(argv[argc - 1], _("invalid PID argument"));
break;
case 'r':
ctl->policy = SCHED_RR;
break;
case 'v':
ctl->verbose = 1;
break;
case 'T':
ctl->runtime = strtou64_or_err(optarg, _("invalid runtime argument"));
break;
case 'P':
ctl->period = strtou64_or_err(optarg, _("invalid period argument"));
break;
case 'D':
ctl->deadline = strtou64_or_err(optarg, _("invalid deadline argument"));
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
ret = EXIT_SUCCESS;
/* fallthrough */
default:
show_usage(ret);
}
}
if (((ctl->pid > -1) && argc - optind < 1) ||
((ctl->pid == -1) && argc - optind < 2))
show_usage(EXIT_FAILURE);
if ((ctl->pid > -1) && (ctl->verbose || argc - optind == 1)) {
show_sched_info(ctl);
if (argc - optind == 1)
return EXIT_SUCCESS;
}
errno = 0;
ctl->priority = strtos32_or_err(argv[optind], _("invalid priority argument"));
#ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork && ctl->policy != SCHED_FIFO && ctl->policy != SCHED_RR)
errx(EXIT_FAILURE, _("--reset-on-fork option is supported for "
"SCHED_FIFO and SCHED_RR policies only"));
#endif
#ifdef SCHED_DEADLINE
if ((ctl->runtime || ctl->deadline || ctl->period) && ctl->policy != SCHED_DEADLINE)
errx(EXIT_FAILURE, _("--sched-{runtime,deadline,period} options "
"are supported for SCHED_DEADLINE only"));
if (ctl->policy == SCHED_DEADLINE) {
/* The basic rule is runtime <= deadline <= period, so we can
* make deadline and runtime optional on command line. Note we
* don't check any values or set any defaults, it's kernel
* responsibility.
*/
if (ctl->deadline == 0)
ctl->deadline = ctl->period;
if (ctl->runtime == 0)
ctl->runtime = ctl->deadline;
}
#else
if (ctl->runtime || ctl->deadline || ctl->period)
errx(EXIT_FAILURE, _("SCHED_DEADLINE is unsupported"));
#endif
if (ctl->pid == -1)
ctl->pid = 0;
set_sched(ctl);
if (ctl->verbose)
show_sched_info(ctl);
if (!ctl->pid) {
argv += optind + 1;
execvp(argv[0], argv);
err(EXIT_FAILURE, _("failed to execute %s"), argv[0]);
}
return EXIT_SUCCESS;
}
