刚写好的FIFO源码（C++），送给需要的人！

armstrong

gy_fifo.hpp

1. #ifndef __FIFO_HPP__
   
2. #define __FIFO_HPP__
   
3. 
   
4. #include <stdint.h>
   
5. 
   
6. class GYFIFO
   
7. {
   
8. private:
   
9.   uint8_t *buffer;
   
10.   uint32_t size;
    
11.   uint32_t ip;
    
12.   uint32_t op;
    
13.   uint32_t (*puter)(GYFIFO& obj, uint8_t const *buf, uint32_t num);
    
14.   /* 作为真正操纵FIFO写入功能的函数 */
    
15.   static uint32_t RealPut(GYFIFO& obj, uint8_t const *buf, uint32_t num);
    
16.   static uint32_t DumyPut(GYFIFO& obj, uint8_t const *buf, uint32_t num);
    
17. public:
    
18.   /* 构造器。切勿调用OS函数 */
    
19.   GYFIFO(uint8_t *buf, uint32_t sz):
    
20.     ip(0), op(0),
    
21.     puter(DumyPut)
    
22.   {
    
23.     buffer = buf;
    
24.     size = sz;
    
25.     if(buf && sz){
    
26.       /* FIFO有效 */
    
27.       puter = RealPut;
    
28.     }
    
29.   }
    
30.   /* 析构器 */
    
31.   ~GYFIFO()
    
32.   {
    
33.     puter = DumyPut;
    
34.     Clear();
    
35.     buffer = NULL;
    
36.     size = 0;
    
37.   }
    
38.   /* 把数据写入FIFO，返回成功写入的字节数 */
    
39.   uint32_t Put(uint8_t const *buf, uint32_t num);
    
40.   /* 读取FIFO里的数据，返回成功读取的字节数 */
    
41.   uint32_t Get(uint8_t *buf, uint32_t sz);
    
42.   /* 查看FIFO里现存的数据字节数 */
    
43.   uint32_t Count() const
    
44.   {
    
45.     int num = (int)(ip - op);
    
46.     if(num < 0){
    
47.       num += size;
    
48.     }
    
49.     return num;
    
50.   }
    
51.   /* 查看FIFO当前剩余的空闲空间 */
    
52.   uint32_t NumFree() const
    
53.   {
    
54.     uint32_t num = Count();
    
55.     return (size - num - 1);
    
56.   }
    
57.   /* 查看FIFO缓冲区的原始容量 */
    
58.   uint32_t Size() const
    
59.   {
    
60.     return size;
    
61.   }
    
62.   /* 清空FIFO */
    
63.   void Clear()
    
64.   {
    
65.     op = ip;
    
66.   }
    
67. };
    
68. 
    
69. #endif /* __FIFO_HPP__ */
    
70. 
    

复制代码

gy_fifo.cpp

1. #include "gy_fifo.hpp"
   
2. 
   
3. /* 作为FIFO无效时的空写入函数 */
   
4. uint32_t GYFIFO::DumyPut(GYFIFO& obj, uint8_t const *buf, uint32_t num)
   
5. {
   
6.   return num;
   
7. }
   
8. 
   
9. uint32_t GYFIFO::RealPut(GYFIFO& obj, uint8_t const *buf, uint32_t num)
   
10. {
    
11.   uint32_t nfree = obj.NumFree();
    
12.   uint32_t index = obj.ip;
    
13.   uint32_t ncpy;
    
14.   
    
15.   if(num > nfree){
    
16.     num = nfree;
    
17.   }
    
18.   ncpy = num;
    
19.   if(index + ncpy >= obj.size){
    
20.     /* 跨越缓存边界，需要分段拷贝 */
    
21.     ncpy = obj.size - index;
    
22.     memcpy(obj.buffer+index, buf, ncpy);
    
23.     buf = buf + ncpy;
    
24.     ncpy = num - ncpy;
    
25.     index = 0;
    
26.   }
    
27.   if(ncpy > 0){
    
28.     memcpy(obj.buffer+index, buf, ncpy);
    
29.     index += ncpy;
    
30.   }
    
31.   
    
32.   obj.ip = index;
    
33.   return num;
    
34. }
    
35. 
    
36. uint32_t GYFIFO::Put(uint8_t const *buf, uint32_t num)
    
37. {
    
38.   return puter(*this, buf, num);
    
39. }
    
40. 
    
41. uint32_t GYFIFO::Get(uint8_t *buf, uint32_t sz)
    
42. {
    
43.   uint32_t ntotal = Count();
    
44.   uint32_t index = op;
    
45.   uint32_t ncpy;
    
46.   
    
47.   if(ntotal > sz){
    
48.     ntotal = sz;
    
49.   }
    
50.   ncpy = ntotal;
    
51.   if(index + ncpy >= size){
    
52.     /* 跨越缓存边界，需要分段拷贝 */
    
53.     ncpy = size - index;
    
54.     memcpy(buf, buffer+index, ncpy);
    
55.     buf = buf + ncpy;
    
56.     ncpy = ntotal - ncpy;
    
57.     index = 0;
    
58.   }
    
59.   if(ncpy > 0){
    
60.     memcpy(buf, buffer+index, ncpy);
    
61.     index += ncpy;
    
62.   }
    
63.   
    
64.   op = index;
    
65.   return ntotal;
    
66. }
    
67. 
    
68. 
    

复制代码

armstrong

我说说本代码的关键优点吧：如果有两个线程访问该FIFO（包括前后台系统的主循环和中断之间），一个读，一个写。这种情况下，该FIFO实现是不需要互斥保护的！
而RealPut和DumyPut的设计，是初始化为无效buffer指针和字节数时，仍然不会非法地址访问；而初始化buffer和size有效时，这样的性能仍然很高（相对于每次Put方法里去判断buffer和size是否有效的做法）！

armstrong

大家有时间再去网络上找找看别人家的FIFO实现，与我的比比看就知道优点有哪些了。

armstrong

如果FIFO缓存的字节数强制2的幂次的话，还可以再优化性能的。
但有得就有失，我就不强制缓存字节数了。

whatcanitbe

谢谢您的分享

chenchaoting

armstrong 发表于 2018-1-25 20:50
我说说本代码的关键优点吧：如果有两个线程访问该FIFO（包括前后台系统的主循环和中断之间），一个读，一个 ...

来个C的应用更广，线程安全实现在哪

armstrong

chenchaoting 发表于 2018-1-25 21:10
来个C的应用更广，线程安全实现在哪

代码本身就实现为线程安全了。
限制是一个读一个写；不能多个读或者多个写。
C++代码很容易改成C，我之前都是用C写的。
这段时间改用C++，所以重新实现了一遍而已。

用MDK，IAR，GCC，都可以开发C++程序的。

chenchaoting

armstrong 发表于 2018-1-25 21:21
代码本身就实现为线程安全了。
限制是一个读一个写；不能多个读或者多个写。
C++代码很容易改成C，我之前 ...

前台要读，中断要写，不需要fifo修改内部代码

tabing

楼主参考一下kfifo，更简洁

armstrong

tabing 发表于 2018-1-25 21:37
楼主参考一下kfifo，更简洁

kfifo强制了size必须2的幂次，才有那样的简洁，如同我3楼所说。我是取舍之后选择灵活性。

此外，kfifo看起来简洁（其memcpy两次没有做条件判断），其实性能不如条件判断。
因为，memcpy传入的size为0时，虽然拷贝0字节。但确实发生了函数调用跳转，甚至堆栈的push-pop。而条件判断在现代的arm处理器上大部分是不会发生跳转的，这叫“分支预测”，比如ADDNE，BNE等等。

tarchen

高手，顶顶顶，
多谢！

lyping1987

学习了。感谢分享

leiyitan

刚写好就拿出来把我们当小白鼠帮你做测试…
嗯，先收藏了再说…⊙∀⊙

armstrong

leiyitan 发表于 2018-1-26 06:39
刚写好就拿出来把我们当小白鼠帮你做测试…
嗯，先收藏了再说…⊙∀⊙

以前用C的，现在改用C++重新实现。不会当你是白鼠的，当青蛙而已。

wuzhujian

这个只适合中断传输，不适合DMA的。
如果是DMA,需要使用队列。

armstrong

wuzhujian 发表于 2018-1-26 08:38
这个只适合中断传输，不适合DMA的。
如果是DMA,需要使用队列。

应用场景是各位应用开发者考虑的事吧

Ai_evan

学习了，谢谢分享

FireHe

c版本的也共享吧，谢谢楼主

lovemini

学习了，希望楼主提供一下C语言版本

leiyitan

armstrong 发表于 2018-1-26 08:13
以前用C的，现在改用C++重新实现。不会当你是白鼠的，当青蛙而已。  ...

希望论坛有更多像你这样乐于分享自己的作品并且把我们当青蛙的大神哈

日日♂夜夜

如果用C++ ，写个模板类把
顺便加上零界接口

armstrong

日日♂夜夜 发表于 2018-1-27 11:15
如果用C++ ，写个模板类把
顺便加上零界接口

我用的是Embedded C++不支持模板，是标准C++的子集。

日日♂夜夜

armstrong 发表于 2018-1-27 13:17
我用的是Embedded C++不支持模板，是标准C++的子集。

这...不会吧,stl都没有么..那用这个C++干啥..
还不如写C算了

hexenzhou

C++ STL容器类强大多了，这个是标准库，换GCC吧，不要用假的C++了

redroof

日日♂夜夜 发表于 2018-1-27 15:04
这...不会吧,stl都没有么..那用这个C++干啥..
还不如写C算了

stl并不是线程安全的。
其实只当作带类的c，己经比纯c好多了

fengyunyu

armstrong 发表于 2018-1-25 20:50
我说说本代码的关键优点吧：如果有两个线程访问该FIFO（包括前后台系统的主循环和中断之间），一个读，一个 ...

不需要互斥保护，能普及下原因么？

eliterxzgxu

感谢楼主分享

shangdawei

fengyunyu 发表于 2018-1-28 14:12
不需要互斥保护，能普及下原因么？

猜测一下，是不是没有并发的读取或者并发写入的原因呢？

w35boz

谢谢分享

armstrong

hexenzhou 发表于 2018-1-27 20:32
C++ STL容器类强大多了，这个是标准库，换GCC吧，不要用假的C++了

今天用了STL的queue了，发现它push加入条目，用的是动态分配内存，而且pop之后内存还不归还，这不适合在小内存单片机上用的。
单片机上通常容器的条目数可预测，也不要频繁new/malloc操作，所以还是自己实现的fifo更适用。