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; }