Parallel and Event Driven Programming in Embedded Systems

1. Architectural background of parallel and event-driven programming, processor and memory virtualization, protection/privilege levels and the MMU, cache coherency, multiprocessor, distributed and heterogeneous systems.

2. Operating systems architectures, operating system types, internal operation, relationship to the applications. Concurrent and cooperative scheduling, priority, scheduling and the HW. System call and its implementations. Real-time operation and safety-critical operation in operating systems.   

Practice: Test system installation into a virtual machine, introduction to the development system, make utility, Eclipse IDE, etc.

3. Implementation of tasks and subtasks, processes and threads, comparison and properties, their implementation. Co-routine and fiber, as implementations of cooperative tasks, details of implementation. Design patterns for using processes and threads in cooperative scheduling.

4. Processes and threads in embedded environments, practical implementations, analyses and comparison from this aspect using design patterns. Monitoring the running and inter-operation of processes and threads using software solutions.

Practice: Creating and using processes and threads on Linux, monitoring their operation. FreeRTOS threads in practice and monitoring their operations.

5. Mutual exclusion, synchronization, and communication in systems having shared memory. Sufficient condition to run task in parallel (Bernstein's condition). Lock-bit, semaphore, mutex, multiple readers single writer mutex, etc. and their operation and usage demonstrated using design patterns. Spinlocks and sleeplocks, their operation, and their effect on the performance of the embedded system including real-time properties and energy use.
6. Analyses of practical solutions for mutual exclusion, synchronization, and communication as a case study.

Practice: Mutual exclusion, synchronization, and communication 1.

7. Continued analyses of mutual exclusion, synchronization, and communication. Comparing the kernel and user space solutions.

8. Handling time in embedded systems, time as a physical unit and its representation in computers in embedded systems. The architecture of clocks, real-time clocks, system clocks, delaying execution and suspension of tasks based on time.

Practice: Mutual exclusion, synchronization, and communication 2.

9. Mutual exclusion, synchronization, and communication in massage passing systems. Properties of message passing, comparison of message passing to shared memory. Mailbox, message queue, pipelines and named pipelines, TCP/IP, remote procedure/method call. Design patterns for message based communications.

10. Mutual exclusion, synchronization, and communication in Linux. Posix and System V solutions. TCP/IP and Unix domain sockets.

Practice: Mutual exclusion, synchronization, and communication using message passing in between processes in Linux.

11. Typical programming errors in the application of mutual exclusion, synchronization, and communication, and common solutions to avoid them. Deadlock, livelocks, priority inversion, other errors. The concept of monitors and its application.

12. Handling of memory. The memory modell of FreeRTOS, reserving and freeing memory, consequences, the role of the heap and the stack. Memory handling in Linux, using virtual memory and its consequences.

Practice: Suspending a task for specified time and running tasks at given time. The application of spinlocks, HW timers and OS virtual timers. Using timeouts for reliability and error handling embedded systems.

13. Tools used during the development of parallel and event-driven system, their operation, and practical application. Tracing with software and hardware tools. Profiling. Tracking memory use and detecting memory leaks with tools. Fault detection, performance analyses and optimization tools for embedded systems.

14. Alternative software and/or hardware solutions. Hardware semaphores, multiport memory, software or hardware transactional memory, lockless programming. Hypervisors and platform virtualization in embedded systems. Peripheral virtualization including sensor virtualization.    

Practices are scheduled for even weeks, but due to some scheduling issues they can be organized on even weeks.