Changes between Version 10 and Version 11 of user_applications


Ignore:
Timestamp:
Oct 16, 2015, 1:47:45 PM (9 years ago)
Author:
alain
Comment:

--

Legend:

Unmodified
Added
Removed
Modified

  • user_applications

    v10 v11  
    44
    55The following applications use the GIET_VM [wiki:library_stdio system calls] and [wiki:user_libraries user libraries].
    6 The multi-threaded applications use the POSIX threads API, and have been specifically designed to analyse the TSAR manycore architecture scalability.
     6The multi-threaded applications use the POSIX threads API.
    77
    88== __shell__ ==
    99
    10 This single thread interactive application can be used to access the FAT32 file system, or to dynamically activate or de-activate
    11 others applications. When is mapped on the target architecture, it is automatically launched at the end of the boot phase.
     10This single thread interactive application can be used to handle the FAT32 file system, or to dynamically activate or de-activate
     11others applications. When this application is mapped on the target architecture, it is automatically launched at the end of the boot phase.
    1212The list of available commands can be obtained with the ''help'' command.
    1313
    … …  
    1818== __ display__ ==
    1919
    20 This single thread application illustrates the use of the CMA (chained Buffer DMA) peripheral to display a stream of images.
     20This single thread application illustrates the use of various peripherals such as the IOC (external block device), or the CMA (chained Buffer DMA) peripheral to display a stream of images.
    2121The application read a stream of images from the ''/misc/images_128.ram'' file,
    22 stored 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.
     22stored on the 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.
    2323
    2424It requires one private TTY terminal.
    … …  
    2828== __coproc__ ==
    2929
    30 This single thread application illustrates the use of multi-channels  hardware accelerators by an user application.
     30This single thread application illustrates the use of hardware accelerators by an user application.
    3131The hardware coprocessor must be connected to the system by a ''vci_mwmr_dma'' component.
    3232In this application, the coprocessor makes the Greater Common Divider computation between two vectors
    … …  
    3939== __sort__ ==
    4040
    41 This multi-threaded application is a very simple parallel sort. The input is an array of randomly generated integers.
     41This first multi-threaded application is a very simple parallel sort. The input is an array of randomly generated integers.
    4242
    4343It can run on a multi-processors, multi-clusters architecture, with one thread per processor core.
    … …  
    8686== __gameoflife__ ==
    8787
     88This multi-threaded application is an emulation of the Game of Life automaton.
     89The world size is defined by the Frame Buffer width and height.
     90
     91It that can run on a multi-processors, multi-clusters architecture.
     92 * If the number of processors is larger than the number of lines, the number of threads is equal to the number of lines, and each thread process one single line.
     93 * if the number of processors is not larger than the number of lines, the number of threads is equal to the number of processors, and each thread process height/nthreads (or height/nthreads + 1) lines.
     94
     95The thread running on processor P(0,0,0) execute the main() function, that initialises the barrier, the TTY terminal, the CMA controler, and launch the other threads, before calling the execute() function.
     96Other threads are just running the execute() function.
     97 
     98The total number of clusters cannot be larger than 16 *16.
     99The total number of processors per cluster cannot be larger than 4.
     100
     101It uses one TTY terminal shared by all threads.
     102
    88103The source code can be found [source:soft/giet_vm/applications/gameoflife/gameoflife.c here], and the mapping is defined [source:soft/giet_vm/applications/gameoflife/gameoflife.py here].
    89104
    … …  
    93108It uses the multi-channels NIC peripheral, and the chained buffers DMA controller, to receive and send packets on the Gigabit Ethernet port.
    94109It can run on architectures containing up to 256 clusters, and up to 8 processors per cluster: one task per processor.
    95 It requires as many private TTYs as the number of processors in cluster[0,0].
     110
     111It requires one TTY terminal shared by all threads. 
    96112
    97113This application is described as a TCG (Task and Communication Graph)  containing (N+2) tasks per cluster: one '''load''' task, one '''store''' task, and N '''analyse''' tasks. Each container can contain from 2 to 60 packets and has a fixed size of 4 Kbytes. These containers are distributed in clusters:
    … …  
    124140== __raycast__ ==
    125141
    126 This multi-threaded application implement a video game requiring 3D image synthesis. The gamer can dynamically explore a maze and the gamer vision (3D images) depends on the gamer moves.
     142This multi-threaded application implement a video game requiring 3D image synthesis. The gamer can dynamically explore a maze and the gamer vision (3D images) depends interactively on the gamer moves.
    127143
    128144It that can run on a multi-processors, multi-clusters architecture, with one thread per processor, and can use any values for
    … …  
    139155== __ router__ ==
    140156
     157This multi-threaded application emulates a network processing application such as an
     158ethernet router. All communications between threads use the  MWMR (Multi-Writer/Multi-Reader) channels middleware.
     159The application is described as a TCG (Task and communication Graph) :
     160 * The number of thread N is (x_size*y_size*nprocs): nprocs threads per clusters.
     161 * There is one producer() thread, one consumer() thread, and N-2 compute() threads.
     162 * The number M of MWMR channels is (2 * x_size * y_size) : one input and one output channel per cluster.
     163
     164It that can run on a multi-processors, multi-clusters architecture, with one thread per processor.
     165In this implementation, only integer token are transfered between threads, but they can be interpreted as job descriptors:
     166 * The main() thread, running on P[0,0,0], makes the initializations, and laugh the N other threads, and exit.
     167 * The producer() thread, running on P[0,0,0] try to write continuously tokens into the M distributed input channels using non-blocking write function.
     168 * The consumer() thread, running on P[0,0,1] try to read continuously tokens from the M distributed output channels, using a non-blocking read function.
     169 * The N-2 compute() threads running on all other processors are reading token  from the local input channel, and writing token to the local output channel, after a random delay emulating a variable processing time.
     170
     171It require one TTY terminal shared by all threads.
     172 
    141173The source code can be found [source:soft/giet_vm/applications/router/router.c here], and the mapping is defined [source:soft/giet_vm/applications/router/router.py here].