Yen-Jo Han

Case Study: Verification Framework of Samsung Reconfigurable Processor

The SRP (Samsung Reconfigurable Processor) is a high-performance, low-power digital signal processor that supports two different operating modes: the VLIW (very long instruction word) mode for running control-intensive code and the CGA (coarse-grained reconfigurable array) mode for running computation-intensive code. In the SRP, an application starts in the VLIW mode, and then may switch back and forth many times between the CGA mode and the VLIW mode throughout its lifetime. In order to support this switching back and forth seamlessly, our C compiler for SRP is capable of generating an executable binary that contain codes for both VLIW and CGA modes. The unusual complexity of SRP verification originates from the unconventional processor architecture/micro-architecture and the complexity of our compiler. In order to manage the unconventional burden that confronts SRP verification engineers, we have aimed to build a scalable verification framework that is both flexible and efficient. In this paper, we report our experience so far, including our effort to be systematic and thorough in our approach.

Verification of CGRA Executable Code and Debugging of Memory Dependence Violation

We present verification and debugging of highly optimized executable code that is generated from C source code to run on CGRA (Coarse-Grained Reconfigurable Array). To generate the executable code, the CGRA compiler uses software pipelining technique that maps instructions in a loop body to multiple FUs (functional units) of CGRA for concurrent execution. Often, the programmer chooses to use aggressive optimization as a way to obtain highly performing executable code. For example, the programmer may turn off memory dependence check in order to suppress false dependence that would otherwise result in overly conservative, therefore poorly performing, executable code. A trouble is that it is not easy to verify correctness of the resulting executable code. In this paper, we propose a method to verify CGRA executable code and to detect memory dependence violation if there occurs such violation and to provide source code position where the violation occurs. We use the behavior of VLIW code as a reference and compare it with the behavior of CGRA code. In order to guide the comparison, compiler-generated mapping table information is used.