sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

base: Rewrite the CircleBuf to fix bugs and add serialization

Browse source 
The CircleBuf class has at least one bug causing it to overwrite the
wrong elements when wrapping. The current code has a lot of unused
functionality and duplicated code. This changeset replaces the old
implementation with a new version that supports serialization and
arbitrary types in the buffer (not just char).
This commit is contained in:
Andreas Sandberg 2015-08-07 09:59:19 +01:00
parent 39d8034475
commit 9b2426ecfc
8 changed files with 382 additions and 328 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/base/SConscript
View file

@ -37,7 +37,6 @@ Source('atomicio.cc')
Source('bigint.cc')
Source('bitmap.cc')
Source('callback.cc')
Source('circlebuf.cc')
Source('cprintf.cc')
Source('debug.cc')
if env['USE_FENV']:

215
src/base/circlebuf.cc
View file

@ -1,215 +0,0 @@
/*
* Copyright (c) 2002-2005 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Nathan Binkert
*/
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include "base/atomicio.hh"
#include "base/circlebuf.hh"
#include "base/cprintf.hh"
#include "base/intmath.hh"
using namespace std;
CircleBuf::CircleBuf(int l)
: _rollover(false), _buflen(l), _size(0), _start(0), _stop(0)
{
_buf = new char[_buflen];
}
CircleBuf::~CircleBuf()
{
if (_buf)
delete [] _buf;
}
void
CircleBuf::dump()
{
cprintf("start = %10d, stop = %10d, buflen = %10d\n",
_start, _stop, _buflen);
fflush(stdout);
atomic_write(STDOUT_FILENO, _buf, _buflen);
atomic_write(STDOUT_FILENO, "<\n", 2);
}
void
CircleBuf::flush()
{
_start = 0;
_stop = 0;
_size = 0;
_rollover = false;
}
void
CircleBuf::read(char *b, int len)
{
_size -= len;
if (_size < 0)
_size = 0;
if (_stop > _start) {
len = min(len, _stop - _start);
memcpy(b, _buf + _start, len);
_start += len;
}
else {
int endlen = _buflen - _start;
if (endlen > len) {
memcpy(b, _buf + _start, len);
_start += len;
}
else {
memcpy(b, _buf + _start, endlen);
_start = min(len - endlen, _stop);
memcpy(b + endlen, _buf, _start);
}
}
}
void
CircleBuf::read(int fd, int len)
{
_size -= len;
if (_size < 0)
_size = 0;
if (_stop > _start) {
len = min(len, _stop - _start);
atomic_write(fd, _buf + _start, len);
_start += len;
}
else {
int endlen = _buflen - _start;
if (endlen > len) {
atomic_write(fd, _buf + _start, len);
_start += len;
}
else {
atomic_write(fd, _buf + _start, endlen);
_start = min(len - endlen, _stop);
atomic_write(fd, _buf, _start);
}
}
}
void
CircleBuf::read(int fd)
{
_size = 0;
if (_stop > _start) {
atomic_write(fd, _buf + _start, _stop - _start);
}
else {
atomic_write(fd, _buf + _start, _buflen - _start);
atomic_write(fd, _buf, _stop);
}
_start = _stop;
}
void
CircleBuf::read(ostream &out)
{
_size = 0;
if (_stop > _start) {
out.write(_buf + _start, _stop - _start);
}
else {
out.write(_buf + _start, _buflen - _start);
out.write(_buf, _stop);
}
_start = _stop;
}
void
CircleBuf::readall(int fd)
{
if (_rollover)
atomic_write(fd, _buf + _stop, _buflen - _stop);
atomic_write(fd, _buf, _stop);
_start = _stop;
}
void
CircleBuf::write(char b)
{
write(&b, 1);
}
void
CircleBuf::write(const char *b)
{
write(b, strlen(b));
}
void
CircleBuf::write(const char *b, int len)
{
if (len <= 0)
return;
_size += len;
if (_size > _buflen)
_size = _buflen;
int old_start = _start;
int old_stop = _stop;
if (len >= _buflen) {
_start = 0;
_stop = _buflen;
_rollover = true;
memcpy(_buf, b + (len - _buflen), _buflen);
return;
}
if (_stop + len <= _buflen) {
memcpy(_buf + _stop, b, len);
_stop += len;
} else {
int end_len = _buflen - old_stop;
_stop = len - end_len;
memcpy(_buf + old_stop, b, end_len);
memcpy(_buf, b + end_len, _stop);
_rollover = true;
}
if ((old_start > old_stop && old_start < _stop) ||
(old_start < old_stop && _stop < old_stop))
_start = _stop + 1;
}

276
src/base/circlebuf.hh
View file

@ -1,6 +1,15 @@
/*
* Copyright (c) 2002-2005 The Regents of The University of Michigan
* All rights reserved.
* Copyright (c) 2015 ARM Limited
* All rights reserved
*
* The license below extends only to copyright in the software and shall
* not be construed as granting a license to any other intellectual
* property including but not limited to intellectual property relating
* to a hardware implementation of the functionality of the software
* licensed hereunder. You may use the software subject to the license
* terms below provided that you ensure that this notice is replicated
* unmodified and in its entirety in all distributions of the software,
* modified or unmodified, in source code or in binary form.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@ -25,40 +34,251 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Nathan Binkert
* Authors: Andreas Sandberg
*/
#ifndef __CIRCLEBUF_HH__
#define __CIRCLEBUF_HH__
#ifndef __BASE_CIRCLEBUF_HH__
#define __BASE_CIRCLEBUF_HH__
#include <iosfwd>
#include <algorithm>
#include <cassert>
#include <vector>
#include "base/misc.hh"
#include "sim/serialize.hh"
/**
* Circular buffer backed by a vector
*
* The data in the cricular buffer is stored in a standard
* vector. _start designates the first element in the buffer and _stop
* points to the last element + 1 (i.e., the position of the next
* insertion). The _stop index may be outside the range of the backing
* store, which means that the actual index must be calculated as
* _stop % capacity.
*
* Invariants:
* <ul>
* <li>_start <= _stop
* <li>_start < capacity
* <li>_stop < 2 * capacity
* </ul>
*/
template<typename T>
class CircleBuf
{
protected:
char *_buf;
bool _rollover;
int _buflen;
int _size;
int _start;
int _stop;
public:
typedef T value_type;
public:
explicit CircleBuf(int l);
~CircleBuf();
explicit CircleBuf(size_t size)
: buf(size), _start(0), _stop(0) {}
/** Is the buffer empty? */
bool empty() const { return _stop == _start; }
/**
* Return the maximum number of elements that can be stored in
* the buffer at any one time.
*/
size_t capacity() const { return buf.size(); }
/** Return the number of elements stored in the buffer. */
size_t size() const { return _stop - _start; }
/**
* Remove all the elements in the buffer.
*
* Note: This does not actually remove elements from the backing
* store.
*/
void flush() {
_start = 0;
_stop = 0;
}
/**
* Copy buffer contents without advancing the read pointer
*
* @param out Output iterator/pointer
* @param len Number of elements to copy
*/
template <class OutputIterator>
void peek(OutputIterator out, size_t len) const {
panic_if(len > size(),
"Trying to read past end of circular buffer.\n");
if (_start + len <= buf.size()) {
std::copy(buf.begin() + _start,
buf.begin() + _start + len,
out);
} else {
const size_t head_size(buf.size() - _start);
const size_t tail_size(len - head_size);
std::copy(buf.begin() + _start, buf.end(),
out);
std::copy(buf.begin(), buf.begin() + tail_size,
out + head_size);
}
}
/**
* Copy buffer contents and advance the read pointer
*
* @param out Output iterator/pointer
* @param len Number of elements to read
*/
template <class OutputIterator>
void read(OutputIterator out, size_t len) {
peek(out, len);
_start += len;
normalize();
}
/**
* Add elements to the end of the ring buffers and advance.
*
* @param in Input iterator/pointer
* @param len Number of elements to read
*/
template <class InputIterator>
void write(InputIterator in, size_t len) {
// Writes that are larger than the backing store are allowed,
// but only the last part of the buffer will be written.
if (len > buf.size()) {
in += len - buf.size();
len = buf.size();
}
const size_t next(_stop % buf.size());
const size_t head_len(std::min(buf.size() - next, len));
std::copy(in, in + head_len, buf.begin() + next);
std::copy(in + head_len, in + len, buf.begin());
_stop += len;
// We may have written past the old _start pointer. Readjust
// the _start pointer to remove the oldest entries in that
// case.
if (size() > buf.size())
_start = _stop - buf.size();
normalize();
}
protected:
/**
* Normalize the start and stop pointers to ensure that pointer
* invariants hold after updates.
*/
void normalize() {
if (_start >= buf.size()) {
_stop -= buf.size();
_start -= buf.size();
}
assert(_start < buf.size());
assert(_stop < 2 * buf.size());
assert(_start <= _stop);
}
protected:
std::vector<value_type> buf;
size_t _start;
size_t _stop;
bool empty() const { return _size == 0; }
int size() const { return _size; }
void dump();
void flush();
void read(char *b, int len);
void read(int fd, int len);
void read(int fd);
void read(std::ostream &out);
void readall(int fd);
void write(char b);
void write(const char *b);
void write(const char *b, int len);
};
#endif // __CIRCLEBUF_HH__
/**
* Simple FIFO implementation backed by a circular buffer.
*
* This class provides the same basic functionallity as the circular
* buffer with the folling differences:
* <ul>
* <li>Writes are checked to ensure that overflows can't happen.
* <li>Unserialization ensures that the data in the checkpoint fits
* in the buffer.
* </ul>
*/
template<typename T>
class Fifo
{
public:
typedef T value_type;
public:
Fifo(size_t size)
: buf(size) {}
bool empty() const { return buf.empty(); }
size_t size() const { return buf.size(); }
size_t capacity() const { return buf.capacity(); }
void flush() { buf.flush(); }
template <class OutputIterator>
void peek(OutputIterator out, size_t len) const { buf.peek(out, len); }
template <class OutputIterator>
void read(OutputIterator out, size_t len) { buf.read(out, len); }
template <class InputIterator>
void write(InputIterator in, size_t len) {
panic_if(size() + len > capacity(),
"Trying to overfill FIFO buffer.\n");
buf.write(in, len);
}
private:
CircleBuf<value_type> buf;
};
template <typename T>
static void
arrayParamOut(CheckpointOut &cp, const std::string &name,
const CircleBuf<T> &param)
{
std::vector<T> temp(param.size());
param.peek(temp.begin(), temp.size());
arrayParamOut(cp, name, temp);
}
template <typename T>
static void
arrayParamIn(CheckpointIn &cp, const std::string &name,
CircleBuf<T> &param)
{
std::vector<T> temp;
arrayParamIn(cp, name, temp);
param.flush();
param.write(temp.cbegin(), temp.size());
}
template <typename T>
static void
arrayParamOut(CheckpointOut &cp, const std::string &name,
const Fifo<T> &param)
{
std::vector<T> temp(param.size());
param.peek(temp.begin(), temp.size());
arrayParamOut(cp, name, temp);
}
template <typename T>
static void
arrayParamIn(CheckpointIn &cp, const std::string &name,
Fifo<T> &param)
{
std::vector<T> temp;
arrayParamIn(cp, name, temp);
fatal_if(param.capacity() < temp.size(),
"Trying to unserialize data into too small FIFO\n");
param.flush();
param.write(temp.cbegin(), temp.size());
}
#endif // __BASE_CIRCLEBUF_HH__

12
src/dev/terminal.cc
View file

@ -205,8 +205,12 @@ Terminal::accept()
write((const uint8_t *)stream.str().c_str(), stream.str().size());
DPRINTFN("attach terminal %d\n", number);
txbuf.readall(data_fd);
char buf[1024];
for (size_t i = 0; i < txbuf.size(); i += sizeof(buf)) {
const size_t chunk_len(std::min(txbuf.size() - i, sizeof(buf)));
txbuf.peek(buf, chunk_len);
write((const uint8_t *)buf, chunk_len);
}
}
void
@ -329,7 +333,7 @@ Terminal::out(char c)
DPRINTF(Terminal, "%s\n", buffer);
delete [] buffer;
} else {
linebuf.write(c);
linebuf.write(&c, 1);
}
}
@ -337,7 +341,7 @@ Terminal::out(char c)
}
#endif
txbuf.write(c);
txbuf.write(&c, 1);
if (data_fd >= 0)
write(c);

6
src/dev/terminal.hh
View file

@ -109,11 +109,11 @@ class Terminal : public SimObject
void accept();
protected:
CircleBuf txbuf;
CircleBuf rxbuf;
CircleBuf<char> txbuf;
CircleBuf<char> rxbuf;
std::ostream *outfile;
#if TRACING_ON == 1
CircleBuf linebuf;
CircleBuf<char> linebuf;
#endif
public:

2
src/unittest/SConscript
View file

@ -34,7 +34,7 @@ Source('unittest.cc')
UnitTest('bituniontest', 'bituniontest.cc')
UnitTest('bitvectest', 'bitvectest.cc')
UnitTest('circletest', 'circletest.cc')
UnitTest('circlebuf', 'circlebuf.cc')
UnitTest('cprintftest', 'cprintftest.cc')
UnitTest('cprintftime', 'cprintftest.cc')
UnitTest('fbtest', 'fbtest.cc')

122
src/unittest/circlebuf.cc Normal file
View file

@ -0,0 +1,122 @@
/*
* Copyright (c) 2015 ARM Limited
* All rights reserved
*
* The license below extends only to copyright in the software and shall
* not be construed as granting a license to any other intellectual
* property including but not limited to intellectual property relating
* to a hardware implementation of the functionality of the software
* licensed hereunder. You may use the software subject to the license
* terms below provided that you ensure that this notice is replicated
* unmodified and in its entirety in all distributions of the software,
* modified or unmodified, in source code or in binary form.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Andreas Sandberg
*/
#include "base/circlebuf.hh"
#include "unittest/unittest.hh"
const char data[] = {
0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
};
int
main(int argc, char *argv[])
{
UnitTest::setCase("Basic non-overflow functionality");
{
CircleBuf<char> buf(8);
char foo[16];
// Write empty buffer, no overflow
buf.write(data, 8);
EXPECT_EQ(buf.size(), 8);
buf.peek(foo, 8);
EXPECT_EQ(memcmp(foo, data, 8), 0);
// Read 2
buf.read(foo, 2);
EXPECT_EQ(memcmp(foo, data, 2), 0);
EXPECT_EQ(buf.size(), 6);
buf.read(foo, 6);
EXPECT_EQ(memcmp(foo, data + 2, 6), 0);
EXPECT_EQ(buf.size(), 0);
}
UnitTest::setCase("Basic single write overflow functionality");
{
CircleBuf<char> buf(8);
char foo[16];
buf.write(data, 16);
EXPECT_EQ(buf.size(), 8);
buf.peek(foo, 8);
EXPECT_EQ(memcmp(data + 8, foo, 8), 0);
}
UnitTest::setCase("Multi-write overflow functionality");
{
CircleBuf<char> buf(8);
char foo[16];
// Write, no overflow, write overflow
buf.write(data, 6);
buf.write(data + 8, 6);
EXPECT_EQ(buf.size(), 8);
buf.peek(foo, 8);
EXPECT_EQ(memcmp(data + 4, foo, 2), 0);
EXPECT_EQ(memcmp(data + 8, foo + 2, 6), 0);
}
UnitTest::setCase("Pointer wrap around");
{
CircleBuf<char> buf(8);
char foo[16];
// _start == 0, _stop = 8
buf.write(data, 8);
// _start == 4, _stop = 8
buf.read(foo, 4);
// _start == 4, _stop = 12
buf.write(data + 8, 4);
EXPECT_EQ(buf.size(), 8);
// _start == 10, _stop = 12
// Normalized: _start == 2, _stop = 4
buf.read(foo + 4, 6);
EXPECT_EQ(buf.size(), 2);
EXPECT_EQ(memcmp(data, foo, 10), 0);
// Normalized: _start == 4, _stop = 4
buf.read(foo + 10, 2);
EXPECT_EQ(buf.size(), 0);
EXPECT_EQ(memcmp(data, foo, 12), 0);
}
return UnitTest::printResults();
}

76
src/unittest/circletest.cc
View file

@ -1,76 +0,0 @@
/*
* Copyright (c) 2002-2005 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Nathan Binkert
*/
#include <fcntl.h>
#include <unistd.h>
#include <iostream>
#include "base/circlebuf.hh"
const char *strings[] = {
"This is the first test\n",
"he went with his woman to the store\n",
"the man with the bat hit the woman with the hat\n",
"that that is is that that was\n",
"sue sells sea shells by the sea shore\n",
"go to the store and buy me some milk and bread\n",
"the friendly flight attendants spoke soothingly to "
"the frightened passengers in their native languages\n"
};
const int num_strings = sizeof(strings) / sizeof(char *);
int
main()
{
CircleBuf buf(1024);
for (int count = 0; count < 100; count++)
buf.write(strings[count % num_strings]);
buf.read(STDOUT_FILENO);
write(STDOUT_FILENO, "<\n", 2);
for (int count = 0; count < 100; count++)
buf.write(strings[count % num_strings]);
buf.read(STDOUT_FILENO, 100);
write(STDOUT_FILENO, "<\n", 2);
buf.flush();
buf.write("asdfa asdf asd fasdf asdf\n");
buf.write("");
buf.write("");
buf.write("");
buf.write("");
buf.write("");
buf.write("");
buf.read(STDOUT_FILENO);
write(STDOUT_FILENO, "<\n", 2);
}