You are previewing Real World Multicore Embedded Systems.
O'Reilly logo
Real World Multicore Embedded Systems

Book Description

This Expert Guide gives you the techniques and technologies in embedded multicore to optimally design and implement your embedded system. Written by experts with a solutions focus, this encyclopedic reference gives you an indispensable aid to tackling the day-to-day problems when building and managing multicore embedded systems.

Following an embedded system design path from start to finish, our team of experts takes you from architecture, through hardware implementation to software programming and debug.

With this book you will learn:

• What motivates multicore

• The architectural options and tradeoffs; when to use what

• How to deal with the unique hardware challenges that multicore presents

• How to manage the software infrastructure in a multicore environment

• How to write effective multicore programs

• How to port legacy code into a multicore system and partition legacy software

• How to optimize both the system and software

• The particular challenges of debugging multicore hardware and software




    • Examples demonstrating timeless implementation details

      • Proven and practical techniques reflecting the authors’ expertise built from years of experience and key advice on tackling critical issues

Table of Contents

  1. Cover image
  2. Title page
  3. Table of Contents
  4. Copyright
  5. About the Editor
  6. About the Authors
  7. Chapter 1. Introduction and Roadmap
    1. Multicore is here
    2. Scope
    3. Who should read this book?
    4. Organization and roadmap
    5. A roadmap of this book
  8. Chapter 2. The Promise and Challenges of Concurrency
    1. Concurrency fundamentals
    2. Two kinds of concurrency
    3. Dependencies
    4. Loops and dependencies
    5. Shared resources
    6. Summary
  9. Chapter 3. Multicore Architectures
    1. The need for multicore architectures
    2. Multicore architecture drivers
    3. Traditional sequential software paradigms break
    4. Scope of multicore hardware architectures
    5. Basic multicore hardware architecture overview
    6. Specific multicore architecture characteristics
    7. Processing architectures
    8. ALU processing architectures
    9. Lightweight processing architectures
    10. Mediumweight processing architectures
    11. Heavyweight processing architectures
    12. Communication architectures
    13. Memory architectures
    14. Application specificity
    15. Application-specific platform topologies
    16. Integration of multicore systems, MPSoCs and sub-systems
    17. Programming challenges
    18. Application characteristics
    19. MPSoC analysis, debug and verification
    20. Shortcomings and solutions
    21. MPSoC parallel programming
    22. Parallel software and MPSoCs
    23. Summary
    24. References
  10. Chapter 4. Memory Models for Embedded Multicore Architecture
    1. Introduction
    2. Memory types
    3. Memory architecture
    4. Memory structure of multicore architecture
    5. Cache coherency
    6. Transactional memory
    7. Summary
    8. References
  11. Chapter 5. Design Considerations for Multicore SoC Interconnections
    1. Introduction
    2. Communication activity in multicore SoCs
    3. Functional requirements and topologies of SoC traffic
    4. Performance considerations
    5. Interconnection networks: representation and terminology
    6. Bus as an SoC interconnection
    7. Fabric-oriented interconnects for larger SoCs
    8. Building blocks of scalable interconnections
    9. Evaluating and comparing interconnection topologies for future SoCs
    10. A survey of interconnection networks suitable for future SoCs
    11. Some practical considerations in designing interconnections
    12. Summary
    13. References
    14. Further reading
  12. Chapter 6. Operating Systems in Multicore Platforms
    1. Introduction
    2. Symmetric multiprocessing systems and scheduling
    3. Assymetric multiprocessor systems
    4. Virtualization
    5. Controlling OS behavior
    6. Debugging a multicore system
    7. Summary
    8. Reference
  13. Chapter 7. System Virtualization in Multicore Systems
    1. What is virtualization?
    2. A brief retrospective
    3. Applications of system virtualization
    4. Hypervisor architectures
    5. Leveraging hardware assists for virtualization
    6. Hypervisor robustness
    7. I/O Virtualization
    8. Case study: power architecture virtualization and the freescale P4080
    9. Example use cases for system virtualization
    10. Conclusion
    11. References
  14. Chapter 8. Communication and Synchronization Libraries
    1. Introduction
    2. Library overview and basics
    3. Explicit threading libraries
    4. OpenMP
    5. Threading Building Blocks
    6. Boost Threads
    7. MCAPI
    8. Conclusion
    9. References
  15. Chapter 9. Programming Languages
    1. Programming languages for multicore embedded systems
    2. C
    3. Assembly language
    4. C++
    5. Java
    6. Python
    7. Ada
    8. Summary
    9. References
  16. Chapter 10. Tools
    1. Introduction
    2. Real-Time operating systems (RTOS)
    3. Communication tools
    4. Parallelizing serial software tools
    5. Software development and debug tools
    6. Benchmarking tools
    7. Conclusion
    8. Acknowledgments
  17. Chapter 11. Partitioning Programs for Multicore Systems
    1. Introduction
    2. What level of parallelism?
    3. The basic cost of partitioning
    4. A high-level partitioning algorithm
    5. The central role of dependencies
    6. Critical sections
    7. Synchronizing data
    8. Implementing a partitioning strategy
    9. Using tools to simplify partitioning
    10. Summary
    11. References
  18. Chapter 12. Software Synchronization
    1. Introduction
    2. Why is synchronization required?
    3. Problems with not synchronizing (or synchronizing badly)
    4. Testing for proper synchronization
    5. How is synchronization achieved?
    6. Specific conditions requiring synchronization
    7. Language support for implementation
    8. Patterns
    9. Side-effects of synchronization
    10. Hardware and OS effects on synchronization
    11. Problems when trying to implement synchronization
    12. References
  19. Chapter 13. Hardware Accelerators
    1. Introduction
    2. Architectural considerations
    3. The interface: registers, drivers, APIs, and ISRs
    4. Initialization
    5. Operating system considerations
    6. Coherency
    7. Making the architectural decisions
    8. Video example
    9. Summary
  20. Chapter 14. Multicore Synchronization Hardware
    1. Chapter overview
    2. Instruction set support for synchronization
    3. Hardware support for synchronization
    4. Hardware support for lock-free programming
    5. Memory subsystem considerations
    6. Conclusions
    7. References
  21. Chapter 15. Bare-Metal Systems
    1. Introduction
    2. Architectural arrangements
    3. Software architecture
    4. Building the executable image(s)
    5. Example: IPv4 forwarding
    6. Conclusion
    7. Reference
  22. Chapter 16. Multicore Debug
    1. Introduction – why debug instrumentation
    2. Background – silicon debug and capabilities
    3. Trace methods for multicore debug analysis
    4. Debug flows and subsystems
    5. Commercial approaches
    6. The future of multicore debug
    7. References
    8. Further reading
  23. Index