Platform:
Intel Pentium II; RedHat 7.2 with kernel version 2.4.7-10, libc 2.2.4-13 and
gcc 2.96.
Problem description:
a program has a thread of priority 12, a thread of priority 10, a thread of
priority 6, and the main process at priority 0. All the threads except main
process is created with pthread_create, and defined SCHED_FIFO as real time
scheduler policy.
There is a global variable I define as 'int cpl'. All the threads and main
process may alter cpl at any time. cpl may have one of these values {0,
0xf000006e, 0xf0000068, 0xe0000000, 0xe0000060}.
<Problem=> at some point of execution which cpl should be a value say
e0000060, but the actual value retained at cpl is another say e0000000; that
is, the value is changed without the program actually done anything on it.
The retained value I observed is kind of historic value(one of these value
in the above set), not the arbituary value. The problem had occured just
after context switch, also occured during a thread execution.
<Confirm> I used Intel debug register to track any writing to the cpl memory
address globally, which is the way GDB use for x86 hardware watchpoint
implementation. I could see all the writing from my program to change cpl,
but failed to see the source from which the problem occured. So I dont know
what cause the problem.
Can anyone listening give me a direction or hint on this annoying situation?
Any help is thanked here.
PS. please cc to this email address.
-Ming
Related questions:
Is linux kernel 2.4.10 considered strictly preemptive such as VxWorks or
other RTOS? I guess 2.4.10 may simulate preemptive with running scheduler on
every syscall or interrupt returns. Am I right?
Is printf() real-time priority thread safe?
> From: Ming Lei [mailto:[email protected]]
>
> ...
>
> There is a global variable I define as 'int cpl'. All the threads and main
> process may alter cpl at any time. cpl may have one of these values {0,
> 0xf000006e, 0xf0000068, 0xe0000000, 0xe0000060}.
>
> <Problem=> at some point of execution which cpl should be a value say
> e0000060, but the actual value retained at cpl is another say e0000000;
that
> is, the value is changed without the program actually done anything on it.
> The retained value I observed is kind of historic value(one of these value
> in the above set), not the arbituary value. The problem had occured just
> after context switch, also occured during a thread execution.
Probably GCC is keeping the value of the variable around in
some register. Did you declare the global variable as 'volatile'?
[as in "it can be modified by entities external to the flow of
the code"]. Try that.
On the other hand - being an integer, access should be atomic,
most of the time, but I would not really trust that, at least
portability wise. Protecting access to it with a mutex would
be a good idea ...
> Is linux kernel 2.4.10 considered strictly preemptive such as VxWorks or
> other RTOS?
Nope
> I guess 2.4.10 may simulate preemptive with running scheduler on
> every syscall or interrupt returns. Am I right?
You need the preemption patches or 2.5
I hope you are not trying to do serious real-time w/ Linux ... are you?
> Is printf() real-time priority thread safe?
Dunno - you'd have to check the internal implementation in
glibc. Last time I heard anything about it, it had some
mutex dangling around, but I could be wrong.
I?aky P?rez-Gonz?lez -- Not speaking for Intel -- all opinions are my own
(and my fault)