我正在使用Java在事件流上实现一个滑动窗口.所以我想要一个允许我执行以下操作的数据结构:
新事件发生时添加到数据结构的末尾;
处理旧事件时从数据结构的开头删除;
获得标准随机访问(size(),get(i))到数据结构的元素; 一般来说,典型的List "读"操作;
对所有上述操作都有效;
没有界限.
无需其他访问权限.并且不需要线程安全.
我目前正在使用ArrayList执行此操作,以便开始运行.但我想要更高效的东西; 该remove(0)方法(2以上)是低效用ArrayList.
数字1.和2.是标准的队列式操作.但是,QueueJDK中的实现(例如ArrayDeque)不允许get(i)在3中实现.
所以,我想知道是否有任何库有这样的实现,并且适合商业用途.
如果没有,我想我会写自己的......
与Windows风格的自解释复制/剪切/粘贴命令不同,我无法理解emacs中的环概念.
由于我不经常在emacs中编程,我可能没有意识到环功能的价值.你能告诉我emacs中的所谓铃声以及如何使用它吗？
我需要一个python脚本为文本文件中的行实现循环缓冲区,限制为N行,如下所示:
row 1 -> pop
row 2
row 3
|
|
push -> row N
什么是最好的解决方案？
编辑:此脚本应创建和维护仅包含最新N行的文本文件.然后它应该弹出推入的第一行.就像一个fifo缓冲区.
我正在开发一个客户端,它将通过tcp接收[EEG]数据并将其写入环形缓冲区.我认为将缓冲区作为ctypes或numpy数组非常方便,因为它可以为这样的缓冲区的任何位置创建一个numpy"视图",并且可以读取/写入/处理数据而无需任何复制操作.或者一般来说这是一个坏主意？
但是,我没有看到如何以这种方式实现固定大小的循环缓冲区.假设我创建了一个在内存中连续的缓冲区对象.达到缓冲区末尾时写入数据的最佳方法是什么？
一种可能的方法是在写指针到达缓冲区数组的末尾时开始覆盖(已经过时的)字节.然而,在边界附近,在这种情况下,某些块(用于处理)的numpy视图无法创建(或者可以吗？),因为其中一些仍然可以位于缓冲区数组的末尾,而另一个已经在它的开始.我读过它是不可能创建这样的圆形切片.怎么解决这个？
UPD:谢谢大家的答案.如果有人也面临同样的问题,这是我得到的最终代码.
到目前为止,这是我对圆形数组的实现.它应该存储输入的最后5个命令,通过在第5个位置输入第6个命令并丢弃第1个命令.到目前为止我设法做的是,能够存储5个命令并打印出来.在第6个命令中,我注意到它进入了第二个位置(k=1)historyArray,但是在调试时,k它等于0至少将最后一个命令推到顶部.如果你能让我再次走上正轨,我将不胜感激.这是代码的一部分.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main (int argc, char *argv[])
{
int i=0;
int j=0;
int k=0;
int tempIndex = 0;
int elementCounter = 0;
char inputString[100];
char *result=NULL;
char delims[] = " ";
char historyArray[5][20] = {0};
char tokenArray[20][20] ;
char hCommand[1][20];
do
{
j = 0;
printf("hshell>");
gets(inputString);
//skip writing "history" in historyArray
if (strcmp(inputString,"history")!= 0)
{
strcpy (historyArray[k], inputString);
}
k = (k+1) % 5;
if …在这里搞乱,用循环缓冲区.这是一个明智的实施还是有更快/更可靠的方式来剥皮这只猫？
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
} finally {
monitor.readLock().unlock()
}
}
}
我有一个固定大小的循环缓冲区(实现为数组):初始化时,缓冲区将填充指定的最大元素数,允许使用单个位置索引,以便跟踪我们在圆圈中的当前位置.
访问循环缓冲区中元素的有效方法是什么？这是我目前的解决方案:
int GetElement(int index)
{
if (index >= buffer_size || index < 0)
{
// some code to handle the case
}
else
{
// wrap the index
index = end_index + index >= buffer_size ? (index + end_index) - buffer_size : end_index + index;
}
return buffer[index];
}
一些定义:
end_index是紧跟在圆圈中最后一个元素之后的元素的索引(它也被认为与start_index或圆的第一个元素相同).
buffer_size是缓冲区的最大大小.
我使用匿名mmap来分配一大块内存.在这里有几个连续的页面,我想使用虚拟内存镜像变成一个环形缓冲区.
维基百科上的这个例子显示了虚拟内存镜像的含义.
假设下面的前14个区块是我巨大的块中的页面.我想将第6页和第7页虚拟地映射到另外两个连续的位置.
[0][1][2][3][4][5][6][7][8][9][10][11][12][13].......[6][7][6][7]
迈克·阿什给出一个破败的什么我想要做的,但使用马赫特定的API.
怎么能在Linux上完成？
对于大型数组（10 ^ 7个元素）上的信号处理，我使用与环形缓冲区连接的不同线程。可悲的是，将数据复制到缓冲区或从缓冲区复制数据只需要太多时间。当前的实现基于boost::lockfree::spsc_queue。
因此，我正在寻找一种解决方案，以通过在向量和向量之间使用unique_ptr来在向量和线程之间交换向量的所有权（请参见附图：在线程和队列之间交换指针）。
移动智能指针不符合我的需求，因为因此我需要在运行时不断为新的矢量元素分配内存。该开销大于复制数据的开销。
我在设计上缺少缺陷吗？
是否有线程安全或什至无锁的环形缓冲区实现允许对push和pop进行交换操作？
编辑：我修改了一个锁环缓冲区以交换unique_ptr。性能提升巨大。虽然这并不是一个优雅的解决方案。有什么建议吗？
// https://github.com/embeddedartistry/embedded-resources/blob/master/examples/cpp/circular_buffer.cpp
#include <memory>
#include <mutex>
template <typename T, int SIZE>
class RingbufferPointer {
typedef std::unique_ptr<T> TPointer;
public:
explicit RingbufferPointer() {
// create objects
for (int i=0; i<SIZE; i++) {
buf_[i] = std::make_unique<T>();
}
}
bool push(TPointer &item) {
std::lock_guard<std::mutex> lock(mutex_);
if (full())
return false;
std::swap(buf_[head_], item);
if (full_)
tail_ = (tail_ + 1) % max_size_;
head_ = (head_ + 1) …