Hi,

I'm trying to learn the differences of thread created using SCHED_FIFO and SCHED_RR. But I couldn't write a program that could demonstrate the difference of them. Can someone help?

Thanks

You need to be root, or have a lax security policy to switch into sched_rr or sched_fifo - otherwise you'll be always running at sched_other.

As far as differences go, there is only one and you probably won't meaningfully have a way of demonstrating it. SCHED_FIFO can not be preempted for time reasons; sched_rr may be preempted by exhaustion of it's time quanta in the current scheduling epoch for a higher priority task. The only way I can think to effectively demonstrate this would make your system unusable once you've executed the program.

In general, if you need something to run without interruption then choose sched_fifo, with the understanding that you MUST YIELD TIME to the system. Otherwise, choose sched_rr, and at least you'll allow higher-priority tasks to preempt you. In either case, you need to have an explicit need for some kind of predictable task execution latency - so you're either writing something that is extremely time critical, or you're just playing around. Be careful - it is very easy to starve your entire system of resources in a tight-loop; if your task is highest priority in that case, you will no longer have a usable machine.

I wrote a program to examine the behavior, I compiled it to create two FIFO threads, and the other to create two RR threads. Both binaries run using root. From the output of the program, data written by the two FIFO threads (with same priority) still overlapped each other. Which didn't show any FIFO behavior.

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <vector>
#include <string>
#include <iostream>

using namespace std;

int loop_count = 10000;
volatile int index = 0;
char data[20000];

#define handle_error_en(en, msg) \
do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

static void *
thread_start1(void *arg) {
for (; index < loop_count; index++) {
data[index] = '1';
}
}
static void *
thread_start2(void *arg) {
for (; index < loop_count; index++) {
data[index] = '2';
}
}

int main(int argc, char *argv[]) {
pthread_t thr, thr2;
pthread_attr_t attr;
pthread_attr_t *attrp; /* NULL or &attr */
int s;

attrp = NULL;

int stack_size;
void *sp;

attrp = &attr;

s = pthread_attr_init(&attr);
if (s != 0)
handle_error_en(s, "pthread_attr_init");

s = pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
if (s != 0)
handle_error_en(s, "pthread_attr_setschedpolicy");

s = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
if (s != 0)
handle_error_en(s, "pthread_attr_setinheritsched");

struct sched_param schedParam;
schedParam.__sched_priority = sched_get_priority_min(SCHED_FIFO);
s = pthread_attr_setschedparam(&attr, &schedParam);
if (s != 0)
handle_error_en(s, "pthread_attr_setschedparam");

s = pthread_create(&thr, attrp, &thread_start1, (void*) "thr1 ");
if (s != 0)
handle_error_en(s, "pthread_create");

s = pthread_create(&thr2, attrp, &thread_start2, (void*) "thr2 ");
if (s != 0)
handle_error_en(s, "pthread_create");

if (attrp != NULL) {
s = pthread_attr_destroy(attrp);
if (s != 0)
handle_error_en(s, "pthread_attr_destroy");
}

pthread_join(thr, NULL);
pthread_join(thr2, NULL);

cout<<index<<endl;
index = 0;
for (; index < loop_count; index++) {
cout << data[index];
}
cout<<endl<<index<<endl;

return 0;
}

1) Please enclose code in the proper tags.

2) You may have missed this:
"As a consequence, it may preempt the currently running process if it has the same priority."

SCHED_FIFO of the same priority _may_ interrupt each other on the same core, if they have the same priority - it isn't forbidden by the POSIX standard, and the kernel only needs to meet POSIX compliance.

3) Additionally, you don't say whether you are on single core machine, or multi-core. In any event your increment of the index loop is likely unsafe.

4) When you need high-prio scheduling, you generally should look to the rt kernel series. Additionally, you need to update your BIOS settings on intel to remove as many SMIs as you can, and on top of that you will likely need to switch off the HPET since it's counting mechanism uses both SMIs _and_ can miss interrupts

5) Finally, what about "... you probably won't meaningfully have a way of demonstrating it" was difficult to grasp? A naive counting program won't be the way to explain FIFO vs. RR. You're better off just trusting that the kernel devs have gotten this one correct.