2. Software acceleration with hardware co-processors#

2.1. Required files#

SpaceStudio Project

2.2. Goal#

The aim of this tutorial is to accelerate an application with hardware co-processors using the SpaceStudio development environment. In this tutorial, the user will optimize a single-threaded algorithm with low performance into a multithreaded algorithm with higher performance.

2.3. Single thread Application Specification#

The Motion JPEG (MJPEG) is a video format composed of a series of JPEG images. Figure 2.25 outlines the MJPEG decoder application’s task. The MJPEG decoder reads the video stream from the input memory and decodes the images to the video controller memory in RGB format. For simplification, an external subsystem initializes the input video with a MJPEG video.

MJPEG decoder flow

Figure 2.25 MJPEG Application#

2.4. Profiling the software application#

Application profiling is performed to determine the time consumed per function. SpaceStudio’s monitoring feature (described in Tutorial 1) was used to determine the execution time of the application’s functions. Figure 2.26 and Table 2.1 outline the results of the execution time.

../../_images/mjpeg_functions_gprof.png

Figure 2.26 MJPEG functions execution time#

Table 2.1 MJPEG functions execution time#

Function

Execution time (%)

calculate_output_pixel

18.93%

operation_IDCT

17.15%

ycbcr2rgba

9.35%

rot

8.46%

bitreader_get_one

6.9%

huff_get_symbol

6.01%

idct_1d

5.12%

Other functions

28.08%

2.5. Single-threaded MJPEG#

As a base reference, we need to determine how the single-threaded algorithm performs on a specific architecture. The supplied project comes with a virtual platform composed of a microblaze executing the MJPEG decoder algorithm as presented by Figure 2.25 . Follow these instructions to determine the decoding performance:

  1. Open the SpaceStudio project

  2. Open the microblaze architecture

  3. Execute the simulation

  4. What is the simulation time for processing two frames?

2.6. Multithreaded MJPEG#

We would like to parallelize the algorithm to achieve better performance. Based on the results presented by Figure 2.26 and Table 2.1, we propose to accelerate two functions: operation_IDCT and calculate_output_pixel.

Hint

The function operation_IDCT is easier to parallelize

Suggested steps :

  1. Create a new solution based on the current one. This will allow keeping the original code intact for further comparisons.

  2. Create a new module (e.g, idct or calculate_output_pixel) in the new solution.

  3. Add the new module to the validation architecture.

  4. Modify the MJPEG and implement the new module (move the function’s body to the module’s thread)

  5. Adapt the communication (inputs and outputs) of the function using the communication API

  6. Compile, run and debug!

Now that you have done a functional verification in validation architecture, modify the microblaze architecture in the new solution (add the co-processor) and compare the simulation time.

  1. What is the speedup?

  2. How can we simulate the hardware co-processor execution’s time?

  3. What can be done to accelerate the algorithm even more?

2.7. Result files#

SpaceStudio Project