C# Ringbuffer 实现+cacheline不同写法性能测试

最新推荐文章于 2024-04-06 20:40:30 发布
最新推荐文章于 2024-04-06 20:40:30 发布
阅读量505 收藏 1
点赞数
分类专栏： 无锁编程 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56766616/article/details/121785789
版权 
using System;
using System.Threading;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace RingBufferTest
{
    public class RingBuffer<T>
    {
        public long start = 0;
        public long end = 0;
        public T[] buffer;

        public RingBuffer(int size)
        {
            buffer = new T[size + 1];
        }

        public bool Empty()
        {
            return start == end;
        }

        public bool Push(T data)
        {
            if (end >= start)
            {
                var freeLen = buffer.Length - (end - start);
                if (freeLen <= 1)
                {
                    return false;
                }

                var cutLen0 = buffer.Length - end;
                if (cutLen0 >= 1)
                {
                    buffer[end] = data;
                    ++end;
                }
                else
                {
                    buffer[0] = data;
                    end = 1;
                }

            }
            else
            {
                var freeLen = start - end;
                if (freeLen <= 1)
                {
                    return false;
                }

                buffer[end] = data;
                ++end;
            }

            return true;
        }

        public T Pop()
        {
            T retObj = default;

            if (end == start)
            {
                return retObj;
            }
            else if (end > start)
            {
                var usedLen = end - start;
                if (usedLen < 1)
                {
                    return retObj;
                }

                retObj = buffer[start];
                ++start;
                return retObj;
            }
            else
            {
                var usedLen = buffer.Length - (start - end);
                if (usedLen < 1)
                {
                    return retObj;
                }

                var cutLen0 = buffer.Length - start;
                if (cutLen0 >= 1)
                {
                    retObj = buffer[start];
                    ++start;
                    return retObj;
                }
                else
                {
                    retObj = buffer[0];
                    start = 1;
                    return retObj;
                }
            }
        }
    }

    public class RingBuffer1<T>
    {
        public long start = 0;
        protected long _x0, _x1, _x2, _x3, _x4, _x5, _x6;
        public long end = 0;
        public T[] buffer;

        public RingBuffer1(int size)
        {
            buffer = new T[size + 1];
        }

        public bool Empty()
        {
            return start == end;
        }

        public bool Push(T data)
        {
            if (end >= start)
            {
                var freeLen = buffer.Length - (end - start);
                if (freeLen <= 1)
                {
                    return false;
                }

                var cutLen0 = buffer.Length - end;
                if (cutLen0 >= 1)
                {
                    buffer[end] = data;
                    ++end;
                }
                else
                {
                    buffer[0] = data;
                    end = 1;
                }

            }
            else
            {
                var freeLen = start - end;
                if (freeLen <= 1)
                {
                    return false;
                }

                buffer[end] = data;
                ++end;
            }

            return true;
        }

        public T Pop()
        {
            T retObj = default;

            if (end == start)
            {
                return retObj;
            }
            else if (end > start)
            {
                var usedLen = end - start;
                if (usedLen < 1)
                {
                    return retObj;
                }

                retObj = buffer[start];
                ++start;
                return retObj;
            }
            else
            {
                var usedLen = buffer.Length - (start - end);
                if (usedLen < 1)
                {
                    return retObj;
                }

                var cutLen0 = buffer.Length - start;
                if (cutLen0 >= 1)
                {
                    retObj = buffer[start];
                    ++start;
                    return retObj;
                }
                else
                {
                    retObj = buffer[0];
                    start = 1;
                    return retObj;
                }
            }
        }
    }

    [StructLayout(LayoutKind.Explicit)]
    public class ByteRingBuffer
    {
        [FieldOffset(0)]
        public long start = 0;
        [FieldOffset(64)]
        public long end = 0;
        [FieldOffset(128)]
        public byte[] buffer;

        public static string getMemory(object o)
        {
            GCHandle h = GCHandle.Alloc(o, GCHandleType.Pinned);
            IntPtr addr = h.AddrOfPinnedObject();
            return addr.ToString();
        }

        public ByteRingBuffer(int size)
        {
            buffer = new byte[size + 1];
          
        }

        public bool Empty()
        {
            return start == end;
        }

        public bool Push(byte data)
        {
            if (end >= start)
            {
                var freeLen = buffer.Length - (end - start);
                if (freeLen <= 1)
                {
                    return false;
                }

                var cutLen0 = buffer.Length - end;
                if (cutLen0 >= 1)
                {
                    buffer[end] = data;
                    ++end;
                }
                else
                {
                    buffer[0] = data;
                    end = 1;
                }

            }
            else
            {
                var freeLen = start - end;
                if (freeLen <= 1)
                {
                    return false;
                }

                buffer[end] = data;
                ++end;
            }

            return true;
        }

        public byte Pop()
        {
            byte retObj = default;

            if (end == start)
            {
                return retObj;
            }
            else if (end > start)
            {
                var usedLen = end - start;
                if (usedLen < 1)
                {
                    return retObj;
                }

                retObj = buffer[start];
                ++start;
                return retObj;
            }
            else
            {
                var usedLen = buffer.Length - (start - end);
                if (usedLen < 1)
                {
                    return retObj;
                }

                var cutLen0 = buffer.Length - start;
                if (cutLen0 >= 1)
                {
                    retObj = buffer[start];
                    ++start;
                    return retObj;
                }
                else
                {
                    retObj = buffer[0];
                    start = 1;
                    return retObj;
                }
            }
        }
    }

    class Program
    {
        const int RingBufferSize = 1024*1024*3;
        const int LoopNum = 100 * 5;

        static float st1 = 0.0f;
        static float st2 = 0.0f;
        
        static void testPushAndPop() {
            float t1 = 0.0f;
            float t2 = 0.0f;
            //var rg = new RingBuffer<byte>(RingBufferSize);
            //var rg = new RingBuffer1<byte>(RingBufferSize);
            var rg = new ByteRingBuffer(RingBufferSize);
            bool push = false;
            bool pop = false;

            var popThread = new Thread(() => {
                Stopwatch st = new Stopwatch();
                st.Start();
                for (var i = 0; i < RingBufferSize; i++)
                {
                    rg.Pop();
                }
                st.Stop();
                t1 += st.ElapsedMilliseconds;
                push = true;
            });

            var pushThread = new Thread(() => {
                Stopwatch st = new Stopwatch();
                st.Start();
                for (var ii = 0; ii < RingBufferSize; ii++)
                {
                    rg.Push(1);
                }
                st.Stop();
                t2 += st.ElapsedMilliseconds;
                pop = true;
            });

            pushThread.Start();
            popThread.Start();

            Thread.Sleep(70);

            while (!pop && !push) {
                Thread.Sleep(10);
            }

            st1 += t1;
            st2 += t2;

            Console.WriteLine("push avg time: " + t1);
            Console.WriteLine("pop avg time: " + t2);
        }

        static void Main(string[] args)
        {
            for (var i = 0; i < LoopNum; i++) {
                Console.WriteLine("current index {0}", i);
                testPushAndPop();
            }
            
            Console.WriteLine("********************");
            Console.WriteLine("push avg time: " + st1 / LoopNum);
            Console.WriteLine("pop avg time: " + st2 / LoopNum);
            Console.ReadKey(true);
        }
    }
}


一个线程读，一个线程写，每次一个读写一个字节。单次读写3M数据，循环500次。
三种写法，仅仅改变类内存布局。 内部函数尚未优化。

测试结果：

ringbuffer 耗时约80ms

ringbuffer1 耗时约60ms

byteringbuffer 耗时约40ms

mqdCha
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
环形缓冲区实现类(RingBuffer)
09-01
环形缓冲区实现类(RingBuffer)
C#环形缓冲区（队列）完全实现（转）
道可盗经常盗
03-10 943
以下为原文。
嵌入式C基础——循环队列 ringbuffer 讲解
最新发布
weixin_37620587的博客
04-06 1136
ringbuffer的原理讲解以及rtos例子，还有实际举例
c# 同步功能的环形缓存区ReadWrite RingBuffer
RainsSoft
11-03 2830
// Define this to use simple synchronisation rather than events. // They are about the same in terms of speed. #define SimpleSynch using System; using System.IO; using System.Threading; using NUnit.
C#中FileStream——循环RingBuffer
小孔明的专栏
07-22 277
http://blog.sina.com.cn/s/blog_a317eab90102v8vj.html
C#网口数据处理-环形缓冲区
qq_27474555的博客
07-18 468
在C#中用环形数据缓冲区对网口数据进行处理
Rt-thead studio软件下使用ringbuffer
04-21
Rt-thead studio软件下使用ringbuffer
ring buffer实现原理
02-28
1、环形缓冲区的实现原理 环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况...
ringbuffer+log方式的调试串口
01-02
ringbuffer+log方式的调试串口
环形缓冲区.ringbuff(C#和java)
weixin_30443747的博客
05-10 292
环形缓冲， 本质就是队列fifo，先进先出的特殊版本，环形队列，是用空间得到了顺序存储的快索引的优点，又避免了删除，移动数据的缺点。并且还享受了单生产/单消费，2线程的无锁线程优势。十分完美。 1.面对频率超级频繁的读写，环形缓冲修改为固定大小的队列，不添加操作，并且使用后，也不删除和移动。坏处是，必须预设内存空间。所以适合超级频繁的读写，反正基本是一直占用。 2.因为要实现环形，所以一般有...
RingBuffer
yhf_szb的专栏
03-20 643
////// 变长的RingBuffer///private class RingBuffer{byte[] _buffer;int _read;int _write;int _count;//有效数据长度////// 缓存区总长度//////protected int length{get{lock ( this . _buffer . SyncRoot ){return this . _buff
ringbuffer - 原创-高效率管理
12-08
原创ringbuffer：具有高效率管理块传输，动态内存分配释放。自适应char8,int16, int32数据类型。
RingBuffer 循环缓存 亲测可用
12-17
运用技术： C++ 11 ，thread ，atomic ，mutex ，condition_variable 。 程序特性： 1.每个实例支持读写双线程。 2.数据一致。 3.ringbuffer为空时，读取时候等待。直到有数据写入，再继续读取。 4.当写入数据的长度大于ringbuffer的可写入长度时，多余的数据将会丢弃。所以写入数据前，先判断ringbuffer的可写入长度。 另外程序包含示例。 支持windows平台的vs与linux平台的clion，语言级别实现，与平台无关。 附件是代码工程，已编译。
Z-Buffer消隐算法C#实现
01-19
采用C#实现计算机图形学中Z-Buffer消隐算法
RingBuffer 循环缓存 亲测可用 V2 修改一处
12-17
运用技术： C++ 11 ，thread ，atomic ，mutex ，condition_variable 。 程序特性： 1.每个实例支持读写双线程。 2.数据一致。 3.ringbuffer为空时，读取时候等待。直到有数据写入，再继续读取。 4.当写入数据的长度大于ringbuffer的可写入长度时，多余的数据将会丢弃。所以写入数据前，先判断ringbuffer的可写入长度。另外程序包含示例。 支持windows平台的vs与linux平台的clion，语言级别实现，与平台无关。 附件是代码工程，已编译。
c#DoubleBuffer画图，适用于学习双缓存画图的同学
06-27
c#DoubleBuffer画图，适用于学习双缓存画图的同学，Form1.cs，Form1.Designer.cs Program.cs AssemblyInfo.cs Settings.Designer.cs
ring buffer示例
ldhshao的专栏
07-30 330
文章目录概述示例引用 概述 ring buffer,或者说循环队列，是嵌入式开发中的一个基本模型，常用于命令队列，资源循环分配场合。 示例 ring_buffer.h ring buffer 封装API testringbuffer.c 测试ring buffer api. //ring_buffer.h #include <stdlib.h> typedef struct s_ring_buffer{ int tail; int head; int size; int item_si
环形缓冲器 circular buffer, ring buffer
tech
01-09 874
关于环形缓冲器，直接看维基百科的解释，简单有效 https://en.wikipedia.org/wiki/Circular_buffer
ringbuf的一个简单实现
开心乐源的专栏
04-23 2161
/* Opaque buffer element type. This would be defined by the application. */ typedef struct { void * buff; } ElemType; /* Circular buffer object */ typedef struct { int size; /* maximu
ringbuffer C语言实现
06-07
以下是一个简单的环形缓冲区的 C 语言实现示例： ```c #define BUFFER_SIZE 16 typedef struct { int head; int tail; int size; char buffer[BUFFER_SIZE]; } RingBuffer; void push(RingBuffer *rb, char c) { rb->buffer[rb->tail] = c; rb->tail = (rb->tail + 1) % BUFFER_SIZE; if (rb->size == BUFFER_SIZE) { rb->head = (rb->head + 1) % BUFFER_SIZE; } else { rb->size++; } } char front(RingBuffer *rb) { return rb->buffer[rb->head]; } void pop(RingBuffer *rb) { rb->head = (rb->head + 1) % BUFFER_SIZE; rb->size--; } int empty(RingBuffer *rb) { return rb->size == 0; } int size(RingBuffer *rb) { return rb->size; } ``` 这个示例中，我们使用了一个结构体来表示环形缓冲区，其中 `head` 表示第一个元素的下标，`tail` 表示下一个元素的下标，`size` 表示缓冲区中当前元素的数量，`buffer` 是实际存储元素的数组。 `push` 函数将一个字符添加到缓冲区的末尾，`front` 函数返回缓冲区的第一个元素，`pop` 函数将缓冲区的第一个元素删除，`empty` 函数返回缓冲区是否为空，`size` 函数返回缓冲区中元素的数量。 注意，在这个示例中，我们使用了取模运算来实现环形缓冲区的循环。这里的 `BUFFER_SIZE` 可以根据实际需要进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值