Changes between Version 5 and Version 6 of user_applications


Ignore:
Timestamp:
Oct 13, 2015, 1:04:41 PM (9 years ago)
Author:
alain
Comment:

--

Legend:

Unmodified
Added
Removed
Modified

  • user_applications

    v5 v6  
    33[[PageOutline]]
    44
    5 The following applications use the GIET_VM [wiki:library_stdio system calls] and [wiki:user_libraries user libraries]. The multi-threaded applications have been designed to analyse the TSAR manycore architecture scalability.
     5The following applications use the GIET_VM [wiki:library_stdio system calls] and [wiki:user_libraries user libraries].
     6The multi-threaded applications use the POSIX threads API, and have been specifically designed to analyse the TSAR manycore architecture scalability.
    67
    78== __ Display__ ==
    89
    9 This mono-processor application read a stream of images (128 lines * 128 pixels / 1 byte per pixel), from a file on a FAT32 disk controller, and display it interactively on the frame buffer. The ''images.raw'' file available in the application directory contains 20 images. This application can be used to test peripherals such as block devices, frame buffer, and dynamic allocation of  TTY terminals.
     10This single thread application illustrates the use of the CMA (chained Buffer DMA) peripheral to display a stream of images.
     11The application read a stream of images from the ''/misc/images_128.ram'' file,
     12stored on a FAT32 disk controller. It displays the stream of images on the FBF (graphical display) peripheral. The ''images_128.raw''  contains 20 images : 128 lines * 128 pixels / 1 byte per pixel.
    1013
    1114It requires one private TTY terminal.
    1215
    13 The source code can be found [source:soft/giet_vm/applications/display/main.c here].
     16The source code can be found [source:soft/giet_vm/applications/display/display.c here], and the mapping directives are defined  [source:soft/giet_vm/applications/display/display.py here].
     17
     18== __Coproc__ ==
     19
     20This single thread application illustrates the use of multi-channels  hardware accelerators by an user application.
     21The hardware coprocessor must be connected to the system by a ''vci_mwmr_dma'' component.
     22In this application, the coprocessor makes the Greater Common Divider computation between two vectors
     23of randomly generated 32 bits integers. The vector size is a parameter.
     24
     25It requires one private TTY terminal.
     26
     27The source code can be found [source:soft/giet_vm/applications/display/coproc.c here], and the mapping directives are defined  [source:soft/giet_vm/applications/display/coproc.py here].
    1428
    1529== __Transpose__ ==
    1630
    17 This multi-threaded application read a stream of images (128 lines * 128 pixels), transpose it (X <-> Y), and display it on the frame buffer.
    18 It can run on a multi-processors, multi-clusters architecture, with one thread per processor.
    19 The input and output buffers containing the image are distributed in all clusters.
     31This multi-threaded application is typical of parallelism that can be exploited in low-level image processing.
     32It can run on a multi-processors, multi-clusters architecture, with one thread per processor core.
     33The total number of threads depends on the hardware architecture, and is computed as ( x_size * y_size * nprocs ) . The main() function is executed by the thread running on P[0,0,0]. All others threads are executing the execute() function. Each execute() function is handling (image_size / nthreads) lines.
    2034
    21 The number of clusters  must be a power of 2 no larger than 32.
     35This application ask the user to enter the name of a file containing an image stored on the FAT32 disk, check that the selected image fit the frame buffer size, transpose the image (X <-> Y), display the result on the graphical display, and save the transposed image to the FAT32 disk.
     36
     37The main() function is executed by the thread running on P[0,0,0], all others threads are executing the execute() function. Each execute() function is handling (image_size / nthreads) lines.  The input and output buffers containing the source and transposed images are allocated from the user heap distributed in all clusters. Therefore, the data read are mostly local, but the data write are mostly remote.
     38
     39The number of clusters  must be a power of 2 no larger than 256.
    2240The number of processors per cluster must be a power of 2 no larger than 4.
    2341
    24 It requires one private TTY terminal.
     42It requires one TTY terminal, shared by all threads.
    2543
    26 For each image the application makes a self test (checksum for each line). The actual display on the frame buffer depends on frame buffer availability.
    27 
    28 The source code can be found [source:soft/giet_vm/applications/transpose/main.c here].
     44The source code can be found [source:soft/giet_vm/applications/transpose/transpose.c here], and the mapping is defined  [source:soft/giet_vm/applications/transpose/transpose.py here].
    2945
    3046== __Convol__ ==
    3147
    32 The source code can be found [source:soft/giet_vm/applications/convol/main.c here].
     48This multi-threaded application is a typical medical image processing application.
     49It implements a 2D convolution product, that can run on a multi-processors, multi-clusters architecture, with one thread
     50per processor. The image  size is 1024 * 1024 pixels, 2 bytes per pixel. It has been provided by Philips, and is stored
     51on the FAT32 disk in ''/misc/philips_image_1024.raw''.
     52The convolution kernel is [201]*[35] pixels, but it can be factored in two independant line and column convolution products,
     53requiring an intermediate image transposition.
     54The five buffers containing the image are distributed in all clusters.
     55
     56The main() function can be executed on any processor P[x,y,p].
     57It makes the initialisations, launch (N-1) threads to run the execute() function on the (N-1) other processors than P[x,y,p], call himself the execute() function, and finally call the instrument() function to display instrumentation results
     58when the parallel execution is completed.
     59
     60The number of clusters containing processors must be power of 2 no larger than 256.
     61The number of processors per cluster must be power of 2 no larger than 8.
     62
     63It requires one TTY terminal, shared by all threads.
     64
     65The source code can be found [source:soft/giet_vm/applications/convol/convol.c here], and the mapping is defined  [source:soft/giet_vm/applications/transpose/transpose.py here].
    3366
    3467== __Classif__ ==
    … …  
    6497Instrumentation results display is done by the "store" task in cluster[0][0] when all "store" tasks completed the number of clusters specified by the CONTAINERS_MAX parameter.
    6598
    66 The source code can be found [source:soft/giet_vm/applications/classif/main.c here].
     99The source code can be found [source:soft/giet_vm/applications/classif/classif.c here], and the mapping is defined [source:soft/giet_vm/applications/classif/classif.py here].