Changeset 722 for soft/giet_vm/giet_libs/mwmr_channel.h

Timestamp:

Nov 21, 2015, 1:57:51 PM (9 years ago)

Author:

alain

Message:

1) introduce the stdint.h file to define uint*_t and int*_t types.
2) introduce the bufio service in the mwmr library.
3) modify the fbf_cma system calls to support chbuf containing more than 2 buffers.

File:

• soft/giet_vm/giet_libs/mwmr_channel.h (modified) (2 diffs)

soft/giet_vm/giet_libs/mwmr_channel.h

@@ -15 +15 @@
 //
 // An MWMR transaction transfer an integer number of items, and an item is
-// an integer number of unsigned int (32 bits words).
+// an integer number of uint32_t (32 bits words).
 // The max number of words that can be stored in a MWMR channel is defined by the
 // "depth" parameter, and the "width" parameter define the minimal number of
@@ -29 +29 @@
 
 #include "user_lock.h"
+#include "stdint.h"
 
 ///////////////////////////////////////////////////////////////////////////////////
-//  MWMR channel structure
+//         MWMR channel 
+// This structure define a - shared - communication buffer between threads.
+// It must be declared as a global variable.
 ///////////////////////////////////////////////////////////////////////////////////
 
 typedef struct mwmr_channel_s 
 {
-    user_lock_t    lock;         // exclusive access lock
-    unsigned int   sts;          // number of words available
-    unsigned int   ptr;          // index of the first valid data word
-    unsigned int   ptw;          // index of the first empty slot 
-    unsigned int   depth;        // max number of words in the channel
-    unsigned int   width;        // number of words in an item      
-    unsigned int*  data;         // circular buffer base address
-    unsigned int   padding[10];  // for 64 bytes alignment
+    user_lock_t lock;         // exclusive access lock
+    uint32_t    sts;          // number of words available
+    uint32_t    ptr;          // index of the first valid data word
+    uint32_t    ptw;          // index of the first empty slot 
+    uint32_t    depth;        // max number of words in the channel
+    uint32_t    width;        // number of words in an item      
+    uint32_t*   data;         // circular buffer base address
 } mwmr_channel_t;
 
+///////////////////////////////////////////////////////////////////////////////////
+//         MWMR bufio 
+// This structure define a - private - input or output buffer, that can be used
+// to move data to (or ftom a shared MWMR communication channel. 
+// It is a local variable in the stack of the reader/writer thread.
+// It can be used to simplify access to a MWMR channel when the transfered
+// data have a non fixed format, and must be analysed or produced byte per byte.
+// An input buffer is automatically refill when it becomes empty.
+// An output buffer is automatically flushed when it becomes full.
+///////////////////////////////////////////////////////////////////////////////////
+
+typedef struct mwmr_bufio_s
+{
+    uint32_t         is_input;    // input buffer if non zero 
+    uint32_t         ptr;         // current byte index (0 to max-1)
+    uint8_t*         base;        // data buffer base address
+    uint32_t         max;         // number of bytes after refill (only for input bufio)
+    uint32_t         nitems;      // buffer size (number of items)
+    uint32_t         nbytes;      // buffer size (number of bytes)
+    mwmr_channel_t*  mwmr;        // associated MWMR channel
+} mwmr_bufio_t;
+
 //////////////////////////////////////////////////////////////////////////////
-//  MWMR access functions
+//  MWMR channel access functions
 //////////////////////////////////////////////////////////////////////////////
 
 void mwmr_init(  mwmr_channel_t* mwmr,
-                 unsigned int*   buffer,    // data buffer base address
-                 unsigned int    width,     // number of words per item
-                 unsigned int    nitems );  // max number of items
+                 uint32_t*       buffer,
+                 uint32_t        width,        // number of words per item
+                 uint32_t        nitems );     // max number of items
+
+void mwmr_dump( mwmr_channel_t* mwmr );
 
 void mwmr_read(  mwmr_channel_t* mwmr,
-                 unsigned int*   buffer,
-                 unsigned int    items );
+                 uint32_t*       buffer,
+                 uint32_t        items );
 
 void mwmr_write( mwmr_channel_t* mwmr,
-                 unsigned int*   buffer,
-                 unsigned int    items );
+                 uint32_t*       buffer,
+                 uint32_t        items );
 
-unsigned int nb_mwmr_read ( mwmr_channel_t * mwmr,
-                            unsigned int * buffer,
-                            unsigned int items );
+uint32_t nb_mwmr_read ( mwmr_channel_t*  mwmr,
+                        uint32_t*        buffer,
+                        uint32_t         items );
 
-unsigned int nb_mwmr_write( mwmr_channel_t * mwmr,
-                            unsigned int * buffer,
-                            unsigned int items );
+uint32_t nb_mwmr_write( mwmr_channel_t*  mwmr,
+                        uint32_t*        buffer,
+                        uint32_t         items );
+
+//////////////////////////////////////////////////////////////////////////////
+//  MWMR bufio access functions
+//////////////////////////////////////////////////////////////////////////////
+
+void mwmr_bufio_init( mwmr_bufio_t*    bufio,  
+                      uint8_t*         buffer, 
+                      uint32_t         size,       // number of bytes 
+                      uint32_t         is_input,
+                      mwmr_channel_t*  mwmr );
+                    
+void mwmr_bufio_dump( mwmr_bufio_t* bufio );
+
+uint8_t mwmr_bufio_read_byte( mwmr_bufio_t* bufio );
+
+void mwmr_bufio_skip( mwmr_bufio_t* bufio,
+                      uint32_t      length );
+
+void mwmr_bufio_align( mwmr_bufio_t* bufio );
+
+void mwmr_bufio_write_byte( mwmr_bufio_t* bufio,
+                            uint8_t       value );
+
+void mwmr_bufio_flush( mwmr_bufio_t* bufio );
 
 #endif