Vital RTOS Interview Preparation Guide

Download PDF

please share....

"IRQ is serviced at a normal priority level and FIQ is
serviced at high priority level." This statement is wrong

FIQ is the fast interrupt i.e. the latency time taken is less because in the FIQ mode (in case of ARM architecture where these modes are encountered) the mode has an additional set of 8 general purpose registers which means in case of the banked registers there is no need to store these registers into stack when the interrupt occurs.

That means r0 to r7 only needs to be stored while moving from User mode to FIQ mode whereas while moving from to IRQ mode r0 to r12 needs to be stored.

When low priority thread is service and high priority theas
is keep on waiting.This situation is called priority
inversion.because even though thread have high priority it
is not executed.

solution:There are different solution one of them is
priority inheritance,It means change the priority of the
thread.make high priority thread to low and lower priority
thread to high.
In this way only the rule high priority should execute first
is follow.

Interrrupt Latency means the time taken by the processor to
pass the control to ISR after the interrupt is raised.
Certainly this is the hardware feature.

Footprint of the OS matters because with the same compiler
and same optimization techniques, Different OS's will have
different footprint.
So this is can be looked upon while selecting the RTOS.

RTOS can be chosen looking at various API support it
provides. Synchronization support, Scheduler algos, and
memory management of the OS.

In Keil
void serial_ISR() interrupt 4 using 0
{
}

& in AVR studio
SIGNAL(Inteerupt_no)
{
}

hardware intterupt normally redirects the uC to predefined
addresses. In case of high end processors the interrupt
table will decide the interrupt vector address and whenever
intterrupt pin goes low, the table is searched for type and
source of interrupt.

Task Spawn is used to create a thread in VXworks.
Once the thread is created than only we can make all the suspended,delete,resume operations.
Syntax
taskSpawn(char *name,int priority,int option,int stacksize,FUNCPTR entrypoint,int avg1,avg2....avg10)

1. name: task name examp: task1
2. priority: 0-255 //0---high, 255---low
3.options: 0 most of the times
4.FUNCPTR: It jumps to function we are calling examp; (FUNCPTR)fun1
5.avg1--avg10: almost 0 every time

NTDS.dit is a active AD data base file stores in %
systemroot%system32\NTDS\ntds.dit.

Edb.chk, Edb*.log, res1, res2 are the files related to AD

only windows embedded compact 7 will support dual core

In Bottom Up Methodology, we build the bottom-most layer
first and then ascend onto the actual application i.e. all
the smaller chunks of code or assisting functions are build
first and then the bigger function which uses these are built.

Bottom Up methodology is followed when we are definite about
the number, type and functionality of the Bottom most
functions(Assisting Functions) to be defined. Once all these
functions are defined, we build the bigger system above it.

Top down approach is followed when we are not very sure
about the number/type of functions that need to be
implemented, so the application is started to be implemented
and as and when smaller functions are needed, they are built.

Top down methodology is one where overall picture of the
system is defined first. Then we go into the details of the
sub-systems in the next level and so on. So to brief this,
first the complex system is seen as a whole and then this
is broken down to smaller simpler pieces.

Top down approach is preferred when understanding of the
complete system is done. Sufficient knowledge of the system
is required.

A device driver is a code that performs device control
operations specific to the device being addressed.
It is software layer that lies between applications and the
actual device.

or a more formal definition would be
Device drivers are distinct black boxes that make a
particular piece of hardware respond to a well defined
internal programming interface.

- Supports various processor x86, MIPS, SH, ARM
- Real TimeOS
- Preemptive
- Max 32 process supported on or previous version of wince
6.x
- XIP
- Small memory foot print.
- Suitable for small gadgets with like Portable media
players, Mobile phones

In the name "Windows CE," the letters "CE" are not an
abbreviation for anything, but rather they imply a number
of the precepts around which Windows CE is designed,
including "Compact," Connectable,"
Compatible," "Companion," and "Efficient."

Normal OS wince
drivers runs under User space(part of device manager)
kernel space

cannot be customized customized for embedded application
for embedded application like mobile phones,thin client...
(exception linux)

kernel - monolithic kernel- micro kernel

MSFT standard SDK's are,

1. Windows Mobile for Smartphone = Windows Mobile Standard.
2. Windows Mobile for Pocket PC = Windows Mobile Classic.
3. Windows Mobile for Pocket PC Phone Edition = Windows
Mobile Professional.

there are four levels in Win CE architecture.
They are
1)Hardware layer
2)OEM layer
3)OS layer
4)Application layer

speciality in the sense ...
1) number of processes supported by wince 5.0 is more
than wince 4.0
2) memory mapping might be varying.

Well there is nothing to related with limited H/w I believe,
Because MFC is just a collection classes designed using the
Windows APIs , to provide ease of use.
So the proper answer may Be...
To design any application on mobile.. We have very limited
APIs which user can directly used. Generally in Embedded
system (even in Soft RTOS also ) , if application design
using less ( comfort )layer like MFC ( and other if it is
there :) ),then your aplication would be more efficient.
That's why even today's era... The application written in
Assembly is the most efficient application then others.

Adv:
1) Supports various types of processor platforms
2) Possible to Customize the Kernel and can reduce its size
(upto ~300KB kernel size)
3) Especially for the embedded device platforms

Disadv:
1) Process limits, max. 32 process at a time in WinCE 5.0
2) Limited space allocation for each processes, 32MB/each
process

a) Use Atomic Instructions
b) Remember to enable interrupts
c) Make the critical section code as small as possible.
(Prefer not more than 20 instructions)
d) Prefer not to call other functions from the critical
section. if u r calling, see that there is no critical
section in the other function too. Critical section is
bounded by Disable Interrupt and Enable Interrupt.
Check the example below.
fnA()
{
/* Critical Section Start */
Disable_Interrupt();
Some Instructions A ....
Call FnB();
/* do Something B */
Some Instructions B ....
/* Critical Section End */
}


fnB()
{
/* Critical Section Start */
Disable_Interrupt();
Some Instructions ..
Enable_Interrupts();
/* Critical Section End */
}


Now the Enable_Interrupts in fnB() will enable the
interrupts and hence "Some Instructions B .." in fnA()
which should have been in critical section will no more be
in critical section because the interrupts are already
enabled!!

Please check if this condition is handled by the Enable and
Disable functions. If you want suggestions on how to solve
this problem, do revert back

Not sure what this question is. But looks like the question
is: Why 4GB addressing space available in Linux. Well, the
simple answer is it can address so much of memory with
available 32 address lines. 2 ^ 32 = 4 GB.

RTOS might be having 10k memory, might not fragmentation
problem, and the largest hole available to user might be
lesser than 5k, this condition might be one of the reason
for NULL error.