關于kfifo

kfifo是內核里面的一個First In First Out數據結構，它采用環形循環隊列的數據結構來實現；它提供一個無邊界的字節流服務，最重要的一點是，它使用并行無鎖編程技術，即當它用于只有一個入隊線程和一個出隊線程的場情時，兩個線程可以并發操作，而不需要任何加鎖行為，就可以保證kfifo的線程安全。

具體什么是環形緩沖區，請看我以前的文章

說明

關于kfifo的相關概念我不會介紹，有興趣可以看他的相關文檔，我只將其實現過程移植重寫，移植到適用stm32開發板上，并且按照我個人習慣重新命名，RingBuff->意為環形緩沖區

RingBuff_t

環形緩沖區的結構體成員變量，具體含義看注釋。

buffer: 用于存放數據的緩存

size: buffer空間的大小

in, out: 和buffer一起構成一個循環隊列。 in指向buffer中隊頭，而且out指向buffer中的隊尾

typedef struct ringbuff 

{

uint8_t *buffer;  /* 數據區域 */

uint32_t size;      /* 環形緩沖區大小 */

uint32_t in;        /* 數據入隊指針 (in % size) */

uint32_t out;       /* 數據出隊指針 (out % size) */

#if USE_MUTEX

MUTEX_T *mutex;       /* 支持rtos的互斥 */

#endif

}RingBuff_t ;

Create_RingBuff

創建一個環形緩沖區，為了適應后續對緩沖區入隊出隊的高效操作，環形緩沖區的大小應為2^n字節，

如果不是這個大小，則系統默認裁剪以對應緩沖區字節。

當然還可以優化，不過我目前并未做，思路如下：如果系統支持動態分配內存，則向上對齊，避免浪費內存空間，否則就按照我默認的向下對齊，當內存越大，對齊導致內存泄漏則會越多。對齊采用的函數是roundup_pow_of_two。如果系統支持互斥量，那么還將創建一個互斥量用來做互斥訪問，防止多線程同時使用導致數據丟失。

/************************************************************

  * @brief   Create_RingBuff

  * @param   rb：環形緩沖區句柄

  *          buffer：環形緩沖區的數據區域

  *          size：環形緩沖區的大小，緩沖區大小要為2^n

  * @return  err_t：ERR_OK表示創建成功，其他表示失敗

  * @author  jiejie

  * @github  https://github.com/jiejieTop

  * @date    2018-xx-xx

  * @version v1.0

  * @note    用于創建一個環形緩沖區

  ***********************************************************/

err_t Create_RingBuff(RingBuff_t* rb, 

                      uint8_t *buffer,

                      uint32_t size

)

{

if((rb == NULL)||(buffer == NULL)||(size == 0))

{

PRINT_ERR("data is null!");

return ERR_NULL;

}

PRINT_DEBUG("ringbuff size is %d!",size);

/* 緩沖區大小必須為2^n字節,系統會強制轉換,

否則可能會導致指針訪問非法地址。

空間大小越大,強轉時丟失內存越多 */

if(size&(size - 1))

{

size = roundup_pow_of_two(size);

PRINT_DEBUG("change ringbuff size is %d!",size);

}

rb->buffer = buffer;

rb->size = size;

rb->in = rb->out = 0;

#if USE_MUTEX

  /* 創建信號量不成功 */

  if(!create_mutex(rb->mutex))

  {

    PRINT_ERR("create mutex fail!");

    ASSERT(ASSERT_ERR);

    return ERR_NOK;

  }

#endif

PRINT_DEBUG("create ringBuff ok!");

return ERR_OK;

}

roundup_pow_of_two

/************************************************************

  * @brief   roundup_pow_of_two

  * @param   size：傳遞進來的數據長度

  * @return  size：返回處理之后的數據長度

  * @author  jiejie

  * @github  https://github.com/jiejieTop

  * @date    2018-xx-xx

  * @version v1.0

  * @note    用于處理數據，使數據長度必須為 2^n

* 如果不是，則轉換，丟棄多余部分，如

* roundup_pow_of_two(66) -> 返回 64

  ***********************************************************/

static unsigned long roundup_pow_of_two(unsigned long x)

{

return (1 << (fls(x-1)-1)); //向下對齊

  //return (1UL << fls(x - 1)); //向上對齊，用動態內存可用使用

}

Delete_RingBuff

刪除一個環形緩沖區，刪除之后，緩沖區真正存儲地址是不會被改變的（目前我是使用自定義數組做緩沖區的），但是刪除之后，就無法對緩沖區進行讀寫操作。并且如果支持os的話，創建的互斥量會被刪除。

/************************************************************

  * @brief   Delete_RingBuff

  * @param   rb：環形緩沖區句柄

  * @return  err_t：ERR_OK表示成功，其他表示失敗

  * @author  jiejie

  * @github  https://github.com/jiejieTop

  * @date    2018-xx-xx

  * @version v1.0

  * @note    刪除一個環形緩沖區

  ***********************************************************/

err_t Delete_RingBuff(RingBuff_t *rb)

{

if(rb == NULL)

{

PRINT_ERR("ringbuff is null!");

return ERR_NULL;

}

rb->buffer = NULL;

rb->size = 0;

rb->in = rb->out = 0;

#if USE_MUTEX

  if(!deleta_mutex(rb->mutex))

  {

    PRINT_DEBUG("deleta mutex is fail!");

    return ERR_NOK;

  }

#endif

return ERR_OK;

}

Write_RingBuff

向環形緩沖區寫入指定數據，支持線程互斥訪問。用戶想要寫入緩沖區的數據長度不一定是真正入隊的長度，在完成的時候還要看看返回值是否與用戶需要的長度一致~

這個函數很有意思，也是比較高效的入隊操作，將指定區域的數據拷貝到指定的緩沖區中，過程看注釋即可

/************************************************************

  * @brief   Write_RingBuff

  * @param   rb:環形緩沖區句柄

  * @param   wbuff:寫入的數據起始地址

  * @param   len:寫入數據的長度(字節)

  * @return  len:實際寫入數據的長度(字節)

  * @author  jiejie

  * @github  https://github.com/jiejieTop

  * @date    2018-xx-xx

  * @version v1.0

  * @note    這個函數會從buff空間拷貝len字節長度的數據到

             rb環形緩沖區中的空閑空間。

  ***********************************************************/

uint32_t Write_RingBuff(RingBuff_t *rb,

                        uint8_t *wbuff, 

                        uint32_t len)

{

  uint32_t l;

#if USE_MUTEX

  /* 請求互斥量，成功才能進行ringbuff的訪問 */

  if(!request_mutex(rb->mutex))

  {

    PRINT_DEBUG("request mutex fail!");

    return 0;

  }

  else  /* 獲取互斥量成功 */

  {

#endif

    len = min(len, rb->size - rb->in + rb->out);

    /* 第一部分的拷貝:從環形緩沖區寫入數據直至緩沖區最后一個地址 */

    l = min(len, rb->size - (rb->in & (rb->size - 1)));

    memcpy(rb->buffer + (rb->in & (rb->size - 1)), wbuff, l);

    /* 如果溢出則在緩沖區頭寫入剩余的部分

       如果沒溢出這句代碼相當于無效 */

    memcpy(rb->buffer, wbuff + l, len - l);

    rb->in += len;

    PRINT_DEBUG("write ringBuff len is %d!",len);

#if USE_MUTEX

  }

  /* 釋放互斥量 */

  release_mutex(rb->mutex);

#endif

  return len;

}

Read_RingBuff

讀取緩沖區數據到指定區域，用戶指定讀取長度，用戶想要讀取的長度不一定是真正讀取的長度，在讀取完成的時候還要看看返回值是否與用戶需要的長度一致~也支持多線程互斥訪問。

也是緩沖區出隊的高效操作。過程看代碼注釋即可

/************************************************************

  * @brief   Read_RingBuff

  * @param   rb:環形緩沖區句柄

  * @param   wbuff:讀取數據保存的起始地址

  * @param   len:想要讀取數據的長度(字節)

  * @return  len:實際讀取數據的長度(字節)

  * @author  jiejie

  * @github  https://github.com/jiejieTop

  * @date    2018-xx-xx

  * @version v1.0

  * @note    這個函數會從rb環形緩沖區中的數據區域拷貝len字節

             長度的數據到rbuff空間。

  ***********************************************************/

uint32_t Read_RingBuff(RingBuff_t *rb,

                       uint8_t *rbuff, 

                       uint32_t len)

{

  uint32_t l;

#if USE_MUTEX

  /* 請求互斥量，成功才能進行ringbuff的訪問 */

  if(!request_mutex(rb->mutex))

  {

    PRINT_DEBUG("request mutex fail!");

    return 0;

  }

  else

  {

#endif

    len = min(len, rb->in - rb->out);

    /* 第一部分的拷貝:從環形緩沖區讀取數據直至緩沖區最后一個 */

    l = min(len, rb->size - (rb->out & (rb->size - 1)));

    memcpy(rbuff, rb->buffer + (rb->out & (rb->size - 1)), l);

    /* 如果溢出則在緩沖區頭讀取剩余的部分

       如果沒溢出這句代碼相當于無效 */

    memcpy(rbuff + l, rb->buffer, len - l);

    rb->out += len;

    PRINT_DEBUG("read ringBuff len is %d!",len);

#if USE_MUTEX

  }

  /* 釋放互斥量 */

  release_mutex(rb->mutex);

#endif

  return len;

}

獲取緩沖區信息

這些就比較簡單了，看看緩沖區可讀可寫的數據有多少

/************************************************************

  * @brief   CanRead_RingBuff

* @param   rb:環形緩沖區句柄

* @return  uint32:可讀數據長度 0 / len

  * @author  jiejie

  * @github  https://github.com/jiejieTop

  * @date    2018-xx-xx

  * @version v1.0

  * @note    可讀數據長度

  ***********************************************************/

uint32_t CanRead_RingBuff(RingBuff_t *rb)

{

if(NULL == rb)

{

PRINT_ERR("ringbuff is null!");

return 0;

}

if(rb->in == rb->out)

return 0;

if(rb->in > rb->out)

return (rb->in - rb->out);

return (rb->size - (rb->out - rb->in));

}

/************************************************************

  * @brief   CanRead_RingBuff

* @param   rb:環形緩沖區句柄

* @return  uint32:可寫數據長度 0 / len

  * @author  jiejie

  * @github  https://github.com/jiejieTop

  * @date    2018-xx-xx

  * @version v1.0

  * @note    可寫數據長度

  ***********************************************************/

uint32_t CanWrite_RingBuff(RingBuff_t *rb)

{

if(NULL == rb)

{

PRINT_ERR("ringbuff is null!");

return 0;

}

return (rb->size - CanRead_RingBuff(rb));

}

附帶

這里的代碼我是用于測試的，隨便寫的

RingBuff_t ringbuff_handle;

uint8_t rb[64];

uint8_t res[64];

Create_RingBuff(&ringbuff_handle, 

rb,

sizeof(rb));

Write_RingBuff(&ringbuff_handle,

                     res, 

                     datapack.data_length);

PRINT_DEBUG("CanRead_RingBuff = %d!",CanRead_RingBuff(&ringbuff_handle));

PRINT_DEBUG("CanWrite_RingBuff = %d!",CanWrite_RingBuff(&ringbuff_handle));

Read_RingBuff(&ringbuff_handle,

                     res, 

                     datapack.data_length);

支持多個os的互斥量操作

此處模仿了文件系統的互斥操作

#if USE_MUTEX

#define  MUTEX_TIMEOUT   1000     /* 超時時間 */

#define  MUTEX_T         mutex_t  /* 互斥量控制塊 */

#endif

/*********************************** mutex **************************************************/