Linux循環緩衝實現

內核中有很好的循環緩衝的實現在kernel/kfifo.c中，以及include/linux/kfifo.h中。

我們可以根據內核的代碼，改爲用戶態的程序，實現如下。

fifo.h文件如下

#ifndef _LINUX_FIFO_H 
#define _LINUX_FIFO_H 
#include "pthread.h" 
#define __u32 unsigned long 
#define __u64 unsigned long long 
#define BUG_ON(condition) do { if (condition) ; } while(0) 
#define min(x,y) ({ / 
        typeof(x) _x = (x);     /
        typeof(y) _y = (y);     /
        (void) (&_x == &_y);            /
        _x < _y ? _x : _y; })
#define max(x,y) ({ / 
        typeof(x) _x = (x);     /
        typeof(y) _y = (y);     /
        (void) (&_x == &_y);            /
        _x > _y ? _x : _y; })
static inline int fls(int x)
{
    int r;
    __asm__("bsrl %1,%0/n/t"
            "jnz 1f/n/t"
            "movl $-1,%0/n"
            "1:" : "=r" (r) : "rm" (x));
    return r+1;
}
static inline int fls64(__u64 x)
{
    __u32 h = x >> 32;
    if (h)
        return fls(h) + 32;
    return fls(x);
}
static inline unsigned fls_long(unsigned long l)
{
    if (sizeof(l) == 4)
        return fls(l);
    return fls64(l);
}
static inline unsigned long roundup_pow_of_two(unsigned long x)
{
    return 1UL << fls_long(x - 1);
}
struct fifo {
    unsigned char *buffer;    /* the buffer holding the data */
    unsigned int size;    /* the size of the allocated buffer */
    unsigned int in;    /* data is added at offset (in % size) */
    unsigned int out;    /* data is extracted from off. (out % size) */
    pthread_mutex_t * mutex;
};
struct fifo *fifo_init(unsigned char *buffer, unsigned int size,pthread_mutex_t * mutex );
struct fifo *fifo_alloc(unsigned int size,pthread_mutex_t * mutex);
void fifo_free(struct fifo *fifo);
unsigned int __fifo_put(struct fifo *fifo, unsigned char *buffer, unsigned int len);
unsigned int __fifo_get(struct fifo *fifo, unsigned char *buffer, unsigned int len);
static inline void __fifo_reset(struct fifo *fifo)
{
    fifo->in = fifo->out = 0;
}
static inline void fifo_reset(struct fifo *fifo)
{
    pthread_mutex_lock(fifo->mutex);
    __fifo_reset(fifo);
    pthread_mutex_unlock(fifo->mutex);
}
static inline unsigned int fifo_put(struct fifo *fifo,
                     unsigned char *buffer, unsigned int len)
{
    unsigned int ret;
    pthread_mutex_lock(fifo->mutex);
    ret = __fifo_put(fifo, buffer, len);
    pthread_mutex_unlock(fifo->mutex);
    return ret;
}
static inline unsigned int fifo_get(struct fifo *fifo,
                     unsigned char *buffer, unsigned int len)
{
    unsigned int ret;
    pthread_mutex_lock(fifo->mutex);
    ret = __fifo_get(fifo, buffer, len);
    if (fifo->in == fifo->out)
        fifo->in = fifo->out = 0;
    pthread_mutex_unlock(fifo->mutex);
    return ret;
}
static inline unsigned int __fifo_len(struct fifo *fifo)
{
    return fifo->in - fifo->out;
}
static inline unsigned int fifo_len(struct fifo *fifo)
{
    unsigned int ret;
    pthread_mutex_lock(fifo->mutex);
    ret = __fifo_len(fifo);
    pthread_mutex_unlock(fifo->mutex);
    return ret;
}
#endif

fifo.c文件如下

#include "stdio.h" 
#include "stdlib.h" 
#include "string.h" 
#include "fifo.h" 
struct fifo *fifo_init(unsigned char *buffer, unsigned int size,pthread_mutex_t * mutex)
{
    struct fifo *fifo;
    fifo = (struct fifo *)malloc(sizeof(struct fifo));
    if (!fifo) {
        printf ( "malloc error/n" );
        return NULL;
    }
    BUG_ON(size & (size-1));
    fifo->buffer = buffer;
    fifo->size = size;
    fifo->in = fifo->out = 0;
    fifo->mutex=mutex;
    return fifo;
}
struct fifo *fifo_alloc(unsigned int size,pthread_mutex_t * mutex)
{
    unsigned char *buffer;
    struct fifo *ret;
    if (size & (size - 1)) {
        fprintf(stderr,"size > 0x80000000/n");
        size = roundup_pow_of_two(size);
    }
    buffer =(unsigned char *) malloc(size);
    if (!buffer){
        printf ( "malloc error/n" );
        return NULL;
    }
    ret = fifo_init(buffer, size, mutex);
    if ((unsigned long)ret<=0)
    {
        free(buffer);
    }
    return ret;
}
void fifo_free(struct fifo *fifo)
{
    free(fifo->buffer);
    free(fifo);
}
unsigned int __fifo_put(struct fifo *fifo, unsigned char *buffer, unsigned int len)
{
    unsigned int l;
    len = min(len, fifo->size - fifo->in + fifo->out);
    l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
    memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), buffer, l);
    memcpy(fifo->buffer, buffer + l, len - l);
    fifo->in += len;
    return len;
}
unsigned int __fifo_get(struct fifo *fifo,
             unsigned char *buffer, unsigned int len)
{
    unsigned int l;
    len = min(len, fifo->in - fifo->out);
    l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
    memcpy(buffer, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
    fifo->out += len;
    return len;
} 

測試程序main.c如下

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include "fifo.h"
#define FIFO_LENGTH 4096
struct ll_param
{
struct fifo * fifo;
int msg_len;
};
static struct ll_param fifo;
void thread_reader(void * param)
{
int read_len=0;
unsigned int counter=0;
unsigned char buffer[FIFO_LENGTH]={0};
struct ll_param * p=(struct ll_param *)param;
for(;;)
{
bzero(buffer,FIFO_LENGTH);
read_len=fifo_get(p->fifo,buffer,32);
if(read_len!=0)
{
printf("Read len:%d,buffer is:%s/n",read_len,buffer);
}
usleep(50000);
}
}
void thread_writer(void * param)
{
unsigned int write_len=0;
unsigned int counter=0;
unsigned char buffer[32]={0};
unsigned int ac_write_len=0;
struct ll_param * p=(struct ll_param *)param;
for(counter=0;counter<1000;counter++)
{
bzero(buffer,32);
sprintf((char *)buffer,"This is %d message./n",counter);
do{
ac_write_len=0;
write_len=fifo_put(p->fifo,buffer+ac_write_len,sizeof(buffer));
ac_write_len+=write_len;
}while(ac_write_len != sizeof(buffer));
usleep(100);
}
}
int main(void)
{
pthread_t pidr;
pthread_t pidw;
pthread_mutex_t mutex;
pthread_mutex_init(&mutex,NULL);
fifo.msg_len=10;
fifo.fifo=fifo_alloc(FIFO_LENGTH,&mutex);
pthread_create(&pidw,NULL,(void *)thread_writer,&fifo);
pthread_create(&pidr,NULL,(void *)thread_reader,&fifo);
pthread_join(pidr,NULL);
pthread_join(pidw,NULL);
fifo_free(fifo.fifo);
　　pthread_mutex_destroy(&mutex);
return 0;
}

do

    gcc -g -O2 -o main main.c fifo.c -lpthread

如果只有一個讀線程和一個寫線程，可以使用不加 __ （下劃線）的函數。這樣可以提高效率。

如果有多個讀寫的話，要使用不帶下劃線的函數。

附上kfifo.c 和kfifo.h作爲對比的參考。

kfifo.c:/*
* A simple kernel FIFO implementation.
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/kfifo.h>
/**
* kfifo_init - allocates a new FIFO using a preallocated buffer
* @buffer: the preallocated buffer to be used.
* @size: the size of the internal buffer, this have to be a power of 2.
* @gfp_mask: get_free_pages mask, passed to kmalloc()
* @lock: the lock to be used to protect the fifo buffer
*
* Do NOT pass the kfifo to kfifo_free() after use ! Simply free the
* struct kfifo with kfree().
*/
struct kfifo *kfifo_init(unsigned char *buffer, unsigned int size,
unsigned int __nocast gfp_mask, spinlock_t *lock)
{
struct kfifo *fifo;
/* size must be a power of 2 */
BUG_ON(size & (size - 1));
fifo = kmalloc(sizeof(struct kfifo), gfp_mask);
if (!fifo)
return ERR_PTR(-ENOMEM);
fifo->buffer = buffer;
fifo->size = size;
fifo->in = fifo->out = 0;
fifo->lock = lock;
return fifo;
}
EXPORT_SYMBOL(kfifo_init);
/**
* kfifo_alloc - allocates a new FIFO and its internal buffer
* @size: the size of the internal buffer to be allocated.
* @gfp_mask: get_free_pages mask, passed to kmalloc()
* @lock: the lock to be used to protect the fifo buffer
*
* The size will be rounded-up to a power of 2.
*/
struct kfifo *kfifo_alloc(unsigned int size, unsigned int __nocast gfp_mask, spinlock_t *lock)
{
unsigned char *buffer;
struct kfifo *ret;
/*
* round up to the next power of 2, since our 'let the indices
* wrap' tachnique works only in this case.
*/
if (size & (size - 1)) {
BUG_ON(size > 0x80000000);
size = roundup_pow_of_two(size);
}
buffer = kmalloc(size, gfp_mask);
if (!buffer)
return ERR_PTR(-ENOMEM);
ret = kfifo_init(buffer, size, gfp_mask, lock);
if (IS_ERR(ret))
kfree(buffer);
return ret;
}
EXPORT_SYMBOL(kfifo_alloc);
/**
* kfifo_free - frees the FIFO
* @fifo: the fifo to be freed.
*/
void kfifo_free(struct kfifo *fifo)
{
kfree(fifo->buffer);
kfree(fifo);
}
EXPORT_SYMBOL(kfifo_free);
/**
* __kfifo_put - puts some data into the FIFO, no locking version
* @fifo: the fifo to be used.
* @buffer: the data to be added.
* @len: the length of the data to be added.
*
* This function copies at most 'len' bytes from the 'buffer' into
* the FIFO depending on the free space, and returns the number of
* bytes copied.
*
* Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions.
*/
unsigned int __kfifo_put(struct kfifo *fifo,
unsigned char *buffer, unsigned int len)
{
unsigned int l;
len = min(len, fifo->size - fifo->in + fifo->out);
/* first put the data starting from fifo->in to buffer end */
l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), buffer, l);
/* then put the rest (if any) at the beginning of the buffer */
memcpy(fifo->buffer, buffer + l, len - l);
fifo->in += len;
return len;
}
EXPORT_SYMBOL(__kfifo_put);
/**
* __kfifo_get - gets some data from the FIFO, no locking version
* @fifo: the fifo to be used.
* @buffer: where the data must be copied.
* @len: the size of the destination buffer.
*
* This function copies at most 'len' bytes from the FIFO into the
* 'buffer' and returns the number of copied bytes.
*
* Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions.
*/
unsigned int __kfifo_get(struct kfifo *fifo,
unsigned char *buffer, unsigned int len)
{
unsigned int l;
len = min(len, fifo->in - fifo->out);
/* first get the data from fifo->out until the end of the buffer */
l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
memcpy(buffer, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
/* then get the rest (if any) from the beginning of the buffer */
memcpy(buffer + l, fifo->buffer, len - l);
fifo->out += len;
return len;
}
EXPORT_SYMBOL(__kfifo_get);

kfifo.h:

/*
* A simple kernel FIFO implementation.
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#ifndef _LINUX_KFIFO_H
#define _LINUX_KFIFO_H
#ifdef __KERNEL__
#include <linux/kernel.h>
#include <linux/spinlock.h>
struct kfifo {
unsigned char *buffer; /* the buffer holding the data */
unsigned int size; /* the size of the allocated buffer */
unsigned int in; /* data is added at offset (in % size) */
unsigned int out; /* data is extracted from off. (out % size) */
spinlock_t *lock; /* protects concurrent modifications */
};
extern struct kfifo *kfifo_init(unsigned char *buffer, unsigned int size,
unsigned int __nocast gfp_mask, spinlock_t *lock);
extern struct kfifo *kfifo_alloc(unsigned int size, unsigned int __nocast gfp_mask,
spinlock_t *lock);
extern void kfifo_free(struct kfifo *fifo);
extern unsigned int __kfifo_put(struct kfifo *fifo,
unsigned char *buffer, unsigned int len);
extern unsigned int __kfifo_get(struct kfifo *fifo,
unsigned char *buffer, unsigned int len);
/**
* __kfifo_reset - removes the entire FIFO contents, no locking version
* @fifo: the fifo to be emptied.
*/
static inline void __kfifo_reset(struct kfifo *fifo)
{
fifo->in = fifo->out = 0;
}
/**
* kfifo_reset - removes the entire FIFO contents
* @fifo: the fifo to be emptied.
*/
static inline void kfifo_reset(struct kfifo *fifo)
{
unsigned long flags;
spin_lock_irqsave(fifo->lock, flags);
__kfifo_reset(fifo);
spin_unlock_irqrestore(fifo->lock, flags);
}
/**
* kfifo_put - puts some data into the FIFO
* @fifo: the fifo to be used.
* @buffer: the data to be added.
* @len: the length of the data to be added.
*
* This function copies at most 'len' bytes from the 'buffer' into
* the FIFO depending on the free space, and returns the number of
* bytes copied.
*/
static inline unsigned int kfifo_put(struct kfifo *fifo,
unsigned char *buffer, unsigned int len)
{
unsigned long flags;
unsigned int ret;
spin_lock_irqsave(fifo->lock, flags);
ret = __kfifo_put(fifo, buffer, len);
spin_unlock_irqrestore(fifo->lock, flags);
return ret;
}
/**
* kfifo_get - gets some data from the FIFO
* @fifo: the fifo to be used.
* @buffer: where the data must be copied.
* @len: the size of the destination buffer.
*
* This function copies at most 'len' bytes from the FIFO into the
* 'buffer' and returns the number of copied bytes.
*/
static inline unsigned int kfifo_get(struct kfifo *fifo,
unsigned char *buffer, unsigned int len)
{
unsigned long flags;
unsigned int ret;
spin_lock_irqsave(fifo->lock, flags);
ret = __kfifo_get(fifo, buffer, len);
/*
* optimization: if the FIFO is empty, set the indices to 0
* so we don't wrap the next time
*/
if (fifo->in == fifo->out)
fifo->in = fifo->out = 0;
spin_unlock_irqrestore(fifo->lock, flags);
return ret;
}
/**
* __kfifo_len - returns the number of bytes available in the FIFO, no locking version
* @fifo: the fifo to be used.
*/
static inline unsigned int __kfifo_len(struct kfifo *fifo)
{
return fifo->in - fifo->out;
}
/**
* kfifo_len - returns the number of bytes available in the FIFO
* @fifo: the fifo to be used.
*/
static inline unsigned int kfifo_len(struct kfifo *fifo)
{
unsigned long flags;
unsigned int ret;
spin_lock_irqsave(fifo->lock, flags);
ret = __kfifo_len(fifo);
spin_unlock_irqrestore(fifo->lock, flags);
return ret;
}
#else
#warning "don't include kernel headers in userspace"
#endif /* __KERNEL__ */
#endif

Linux循環緩衝實現

SQL優化-20231016

cli()/sti()移除指南

44b0引導註釋

Linux下使用math函數庫注意

如何使用multiICE燒寫Bootload

如何在uClinux上添加用戶程序

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結