Microkernel Development

Microkernel development: from project to implementation Rodrigo Maximiano Antunes de Almeida E-mail: rmaalmeida@gmail.com Twitter: @rmaalmeida Universidade Federal de Itajubá

Creative Commons License The work ” Microkernel development: from project to implementation ” of Rodrigo Maximiano Antunes de Almeida was licensed with Creative Commons 3.0 – Attribution – Non Commercial – Share Alike license . Additional permission can be given by the author through direct contact using the e-mail: rmaalmeida@gmail.com

“ I reinvented the wheel last week. I sat down and deliberately coded something that I knew already existed, and had probably also been done by many many other people. In conventional programming terms, I wasted my time. But it was worthwhile, and what's more I would recommend almost any serious programmer do precisely the same thing.” James Hart

//today topics void main (void){ //variable declaration kernel_project ( 1 ); //initialization concepts ( 2 ); //hard-work microkernel ( 3 ); }

void kernel_project (float i ){ what_is_a_kernel ( 1.1 ); alternatives ( 1.2 ); kernel_design_decisions ( 1.3 ); }

kernel_project ( 1 ); Kernel tasks: Manage and coordinate the processes execution using “some criteria” Manage the free memory and coordinate the processes access to it Intermediate the communication between the hardware drivers and the processes

kernel_project ( 1 ); Alternatives Windows Embedded Compact® VxWorks® X RTOS® uClinux FreeRTOS BRTOS

kernel_project ( 1 ); Monolithic kernel versus microkernel Linus Torvalds and Andrew Tanenbaum

kernel_project ( 1 ); Kernel design decisions I/O devices management Process management System safety

kernel_project ( 1 ); Our decisions: Microkernel Non-preemptive Cooperative No memory management Process scheduled based on timer Isolate drivers using a controller

void concepts (float i ){ function_pointers ( 2.1 ); temporal_conditions ( 2.2 ); void_pointers ( 2.3 ); }

concepts ( 2 ); function_pointers ( 2.1 );

concepts ( 2 ); Function pointers Work almost as a normal pointer Hold the address of a function start point instead the address of a variable The compiler need no known the function signature to pass the correct parameters and the return value. Awkard declaration (it is best to use a typedef)

concepts ( 2 ); //defining the type pointerTest //it is a pointer to function that: // receives no parameter // returns no parameter typedef void (* pointerTest )(void); //Function to be called void nop (void){ __asm NOP __endasm } //creating an pointerTest variable; pointerTest foo ; foo = nop ; (* foo )(); //calling the function via pointer

concepts ( 2 ); temporal_conditions ( 2.2 );

concepts ( 2 ); In the majority part of embedded systems, we need to guarantee that a function will be executed in a certain frequency. Some systems may even fail if these deadlines are not met.

concepts ( 2 ); To implement temporal conditions: There must be a tick event that occurs with a precise frequency The kernel must be informed of the execution frequency needed for each process. The sum of process duration must “fit” within the processor available time.

concepts ( 2 ); 1 st condition: Needs an internal timer that can generate an interrupt. 2 nd condition: Add the information for each process when creating it 3 rd condition: Test, test and test. If fail, change chip first, optimize only on last case

concepts ( 2 ); Scheduling processes: Using a finite timer to schedule will result in overflow Example: scheduling 2 processes for 10 and 50 seconds ahead.

concepts ( 2 ); And if two process are to be called in the same time?

concepts ( 2 ); Question: From the timeline above (only the timeline) is P2 late or it was scheduled to happen 55(s) from now?

concepts ( 2 ); Solution: Use a downtime counter for each process instead of setting a trigger time. Problem: Each counter must be decremented in the interrupt subroutine. Is it a problem for your system?

concepts ( 2 ); void_pointers ( 2.3 );

concepts ( 2 ); Void pointers Abstraction that permits to the programmer to pass parameters with different types to the same function. The function which is receiving the parameter must know how to deal with it It can not be used without proper casting!

concepts ( 2 ); char * name = "Paulo" ; double weight = 87.5 ; unsigned int children = 3 ; void main (void){ //its not printf, yet. print ( 0 , & name ); print ( 1 , & weight ); print ( 2 , & children ); }

concepts ( 2 ); void print (int option ; void * parameter ){ switch( option ){ case 0 : printf ( "%s" ,(char*) parameter ); break; case 1 : printf ( "%f" ,*((double*) parameter )); break; case 2 : printf ( "%d" ,*((unsigned int*) parameter )); break; } }

void microkernel (float i ){ init_kernel ( 3.0 ); for(int i = 1 ; i < 4 ; i ++;) { kernel_example ( 3 + i / 10 ); } }

microkernel ( 3 ); init_kernel ( 3.0 );

microkernel ( 3 ); We will present the examples using a minimum of hardware or platform specific commands. Unfortunately some actions (specifically the timer) needs to access the hardware. We'll present a brief resume about our platform and some custom headers.

microkernel ( 3 ); //CONFIG.H code char at 0x300000 CONFIG1L = 0x01 ; // No prescaler used code char at 0x300001 CONFIG1H = 0x0C ; // HS: High Speed Cristal code char at 0x300003 CONFIG2H = 0x00 ; // Disabled-Controlled by SWDTEN bit code char at 0x300006 CONFIG4L = 0x00 ; // Disabled low voltage programming //INT.H void InicializaInterrupt (void); //TIMER.H char FimTimer (void); void AguardaTimer (void); void ResetaTimer (unsigned int tempo ); void InicializaTimer (void); //BASICO.H (only part of it) #define SUCCESS 0 #define FAIL 1 #define REPEAT 2 //bit functions #define BitFlp ( arg , bit ) (( arg ) ^= ( 1 << bit )) //special register information #define PORTD (*(volatile __near unsigned char*) 0xF83 ) #define TRISC (*(volatile __near unsigned char*) 0xF94 )

microkernel ( 3 ); //first implementation kernel_example ( 3 + 1 / 10 );

microkernel ( 3 ); In this first example we will build the main part of our kernel. It should have a way to store which functions are needed to be executed and in which order. This will be done by a static vector of pointers to function //pointer function declaration typedef void(* ptrFunc )(void); //process pool static ptrFunc pool [ 4 ];

microkernel ( 3 ); Each process is a function with the same signature of ptrFunc void tst1 (void){ printf ( "Process 1\n" ); } void tst2 (void){ printf ( "Process 2\n" ); } void tst3 (void){ printf ( "Process 3\n" ); }

microkernel ( 3 ); The kernel itself consists of three functions: One to initialize all the internal variables One to add a new process One to execute the main kernel loop //kernel internal variables ptrFunc pool [ 4 ]; int end ; //kernel function's prototypes void kernelInit (void); void kernelAddProc (ptrFunc newFunc ); void kernelLoop (void);

microkernel ( 3 ); //kernel function's implementation void kernelInit (void){ end = 0 ; } void kernelAddProc (ptrFunc newFunc ){ if ( end < 4 ){ pool [ end ] = newFunc ; end ++; } }

microkernel ( 3 ); //kernel function's implementatio n void kernelLoop (void){ int i ; for(;;){ //cycle through the processes for( i = 0 ; i < end ; i ++){ (* pool [ i ])(); } } }

microkernel ( 3 ); //main loop void main (void){ kernelInit (); kernelAddProc ( tst1 ); kernelAddProc ( tst2 ); kernelAddProc ( tst3 ); kernelLoop (); }

microkernel ( 3 ); //second implementation //circular buffer and struct added kernel_example ( 3 + 2 / 10 );

microkernel ( 3 ); The only struct field is the function pointer. Other fields will be added latter. The circular buffer open a new possibility: A process now can state if it wants to be rescheduled or if it is a one-time run process In order to implement this every process must return a code. This code also says if there was any error in the process execution

microkernel ( 3 ); //return code #define SUCCESS 0 #define FAIL 1 #define REPEAT 2 //function pointer declaration typedef char(* ptrFunc )(void); //process struct typedef struct { ptrFunc function ; } process ; process pool [ POOL_SIZE ];

microkernel ( 3 ); char kernelInit (void){ start = 0 ; end = 0 ; return SUCCESS ; } char kernelAddProc (process newProc ){ //checking for free space if ( (( end + 1 )% POOL_SIZE ) != start ){ pool [ end ] = newProc ; end = ( end + 1 )% POOL_SIZE ; return SUCCESS ; } return FAIL ; }

microkernel ( 3 ); void kernelLoop (void){ int i = 0 ; for(;;){ //Do we have any process to execute? if ( start != end ){ printf ( "Ite. %d, Slot. %d: " , i , start ); //check if there is need to reschedule if ((*( pool [ start ]. Func ))() == REPEAT ){ kernelAddProc ( pool [ start ]); } //prepare to get the next process; start = ( start + 1 )% POOL_SIZE ; i ++; // only for debug; } } }

microkernel ( 3 ); //vector of structs process pool [ POOL_SIZE ]; // pool[i] // pool[i].func // *(pool[i].func) // (*(pool[i].func))() //vetor of pointers for struct process* pool [ POOL_SIZE ]; // pool[i] // pool[i].func // pool[i]->func // pool[i]->func()

microkernel ( 3 ); void kernelLoop (void){ int i = 0 ; for(;;){ //Do we have any process to execute? if ( start != end ){ printf ( "Ite. %d, Slot. %d: " , i , start ); //check if there is need to reschedule if ( pool [ start ]-> Func () == REPEAT ){ kernelAddProc ( pool [ start ]); } //prepare to get the next process; start = ( start + 1 )% POOL_SIZE ; i ++; // only for debug; } } }

microkernel ( 3 ); Presenting the new processes void tst1 (void){ printf ( "Process 1\n" ); return REPEAT ; } void tst2 (void){ printf ( "Process 2\n" ); return SUCCESS ; } void tst3 (void){ printf ( "Process 3\n" ); return REPEAT ; }

microkernel ( 3 ); void main (void){ //declaring the processes process p1 = { tst1 }; process p2 = { tst2 }; process p3 = { tst3 }; kernelInit (); //Test if the process was added successfully if ( kernelAddProc ( p1 ) == SUCCESS ){ printf ( "1st process added\n" );} if ( kernelAddProc ( p2 ) == SUCCESS ){ printf ( "2nd process added\n" );} if ( kernelAddProc ( p3 ) == SUCCESS ){ printf ( "3rd process added\n" );} kernelLoop (); }

microkernel ( 3 ); Notes: Only process 1 and 3 are repeating The user don't notice that the pool is finite* Console Output: --------------------------- 1st process added 2nd process added 3rd process added Ite. 0, Slot. 0: Process 1 Ite. 1, Slot. 1: Process 2 Ite. 2, Slot. 2: Process 3 Ite. 3, Slot. 3: Process 1 Ite. 4, Slot. 0: Process 3 Ite. 5, Slot. 1: Process 1 Ite. 6, Slot. 2: Process 3 Ite. 7, Slot. 3: Process 1 Ite. 8, Slot. 0: Process 3 ... ---------------------------

microkernel ( 3 ); //third implementation //time conditions added kernel_example ( 3 + 3 / 10 );

microkernel ( 3 ); The first modification is to add one counter to each process //process struct typedef struct { ptrFunc function ; int period ; int start ; } process ;

microkernel ( 3 ); We must create an function that will run on each timer interrupt updating the counters void isr (void) interrupt 1 { unsigned char i ; i = ini ; while( i != fim ){ if(( pool [ i ]. start )>( MIN_INT )){ pool [ i ]. start --; } i = ( i + 1 )% SLOT_SIZE ; } }

microkernel ( 3 ); The add process function will be the responsible to initialize correctly the fields char AddProc (process newProc ){ //checking for free space if ( (( end + 1 )% SLOT_SIZE ) != start ){ pool [ end ] = newProc ; //increment start timer with period pool [ end ]. start += newProc . period ; end = ( end + 1 )% SLOT_SIZE ; return SUCCESS ; } return FAIL ; }

microkernel ( 3 ); if ( start != end ){ //Finding the process with the smallest start j = ( start + 1 )% SLOT _ SIZE ; next = start ; while ( j != end ){ if ( pool [ j ]. start < pool [ next ]. start ){ next = j ; } j = ( j + 1 )% SLOT_SIZE ; } //exchanging positions in the pool tempProc = pool [ next ]; pool [ next ] = pool [ start ]; pool [ start ] = tempProc ; while( pool [ start ]. start > 0 ){ } //great place to use low power mode if ( (*( pool [ ini ]. function ))() == REPEAT ){ AddProc (&( vetProc [ ini ])); } ini = ( ini + 1 )% SLOT_SIZE ; }

“ Don't Reinvent The Wheel, Unless You Plan on Learning More About Wheels” Jeff Atwood Microkernel development: from project to implementation Rodrigo Maximiano Antunes de Almeida E-mail: rmaalmeida@gmail.com Twitter: @rmaalmeida Universidade Federal de Itajubá

Microkernel Development

Recommended

More Related Content

What's hot (20)

Similar to Microkernel Development (20)

More from Rodrigo Almeida (20)

Recently uploaded (20)

Microkernel Development