int main(int argc, char **argv)
{
struct timespec interval0;
struct timespec interval1;
int result0 = -1;
int result1 = -1;
interval0.tv_sec = -1;
interval0.tv_nsec = -1;
interval1.tv_sec = -1;
interval1.tv_nsec = -1;
result0 = sched_rr_get_interval(0, &interval0);
result1 = sched_rr_get_interval(getpid(), &interval1);
if(result0 == result1 &&
interval0.tv_sec == interval1.tv_sec &&
interval0.tv_nsec == interval1.tv_nsec &&
errno == 0) {
printf("Test PASSED\n");
return PTS_PASS;
} else if(errno != 0) {
perror("Unexpected error");
return PTS_FAIL;
} else {
printf("Different results between pid == 0 and pid == getpid().\n");
return PTS_FAIL;
}
}
extern int
main (int argc, char * argv[])
{
long delta;
struct timespec tspec;
struct sched_param sp;
int pid, idx;
if (argc != 2)
{
fprintf (stderr, "Usage: %s <proces-number 0..4>\n", argv [0]);
return (-1);
}
pid = atoi(argv[1]);
// Set scheduler and priority
sp.sched_priority = 1;
if(sched_setscheduler(0, SCHED_RR, &sp) != 0)
{
perror("Error: sched_setscheduler\n");
}
// Synchronize
if(pid == 0) {
sem_sync = sem_open (sem_sync_name, O_CREAT | O_EXCL, 0600, 0);
sem_wait(sem_sync);
}else{
sem_sync = sem_open (sem_sync_name, 0);
sem_post(sem_sync);
}
// Collect time and store in array
for (idx = 0; idx < MAX_SIZE; ++idx)
{
clock_gettime(CLOCK_REALTIME, &ts[idx]);
usleep(10);
}
// Printout time data
for (idx = 1; idx < MAX_SIZE; ++idx)
{
printf("%lu.%lu, delta = %lu", ts[idx].tv_sec, ts[idx].tv_nsec, ts[idx].tv_nsec - ts[idx-1].tv_nsec);
if(ts[idx].tv_nsec - ts[idx-1].tv_nsec > 10000)
{
printf(" <-------------------------\n");
}
else
{
printf("\n");
}
}
// Get RR interval
if(sched_rr_get_interval(0, &tspec) != 0)
{
perror("Error: Retreiving sched_rr_get_interval\n");
}
printf("Timeslice: %lums\n", tspec.tv_nsec / 1000L / 1000L);
// Close and unlink semafore
sem_close (sem_sync);
sem_unlink (sem_sync_name);
exit(EXIT_SUCCESS);
}
int main(int argc,char* argv[]) {
struct timespec tp;
int status;
status = sched_rr_get_interval(0, &tp);
if( status == 0 )
printf("Timeslice is %d nano secs\n",tp.tv_nsec);
else
printf("fail status is %d",status);
}
int
main (int argc, char * argv [])
{
int pid;
int ordonnancement;
int prior;
struct sched_param param;
struct timespec intervalle;
if ((argc != 2) || (sscanf (argv [1], "%d", & pid) != 1))
syntaxe (argv [0]);
if (pid == 0)
pid = getpid();
if ((ordonnancement = sched_getscheduler (pid)) < 0) {
perror ("sched_getscheduler");
exit (1);
}
if (sched_getparam (pid, & param) < 0) {
perror ("sched_getparam");
exit (1);
}
if (ordonnancement == SCHED_RR)
if (sched_rr_get_interval (pid, & intervalle) < 0) {
perror ("sched_rr_get_interval");
exit (1);
}
if (ordonnancement == SCHED_OTHER) {
errno = 0;
if (((prior = getpriority (PRIO_PROCESS, pid)) == -1)
&& (errno != 0)) {
perror ("getpriority");
exit (1);
}
}
switch (ordonnancement) {
case SCHED_RR :
printf ("RR : Priorité = %d, intervalle = %ld.%09ld s. \n",
param . sched_priority,
intervalle . tv_sec,
intervalle . tv_nsec);
break;
case SCHED_FIFO :
printf ("FIFO : Priorité = %d \n",
param . sched_priority);
break;
case SCHED_OTHER :
printf ("OTHER : Priorité statique = %d dynamique = %d \n",
param . sched_priority,
prior);
break;
default :
fprintf (stdout, "???\n");
break;
}
return (0);
}
void testValues() {
f = 2;
struct timespec p;
sched_rr_get_interval(anyint(), &p);
//@ assert f == 2;
//@ assert vacuous: \false;
}
int main()
{
struct timespec ts;
int ret;
/* real apps must check return values */
ret = sched_rr_get_interval(0, &ts);
printf("Timeslice: %lu.%lu\n", ts.tv_sec, ts.tv_nsec);
}
int main(void)
{
struct timespec interval0;
struct timespec interval1;
int result0 = -1;
int result1 = -1;
struct sched_param param;
param.sched_priority = sched_get_priority_min(SCHED_RR);
if (sched_setscheduler(0, SCHED_RR, ¶m) == -1) {
printf("sched_setscheduler failed: %d (%s)\n",
errno, strerror(errno));
return PTS_UNRESOLVED;
}
interval0.tv_sec = -1;
interval0.tv_nsec = -1;
interval1.tv_sec = -1;
interval1.tv_nsec = -1;
result0 = sched_rr_get_interval(0, &interval0);
result1 = sched_rr_get_interval(getpid(), &interval1);
if (result0 == result1 &&
interval0.tv_sec == interval1.tv_sec &&
interval0.tv_nsec == interval1.tv_nsec && errno == 0) {
printf("Test PASSED\n");
return PTS_PASS;
} else if (errno != 0) {
perror("Unexpected error");
return PTS_FAIL;
} else {
printf
("Different results between pid == 0 and pid == getpid().\n");
return PTS_FAIL;
}
}
int main (void)
{
int policy;
struct sched_param sp = { .sched_priority = 1 };
struct timespec tp;
int ret;
ret = sched_setscheduler (0, SCHED_RR, &sp);
if (ret == -1) {
perror ("sched_setscheduler");
return 1;
}
policy = sched_getscheduler (0);
switch (policy) {
case SCHED_OTHER:
printf ("policy is normal\n");
break;
case SCHED_RR:
printf ("policy is round-robin\n");
break;
case SCHED_FIFO:
printf ("policy is first-in, first-out\n");
break;
case -1:
perror ("sched_getscheduler");
break;
default:
fprintf (stderr, "Unknown policy!\n");
}
ret = sched_getparam (0, &sp);
if (ret == -1) {
perror ("sched_getparam");
return 1;
}
printf ("Our priority is %d\n", sp.sched_priority);
ret = sched_rr_get_interval (0, &tp);
if (ret == -1) {
perror ("sched_rr_get_interval");
return 1;
}
printf ("Our time quantum is %.2lf milliseconds\n",
(tp.tv_sec * 1000.0f) + (tp.tv_nsec / 1000000.0f));
return 0;
}
int test_rr_interval(){
struct timespec ts;
int err;
printf("Test sched_rr_get_interval()...");
memset(&ts, 0, sizeof(struct timespec));
err = sched_rr_get_interval(getpid(), &ts);
if ( err == 0 ){
if ( ts.tv_nsec == 0 ){
printf("Failed: RR time is zero\n");
return -1;
} else {
printf("%ld ns...", ts.tv_nsec);
}
} else {
fflush(stdout);
perror("failed");
return -1;
}
printf("passed\n");
printf("Test sched_rr_get_interval() (ERSCH)...");
memset(&ts, 0, sizeof(struct timespec));
err = sched_rr_get_interval(-1, &ts);
if ( (err == 0) || (errno != ESRCH) ){
fflush(stdout);
perror("should have failed with ESRCH");
return -1;
} else {
errno = 0;
printf("passed\n");
}
return 0;
}
int main(int ac, char **av)
{
int lc, i; /* loop counter */
char *msg; /* message returned from parse_opts */
/* parse standard options */
if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL))
!= (char *)NULL) {
tst_brkm(TBROK, tst_exit, "OPTION PARSING ERROR - %s", msg);
}
/* perform global setup for test */
setup();
/* check looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset Tst_count in case we are looping. */
Tst_count = 0;
for (i = 0; i < TST_TOTAL; ++i) {
/*
* Call sched_rr_get_interval(2)
*/
TEST(sched_rr_get_interval(test_cases[i].pid,
test_cases[i].tp));
if ((TEST_RETURN == -1) &&
(TEST_ERRNO == test_cases[i].exp_errno)) {
tst_resm(TPASS, "Test Passed");
} else {
tst_resm(TFAIL|TTERRNO, "Test Failed,"
" sched_rr_get_interval() returned %ld", TEST_RETURN);
}
TEST_ERROR_LOG(TEST_ERRNO);
}
} /* End for TEST_LOOPING */
/* cleanup and exit */
cleanup();
/*NOTREACHED*/ return 0;
} /* End main */
long
lx_sched_rr_get_interval(uintptr_t pid, uintptr_t timespec)
{
struct timespec ts;
pid_t s_pid;
if ((pid_t)pid < 0)
return (-EINVAL);
if (lx_lpid_to_spid((pid_t)pid, &s_pid) < 0)
return (-ESRCH);
if (uucopy((struct timespec *)timespec, &ts,
sizeof (struct timespec)) != 0)
return (-errno);
return ((sched_rr_get_interval(s_pid, &ts) == -1) ? -errno : 0);
}
int main(int argc, char **argv)
{
struct timespec interval;
int result = -2, child_pid, stat_loc;
/* Create a child process which exit immediately */
child_pid = fork();
if(child_pid == -1){
perror("An error occurs when calling fork()");
return PTS_UNRESOLVED;
} else if (child_pid == 0){
exit(0);
}
/* Wait for the child process to exit */
if(wait(&stat_loc) == -1){
perror("An error occurs when calling wait()");
return PTS_UNRESOLVED;
}
/* Assume the pid is not yet reatributed to an other process */
result = sched_rr_get_interval(child_pid, &interval);
if(result == -1 && errno == ESRCH) {
printf("Test PASSED\n");
return PTS_PASS;
}
if( errno != ESRCH ) {
perror("Returned error is not ESRCH");
return PTS_FAIL;
}
if( result == 0 ) {
printf("Returned code == 0.\n");
return PTS_FAIL;
} else {
perror("Unresolved test error");
return PTS_UNRESOLVED;
}
}
int main(int argc, char **argv)
{
struct timespec interval;
int result = -2;
interval.tv_sec = -1;
interval.tv_nsec = -1;
result = sched_rr_get_interval(0, &interval);
if(result == 0 &&
interval.tv_sec >= 0 &&
interval.tv_nsec >= 0 &&
errno == 0) {
printf("Test PASSED\n");
return PTS_PASS;
}
if( interval.tv_sec == -1 ) {
printf("interval.tv_sec not updated.\n");
return PTS_FAIL;
}
if( interval.tv_nsec == -1 ) {
printf("interval.tv_nsec not updated.\n");
return PTS_FAIL;
}
if(result != 0) {
printf("Returned code != 0.\n");
return PTS_FAIL;
}
if(errno != 0 ) {
perror("Unexpected error");
return PTS_FAIL;
} else {
perror("Unresolved test error");
return PTS_UNRESOLVED;
}
}
int main(void)
{
int result = -2;
result = sched_rr_get_interval(0, NULL);
if (result == -1 && errno == EFAULT) {
printf
("sched_rr_get_interval() sets errno == EFAULT when interval argument points to NULL\n");
return PTS_PASS;
}
if (result == -1 && errno == EINVAL) {
printf
("sched_rr_get_interval() sets errno == EINVAL when interval argument points to NULL\n");
return PTS_PASS;
}
printf("sched_rr_get_interval() return %i and sets errno == %i.\n",
result, errno);
return PTS_UNRESOLVED;
}
int main(int ac, char **av)
{
int lc, i;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
Tst_count = 0;
for (i = 0; i < TST_TOTAL; ++i) {
/*
* Call sched_rr_get_interval(2)
*/
TEST(sched_rr_get_interval(test_cases[i].pid,
test_cases[i].tp));
if ((TEST_RETURN == -1) &&
(TEST_ERRNO == test_cases[i].exp_errno)) {
tst_resm(TPASS, "Test Passed");
} else {
tst_resm(TFAIL | TTERRNO, "Test Failed,"
" sched_rr_get_interval() returned %ld",
TEST_RETURN);
}
TEST_ERROR_LOG(TEST_ERRNO);
}
}
/* cleanup and exit */
cleanup();
tst_exit();
}
int main(int argc, char* argv[]){
(void) argc;
(void) argv;
struct sched_param param;
int policy;
struct timespec tp;
double qs = 0.0;
/* Set Policy */
policy = SCHED_RR;
/* Set process to max priority for given scheduler */
param.sched_priority = sched_get_priority_max(policy);
/* Set new scheduler policy */
fprintf(stdout, "Current Scheduling Policy: %d\n", sched_getscheduler(0));
fprintf(stdout, "Setting Scheduling Policy to: %d\n", policy);
if(sched_setscheduler(0, policy, ¶m)){
perror("Error setting scheduler policy");
exit(EXIT_FAILURE);
}
fprintf(stdout, "New Scheduling Policy: %d\n", sched_getscheduler(0));
/* Find RR Quantum */
if(sched_rr_get_interval(getpid(), &tp)){
perror("Error getting RR Quantum");
exit(EXIT_FAILURE);
}
fprintf(stdout, "tp.tv_sec = %ld\n", tp.tv_sec);
fprintf(stdout, "tp.tv_nsec = %ld\n", tp.tv_nsec);
qs = (tp.tv_nsec / NANO) + tp.tv_sec;
fprintf(stdout, "RR Quantum = %f seconds\n", qs);
return 0;
}
int main(int ac, char **av)
{
int lc; /* loop counter */
char *msg; /* message returned from parse_opts */
/* parse standard options */
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
Tst_count = 0;
/*
* Call sched_rr_get_interval(2) with pid=0 so that it will
* write into the timespec structure pointed to by tp, the
* round robin time quantum for the current process.
*/
TEST(sched_rr_get_interval(0, &tp));
if (TEST_RETURN == 0) {
tst_resm(TPASS, "sched_rr_get_interval() returned %ld",
TEST_RETURN);
} else {
tst_resm(TFAIL|TTERRNO, "Test Failed, sched_rr_get_interval()"
"returned %ld", TEST_RETURN);
}
}
/* cleanup and exit */
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc, i;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; ++i) {
/*
* Call sched_rr_get_interval(2)
*/
TEST(sched_rr_get_interval(*(test_cases[i].pid),
test_cases[i].tp));
if ((TEST_RETURN == -1) &&
(TEST_ERRNO == test_cases[i].exp_errno)) {
tst_resm(TPASS, "Test Passed");
} else {
tst_resm(TFAIL | TTERRNO, "Test Failed,"
" sched_rr_get_interval() returned %ld",
TEST_RETURN);
}
}
}
/* cleanup and exit */
cleanup();
tst_exit();
}
void runFailure() {
sched_rr_get_interval(anyint(), NULL);
}
void runSuccess() {
struct timespec p;
sched_rr_get_interval(anyint(), &p);
}
int main(){
pid_t ret, pid;
int politique, status;
struct timespec quantum;
struct sched_param param;
ret = fork();
if(ret == 0){ // I'm the son
pid = getpid();
printf("Je suis le fils: \n");
printf("Ma priorité d'ordonnancement est %d\n", getpriority(PRIO_PROCESS, pid));
politique = sched_getscheduler(pid);
switch(politique){
case SCHED_RR:
printf("politique d'ordonnancement: SCHED_RR\n");
break;
case SCHED_FIFO:
printf("politique d'ordonnancement: SCHED_FIFO\n");
break;
case SCHED_OTHER:
printf("politique d'ordonnancement: SCHED_OTHER\n");
break;
default:
printf("politique d'ordonnancement: %d\n", politique);
}
setpriority(PRIO_PROCESS, pid, 5);
printf("Ma priorité d'ordonnancement est %d\n", getpriority(PRIO_PROCESS, pid));
printf("application de la politique FIFO\n");
param.sched_priority = 10;
if(sched_setscheduler(pid, SCHED_FIFO, ¶m) == -1){
perror("Problème setscheduler");
switch(errno){
case ESRCH:
printf("problem: ESRCH\n");
break;
case EACCES:
printf("problem: EACCESS\n");
break;
case EPERM:
printf("problem: EPERM\n");
break;
default:
printf("problem: %d\n", errno);
}
}
printf("Ma priorité d'ordonnancement est %d\n", getpriority(PRIO_PROCESS, pid));
politique = sched_getscheduler(pid);
switch(politique){
case SCHED_RR:
printf("politique d'ordonnancement: SCHED_RR\n");
break;
case SCHED_FIFO:
printf("politique d'ordonnancement: SCHED_FIFO\n");
break;
case SCHED_OTHER:
printf("politique d'ordonnancement: SCHED_OTHER\n");
break;
default:
printf("politique d'ordonnancement: %d\n", politique);
}
}else{
printf("Je suis le père: \n");
printf("priorité min %d et max %d de la politique FIFO\n",
sched_get_priority_min(SCHED_FIFO),
sched_get_priority_max(SCHED_FIFO));
printf("priorité min %d et max %d de la politique RR\n",
sched_get_priority_min(SCHED_RR),
sched_get_priority_max(SCHED_RR));
sched_rr_get_interval(0, &quantum);
printf("voici les valeurs du quantum de la politique SCHED_RR, %d secondes, %ld nanosecondes\n",
(int) quantum.tv_sec, quantum.tv_nsec);
wait(&status);
}
return 0;
}
void *POSIX_Init(
void *argument
)
{
struct timespec tr;
int status;
int priority;
pthread_t thread_id;
struct utsname uts;
puts( "\n\n*** POSIX TEST 1 ***" );
/* print some system information */
puts( "Init: uname - EFAULT (invalid uts pointer argument)" );
status = uname( NULL );
rtems_test_assert( status == -1 );
rtems_test_assert( errno == EFAULT );
status = uname( &uts );
rtems_test_assert( !status );
printf( "Init: uts.sysname: %s\n", uts.sysname );
printf( "Init: uts.nodename: %s\n", uts.nodename );
printf( "Init: uts.release: %s\n", uts.release );
printf( "Init: uts.version: %s\n", uts.version );
printf( "Init: uts.machine: %s\n", uts.machine );
puts("");
/* get id of this thread */
Init_id = pthread_self();
printf( "Init: ID is 0x%08" PRIxpthread_t "\n", Init_id );
/* exercise get minimum priority */
priority = sched_get_priority_min( SCHED_FIFO );
printf( "Init: sched_get_priority_min (SCHED_FIFO) -- %d\n", priority );
rtems_test_assert( priority != -1 );
puts( "Init: sched_get_priority_min -- EINVAL (invalid policy)" );
priority = sched_get_priority_min( -1 );
rtems_test_assert( priority == -1 );
rtems_test_assert( errno == EINVAL );
/* exercise get maximum priority */
priority = sched_get_priority_max( SCHED_FIFO );
printf( "Init: sched_get_priority_max (SCHED_FIFO) -- %d\n", priority );
rtems_test_assert( priority != -1 );
puts( "Init: sched_get_priority_max -- EINVAL (invalid policy)" );
priority = sched_get_priority_max( -1 );
rtems_test_assert( priority == -1 );
rtems_test_assert( errno == EINVAL );
puts( "Init: sched_rr_get_interval -- ESRCH (invalid PID)" );
status = sched_rr_get_interval( 4, &tr );
rtems_test_assert( status == -1 );
rtems_test_assert( errno == ESRCH );
puts( "Init: sched_rr_get_interval -- EINVAL (invalid interval pointer)" );
status = sched_rr_get_interval( getpid(), NULL );
rtems_test_assert( status == -1 );
rtems_test_assert( errno == EINVAL );
/* print the round robin time quantum */
status = sched_rr_get_interval( getpid(), &tr );
printf(
"Init: Round Robin quantum is %ld seconds, %ld nanoseconds\n",
tr.tv_sec,
tr.tv_nsec
);
rtems_test_assert( !status );
/* create a thread */
puts( "Init: pthread_create - SUCCESSFUL" );
status = pthread_create( &thread_id, NULL, Task_1_through_3, NULL );
rtems_test_assert( !status );
/* too may threads error */
puts( "Init: pthread_create - EAGAIN (too many threads)" );
status = pthread_create( &thread_id, NULL, Task_1_through_3, NULL );
rtems_test_assert( status == EAGAIN );
puts( "Init: sched_yield to Task_1" );
status = sched_yield();
rtems_test_assert( !status );
/* switch to Task_1 */
/* exit this thread */
puts( "Init: pthread_exit" );
pthread_exit( NULL );
/* switch to Task_1 */
return NULL; /* just so the compiler thinks we returned something */
}
int fifo(int argc, char *argv[])
{
int e = 0;
volatile long *p, pid;
int i;
struct sched_param fifo_param;
struct timespec interval;
#define MAX_RANAT 32
struct timeval ranat[MAX_RANAT];
#ifdef CAN_USE_ALARMS
static struct itimerval itimerval;
#endif
/* What is the round robin interval?
*/
if (sched_rr_get_interval(0, &interval) == -1) {
perror("sched_rr_get_interval");
exit(errno);
}
#ifdef CAN_USE_ALARMS
signal(SIGALRM, tick);
#endif
fifo_param.sched_priority = 1;
p = (long *)mmap(0, sizeof(*p),
PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
if (p == (long *)-1)
err(errno, "mmap");
*p = 0;
if (sched_setscheduler(0, SCHED_FIFO, &fifo_param) == -1)
{
perror("sched_setscheduler");
return -1;
}
pid = getpid();
if ((child = fork()) == 0)
{
/* Child process. Just keep setting the pointer to our
* PID. The parent will kill us when it wants to.
*/
pid = getpid();
while (1)
*p = pid;
}
else
{
atexit(tidyup);
*p = pid;
ticked = 0;
#ifdef CAN_USE_ALARMS
/* Set an alarm for 250 times the round-robin interval.
* Then we will verify that a similar priority process
* will not run when we are using the FIFO scheduler.
*/
itimerval.it_value.tv_usec = interval.tv_nsec / (1000 / 250);
itimerval.it_value.tv_sec = itimerval.it_value.tv_usec / 1000000;
itimerval.it_value.tv_usec %= 1000000;
if (setitimer(ITIMER_REAL, &itimerval, 0) == -1) {
perror("setitimer");
exit(errno);
}
#endif
gettimeofday(ranat, 0);
i = 1;
while (!ticked && i < MAX_RANAT)
if (*p == child) {
gettimeofday(ranat + i, 0);
*p = 0;
e = -1;
i++;
}
if (e) {
int j;
fprintf(stderr,
"SCHED_FIFO had erroneous context switches:\n");
for (j = 1; j < i; j++) {
fprintf(stderr, "%d %g\n", j,
tvsub(ranat + j, ranat + j - 1));
}
return e;
}
/* Switch to the round robin scheduler and the child
* should run within twice the interval.
*/
if (sched_setscheduler(child, SCHED_RR, &fifo_param) == -1 ||
sched_setscheduler(0, SCHED_RR, &fifo_param) == -1)
{
perror("sched_setscheduler");
return -1;
}
e = -1;
ticked = 0;
#ifdef CAN_USE_ALARMS
/* Now we do want to see it run. But only set
* the alarm for twice the interval:
*/
itimerval.it_value.tv_usec = interval.tv_nsec / 500;
if (setitimer(ITIMER_REAL, &itimerval, 0) == -1) {
perror("setitimer");
exit(errno);
}
#endif
for (i = 0; !ticked; i++)
if (*p == child) {
e = 0;
break;
}
if (e)
fprintf(stderr,"Child never ran when it should have.\n");
}
exit(e);
}
int main(void)
{
sched_rr_get_interval(0, 0);
return 0;
}
