void main(void) { int rc, scope; printf("Before adjustments to scheduling policy:\n"); print_scheduler(); #ifdef RUN_RT_THREAD pthread_attr_init(&main_sched_attr); pthread_attr_setinheritsched(&main_sched_attr, PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&main_sched_attr, SCHED_FIFO); rt_max_prio = sched_get_priority_max(SCHED_FIFO); rt_min_prio = sched_get_priority_min(SCHED_FIFO); main_param.sched_priority = rt_max_prio; rc=sched_setscheduler(getpid(), SCHED_FIFO, &main_param); if (rc) { printf("ERROR; sched_setscheduler rc is %d\n", rc); perror("sched_setschduler"); exit(-1); } printf("After adjustments to scheduling policy:\n"); print_scheduler(); main_param.sched_priority = rt_max_prio; pthread_attr_setschedparam(&main_sched_attr, &main_param); rc = pthread_create(&main_thread, &main_sched_attr, delay_test, (void *)0); if (rc) { printf("ERROR; pthread_create() rc is %d\n", rc); perror("pthread_create"); exit(-1); } pthread_join(main_thread, NULL); if(pthread_attr_destroy(&main_sched_attr) != 0) perror("attr destroy"); #else delay_test((void *)0); #endif printf("TEST COMPLETE\n"); }
int main (int argc, char *argv[]) { int rc, invSafe=0, i, scope; struct timespec sleepTime, dTime; CScount=0; if(argc < 2) { printf("Usage: pthread interfere-seconds\n"); exit(-1); } else if(argc >= 2) { sscanf(argv[1], "%d", &intfTime); printf("interference time = %d secs\n", intfTime); printf("unsafe mutex will be created\n"); } print_scheduler(); pthread_attr_init(&rt_sched_attr[START_SERVICE]); pthread_attr_setinheritsched(&rt_sched_attr[START_SERVICE], PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&rt_sched_attr[START_SERVICE], SCHED_FIFO); pthread_attr_init(&rt_sched_attr[HIGH_PRIO_SERVICE]); pthread_attr_setinheritsched(&rt_sched_attr[HIGH_PRIO_SERVICE], PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&rt_sched_attr[HIGH_PRIO_SERVICE], SCHED_FIFO); pthread_attr_init(&rt_sched_attr[MID_PRIO_SERVICE]); pthread_attr_setinheritsched(&rt_sched_attr[MID_PRIO_SERVICE], PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&rt_sched_attr[MID_PRIO_SERVICE], SCHED_FIFO); pthread_attr_init(&rt_sched_attr[LOW_PRIO_SERVICE]); pthread_attr_setinheritsched(&rt_sched_attr[LOW_PRIO_SERVICE], PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&rt_sched_attr[LOW_PRIO_SERVICE], SCHED_FIFO); rt_max_prio = sched_get_priority_max(SCHED_FIFO); rt_min_prio = sched_get_priority_min(SCHED_FIFO); rc=sched_getparam(getpid(), &nrt_param); if (rc) { printf("ERROR; sched_setscheduler rc is %d\n", rc); perror(NULL); exit(-1); } print_scheduler(); printf("min prio = %d, max prio = %d\n", rt_min_prio, rt_max_prio); pthread_attr_getscope(&rt_sched_attr[START_SERVICE], &scope); if(scope == PTHREAD_SCOPE_SYSTEM) printf("PTHREAD SCOPE SYSTEM\n"); else if (scope == PTHREAD_SCOPE_PROCESS) printf("PTHREAD SCOPE PROCESS\n"); else printf("PTHREAD SCOPE UNKNOWN\n"); pthread_mutex_init(&msgSem, NULL); rt_param[START_SERVICE].sched_priority = rt_max_prio; pthread_attr_setschedparam(&rt_sched_attr[START_SERVICE], &rt_param[START_SERVICE]); printf("Creating thread %d\n", START_SERVICE); rc = pthread_create(&threads[START_SERVICE], &rt_sched_attr[START_SERVICE], startService, (void *)START_SERVICE); if (rc) { printf("ERROR; pthread_create() rc is %d\n", rc); perror(NULL); exit(-1); } printf("Start services thread spawned\n"); printf("will join service threads\n"); if(pthread_join(threads[START_SERVICE], NULL) == 0) printf("START SERVICE done\n"); else perror("START SERVICE"); rc=sched_setscheduler(getpid(), SCHED_OTHER, &nrt_param); if(pthread_mutex_destroy(&msgSem) != 0) perror("mutex destroy"); printf("All done\n"); exit(0); }
int main (int argc, char *argv[]) { int rc, scope; if(argc == 2) { sscanf(argv[1], "%llu", &reqIterations); seqIterations = reqIterations % FIB_LIMIT_FOR_32_BIT; Iterations = reqIterations / seqIterations; //printf("request=%llu, seqIter=%llu, iter=%llu, total=%llu, Diff=%lld\n", reqIterations, seqIterations, Iterations, (seqIterations*Iterations), (reqIterations - (seqIterations*Iterations))); } else if(argc == 1) printf("Using defaults\n"); else printf("Usage: fibtest [Num iterations]\n"); printf("Before adjustments to scheduling policy:\n"); print_scheduler(); // Set POSIX Scheduling Policy // // Note that FIFO is essentially priority preemptive run to // completion on Linux with NPTL since each thread will run // uninterrupted at it's given priority level. // // RR allows threads to run in a Round Robin fashion. // // We set all threads to be run to completion at high // priority so that we can determine whether the hardware // provides speed-up by mapping threads onto multiple cores // and/or SMT (Symmetric Multi-threading) on each core. // pthread_attr_init(&rt_sched_attr); pthread_attr_init(&main_sched_attr); pthread_attr_setinheritsched(&rt_sched_attr, PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&rt_sched_attr, SCHED_FIFO); pthread_attr_setinheritsched(&main_sched_attr, PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&main_sched_attr, SCHED_FIFO); rt_max_prio = sched_get_priority_max(SCHED_FIFO); rt_min_prio = sched_get_priority_min(SCHED_FIFO); rc=sched_getparam(getpid(), &nrt_param); rt_param.sched_priority = rt_max_prio; rc=sched_setscheduler(getpid(), SCHED_FIFO, &rt_param); if (rc) { printf("ERROR; sched_setscheduler rc is %d\n", rc); perror(NULL); exit(-1); } printf("After adjustments to scheduling policy:\n"); print_scheduler(); printf("min prio = %d, max prio = %d\n", rt_min_prio, rt_max_prio); pthread_attr_getscope(&rt_sched_attr, &scope); // Check the scope of the POSIX scheduling mechanism // if(scope == PTHREAD_SCOPE_SYSTEM) printf("PTHREAD SCOPE SYSTEM\n"); else if (scope == PTHREAD_SCOPE_PROCESS) printf("PTHREAD SCOPE PROCESS\n"); else printf("PTHREAD SCOPE UNKNOWN\n"); // Note that POSIX priorities are such that the highest priority // thread has a large priority number. This is very different // than VxWorks for example where low priority numbers mean high // scheduling priority. As long as the sched_get_priority_max(<policy>) // function call is used, then the number is not important. // // IMPORTANT: for this test, note that the thread that creates all other // threads has higher priority than the workload threads // themselves - this prevents it from being preempted so that // it can continue to create all threads in order to get them // concurrently active. // rt_param.sched_priority = rt_max_prio-1; pthread_attr_setschedparam(&rt_sched_attr, &rt_param); main_param.sched_priority = rt_max_prio; pthread_attr_setschedparam(&main_sched_attr, &main_param); rc = pthread_create(&main_thread, &main_sched_attr, testThread, (void *)0); if (rc) { printf("ERROR; pthread_create() rc is %d\n", rc); perror(NULL); exit(-1); } pthread_join(main_thread, NULL); if(pthread_attr_destroy(&rt_sched_attr) != 0) perror("attr destroy"); rc=sched_setscheduler(getpid(), SCHED_OTHER, &nrt_param); printf("TEST COMPLETE\n"); }