SlideShare una empresa de Scribd logo
1 de 58
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

Más contenido relacionado

La actualidad más candente

Cockatrice: A Hardware Design Environment with Elixir
Cockatrice: A Hardware Design Environment with ElixirCockatrice: A Hardware Design Environment with Elixir
Cockatrice: A Hardware Design Environment with ElixirHideki Takase
 
Low-level Shader Optimization for Next-Gen and DX11 by Emil Persson
Low-level Shader Optimization for Next-Gen and DX11 by Emil PerssonLow-level Shader Optimization for Next-Gen and DX11 by Emil Persson
Low-level Shader Optimization for Next-Gen and DX11 by Emil PerssonAMD Developer Central
 
“Linux Kernel CPU Hotplug in the Multicore System”
“Linux Kernel CPU Hotplug in the Multicore System”“Linux Kernel CPU Hotplug in the Multicore System”
“Linux Kernel CPU Hotplug in the Multicore System”GlobalLogic Ukraine
 
IPSec (Internet Protocol Security) - PART 1
IPSec (Internet Protocol Security) - PART 1IPSec (Internet Protocol Security) - PART 1
IPSec (Internet Protocol Security) - PART 1Shobhit Sharma
 
ACRi HLSチャレンジ紹介
ACRi HLSチャレンジ紹介ACRi HLSチャレンジ紹介
ACRi HLSチャレンジ紹介Jun Ando
 
DX12 & Vulkan: Dawn of a New Generation of Graphics APIs
DX12 & Vulkan: Dawn of a New Generation of Graphics APIsDX12 & Vulkan: Dawn of a New Generation of Graphics APIs
DX12 & Vulkan: Dawn of a New Generation of Graphics APIsAMD Developer Central
 
Optimization Deep Dive: Unreal Engine 4 on Intel
Optimization Deep Dive: Unreal Engine 4 on IntelOptimization Deep Dive: Unreal Engine 4 on Intel
Optimization Deep Dive: Unreal Engine 4 on IntelIntel® Software
 
Looking into trusted and encrypted keys
Looking into trusted and encrypted keysLooking into trusted and encrypted keys
Looking into trusted and encrypted keysSUSE Labs Taipei
 
組み込み関数(intrinsic)によるSIMD入門
組み込み関数(intrinsic)によるSIMD入門組み込み関数(intrinsic)によるSIMD入門
組み込み関数(intrinsic)によるSIMD入門Norishige Fukushima
 
Dx11 performancereloaded
Dx11 performancereloadedDx11 performancereloaded
Dx11 performancereloadedmistercteam
 
Masked Software Occlusion Culling
Masked Software Occlusion CullingMasked Software Occlusion Culling
Masked Software Occlusion CullingIntel® Software
 
Heterogeneous Systems Architecture: The Next Area of Computing Innovation
Heterogeneous Systems Architecture: The Next Area of Computing Innovation Heterogeneous Systems Architecture: The Next Area of Computing Innovation
Heterogeneous Systems Architecture: The Next Area of Computing Innovation AMD
 
Precomputed Voxelized-Shadows for Large-scale Scene and Many lights
Precomputed Voxelized-Shadows for Large-scale Scene and Many lightsPrecomputed Voxelized-Shadows for Large-scale Scene and Many lights
Precomputed Voxelized-Shadows for Large-scale Scene and Many lightsSeongdae Kim
 
[若渴計畫]由GPU硬體概念到coding CUDA
[若渴計畫]由GPU硬體概念到coding CUDA[若渴計畫]由GPU硬體概念到coding CUDA
[若渴計畫]由GPU硬體概念到coding CUDAAj MaChInE
 
Checkerboard Rendering in Dark Souls: Remastered by QLOC
Checkerboard Rendering in Dark Souls: Remastered by QLOCCheckerboard Rendering in Dark Souls: Remastered by QLOC
Checkerboard Rendering in Dark Souls: Remastered by QLOCQLOC
 
Vivado hls勉強会1(基礎編)
Vivado hls勉強会1(基礎編)Vivado hls勉強会1(基礎編)
Vivado hls勉強会1(基礎編)marsee101
 
Play with FILE Structure - Yet Another Binary Exploit Technique
Play with FILE Structure - Yet Another Binary Exploit TechniquePlay with FILE Structure - Yet Another Binary Exploit Technique
Play with FILE Structure - Yet Another Binary Exploit TechniqueAngel Boy
 
COSCUP 2020 RISC-V 32 bit linux highmem porting
COSCUP 2020 RISC-V 32 bit linux highmem portingCOSCUP 2020 RISC-V 32 bit linux highmem porting
COSCUP 2020 RISC-V 32 bit linux highmem portingEric Lin
 
Zynq mp勉強会資料
Zynq mp勉強会資料Zynq mp勉強会資料
Zynq mp勉強会資料一路 川染
 

La actualidad más candente (20)

Cockatrice: A Hardware Design Environment with Elixir
Cockatrice: A Hardware Design Environment with ElixirCockatrice: A Hardware Design Environment with Elixir
Cockatrice: A Hardware Design Environment with Elixir
 
Low-level Shader Optimization for Next-Gen and DX11 by Emil Persson
Low-level Shader Optimization for Next-Gen and DX11 by Emil PerssonLow-level Shader Optimization for Next-Gen and DX11 by Emil Persson
Low-level Shader Optimization for Next-Gen and DX11 by Emil Persson
 
“Linux Kernel CPU Hotplug in the Multicore System”
“Linux Kernel CPU Hotplug in the Multicore System”“Linux Kernel CPU Hotplug in the Multicore System”
“Linux Kernel CPU Hotplug in the Multicore System”
 
IPSec (Internet Protocol Security) - PART 1
IPSec (Internet Protocol Security) - PART 1IPSec (Internet Protocol Security) - PART 1
IPSec (Internet Protocol Security) - PART 1
 
ACRi HLSチャレンジ紹介
ACRi HLSチャレンジ紹介ACRi HLSチャレンジ紹介
ACRi HLSチャレンジ紹介
 
DX12 & Vulkan: Dawn of a New Generation of Graphics APIs
DX12 & Vulkan: Dawn of a New Generation of Graphics APIsDX12 & Vulkan: Dawn of a New Generation of Graphics APIs
DX12 & Vulkan: Dawn of a New Generation of Graphics APIs
 
Optimization Deep Dive: Unreal Engine 4 on Intel
Optimization Deep Dive: Unreal Engine 4 on IntelOptimization Deep Dive: Unreal Engine 4 on Intel
Optimization Deep Dive: Unreal Engine 4 on Intel
 
Looking into trusted and encrypted keys
Looking into trusted and encrypted keysLooking into trusted and encrypted keys
Looking into trusted and encrypted keys
 
組み込み関数(intrinsic)によるSIMD入門
組み込み関数(intrinsic)によるSIMD入門組み込み関数(intrinsic)によるSIMD入門
組み込み関数(intrinsic)によるSIMD入門
 
Dx11 performancereloaded
Dx11 performancereloadedDx11 performancereloaded
Dx11 performancereloaded
 
Masked Software Occlusion Culling
Masked Software Occlusion CullingMasked Software Occlusion Culling
Masked Software Occlusion Culling
 
Heterogeneous Systems Architecture: The Next Area of Computing Innovation
Heterogeneous Systems Architecture: The Next Area of Computing Innovation Heterogeneous Systems Architecture: The Next Area of Computing Innovation
Heterogeneous Systems Architecture: The Next Area of Computing Innovation
 
Precomputed Voxelized-Shadows for Large-scale Scene and Many lights
Precomputed Voxelized-Shadows for Large-scale Scene and Many lightsPrecomputed Voxelized-Shadows for Large-scale Scene and Many lights
Precomputed Voxelized-Shadows for Large-scale Scene and Many lights
 
[若渴計畫]由GPU硬體概念到coding CUDA
[若渴計畫]由GPU硬體概念到coding CUDA[若渴計畫]由GPU硬體概念到coding CUDA
[若渴計畫]由GPU硬體概念到coding CUDA
 
Checkerboard Rendering in Dark Souls: Remastered by QLOC
Checkerboard Rendering in Dark Souls: Remastered by QLOCCheckerboard Rendering in Dark Souls: Remastered by QLOC
Checkerboard Rendering in Dark Souls: Remastered by QLOC
 
Vivado hls勉強会1(基礎編)
Vivado hls勉強会1(基礎編)Vivado hls勉強会1(基礎編)
Vivado hls勉強会1(基礎編)
 
Play with FILE Structure - Yet Another Binary Exploit Technique
Play with FILE Structure - Yet Another Binary Exploit TechniquePlay with FILE Structure - Yet Another Binary Exploit Technique
Play with FILE Structure - Yet Another Binary Exploit Technique
 
Spi drivers
Spi driversSpi drivers
Spi drivers
 
COSCUP 2020 RISC-V 32 bit linux highmem porting
COSCUP 2020 RISC-V 32 bit linux highmem portingCOSCUP 2020 RISC-V 32 bit linux highmem porting
COSCUP 2020 RISC-V 32 bit linux highmem porting
 
Zynq mp勉強会資料
Zynq mp勉強会資料Zynq mp勉強会資料
Zynq mp勉強会資料
 

Destacado

EtherCAT @ Hogeschool PXL (PXL-TECH)
EtherCAT @ Hogeschool PXL (PXL-TECH)EtherCAT @ Hogeschool PXL (PXL-TECH)
EtherCAT @ Hogeschool PXL (PXL-TECH)Vincent Claes
 
Thread And Seam Construction
Thread And Seam ConstructionThread And Seam Construction
Thread And Seam ConstructionMackenzie Walton
 
Industrial Revolution Powerpoint
Industrial Revolution PowerpointIndustrial Revolution Powerpoint
Industrial Revolution Powerpointtheironegoodson
 
ScilabTEC 2015 - Xilinx
ScilabTEC 2015 - XilinxScilabTEC 2015 - Xilinx
ScilabTEC 2015 - XilinxScilab
 
Hadoop Summit Europe 2014: Apache Storm Architecture
Hadoop Summit Europe 2014: Apache Storm ArchitectureHadoop Summit Europe 2014: Apache Storm Architecture
Hadoop Summit Europe 2014: Apache Storm ArchitectureP. Taylor Goetz
 

Destacado (6)

Maker Revolution
Maker RevolutionMaker Revolution
Maker Revolution
 
EtherCAT @ Hogeschool PXL (PXL-TECH)
EtherCAT @ Hogeschool PXL (PXL-TECH)EtherCAT @ Hogeschool PXL (PXL-TECH)
EtherCAT @ Hogeschool PXL (PXL-TECH)
 
Thread And Seam Construction
Thread And Seam ConstructionThread And Seam Construction
Thread And Seam Construction
 
Industrial Revolution Powerpoint
Industrial Revolution PowerpointIndustrial Revolution Powerpoint
Industrial Revolution Powerpoint
 
ScilabTEC 2015 - Xilinx
ScilabTEC 2015 - XilinxScilabTEC 2015 - Xilinx
ScilabTEC 2015 - Xilinx
 
Hadoop Summit Europe 2014: Apache Storm Architecture
Hadoop Summit Europe 2014: Apache Storm ArchitectureHadoop Summit Europe 2014: Apache Storm Architecture
Hadoop Summit Europe 2014: Apache Storm Architecture
 

Similar a Xilkernel

Evergreen Sysadmin Survival Skills
Evergreen Sysadmin Survival SkillsEvergreen Sysadmin Survival Skills
Evergreen Sysadmin Survival SkillsEvergreen ILS
 
Intro To .Net Threads
Intro To .Net ThreadsIntro To .Net Threads
Intro To .Net Threadsrchakra
 
Tuning parallelcodeonsolaris005
Tuning parallelcodeonsolaris005Tuning parallelcodeonsolaris005
Tuning parallelcodeonsolaris005dflexer
 
Lec 9-os-review
Lec 9-os-reviewLec 9-os-review
Lec 9-os-reviewMothi R
 
Brief Introduction to Parallella
Brief Introduction to ParallellaBrief Introduction to Parallella
Brief Introduction to ParallellaSomnath Mazumdar
 
System Device Tree and Lopper: Concrete Examples - ELC NA 2022
System Device Tree and Lopper: Concrete Examples - ELC NA 2022System Device Tree and Lopper: Concrete Examples - ELC NA 2022
System Device Tree and Lopper: Concrete Examples - ELC NA 2022Stefano Stabellini
 
Fedora Virtualization Day: Linux Containers & CRIU
Fedora Virtualization Day: Linux Containers & CRIUFedora Virtualization Day: Linux Containers & CRIU
Fedora Virtualization Day: Linux Containers & CRIUAndrey Vagin
 
Lec 10-linux-review
Lec 10-linux-reviewLec 10-linux-review
Lec 10-linux-reviewabinaya m
 
Multithreading computer architecture
 Multithreading computer architecture  Multithreading computer architecture
Multithreading computer architecture Haris456
 
2. Vagin. Linux containers. June 01, 2013
2. Vagin. Linux containers. June 01, 20132. Vagin. Linux containers. June 01, 2013
2. Vagin. Linux containers. June 01, 2013ru-fedora-moscow-2013
 
New hope is comming? Project Loom.pdf
New hope is comming? Project Loom.pdfNew hope is comming? Project Loom.pdf
New hope is comming? Project Loom.pdfKrystian Zybała
 
cachegrand: A Take on High Performance Caching
cachegrand: A Take on High Performance Cachingcachegrand: A Take on High Performance Caching
cachegrand: A Take on High Performance CachingScyllaDB
 
Multithreaded processors ppt
Multithreaded processors pptMultithreaded processors ppt
Multithreaded processors pptSiddhartha Anand
 
Current and Future of Non-Volatile Memory on Linux
Current and Future of Non-Volatile Memory on LinuxCurrent and Future of Non-Volatile Memory on Linux
Current and Future of Non-Volatile Memory on Linuxmountpoint.io
 
Taming Non-blocking Caches to Improve Isolation in Multicore Real-Time Systems
Taming Non-blocking Caches to Improve Isolation in Multicore Real-Time SystemsTaming Non-blocking Caches to Improve Isolation in Multicore Real-Time Systems
Taming Non-blocking Caches to Improve Isolation in Multicore Real-Time SystemsHeechul Yun
 
Nodes and Networks for HPC computing
Nodes and Networks for HPC computingNodes and Networks for HPC computing
Nodes and Networks for HPC computingrinnocente
 

Similar a Xilkernel (20)

General Purpose GPU Computing
General Purpose GPU ComputingGeneral Purpose GPU Computing
General Purpose GPU Computing
 
Evergreen Sysadmin Survival Skills
Evergreen Sysadmin Survival SkillsEvergreen Sysadmin Survival Skills
Evergreen Sysadmin Survival Skills
 
Intro To .Net Threads
Intro To .Net ThreadsIntro To .Net Threads
Intro To .Net Threads
 
Memory model
Memory modelMemory model
Memory model
 
Tuning parallelcodeonsolaris005
Tuning parallelcodeonsolaris005Tuning parallelcodeonsolaris005
Tuning parallelcodeonsolaris005
 
Lec 9-os-review
Lec 9-os-reviewLec 9-os-review
Lec 9-os-review
 
Windows kernel
Windows kernelWindows kernel
Windows kernel
 
Brief Introduction to Parallella
Brief Introduction to ParallellaBrief Introduction to Parallella
Brief Introduction to Parallella
 
System Device Tree and Lopper: Concrete Examples - ELC NA 2022
System Device Tree and Lopper: Concrete Examples - ELC NA 2022System Device Tree and Lopper: Concrete Examples - ELC NA 2022
System Device Tree and Lopper: Concrete Examples - ELC NA 2022
 
Fedora Virtualization Day: Linux Containers & CRIU
Fedora Virtualization Day: Linux Containers & CRIUFedora Virtualization Day: Linux Containers & CRIU
Fedora Virtualization Day: Linux Containers & CRIU
 
Lec 10-linux-review
Lec 10-linux-reviewLec 10-linux-review
Lec 10-linux-review
 
Multithreading computer architecture
 Multithreading computer architecture  Multithreading computer architecture
Multithreading computer architecture
 
2. Vagin. Linux containers. June 01, 2013
2. Vagin. Linux containers. June 01, 20132. Vagin. Linux containers. June 01, 2013
2. Vagin. Linux containers. June 01, 2013
 
New hope is comming? Project Loom.pdf
New hope is comming? Project Loom.pdfNew hope is comming? Project Loom.pdf
New hope is comming? Project Loom.pdf
 
cachegrand: A Take on High Performance Caching
cachegrand: A Take on High Performance Cachingcachegrand: A Take on High Performance Caching
cachegrand: A Take on High Performance Caching
 
Multithreaded processors ppt
Multithreaded processors pptMultithreaded processors ppt
Multithreaded processors ppt
 
Current and Future of Non-Volatile Memory on Linux
Current and Future of Non-Volatile Memory on LinuxCurrent and Future of Non-Volatile Memory on Linux
Current and Future of Non-Volatile Memory on Linux
 
Taming Non-blocking Caches to Improve Isolation in Multicore Real-Time Systems
Taming Non-blocking Caches to Improve Isolation in Multicore Real-Time SystemsTaming Non-blocking Caches to Improve Isolation in Multicore Real-Time Systems
Taming Non-blocking Caches to Improve Isolation in Multicore Real-Time Systems
 
Mmap failure analysis
Mmap failure analysisMmap failure analysis
Mmap failure analysis
 
Nodes and Networks for HPC computing
Nodes and Networks for HPC computingNodes and Networks for HPC computing
Nodes and Networks for HPC computing
 

Más de Vincent Claes

Percepio Tracealyzer for FreeRTOS on MiniZED
Percepio Tracealyzer for FreeRTOS on MiniZEDPercepio Tracealyzer for FreeRTOS on MiniZED
Percepio Tracealyzer for FreeRTOS on MiniZEDVincent Claes
 
Xilinx Vitis FreeRTOS Hello World
Xilinx Vitis FreeRTOS Hello WorldXilinx Vitis FreeRTOS Hello World
Xilinx Vitis FreeRTOS Hello WorldVincent Claes
 
Programming STM32L432 Nucleo with Keil MDK
Programming STM32L432 Nucleo with Keil MDKProgramming STM32L432 Nucleo with Keil MDK
Programming STM32L432 Nucleo with Keil MDKVincent Claes
 
Debugging Xilinx Zynq Project using ILA Integrated Logic Analyzer IP Block
Debugging Xilinx Zynq Project using ILA Integrated Logic Analyzer IP BlockDebugging Xilinx Zynq Project using ILA Integrated Logic Analyzer IP Block
Debugging Xilinx Zynq Project using ILA Integrated Logic Analyzer IP BlockVincent Claes
 
Using Virtual IO (VIO) on Xilinx ZYNQ FPGA's
Using Virtual IO (VIO) on Xilinx ZYNQ FPGA'sUsing Virtual IO (VIO) on Xilinx ZYNQ FPGA's
Using Virtual IO (VIO) on Xilinx ZYNQ FPGA'sVincent Claes
 
Profiling Xilinx Zynq Software Applications in SDK (MiniZED board)
Profiling Xilinx Zynq Software Applications in SDK (MiniZED board)Profiling Xilinx Zynq Software Applications in SDK (MiniZED board)
Profiling Xilinx Zynq Software Applications in SDK (MiniZED board)Vincent Claes
 
Workshop: Introductie tot Python
Workshop: Introductie tot PythonWorkshop: Introductie tot Python
Workshop: Introductie tot PythonVincent Claes
 
Installation Anaconda Navigator for Python Workshop
Installation Anaconda Navigator for Python WorkshopInstallation Anaconda Navigator for Python Workshop
Installation Anaconda Navigator for Python WorkshopVincent Claes
 
ZYNQ BRAM Implementation
ZYNQ BRAM ImplementationZYNQ BRAM Implementation
ZYNQ BRAM ImplementationVincent Claes
 
Implementing a Database and API for your Cloud Service
Implementing a Database and API for your Cloud ServiceImplementing a Database and API for your Cloud Service
Implementing a Database and API for your Cloud ServiceVincent Claes
 
Launching Python Cloud Services for AI/IoT Projects
Launching Python Cloud Services for AI/IoT ProjectsLaunching Python Cloud Services for AI/IoT Projects
Launching Python Cloud Services for AI/IoT ProjectsVincent Claes
 
Real Time Filtering on Embedded ARM
Real Time Filtering on Embedded ARMReal Time Filtering on Embedded ARM
Real Time Filtering on Embedded ARMVincent Claes
 
R Markdown, Rpubs & github publishing and Shiny by Example
R Markdown, Rpubs & github publishing and Shiny by ExampleR Markdown, Rpubs & github publishing and Shiny by Example
R Markdown, Rpubs & github publishing and Shiny by ExampleVincent Claes
 
Using Texas Instruments Code Composer Studio for The CC3200XL Launchpad
Using Texas Instruments Code Composer Studio for The CC3200XL LaunchpadUsing Texas Instruments Code Composer Studio for The CC3200XL Launchpad
Using Texas Instruments Code Composer Studio for The CC3200XL LaunchpadVincent Claes
 
Hogeschool PXL Smart Mirror
Hogeschool PXL Smart MirrorHogeschool PXL Smart Mirror
Hogeschool PXL Smart MirrorVincent Claes
 
Softcore vs Hardcore processor
Softcore vs Hardcore processorSoftcore vs Hardcore processor
Softcore vs Hardcore processorVincent Claes
 
Implementing an interface in r to communicate with programmable fabric in a x...
Implementing an interface in r to communicate with programmable fabric in a x...Implementing an interface in r to communicate with programmable fabric in a x...
Implementing an interface in r to communicate with programmable fabric in a x...Vincent Claes
 
Debugging IoT Sensor Interfaces (SPI) with Digilent Analog Discovery 2
Debugging IoT Sensor Interfaces (SPI) with Digilent Analog Discovery 2Debugging IoT Sensor Interfaces (SPI) with Digilent Analog Discovery 2
Debugging IoT Sensor Interfaces (SPI) with Digilent Analog Discovery 2Vincent Claes
 

Más de Vincent Claes (20)

Percepio Tracealyzer for FreeRTOS on MiniZED
Percepio Tracealyzer for FreeRTOS on MiniZEDPercepio Tracealyzer for FreeRTOS on MiniZED
Percepio Tracealyzer for FreeRTOS on MiniZED
 
Xilinx Vitis FreeRTOS Hello World
Xilinx Vitis FreeRTOS Hello WorldXilinx Vitis FreeRTOS Hello World
Xilinx Vitis FreeRTOS Hello World
 
Programming STM32L432 Nucleo with Keil MDK
Programming STM32L432 Nucleo with Keil MDKProgramming STM32L432 Nucleo with Keil MDK
Programming STM32L432 Nucleo with Keil MDK
 
Debugging Xilinx Zynq Project using ILA Integrated Logic Analyzer IP Block
Debugging Xilinx Zynq Project using ILA Integrated Logic Analyzer IP BlockDebugging Xilinx Zynq Project using ILA Integrated Logic Analyzer IP Block
Debugging Xilinx Zynq Project using ILA Integrated Logic Analyzer IP Block
 
Using Virtual IO (VIO) on Xilinx ZYNQ FPGA's
Using Virtual IO (VIO) on Xilinx ZYNQ FPGA'sUsing Virtual IO (VIO) on Xilinx ZYNQ FPGA's
Using Virtual IO (VIO) on Xilinx ZYNQ FPGA's
 
Profiling Xilinx Zynq Software Applications in SDK (MiniZED board)
Profiling Xilinx Zynq Software Applications in SDK (MiniZED board)Profiling Xilinx Zynq Software Applications in SDK (MiniZED board)
Profiling Xilinx Zynq Software Applications in SDK (MiniZED board)
 
Workshop: Introductie tot Python
Workshop: Introductie tot PythonWorkshop: Introductie tot Python
Workshop: Introductie tot Python
 
Installation Anaconda Navigator for Python Workshop
Installation Anaconda Navigator for Python WorkshopInstallation Anaconda Navigator for Python Workshop
Installation Anaconda Navigator for Python Workshop
 
ZYNQ BRAM Implementation
ZYNQ BRAM ImplementationZYNQ BRAM Implementation
ZYNQ BRAM Implementation
 
Implementing a Database and API for your Cloud Service
Implementing a Database and API for your Cloud ServiceImplementing a Database and API for your Cloud Service
Implementing a Database and API for your Cloud Service
 
Launching Python Cloud Services for AI/IoT Projects
Launching Python Cloud Services for AI/IoT ProjectsLaunching Python Cloud Services for AI/IoT Projects
Launching Python Cloud Services for AI/IoT Projects
 
Real Time Filtering on Embedded ARM
Real Time Filtering on Embedded ARMReal Time Filtering on Embedded ARM
Real Time Filtering on Embedded ARM
 
R Markdown, Rpubs & github publishing and Shiny by Example
R Markdown, Rpubs & github publishing and Shiny by ExampleR Markdown, Rpubs & github publishing and Shiny by Example
R Markdown, Rpubs & github publishing and Shiny by Example
 
Using Texas Instruments Code Composer Studio for The CC3200XL Launchpad
Using Texas Instruments Code Composer Studio for The CC3200XL LaunchpadUsing Texas Instruments Code Composer Studio for The CC3200XL Launchpad
Using Texas Instruments Code Composer Studio for The CC3200XL Launchpad
 
Hogeschool PXL Smart Mirror
Hogeschool PXL Smart MirrorHogeschool PXL Smart Mirror
Hogeschool PXL Smart Mirror
 
Softcore vs Hardcore processor
Softcore vs Hardcore processorSoftcore vs Hardcore processor
Softcore vs Hardcore processor
 
MySQL / PHP Server
MySQL / PHP ServerMySQL / PHP Server
MySQL / PHP Server
 
Implementing an interface in r to communicate with programmable fabric in a x...
Implementing an interface in r to communicate with programmable fabric in a x...Implementing an interface in r to communicate with programmable fabric in a x...
Implementing an interface in r to communicate with programmable fabric in a x...
 
fTales workshop
fTales workshopfTales workshop
fTales workshop
 
Debugging IoT Sensor Interfaces (SPI) with Digilent Analog Discovery 2
Debugging IoT Sensor Interfaces (SPI) with Digilent Analog Discovery 2Debugging IoT Sensor Interfaces (SPI) with Digilent Analog Discovery 2
Debugging IoT Sensor Interfaces (SPI) with Digilent Analog Discovery 2
 

Último

Building Your Own AI Instance (TBLC AI )
Building Your Own AI Instance (TBLC AI )Building Your Own AI Instance (TBLC AI )
Building Your Own AI Instance (TBLC AI )Brian Pichman
 
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdfIaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdfDaniel Santiago Silva Capera
 
ADOPTING WEB 3 FOR YOUR BUSINESS: A STEP-BY-STEP GUIDE
ADOPTING WEB 3 FOR YOUR BUSINESS: A STEP-BY-STEP GUIDEADOPTING WEB 3 FOR YOUR BUSINESS: A STEP-BY-STEP GUIDE
ADOPTING WEB 3 FOR YOUR BUSINESS: A STEP-BY-STEP GUIDELiveplex
 
UiPath Community: AI for UiPath Automation Developers
UiPath Community: AI for UiPath Automation DevelopersUiPath Community: AI for UiPath Automation Developers
UiPath Community: AI for UiPath Automation DevelopersUiPathCommunity
 
UiPath Studio Web workshop series - Day 8
UiPath Studio Web workshop series - Day 8UiPath Studio Web workshop series - Day 8
UiPath Studio Web workshop series - Day 8DianaGray10
 
Videogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfVideogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfinfogdgmi
 
Linked Data in Production: Moving Beyond Ontologies
Linked Data in Production: Moving Beyond OntologiesLinked Data in Production: Moving Beyond Ontologies
Linked Data in Production: Moving Beyond OntologiesDavid Newbury
 
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve DecarbonizationUsing IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve DecarbonizationIES VE
 
Designing A Time bound resource download URL
Designing A Time bound resource download URLDesigning A Time bound resource download URL
Designing A Time bound resource download URLRuncy Oommen
 
Machine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfMachine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfAijun Zhang
 
Basic Building Blocks of Internet of Things.
Basic Building Blocks of Internet of Things.Basic Building Blocks of Internet of Things.
Basic Building Blocks of Internet of Things.YounusS2
 
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1DianaGray10
 
Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Adtran
 
Igniting Next Level Productivity with AI-Infused Data Integration Workflows
Igniting Next Level Productivity with AI-Infused Data Integration WorkflowsIgniting Next Level Productivity with AI-Infused Data Integration Workflows
Igniting Next Level Productivity with AI-Infused Data Integration WorkflowsSafe Software
 
UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7DianaGray10
 
OpenShift Commons Paris - Choose Your Own Observability Adventure
OpenShift Commons Paris - Choose Your Own Observability AdventureOpenShift Commons Paris - Choose Your Own Observability Adventure
OpenShift Commons Paris - Choose Your Own Observability AdventureEric D. Schabell
 
20230202 - Introduction to tis-py
20230202 - Introduction to tis-py20230202 - Introduction to tis-py
20230202 - Introduction to tis-pyJamie (Taka) Wang
 
UiPath Studio Web workshop series - Day 6
UiPath Studio Web workshop series - Day 6UiPath Studio Web workshop series - Day 6
UiPath Studio Web workshop series - Day 6DianaGray10
 
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...Will Schroeder
 

Último (20)

201610817 - edge part1
201610817 - edge part1201610817 - edge part1
201610817 - edge part1
 
Building Your Own AI Instance (TBLC AI )
Building Your Own AI Instance (TBLC AI )Building Your Own AI Instance (TBLC AI )
Building Your Own AI Instance (TBLC AI )
 
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdfIaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
 
ADOPTING WEB 3 FOR YOUR BUSINESS: A STEP-BY-STEP GUIDE
ADOPTING WEB 3 FOR YOUR BUSINESS: A STEP-BY-STEP GUIDEADOPTING WEB 3 FOR YOUR BUSINESS: A STEP-BY-STEP GUIDE
ADOPTING WEB 3 FOR YOUR BUSINESS: A STEP-BY-STEP GUIDE
 
UiPath Community: AI for UiPath Automation Developers
UiPath Community: AI for UiPath Automation DevelopersUiPath Community: AI for UiPath Automation Developers
UiPath Community: AI for UiPath Automation Developers
 
UiPath Studio Web workshop series - Day 8
UiPath Studio Web workshop series - Day 8UiPath Studio Web workshop series - Day 8
UiPath Studio Web workshop series - Day 8
 
Videogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfVideogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdf
 
Linked Data in Production: Moving Beyond Ontologies
Linked Data in Production: Moving Beyond OntologiesLinked Data in Production: Moving Beyond Ontologies
Linked Data in Production: Moving Beyond Ontologies
 
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve DecarbonizationUsing IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
 
Designing A Time bound resource download URL
Designing A Time bound resource download URLDesigning A Time bound resource download URL
Designing A Time bound resource download URL
 
Machine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfMachine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdf
 
Basic Building Blocks of Internet of Things.
Basic Building Blocks of Internet of Things.Basic Building Blocks of Internet of Things.
Basic Building Blocks of Internet of Things.
 
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
 
Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™
 
Igniting Next Level Productivity with AI-Infused Data Integration Workflows
Igniting Next Level Productivity with AI-Infused Data Integration WorkflowsIgniting Next Level Productivity with AI-Infused Data Integration Workflows
Igniting Next Level Productivity with AI-Infused Data Integration Workflows
 
UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7
 
OpenShift Commons Paris - Choose Your Own Observability Adventure
OpenShift Commons Paris - Choose Your Own Observability AdventureOpenShift Commons Paris - Choose Your Own Observability Adventure
OpenShift Commons Paris - Choose Your Own Observability Adventure
 
20230202 - Introduction to tis-py
20230202 - Introduction to tis-py20230202 - Introduction to tis-py
20230202 - Introduction to tis-py
 
UiPath Studio Web workshop series - Day 6
UiPath Studio Web workshop series - Day 6UiPath Studio Web workshop series - Day 6
UiPath Studio Web workshop series - Day 6
 
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
 

Xilkernel

  • 1. Xilkernel Ing. Vincent Claes    
  • 2. 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
  • 3. Xilkernel - overview • Small, robust and modular kernel • RTOS • POSIX API • Microblaze, PowerPC • Xilinx Platform Studio (EDK) • Light-weight (16 – 32 kb)
  • 4. 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
  • 5. 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.
  • 6. Xilkernel - Configuration • Configuration – “Software Platform Settings” • Kernel starts by calling xilkernel_main() – Code after this → never reached • Include library “xmk.h” as first library
  • 9. 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
  • 10. 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)
  • 11. 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
  • 12. Xilkernel scheduling model • SCHED_PRIO – As many ready queues as there are priority levels – Priority 0 → highest priority – Higher values → lower priority
  • 14. 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
  • 15. Xilkernel – Process Context States
  • 16. 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
  • 17. 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
  • 18. 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
  • 19. 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”)
  • 20. Xilkernel - Threading • Pthread support – pthread_create() – pthread_exit() – pthread_join() – pthread_attr_init() – pthread_setschedparam()
  • 21. 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
  • 22. 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
  • 23. 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
  • 24. Xilkernel - Semaphores • sem_init() • sem_getvalue() • sem_wait() • sem_post()
  • 25. 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
  • 26. 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
  • 27. 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()
  • 28. 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
  • 29. Xilkernel – Shared Memory • Specification – Buffer memory is allocated to each shared memory region • Shared Memory – Not allocated dynamically at run-time
  • 30. 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
  • 31. 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
  • 32. Xilkernel – Shared Memory • int shmget() • int shmctl() • void* shmat() • int shm_dt()
  • 33. 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.
  • 34. 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()
  • 35. 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.
  • 36. 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.
  • 37. Xilkernel – Dynamic Memory • Used for allocating buffers of custom sizes and widths • bufcreate() • bufdestroy() • bufmalloc() • buffree()
  • 38. 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)
  • 39. 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.
  • 40. 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.
  • 41. Xilkernel – Interrupt Handling • Additionally, Xilkernel can handle multiple interrupts when connected through an interrupt controller, and works with the opb_intc interrupt controller core.
  • 42. Xilkernel – Interrupt Handling • Basic Interrupt Service in Xilkernel
  • 43. 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.
  • 44. 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
  • 45. 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
  • 46. Xilkernel – Memory Protection • Memory protection is an extremely useful feature that can increase the robustness, reliability, and fault tolerance of your Xilkernel-based application.
  • 47. 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.
  • 48. 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.
  • 49. 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.
  • 50. 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.
  • 51. 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.
  • 52. Xilkernel – Hardware Requirements • Xilkernel handles non-cascaded interrupt controllers; cascaded interrupt controllers are not supported.
  • 53. 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( ).
  • 54. 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( ).
  • 55. 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.
  • 56. 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.
  • 58. 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