circular-buffer

I'm trying to find a way to make a Lock Free OR Non-blocking way to make a Ring Buffer for single consumer / single consumer that will over-write the oldest data int the buffer. I've read a lot of lock-free algorithms that work when you "return false" if the buffer is full--ie, don't add; but I can't find even pseudo-code that talks about how to do it when you need to overwrite the oldest data. I am using GCC 4.1.2 (restriction at work, i can't upgrade the version...) and I have the Boost libraries, and in the past I made my own Atomic< T > variable type that follows pretty closely to the

I need a python script implementing a circular buffer for rows in a text file limited to N rows like this: row 1 -> pop row 2 row 3 | | push -> row N What's the best solution? EDIT: This script should create and maintain the text file which only contains the latest N lines. Then it should pop the first line pushed in. Like a fifo buffer. Try my recipe and sorry for italian usage: #!/usr/bin/env python # -*- coding: utf-8 -*- # # fifo(.py) # # Copyright 2011 Fabio Di Bernardini <fdb@altraqua.com> # # This program is free software; you can redistribute it and/or modify # it under the terms of

I'm developing a client which will receive the [EEG] data over tcp and write it to the ring buffer. I thought it can be very convenient to have the buffer as a ctypes or numpy array because it's possible to create a numpy 'view' to any location of such buffer and read/write/process the data without any copying operations. Or is it a bad idea in general? However, I don't see how to implement a circular buffer of a fixed size this way. Suppose I have created a buffer object which is contiguous in memory. What is the best way to write the data when the end of the buffer is reached? One possible

How to find the number of lexicographically minimal string rotation ? For example: S = abab, N = 2 S = abca, N = 1 S = aaaa, N = 4 I tried Duval's algorithm, it works very long. The string length of 100000000 characters. Easy -- just determine the minimum period of the string. A string which is periodic in minimal period K will produce identical (and hence lexicographically equal) strings for exactly N/K different rotations, so whatever the lexicographic minimum is, it'll be the result of N/K different rotations. 来源： https://stackoverflow.com/questions/21026091/how-to-find-the-number-of-the

Iterating forward through a circular buffer without using a conditional is easy with the remainder operator... iterator = (iterator + 1) % buffer_size; I can't for the life of me figure out the reverse operation, iterating backward. Does iterator = (iterator + buffer_size - 1) % buffer_size work for you? Go one less than all the way around. Borealid's answer works. (note: iterator is set to 0 initially). Another solution is iterator = buffer_size - 1 - (buffer_size - iterator) % buffer_size with iterator set to buffer_size initially. 来源： https://stackoverflow.com/questions/3437477/how-do-you

Just messing about here, with circular buffers. Is this a sensible implementation or is there a faster/more reliable way to skin this cat? class CircularBuffer[T](size: Int)(implicit mf: Manifest[T]) { private val arr = new scala.collection.mutable.ArrayBuffer[T]() private var cursor = 0 val monitor = new ReentrantReadWriteLock() def push(value: T) { monitor.writeLock().lock() try { arr(cursor) = value cursor += 1 cursor %= size } finally { monitor.writeLock().unlock() } } def getAll: Array[T] = { monitor.readLock().lock() try { val copy = new Array[T](size) arr.copyToArray(copy) copy }

I want a simple yet efficient circular buffer/queue. If I use std::vector , I have to do this: if ( v.size() >= limit ) { std::vector<int> it = v.begin(); v.insert( it, data ); v.erase( it+1 ); } Is there any simpler solution? You want to maintain the size of the buffer, overwriting older items. Just overwrite the old ones as time goes on. If you want to deal with the case where nItems < limit, then you would need to deal with that, this is just a simple example of using modulo to insert into a fixed size buffer. std::vector<int> data(10); for (int i = 0 ; i < 100 ; ++i) { data[i%10] = i; }