内核中有很好的循环缓冲的实现 在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;
- }
makefile文件如下
do:
gcc -g -O2 -o main main.c fifo.c -lpthread
如果只有一个读线程和一个写线程,可以使用不加 __ (下划线)的函数。这样可以提高效率。
如果有多个读写的话,要使用不带下划线的函数。
附上kfifo.c 和kfifo.h作为对比的参考。
kfifo.h:
- kfifo.c:/*
- * A simple kernel FIFO implementation.
- *
- * Copyright (C) 2004 Stelian Pop <stelian@popies.net>
- *
- * 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);
- /*
- * A simple kernel FIFO implementation.
- *
- * Copyright (C) 2004 Stelian Pop <stelian@popies.net>
- *
- * 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