• Save
Xilkernel
Upcoming SlideShare
Loading in...5
×
 

Xilkernel

on

  • 11,075 views

Xilkernel...

Xilkernel
Ing. Vincent Claes

Inleiding
OS?
Single-task OS
Multi-Tasking en Multi-User OS
Process and Threads
Memory and Storage
Networks: Services and protocols
TCP/IP Networks
Security: design considerations
XMK + MPSoC
Xilkernel - overview
Small, robust and modular kernel
RTOS
POSIX API
Microblaze, PowerPC
Xilinx Platform Studio (EDK)
Light-weight (16 – 32 kb)

Xilkernel – Why use a kernel?
Typical embedded applications
Various tasks in particular sequence or schedule
Tasks → individual applications on a operating system (OS) is much more intuitive
Enables you to write code at an abstract level

Xilkernel – Why use a kernel?
Many applications rely on OS services like
file systems,
time management,
and so forth.
Xilkernel is a thin library that provides these essential services. Porting or using common and open source libraries (such as graphics or network protocols) might require some form of these OS services.
Xilkernel - Configuration
Configuration
“Software Platform Settings”
Kernel starts by calling xilkernel_main()
Code after this → never reached
Include library “xmk.h” as first library
Xilkernel - Organization
Xilkernel Development Flow
Xilkernel Process Model
Units of execution within xilkernel: process contexts
Scheduling done at process context level
POSIX threads API is primary user-visible interface to process contexts
Interfaces allow creating, destroying and manipulating created application threads (see Xilkernel API)
Threads manipulated with thread identifiers
Underlying process context is identified with process identifier pid_t
Xilkernel scheduling model
Xilkernel
Priority-driven, preemptive scheduling with time slicing (SCHED_PRIO)
Simple Round-robin scheduling (SCHED_RR)
Cannot be changed on a per-thread basis.
Configured statically (at kernel generation time)
Xilkernel scheduling model
SCHED_RR
Single ready queue
Each process context executes for a configured time slice before yielding execution to the next process context in the queue
Xilkernel scheduling model
SCHED_PRIO
As many ready queues as there are priority levels
Priority 0 → highest priority
Higher values → lower priority
Xilkernel scheduling model
SCHED_PRIO
Xilkernel – Process Context States
Each process context
PROC_NEW
A newly created process
PROC_READY
A process ready to execute
PROC_RUN
A process that is running
PROC_WAIT
A process that is blocked on a resource
PROC_DELAY
A process that is waiting for a timeout
PROC_TIMED_WAIT
A process that is blocked on a resource and has an associated timeout
Xilkernel – Process Context States
Xilkernel - Features
Supplies programmer extra abstracted advanced functionality
Thread Management
Semaphores
Message Queues
Shared Memory
Mutex Locks
Dynamic Buffer Memory Management
Software Timers
User-Level Interrupt Handling APIs
ELF Process Management (Deprecated)
Non-lineair execution !
Controlled resource sharing
Xilkernel - Threading
Thread (in xilkernel): a function that is not necessarily processed linearly
Threads are coded like functions, but can work “in parallel”
Threads
Interacting with each other
Pass data back and forth
Xilkernel - Threading
At least one thread required to spawn from the system at kernel start
Main threads → void* without inputs
“OS and Libraries”
“config_pthread_support”
static_pthread_table
Xilkernel - Threading
Xilkernel
2 scheduling modes
SCHED_PRIO
Priority based scheduling
Lower priority threads will always yield to higher priority threads (lower priority number) untill higher priority thread finishes or pthread-joining is used
If 2 threads with same priority → round-robin based scheduling
SCHED_RR
Round-Robin based scheduling
All threads must be processed at close-to the same time. (“parallel”)
Xilkernel - Threading
Pthread support
pthread_create()
pthread_exit()
pthread_join()
pthread_attr_init()
pthread_setschedparam()
Xilkernel – Thread Management
Xilkernel
Basic POSIX threads API
Thread creation and manipulation in st

Statistics

Views

Total Views
11,075
Views on SlideShare
10,999
Embed Views
76

Actions

Likes
9
Downloads
0
Comments
0

8 Embeds 76

http://www.slideshare.net 40
http://www.fachak.com 25
http://fachak.com 3
http://www.slideee.com 3
http://translate.googleusercontent.com 2
http://localhost 1
http://mobile.skynetblogs.be 1
http://ns3.apthost.com 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Xilkernel Xilkernel Presentation Transcript

  • Xilkernel Ing. Vincent Claes    
  • Inleiding • OS? • Single-task OS • Multi-Tasking en Multi-User OS • Process and Threads • Memory and Storage • Networks: Services and protocols • TCP/IP Networks • Security: design considerations • XMK + MPSoC
  • Xilkernel - overview • Small, robust and modular kernel • RTOS • POSIX API • Microblaze, PowerPC • Xilinx Platform Studio (EDK) • Light-weight (16 – 32 kb)
  • Xilkernel – Why use a kernel? • Typical embedded applications – Various tasks in particular sequence or schedule • Tasks → individual applications on a operating system (OS) is much more intuitive • Enables you to write code at an abstract level
  • Xilkernel – Why use a kernel? • Many applications rely on OS services like – file systems, – time management, – and so forth. • Xilkernel is a thin library that provides these essential services. Porting or using common and open source libraries (such as graphics or network protocols) might require some form of these OS services.
  • Xilkernel - Configuration • Configuration – “Software Platform Settings” • Kernel starts by calling xilkernel_main() – Code after this → never reached • Include library “xmk.h” as first library
  • Xilkernel - Organization
  • Xilkernel Development Flow
  • Xilkernel Process Model • Units of execution within xilkernel: process contexts • Scheduling done at process context level • POSIX threads API is primary user-visible interface to process contexts • Interfaces allow creating, destroying and manipulating created application threads (see Xilkernel API) • Threads manipulated with thread identifiers • Underlying process context is identified with process identifier pid_t
  • Xilkernel scheduling model • Xilkernel – Priority-driven, preemptive scheduling with time slicing (SCHED_PRIO) – Simple Round-robin scheduling (SCHED_RR) • Cannot be changed on a per-thread basis. • Configured statically (at kernel generation time)
  • Xilkernel scheduling model • SCHED_RR – Single ready queue – Each process context executes for a configured time slice before yielding execution to the next process context in the queue
  • Xilkernel scheduling model • SCHED_PRIO – As many ready queues as there are priority levels – Priority 0 → highest priority – Higher values → lower priority
  • Xilkernel scheduling model • SCHED_PRIO
  • Xilkernel – Process Context States • Each process context – PROC_NEW • A newly created process – PROC_READY • A process ready to execute – PROC_RUN • A process that is running – PROC_WAIT • A process that is blocked on a resource – PROC_DELAY • A process that is waiting for a timeout – PROC_TIMED_WAIT • A process that is blocked on a resource and has an associated timeout
  • Xilkernel – Process Context States
  • Xilkernel - Features • Supplies programmer extra abstracted advanced functionality – Thread Management – Semaphores – Message Queues – Shared Memory – Mutex Locks – Dynamic Buffer Memory Management – Software Timers – User-Level Interrupt Handling APIs – ELF Process Management (Deprecated) • Non-lineair execution ! • Controlled resource sharing
  • Xilkernel - Threading • Thread (in xilkernel): a function that is not necessarily processed linearly • Threads are coded like functions, but can work “in parallel” • Threads – Interacting with each other – Pass data back and forth
  • Xilkernel - Threading • At least one thread required to spawn from the system at kernel start • Main threads → void* without inputs • “OS and Libraries” – “config_pthread_support” • static_pthread_table
  • Xilkernel - Threading • Xilkernel – 2 scheduling modes • SCHED_PRIO – Priority based scheduling » Lower priority threads will always yield to higher priority threads (lower priority number) untill higher priority thread finishes or pthread- joining is used » If 2 threads with same priority → round-robin based scheduling • SCHED_RR – Round-Robin based scheduling » All threads must be processed at close-to the same time. (“parallel”)
  • Xilkernel - Threading • Pthread support – pthread_create() – pthread_exit() – pthread_join() – pthread_attr_init() – pthread_setschedparam()
  • Xilkernel – Thread Management • Xilkernel – Basic POSIX threads API • Thread creation and manipulation in standard POSIX notation • Threads identified by a unique thread identifier – type: pthread_t
  • Xilkernel - Semaphores • Xilkernel supports Kernel allocated POSIX semaphores – Used for synchronization • POSIX semaphores – Counting semaphores (also below zero) • Negative value: number of processes blocked on the semaphore) • Named semaphores
  • Xilkernel - Semaphores • Mutex + extra functionality – Can be given string names – Contain “counting” information • How many threads it is blocking – More advanced waiting functions such as timed-waiting
  • Xilkernel - Semaphores • sem_init() • sem_getvalue() • sem_wait() • sem_post()
  • Xilkernel – Message Queues • Xilkernel supports Kernel allocated X/ Open System Interface (XSI) message queues • XSI = optional interfaces under POSIX • Message queues → IPC mechanism • Depends on semaphore module and dynamic buffer memory allocation module
  • Xilkernel – Message Queues • Extremely powerful feature • Easy and safe means of transferring data back and forth between multiple processes • Messaging is safe because the functionality uses semaphores internally • Messages can take in custom structs
  • Xilkernel – Message Queues • 4 functions are needed to setup, send and receive messages between threads • Support for multiple messages in the system • msgget() • msgctl() • msgsnd() • msgrcv()
  • Xilkernel – Shared Memory • Xilkernel supports Kernel-allocated XSI shared memory – XSI: X/Open System Interface, an optional interface under POSIX • Shared memory – Low-latency IPC mechanism • Shared memory blocks required during run-time must be identified and specified during system configuration
  • Xilkernel – Shared Memory • Specification – Buffer memory is allocated to each shared memory region • Shared Memory – Not allocated dynamically at run-time
  • Xilkernel – Shared Memory • Xilkernel supports Kernel-allocated XSI shared memory – X/Open System Interface • Set of optional interfaces under POSIX • Shared Memory – Common, low-latency IPC mechanism – Shared memory blocks • Must be identified and specified during system configuration
  • Xilkernel – Shared Memory • From this specification – Buffer memory allocated to each shared memory region • Shared memory is currently not allocated dynamically at run-time • Optional module can be configured in or out during system specification
  • Xilkernel – Shared Memory • int shmget() • int shmctl() • void* shmat() • int shm_dt()
  • Xilkernel – Mutex Locks • Xilkernel has support for Kernel allocated POSIX thread mutex locks • This synchronization mechanism can be used alongside of the pthread API • Mutex lock types – PTHREAD_MUTEX_DEFAULT • Cannot be locked repeatedly by the owner. Attempts by a thread to relock an already held mutex, or to lock a mutex that was held by another thread when that thread terminated result in a deadlock condition. – PTHREAD_MUTEX_RECURSIVE • A recursive mutex can be locked repeatedly by the owner. The mutex doesn't become unlocked until the owner has called pthread_mutex_unlock() for each successful lock request that it has outstanding on the mutex.
  • Xilkernel - Mutex • “Mutual exclusion lock” – Very simple form of semaphore • pthread_mutex_init() • pthread_mutex_lock() • pthread_mutex_unlock() • pthread_mutexattr_init() • pthread_mutexattr_settype()
  • Xilkernel – Dynamic Buffer Memory Management • Xilkernel provides a buffer memory allocation scheme, can be used by applications that need dynamic memory allocation • Alternatives for standard C memory allocation routines like malloc() and free() which are much slower and bigger, though more powerful • The allocation routines hand off pieces of memory from a pool of memory that the user passes to the buffer memory manager.
  • Xilkernel – Dynamic Buffer Memory Management • The buffer memory manager manages the pool of memory. You can dynamically create new pools of memory. • You can statically specify the different memory blocks sizes and number of such memory blocks required for your applications • This method of buffer management is relatively simple, small and a fast way of allocating memory.
  • Xilkernel – Dynamic Memory • Used for allocating buffers of custom sizes and widths • bufcreate() • bufdestroy() • bufmalloc() • buffree()
  • Xilkernel – Software Timers • Xilkernel provides software timer functionality, for time relating processing. – unsigned int xget_clock_ticks() – time_t time(time_t *timer) – unsigned sleep(unsigned int ms)
  • Xilkernel – Interrupt Handling • Xilkernel abstracts primary interrupt handling requirements from the user application • Even though the Kernel is functional without any interrupts, it makes sense for the system to be driven by a single timer interrupt for scheduling.
  • Xilkernel – Interrupt Handling • Kernel handles the main timer interrupt, using it as the Kernel tick to perform scheduling. • The timer interrupt is initialized and tied to the vectoring code during system initialization. • This Kernel pulse provides software timer facilities and time-related routines also.
  • Xilkernel – Interrupt Handling • Additionally, Xilkernel can handle multiple interrupts when connected through an interrupt controller, and works with the opb_intc interrupt controller core.
  • Xilkernel – Interrupt Handling • Basic Interrupt Service in Xilkernel
  • Xilkernel – Exception Handling • Xilkernel handles exceptions for the MicroBlaze processor, threating them as faulting conditions by the executing processes/threads. • Xilkernel kills the faulting process and reports using a message to the console (if verbose mode is on) as to the nature of the exception. • You cannot register your own handlers for these exceptions and Xilkernel handles them all natively.
  • Xilkernel – Interrupts in C • Xilkernel abstracts the function calls to the interrupt controller • Peripherals must be tied to the interrupt controller in hardware – 1. “Software Platform Settings” under “Interrupt Handlers” give desired interrupt a handler name. The interrupt controller does not require a handler unless the user would like a special function call for any interrupt that occurs
  • Xilkernel – Interrupts in C – 2. In main code, initialize the interrupting peripheral with it's API – 3. Initialize the interrupting peripheral's interrupt with it's API and start it running if required (such as a timer) – 4. use the xilkernel function: “enable_interrupt()” - which takes in the interrupt ID of the peripheral found in “xparameters.h”. For the enable function call, it is of type “int_id_t” – 5. Have a function prepared with the handler name
  • Xilkernel – Memory Protection • Memory protection is an extremely useful feature that can increase the robustness, reliability, and fault tolerance of your Xilkernel-based application.
  • Xilkernel – Memory Protection • Memory protection requires support from the hardware. • Xilkernel is designed to make use of the MicroBlaze Memory Management (Protection) Unit (MMU) features when available. This allows you to build fail- safe applications that each run within the valid sandbox of the system, as determined by the executable file and available I/O devices.
  • Xilkernel – Memory Protection • Note: Full virtual memory management is not supported by Xilkernel. Even when a full MMU is available on MicroBlaze, only transparent memory translations are used, and there is no concept of demand paging. • Note: Xilkernel does not support the same set of features using the MMU on PowerPC processors.
  • Xilkernel – Hardware Requirements • Scheduling and all the dependent features require a periodic Kernel tick and typically some kind of timer is used. • Xilkernel has been designed to be able to work with either the Xilinx fit_timer IP core or the opb_timer IP core.
  • Xilkernel – Hardware Requirements • Xilkernel has also been designed to work in scenarios involving multiple- interrupting peripherals. • The opb_intc IP core is used to handle the hardware interrupts and then feed a single IRQ line from the controller to the processor.
  • Xilkernel – Hardware Requirements • By specifying the name of the interruptcontroller peripheral in the software platform configuration, you would be getting Kernel awareness of multiple interrupts. Xilkernel would automatically initialize the hardware cores, interrupt system, and the second level of software handlers as a part of its startup. • You don't have to do this manually.
  • Xilkernel – Hardware Requirements • Xilkernel handles non-cascaded interrupt controllers; cascaded interrupt controllers are not supported.
  • Xilkernel – System Initialization • The entry point for the Kernel is the xilkernel_main( ) routine defined in main.c. • Any user initialization that must be performed can be done before the call to xilkernel_main( ). This includes any system-wide features that might need to be enabled before invoking xilkernel_main( ).
  • Xilkernel – System Initialization • These are typically machine-state features such as cache enablement or hardware exception enablement that must be quot;always ONquot; even when context switching between applications. • Make sure to set up such system states before invoking xilkernel_main( ).
  • Xilkernel – System Initialization • The first action that is performed within xilkernel_init is kernel-specific • hardware initialization. – This includes • registering the interrupt handlers and configuring the system timer, • as well as memory protection initialization. Interrupts/exceptions are not enabled • after completing hw_init( ). The sys_init( ) routine is entered next.
  • Xilkernel – System Initialization • This routine performs initialization of each module, such as processes and threads, initializing in the following order: – 1. Internal process context structures – 2. Ready queues – 3. pthread module – 4. Semaphore module – 5. Message queue module – 6. Shared memory module – 7. Memory allocation module – 8. Software timers module – 9. Idle task creation – 10. Static pthread creation • After these steps, interrupts, and exceptions are enabled, the Kernel loops infinitely in the idle task, enabling the scheduler to start scheduling processes.
  • Xilkernel – Example MSS
  • Xilkernel - Links • Wireless Open-Access Research Platform – http://warp.rice.edu/trac/wiki/xilkernel_ref – http://warp.rice.edu/trac/wiki/ppc_prog_overv • Microblaze SMP Project – http://www.escet.urjc.es/~phuerta/SMP_proje • University of Dayton – http://academic.udayton.edu/markpatterson/ • Team iBox – www.et.byu.edu/groups/ibox/public/doc