Abstract

Our aim is to investigate the suitability of hardware multithreading for real-time event handling in combination with appropriate real-time scheduling techniques. We designed and evaluated a multithreaded microcontroller based on a Java processor core. Java threads are used as Interrupt Service Threads (ISTs) instead of the Interrupt Service Routines (ISRs) of conventional processors. Our proposed Komodo microcontroller supports multiple ISTs with zero-cycle context switching overhead. A so-called priority manager implements several real-time scheduling algorithms in hardware.

We show the feasibility of a hardware real-time scheduler integrated deeply into the processor pipeline with a VHDL design and its synthesis. Evaluations with a software simulator and real-time applications as benchmarks show that hardware multithreading reaches a 1.2–1.4 performance increase for hard real-time applications (multithreading without latency utilization) and a 2.0–2.6 speedup by latency utilization for programs without hard real-time requirements. With respect to real-time scheduling on a multithreaded microcontroller, the Least Laxity First (LLF) scheme outperforms the Fixed Priority Preemptive (FPP), Earliest Deadline First (EDF), and Guaranteed Percentage (GP) schemes, but suffers from the highest implementation costs.

Author Keywords: Multithreaded processor; Java processor; Multithreaded microcontroller; Real-time scheduling; Real-time event handling

Article Outline

1. Introduction

2. The Komodo system architecture

3. Interrupt service threads and real-time scheduling

3.1. The interrupt service thread concept

3.2. Real-time scheduling algorithms

3.3. The IST concept compared to ISR and AST

4. The Komodo microcontroller

4.1. Processor core

4.2. The priority manager

4.3. The IST concept in the Komodo microcontroller

5. Evaluation of the IST concept and the Komodo microcontroller

5.1. Qualitative features

5.2. Synthesis of the priority manager

5.3. Quantitative evaluation

5.3.1. Evaluation methodology

5.3.2. Analytical comparison with the picoJava-II

5.3.3. Measurements for multithreading and scheduling

5.3.4. Varying the load/store latencies

6. Conclusions

References