Abstract
This paper proposes a hardware thread manager for a polymorphic parallel processor. The thread manager supports MIMD mode with 8 threads and SIMD mode with multiple threads using SIMD controllers in a unified approach to manage two operating modes, achieving a mixture of three types of parallel computation. The thread manager monitors the progress of each thread, the activity of near-neighbor shared memory, and the status of the router to schedule execution slots. It can start, stop, pause, and resume threads while recording their working status to avoid data availability delays. This manager maximizes the efficiency of processing elements in a polymorphic array processor.
Introduction
As computer architecture has evolved from simple uni-processors to complex many-core parallel systems, the "power wall" has limited the effectiveness of increasing clock speeds. While multi-core architectures offer a path forward, their performance is often bottlenecked by software-level management of context switching and data synchronization. In multimedia processing, threads frequently stall while waiting for data from neighboring elements or remote memory. Traditional software-based management of these "waiting" states is slow and inefficient. This research introduces a dedicated hardware thread manager designed to bridge this gap by monitoring data arrival and switching threads at the silicon level, thereby maximizing the utilization of every processing element (PE).
System Architecture and Methodology
The proposed Hardware Thread Manager (TM) is integrated directly into the Processing Elements of the Polymorphic Array Architecture for Graphics and Image Processing (PAAG). This architecture typically consists of a grid of PEs connected via a network-on-chip.
The TM is designed to handle both SIMD (Single Instruction Multiple Data) and MIMD (Multiple Instruction Multiple Data) modes simultaneously. This allows the processor to exploit data-level, thread-level, and instruction-level parallelism in a unified framework. The TM is composed of five primary functional modules:
- tm_ctrl: The central arbiter that manages operating modes and coordinates other modules.
- regfile: A register file storing configuration and status bits for up to 8 threads.
- stamp_ctrl: Manages execution "quantums" or time slices to ensure fair resource sharing.
- rank_ctrl: A priority-based scheduler that determines the next thread for execution.
- state_ctrl: A state machine tracking thread status (idle, ready, running, or waiting).
By monitoring hardware signals from the router and shared memories, the TM can detect when a thread is blocked by a data dependency. It can then immediately context-switch to a ready thread, effectively "hiding" the communication latency that would otherwise stall the ALU.
Evaluation and Results
The design was verified through ModelSim functional simulations and implemented on a Xilinx V6-550 FPGA board. Performance was evaluated using a suite of eight benchmark programs designed for a 16-core PE array, focusing on thread switching and data communication efficiency.
The hardware implementation successfully managed 8 SIMD and 8 MIMD threads per PE. In comparative testing, a workload that required 3,762 clock cycles without the TM was completed in 3,127 cycles with the TM enabled. This represents a 16.9% improvement in overall computational performance. This gain is primarily attributed to the reduction in ALU idle time, as the TM ensures that the processing unit is almost always executing a ready thread while others wait for data.
Conclusion and Future Work
The hardware thread manager provides a significant performance boost for polymorphic multimedia processors by offloading scheduling tasks from software to dedicated circuitry. While the current rank-based scheduling is effective, future work could explore more complex algorithms to further optimize thread prioritization. Additionally, while the 4x4 cluster demonstrated clear benefits, further research is needed to evaluate the scalability and power overhead of this approach in much larger processor arrays.
Summary updated