qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-25 17:27:58 -07:00
Code Releases Activity

restore the old algorithm. the new one is more memory efficient in large cases

Browse Source 
but too slow across the board.

R=rsc
DELTA=315  (50 added, 219 deleted, 46 changed)
OCL=34868
CL=34902
This commit is contained in:
Rob Pike 2009-09-22 14:53:48 -07:00
parent b9493ded12
commit 9e7f3a46d3
1 changed files with 96 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

361
src/pkg/bytes/buffer.go
View File

@ -4,131 +4,11 @@
package bytes package bytes
import "os" // Simple byte buffer for marshaling data.
// Efficient construction of large strings and byte arrays. import (
// Implements io.Reader and io.Writer. "os";
)
// A Buffer provides efficient construction of large strings
// and slices of bytes. It implements io.Reader and io.Writer.
// Appends (writes) are efficient.
// The zero value for Buffer is an empty buffer ready to use.
type Buffer struct {
blk []block;
len int;
oneByte [1]byte;
}
// There are two kinds of block: a string or a []byte.
// When the user writes big strings, we add string blocks;
// when the user writes big byte slices, we add []byte blocks.
// Small writes are coalesced onto the end of the last block,
// whatever it is.
// This strategy is intended to reduce unnecessary allocation.
type block interface {
Len() int;
String() string;
appendBytes(s []byte);
appendString(s string);
setSlice(m, n int);
}
// stringBlocks represent strings. We use pointer receivers
// so append and setSlice can overwrite the receiver.
type stringBlock string
func (b *stringBlock) Len() int {
return len(*b)
}
func (b *stringBlock) String() string {
return string(*b)
}
func (b *stringBlock) appendBytes(s []byte) {
*b += stringBlock(s)
}
func (b *stringBlock) appendString(s string) {
*b = stringBlock(s)
}
func (b *stringBlock) setSlice(m, n int) {
*b = (*b)[m:n]
}
// byteBlock represent slices of bytes. We use pointer receivers
// so append and setSlice can overwrite the receiver.
type byteBlock []byte
func (b *byteBlock) Len() int {
return len(*b)
}
func (b *byteBlock) String() string {
return string(*b)
}
func (b *byteBlock) resize(max int) {
by := []byte(*b);
if cap(by) >= max {
by = by[0:max];
} else {
nby := make([]byte, max, 3*(max+10)/2);
copyBytes(nby, 0, by);
by = nby;
}
*b = by;
}
func (b *byteBlock) appendBytes(s []byte) {
curLen := b.Len();
b.resize(curLen + len(s));
copyBytes([]byte(*b), curLen, s);
}
func (b *byteBlock) appendString(s string) {
curLen := b.Len();
b.resize(curLen + len(s));
copyString([]byte(*b), curLen, s);
}
func (b *byteBlock) setSlice(m, n int) {
*b = (*b)[m:n]
}
// Because the user may overwrite the contents of byte slices, we need
// to make a copy. Allocation strategy: leave some space on the end so
// small subsequent writes can avoid another allocation. The input
// is known to be non-empty.
func newByteBlock(s []byte) *byteBlock {
l := len(s);
// Capacity with room to grow. If small, allocate a mininum. If medium,
// double the size. If huge, use the size plus epsilon (room for a newline,
// at least).
c := l;
switch {
case l < 32:
c = 64
case l < 1<<18:
c *= 2;
default:
c += 8
}
b := make([]byte, l, c);
copyBytes(b, 0, s);
return &b;
}
// Copy from block to byte array at offset doff. Assume there's room.
func copy(dst []byte, doff int, src block) {
switch s := src.(type) {
case *stringBlock:
copyString(dst, doff, string(*s));
case *byteBlock:
copyBytes(dst, doff, []byte(*s));
}
}
// Copy from string to byte array at offset doff. Assume there's room. // Copy from string to byte array at offset doff. Assume there's room.
func copyString(dst []byte, doff int, str string) { func copyString(dst []byte, doff int, str string) {
@ -146,134 +26,105 @@ func copyBytes(dst []byte, doff int, src []byte) {
} }
} }
// Bytes returns the contents of the unread portion of the buffer // A Buffer is a variable-sized buffer of bytes
// as a byte array. // with Read and Write methods.
// The zero value for Buffer is an empty buffer ready to use.
type Buffer struct {
buf []byte; // contents are the bytes buf[off : len(buf)]
off int; // read at &buf[off], write at &buf[len(buf)]
oneByte []byte; // avoid allocation of slice on each WriteByte
}
// Bytes returns the contents of the unread portion of the buffer;
// len(b.Bytes()) == b.Len().
func (b *Buffer) Bytes() []byte { func (b *Buffer) Bytes() []byte {
n := b.len; return b.buf[b.off : len(b.buf)]
bytes := make([]byte, n);
nbytes := 0;
for _, s := range b.blk {
copy(bytes, nbytes, s);
nbytes += s.Len();
}
return bytes;
} }
// String returns the contents of the unread portion of the buffer // String returns the contents of the unread portion of the buffer
// as a string. // as a string.
func (b *Buffer) String() string { func (b *Buffer) String() string {
if len(b.blk) == 1 { // important special case return string(b.buf[b.off : len(b.buf)])
return b.blk[0].String()
}
return string(b.Bytes())
} }
// Len returns the number of bytes in the unread portion of the buffer; // Len returns the number of bytes of the unread portion of the buffer;
// b.Len() == len(b.Bytes()) == len(b.String()). // b.Len() == len(b.Bytes()).
func (b *Buffer) Len() int { func (b *Buffer) Len() int {
return b.len return len(b.buf) - b.off
} }
// Truncate discards all but the first n unread bytes from the buffer. // Truncate discards all but the first n unread bytes from the buffer.
// It is an error to call b.Truncate(n) with n > b.Len().
func (b *Buffer) Truncate(n int) { func (b *Buffer) Truncate(n int) {
b.len = 0; // recompute during scan. if n == 0 {
for i, s := range b.blk { // Reuse buffer space.
if n <= 0 { b.off = 0;
b.blk = b.blk[0:i];
break;
}
if l := s.Len(); n < l {
b.blk[i].setSlice(0, n);
b.len += n;
n = 0;
} else {
b.len += l;
n -= l;
}
} }
b.buf = b.buf[0 : b.off + n];
} }
// Reset resets the buffer so it has no content. // Reset resets the buffer so it has no content.
// b.Reset() is the same as b.Truncate(0). // b.Reset() is the same as b.Truncate(0).
func (b *Buffer) Reset() { func (b *Buffer) Reset() {
b.blk = b.blk[0:0]; b.Truncate(0);
b.len = 0;
}
// Can n bytes be appended efficiently to the end of the final string?
func (b *Buffer) canCombine(n int) bool {
return len(b.blk) > 0 && n+b.blk[len(b.blk)-1].Len() <= 64
}
// WriteString appends string s to the buffer. The return
// value n is the length of s; err is always nil.
func (b *Buffer) WriteString(s string) (n int, err os.Error) {
n = len(s);
if n == 0 {
return
}
b.len += n;
numStr := len(b.blk);
// Special case: If the last piece is short and this one is short,
// combine them and avoid growing the list.
if b.canCombine(n) {
b.blk[numStr-1].appendString(s);
return
}
if cap(b.blk) == numStr {
nstr := make([]block, numStr, 3*(numStr+10)/2);
for i, s := range b.blk {
nstr[i] = s;
}
b.blk = nstr;
}
b.blk = b.blk[0:numStr+1];
// The string is immutable; no need to make a copy.
b.blk[numStr] = (*stringBlock)(&s);
return
} }
// Write appends the contents of p to the buffer. The return // Write appends the contents of p to the buffer. The return
// value n is the length of p; err is always nil. // value n is the length of p; err is always nil.
func (b *Buffer) Write(p []byte) (n int, err os.Error) { func (b *Buffer) Write(p []byte) (n int, err os.Error) {
m := b.Len();
n = len(p); n = len(p);
if n == 0 {
return if len(b.buf) + n > cap(b.buf) {
} // not enough space at end
b.len += n; buf := b.buf;
numStr := len(b.blk); if m + n > cap(b.buf) {
// Special case: If the last piece is short and this one is short, // not enough space anywhere
// combine them and avoid growing the list. buf = make([]byte, 2*cap(b.buf) + n)
if b.canCombine(n) {
b.blk[numStr-1].appendBytes(p);
return
}
if cap(b.blk) == numStr {
nstr := make([]block, numStr, 3*(numStr+10)/2);
for i, s := range b.blk {
nstr[i] = s;
} }
b.blk = nstr; copyBytes(buf, 0, b.buf[b.off:b.off+m]);
b.buf = buf;
b.off = 0
} }
b.blk = b.blk[0:numStr+1];
// Need to copy the data - user might overwrite the data. b.buf = b.buf[0 : b.off + m + n];
b.blk[numStr] = newByteBlock(p); copyBytes(b.buf, b.off + m, p);
return return n, nil
}
// WriteString appends the contents of s to the buffer. The return
// value n is the length of s; err is always nil.
func (b *Buffer) WriteString(s string) (n int, err os.Error) {
m := b.Len();
n = len(s);
if len(b.buf) + n > cap(b.buf) {
// not enough space at end
buf := b.buf;
if m + n > cap(b.buf) {
// not enough space anywhere
buf = make([]byte, 2*cap(b.buf) + n)
}
copyBytes(buf, 0, b.buf[b.off:b.off+m]);
b.buf = buf;
b.off = 0
}
b.buf = b.buf[0 : b.off + m + n];
copyString(b.buf, b.off+m, s);
return n, nil
} }
// WriteByte appends the byte c to the buffer. // WriteByte appends the byte c to the buffer.
// The returned error is always nil, but is included // The returned error is always nil, but is included
// to match bufio.Writer's WriteByte. // to match bufio.Writer's WriteByte.
func (b *Buffer) WriteByte(c byte) os.Error { func (b *Buffer) WriteByte(c byte) os.Error {
b.oneByte[0] = c; if b.oneByte == nil {
// For WriteByte, canCombine is almost always true so it's worth // Only happens once per Buffer, and then we have a slice.
// doing here. b.oneByte = make([]byte, 1);
if b.canCombine(1) {
b.blk[len(b.blk)-1].appendBytes(&b.oneByte);
b.len++;
return nil
} }
b.Write(&b.oneByte); b.oneByte[0] = c;
b.Write(b.oneByte);
return nil; return nil;
} }
@ -282,63 +133,43 @@ func (b *Buffer) WriteByte(c byte) os.Error {
// buffer has no data to return, err is os.EOF even if len(p) is zero; // buffer has no data to return, err is os.EOF even if len(p) is zero;
// otherwise it is nil. // otherwise it is nil.
func (b *Buffer) Read(p []byte) (n int, err os.Error) { func (b *Buffer) Read(p []byte) (n int, err os.Error) {
if len(b.blk) == 0 { if b.off >= len(b.buf) {
return 0, os.EOF return 0, os.EOF
} }
for len(b.blk) > 0 { m := b.Len();
blk := b.blk[0]; n = len(p);
m := len(p) - n;
if l := blk.Len(); m >= l { if n > m {
// consume all of this string. // more bytes requested than available
copy(p, n, blk); n = m
n += l;
b.blk = b.blk[1:len(b.blk)];
} else {
// consume some of this block; it's the last piece.
switch b := blk.(type) {
case *stringBlock:
copyString(p, n, string(*b)[0:m]);
case *byteBlock:
copyBytes(p, n, []byte(*b)[0:m]);
}
n += m;
b.blk[0].setSlice(m, l);
break;
}
} }
b.len -= n;
return copyBytes(p, 0, b.buf[b.off:b.off+n]);
b.off += n;
return n, err
} }
// ReadByte reads and returns the next byte from the buffer. // ReadByte reads and returns the next byte from the buffer.
// If no byte is available, it returns error os.EOF. // If no byte is available, it returns error os.EOF.
func (b *Buffer) ReadByte() (c byte, err os.Error) { func (b *Buffer) ReadByte() (c byte, err os.Error) {
if _, err := b.Read(&b.oneByte); err != nil { if b.off >= len(b.buf) {
return 0, err return 0, os.EOF;
} }
return b.oneByte[0], nil c = b.buf[b.off];
} b.off++;
return c, nil;
// NewBufferString creates and initializes a new Buffer
// using a string as its initial contents.
func NewBufferString(str string) *Buffer {
b := new(Buffer);
if len(str) > 0 {
b.blk = make([]block, 1, 10); // room to grow
b.blk[0] = (*stringBlock)(&str);
}
b.len = len(str);
return b;
} }
// NewBuffer creates and initializes a new Buffer // NewBuffer creates and initializes a new Buffer
// using a byte slice as its initial contents. // using buf as its initial contents.
func NewBuffer(by []byte) *Buffer { func NewBuffer(buf []byte) *Buffer {
b := new(Buffer); return &Buffer{buf: buf};
if len(by) > 0 { }
b.blk = make([]block, 1, 10); // room to grow
b.blk[0] = (*byteBlock)(&by); // NewBufferString creates and initializes a new Buffer
} // using string s as its initial contents.
b.len = len(by); func NewBufferString(s string) *Buffer {
return b; buf := make([]byte, len(s));
copyString(buf, 0, s);
return &Buffer{buf: buf};
} }