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