From 5611cb6d476540e6a1c654c1f9acdce2787b3505 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Mon, 23 Apr 2012 16:19:39 -0400
Subject: Okay, imported the core-http library and got it compiling
 suspiciously easily. The unit/integration tests don't work yet as I'm still
 battling cmake/autobuild as usual but first milestone passed.

---
 indra/llcorehttp/bufferarray.h | 168 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 168 insertions(+)
 create mode 100644 indra/llcorehttp/bufferarray.h

(limited to 'indra/llcorehttp/bufferarray.h')

diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
new file mode 100644
index 0000000000..b26ad1b297
--- /dev/null
+++ b/indra/llcorehttp/bufferarray.h
@@ -0,0 +1,168 @@
+/**
+ * @file bufferarray.h
+ * @brief Public-facing declaration for the BufferArray scatter/gather class
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef	_LLCORE_BUFFER_ARRAY_H_
+#define	_LLCORE_BUFFER_ARRAY_H_
+
+
+#include <cstdlib>
+#include <vector>
+
+#include "_refcounted.h"
+
+
+namespace LLCore
+{
+
+
+/// A very simple scatter/gather type map for bulk data.  The motivation
+/// for this class is the writedata callback used by libcurl.  Response
+/// bodies are delivered to the caller in a sequence of sequential write
+/// operations and this class captures them without having to reallocate
+/// and move data.
+///
+/// The interface looks a little like a unix file descriptor but only
+/// just.  There is a notion of a current position, starting from 0,
+/// which is used as the position in the data when performing read and
+/// write operations.  The position also moves after various operations:
+/// - seek(...)
+/// - read(...)
+/// - write(...)
+/// - append(...)
+/// - appendBufferAlloc(...)
+/// The object also keeps a total length value which is updated after
+/// write and append operations and beyond which the current position
+/// cannot be set.
+///
+/// Threading:  not thread-safe
+///
+/// Allocation:  Refcounted, heap only.  Caller of the constructor
+/// is given a single refcount.
+///
+class BufferArray : public LLCoreInt::RefCounted
+{
+public:
+	BufferArray();
+	virtual ~BufferArray();
+
+private:
+	BufferArray(const BufferArray &);			// Not defined
+	void operator=(const BufferArray &);		// Not defined
+
+public:
+	/// Appends the indicated data to the BufferArray
+	/// modifying current position and total size.  New
+	/// position is one beyond the final byte of the buffer.
+	///
+	/// @return			Count of bytes copied to BufferArray
+	size_t append(const char * src, size_t len);
+
+	/// Similar to @see append(), this call guarantees a
+	/// contiguous block of memory of requested size placed
+	/// at the current end of the BufferArray.  On return,
+	/// the data in the memory is considered valid whether
+	/// the caller writes to it or not.
+	///
+	/// @return			Pointer to contiguous region at end
+	///					of BufferArray of 'len' size.
+	char * appendBufferAlloc(size_t len);
+
+	/// Current count of bytes in BufferArray instance.
+	size_t size() const
+		{
+			return mLen;
+		}
+
+	/// Set the current position for subsequent read and
+	/// write operations.  'pos' values before the beginning
+	/// or greater than the size of the buffer are coerced
+	/// to a value within the buffer.
+	///
+	/// @return			Actual current position after seek.
+	size_t seek(size_t pos);
+
+	/// Copies data from the current position in the instance
+	/// to the caller's buffer.  Will return a short count of
+	/// bytes copied if the 'len' extends beyond the data.
+	size_t read(char * dst, size_t len);
+
+	/// Copies data from the caller's buffer to the instance
+	/// at the current position.  May overwrite existing data,
+	/// append data when current position is equal to the
+	/// size of the instance or do a mix of both.
+	size_t write(const char * src, size_t len);
+	
+protected:
+	int findBlock(size_t pos, size_t * ret_offset);
+	
+protected:
+	class Block;
+	typedef std::vector<Block *> container_t;
+
+	container_t			mBlocks;
+	size_t				mPos;
+	size_t				mLen;
+};  // end class BufferArray
+
+
+#if 0
+
+// Conceptual for now.  Another possibility is going with
+// something like Boost::asio's buffers interface.  They're
+// trying to achieve the same thing above and below....
+
+class BufferStream : public std::streambuf
+{
+public:
+	BufferStream(BufferArray * buffer);
+	virtual ~BufferStream();
+
+private:
+	BufferStream(const BufferStream &);			// Not defined
+	void operator=(const BufferStream &);		// Not defined
+
+public:
+	// Types
+	typedef std::streambuf::pos_type pos_type;
+	typedef std::streambuf::off_type off_type;
+
+	virtual int underflow();
+
+	virtual int overflow(int c);
+
+	virtual int sync();
+
+	virtual pos_type seekoff(off_type off, std::ios::seekdir way, std::ios::openmode which);
+
+protected:
+	BufferArray *		mBufferArray;
+};  // end class BufferStream
+
+#endif // 0
+
+}  // end namespace LLCore
+
+#endif	// _LLCORE_BUFFER_ARRAY_H_
-- 
cgit v1.3


From 4155301015525a242a79b9b3134e66d366bc0ebd Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Fri, 1 Jun 2012 21:30:45 -0400
Subject: Do some work on BufferArray to make it a bit less naive about
 chunking data.  Remove the stateful use of a seek pointer so that shared read
 is possible (though maybe not interesting).

---
 indra/llcorehttp/_httpoprequest.cpp         |  14 ++--
 indra/llcorehttp/bufferarray.cpp            | 126 +++++++++++++++++++---------
 indra/llcorehttp/bufferarray.h              |  53 ++----------
 indra/llcorehttp/tests/test_bufferarray.hpp |  89 ++++++++------------
 indra/newview/lltexturefetch.cpp            |   3 +-
 5 files changed, 133 insertions(+), 152 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.h')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 791ee5f860..196011f953 100644
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -340,7 +340,6 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 			long data_size(0);
 			if (mReqBody)
 			{
-				mReqBody->seek(0);
 				data_size = mReqBody->size();
 			}
 			curl_easy_setopt(mCurlHandle, CURLOPT_POSTFIELDS, static_cast<void *>(NULL));
@@ -356,7 +355,6 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 			long data_size(0);
 			if (mReqBody)
 			{
-				mReqBody->seek(0);
 				data_size = mReqBody->size();
 			}
 			curl_easy_setopt(mCurlHandle, CURLOPT_INFILESIZE, data_size);
@@ -423,10 +421,8 @@ size_t HttpOpRequest::writeCallback(void * data, size_t size, size_t nmemb, void
 		op->mReplyBody = new BufferArray();
 	}
 	const size_t req_size(size * nmemb);
-	char * lump(op->mReplyBody->appendBufferAlloc(req_size));
-	memcpy(lump, data, req_size);
-
-	return req_size;
+	const size_t write_size(op->mReplyBody->append(static_cast<char *>(data), req_size));
+	return write_size;
 }
 
 		
@@ -450,9 +446,9 @@ size_t HttpOpRequest::readCallback(void * data, size_t size, size_t nmemb, void
 	}
 
 	const size_t do_size((std::min)(req_size, body_size - op->mCurlBodyPos));
-	op->mReqBody->read(static_cast<char *>(data), do_size);
-	op->mCurlBodyPos += do_size;
-	return do_size;
+	const size_t read_size(op->mReqBody->read(op->mCurlBodyPos, static_cast<char *>(data), do_size));
+	op->mCurlBodyPos += read_size;
+	return read_size;
 }
 
 		
diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 4c20350b13..c13b1a3540 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -27,6 +27,18 @@
 #include "bufferarray.h"
 
 
+// BufferArray is a list of chunks, each a BufferArray::Block, of contiguous
+// data presented as a single array.  Chunks are at least BufferArray::BLOCK_ALLOC_SIZE
+// in length and can be larger.  Any chunk may be partially filled or even
+// empty.
+//
+// The BufferArray itself is sharable as a RefCounted entity.  As shared
+// reads don't work with the concept of a current position/seek value,
+// none is kept with the object.  Instead, the read and write operations
+// all take position arguments.  Single write/shared read isn't supported
+// directly and any such attempts have to be serialized outside of this
+// implementation.
+
 namespace LLCore
 {
 
@@ -58,7 +70,8 @@ public:
 	static Block * alloc(size_t len);
 
 public:
-	size_t mLen;
+	size_t mUsed;
+	size_t mAlloced;
 
 	// *NOTE:  Must be last member of the object.  We'll
 	// overallocate as requested via operator new and index
@@ -74,7 +87,6 @@ public:
 
 BufferArray::BufferArray()
 	: LLCoreInt::RefCounted(true),
-	  mPos(0),
 	  mLen(0)
 {}
 
@@ -94,19 +106,45 @@ BufferArray::~BufferArray()
 
 size_t BufferArray::append(const char * src, size_t len)
 {
-	if (len)
+	const size_t ret(len);
+	
+	// First, try to copy into the last block
+	if (len && ! mBlocks.empty())
+	{
+		Block & last(*mBlocks.back());
+		if (last.mUsed < last.mAlloced)
+		{
+			// Some will fit...
+			const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
+
+			memcpy(&last.mData[last.mUsed], src, copy_len);
+			last.mUsed += copy_len;
+			llassert_always(last.mUsed <= last.mAlloced);
+			mLen += copy_len;
+			src += copy_len;
+			len -= copy_len;
+		}
+	}
+
+	// Then get new blocks as needed
+	while (len)
 	{
+		const size_t copy_len((std::min)(len, BLOCK_ALLOC_SIZE));
+		
 		if (mBlocks.size() >= mBlocks.capacity())
 		{
 			mBlocks.reserve(mBlocks.size() + 5);
 		}
-		Block * block = Block::alloc(len);
-		memcpy(block->mData, src, len);
+		Block * block = Block::alloc(BLOCK_ALLOC_SIZE);
+		memcpy(block->mData, src, copy_len);
+		block->mUsed = copy_len;
+		llassert_always(block->mUsed <= block->mAlloced);
 		mBlocks.push_back(block);
-		mLen += len;
-		mPos = mLen;
+		mLen += copy_len;
+		src += copy_len;
+		len -= copy_len;
 	}
-	return len;
+	return ret;
 }
 
 
@@ -117,41 +155,33 @@ char * BufferArray::appendBufferAlloc(size_t len)
 	{
 		mBlocks.reserve(mBlocks.size() + 5);
 	}
-	Block * block = Block::alloc(len);
+	Block * block = Block::alloc((std::max)(BLOCK_ALLOC_SIZE, len));
+	block->mUsed = len;
 	mBlocks.push_back(block);
 	mLen += len;
-	mPos = mLen;
 	return block->mData;
 }
 
 
-size_t BufferArray::seek(size_t pos)
+size_t BufferArray::read(size_t pos, char * dst, size_t len)
 {
-	if (pos > mLen)
-		pos = mLen;
-	mPos = pos;
-	return mPos;
-}
-
-	
-size_t BufferArray::read(char * dst, size_t len)
-{
-	size_t result(0), offset(0);
-	size_t len_limit(mLen - mPos);
+	if (pos >= mLen)
+		return 0;
+	size_t len_limit(mLen - pos);
 	len = std::min(len, len_limit);
-
-	if (mPos >= mLen || 0 == len)
+	if (0 == len)
 		return 0;
 	
+	size_t result(0), offset(0);
 	const int block_limit(mBlocks.size());
-	int block_start(findBlock(mPos, &offset));
+	int block_start(findBlock(pos, &offset));
 	if (block_start < 0)
 		return 0;
 
 	do
 	{
 		Block & block(*mBlocks[block_start]);
-		size_t block_limit(block.mLen - offset);
+		size_t block_limit(block.mUsed - offset);
 		size_t block_len(std::min(block_limit, len));
 		
 		memcpy(dst, &block.mData[offset], block_len);
@@ -163,19 +193,18 @@ size_t BufferArray::read(char * dst, size_t len)
 	}
 	while (len && block_start < block_limit);
 
-	mPos += result;
 	return result;
 }
 
 
-size_t BufferArray::write(const char * src, size_t len)
+size_t BufferArray::write(size_t pos, const char * src, size_t len)
 {
-	size_t result(0), offset(0);
-	if (mPos > mLen || 0 == len)
+	if (pos > mLen || 0 == len)
 		return 0;
 	
+	size_t result(0), offset(0);
 	const int block_limit(mBlocks.size());
-	int block_start(findBlock(mPos, &offset));
+	int block_start(findBlock(pos, &offset));
 
 	if (block_start >= 0)
 	{
@@ -184,20 +213,39 @@ size_t BufferArray::write(const char * src, size_t len)
 		do
 		{
 			Block & block(*mBlocks[block_start]);
-			size_t block_limit(block.mLen - offset);
+			size_t block_limit(block.mUsed - offset);
 			size_t block_len(std::min(block_limit, len));
 		
 			memcpy(&block.mData[offset], src, block_len);
 			result += block_len;
-			len -= block_len;
 			src += block_len;
+			len -= block_len;
 			offset = 0;
 			++block_start;
 		}
 		while (len && block_start < block_limit);
 	}
-	mPos += result;
 
+	// Something left, see if it will fit in the free
+	// space of the last block.
+	if (len && ! mBlocks.empty())
+	{
+		Block & last(*mBlocks.back());
+		if (last.mUsed < last.mAlloced)
+		{
+			// Some will fit...
+			const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
+
+			memcpy(&last.mData[last.mUsed], src, copy_len);
+			last.mUsed += copy_len;
+			result += copy_len;
+			llassert_always(last.mUsed <= last.mAlloced);
+			mLen += copy_len;
+			src += copy_len;
+			len -= copy_len;
+		}
+	}
+	
 	if (len)
 	{
 		// Some or all of the remaining write data will
@@ -218,12 +266,12 @@ int BufferArray::findBlock(size_t pos, size_t * ret_offset)
 	const int block_limit(mBlocks.size());
 	for (int i(0); i < block_limit; ++i)
 	{
-		if (pos < mBlocks[i]->mLen)
+		if (pos < mBlocks[i]->mUsed)
 		{
 			*ret_offset = pos;
 			return i;
 		}
-		pos -= mBlocks[i]->mLen;
+		pos -= mBlocks[i]->mUsed;
 	}
 
 	// Shouldn't get here but...
@@ -237,7 +285,8 @@ int BufferArray::findBlock(size_t pos, size_t * ret_offset)
 
 
 BufferArray::Block::Block(size_t len)
-	: mLen(len)
+	: mUsed(0),
+	  mAlloced(len)
 {
 	memset(mData, 0, len);
 }
@@ -245,7 +294,8 @@ BufferArray::Block::Block(size_t len)
 
 BufferArray::Block::~Block()
 {
-	mLen = 0;
+	mUsed = 0;
+	mAlloced = 0;
 }
 
 
diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index b26ad1b297..9ccd85d4f8 100644
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -73,6 +73,9 @@ private:
 	void operator=(const BufferArray &);		// Not defined
 
 public:
+	// Internal magic number, may be used by unit tests.
+	static const size_t BLOCK_ALLOC_SIZE = 1504;
+	
 	/// Appends the indicated data to the BufferArray
 	/// modifying current position and total size.  New
 	/// position is one beyond the final byte of the buffer.
@@ -96,24 +99,16 @@ public:
 			return mLen;
 		}
 
-	/// Set the current position for subsequent read and
-	/// write operations.  'pos' values before the beginning
-	/// or greater than the size of the buffer are coerced
-	/// to a value within the buffer.
-	///
-	/// @return			Actual current position after seek.
-	size_t seek(size_t pos);
-
-	/// Copies data from the current position in the instance
+	/// Copies data from the given position in the instance
 	/// to the caller's buffer.  Will return a short count of
 	/// bytes copied if the 'len' extends beyond the data.
-	size_t read(char * dst, size_t len);
+	size_t read(size_t pos, char * dst, size_t len);
 
 	/// Copies data from the caller's buffer to the instance
 	/// at the current position.  May overwrite existing data,
 	/// append data when current position is equal to the
 	/// size of the instance or do a mix of both.
-	size_t write(const char * src, size_t len);
+	size_t write(size_t pos, const char * src, size_t len);
 	
 protected:
 	int findBlock(size_t pos, size_t * ret_offset);
@@ -123,46 +118,10 @@ protected:
 	typedef std::vector<Block *> container_t;
 
 	container_t			mBlocks;
-	size_t				mPos;
 	size_t				mLen;
 };  // end class BufferArray
 
 
-#if 0
-
-// Conceptual for now.  Another possibility is going with
-// something like Boost::asio's buffers interface.  They're
-// trying to achieve the same thing above and below....
-
-class BufferStream : public std::streambuf
-{
-public:
-	BufferStream(BufferArray * buffer);
-	virtual ~BufferStream();
-
-private:
-	BufferStream(const BufferStream &);			// Not defined
-	void operator=(const BufferStream &);		// Not defined
-
-public:
-	// Types
-	typedef std::streambuf::pos_type pos_type;
-	typedef std::streambuf::off_type off_type;
-
-	virtual int underflow();
-
-	virtual int overflow(int c);
-
-	virtual int sync();
-
-	virtual pos_type seekoff(off_type off, std::ios::seekdir way, std::ios::openmode which);
-
-protected:
-	BufferArray *		mBufferArray;
-};  // end class BufferStream
-
-#endif // 0
-
 }  // end namespace LLCore
 
 #endif	// _LLCORE_BUFFER_ARRAY_H_
diff --git a/indra/llcorehttp/tests/test_bufferarray.hpp b/indra/llcorehttp/tests/test_bufferarray.hpp
index ecbb5ef250..2ad9391d1c 100644
--- a/indra/llcorehttp/tests/test_bufferarray.hpp
+++ b/indra/llcorehttp/tests/test_bufferarray.hpp
@@ -67,7 +67,7 @@ void BufferArrayTestObjectType::test<1>()
 
 	// Try to read
 	char buffer[20];
-	size_t read_len(ba->read(buffer, sizeof(buffer)));
+	size_t read_len(ba->read(0, buffer, sizeof(buffer)));
 	ensure("Read returns empty", 0 == read_len);
 	
 	// release the implicit reference, causing the object to be released
@@ -92,16 +92,13 @@ void BufferArrayTestObjectType::test<2>()
 	char str1[] = "abcdefghij";
  	char buffer[256];
 	
-	size_t len = ba->write(str1, strlen(str1));
+	size_t len = ba->write(0, str1, strlen(str1));
 	ensure("Wrote length correct", strlen(str1) == len);
 	ensure("Recorded size correct", strlen(str1) == ba->size());
 
 	// read some data back
-	len = ba->seek(2);
-	ensure("Seek worked", 2 == len);
-
 	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, 2);
+	len = ba->read(2, buffer, 2);
 	ensure("Read length correct", 2 == len);
 	ensure("Read content correct", 'c' == buffer[0] && 'd' == buffer[1]);
 	ensure("Read didn't overwrite", 'X' == buffer[2]);
@@ -130,32 +127,26 @@ void BufferArrayTestObjectType::test<3>()
 	size_t str1_len(strlen(str1));
  	char buffer[256];
 	
-	size_t len = ba->write(str1, str1_len);
+	size_t len = ba->write(0, str1, str1_len);
 	ensure("Wrote length correct", str1_len == len);
 	ensure("Recorded size correct", str1_len == ba->size());
 
 	// again...
-	len = ba->write(str1, strlen(str1));
+	len = ba->write(str1_len, str1, strlen(str1));
 	ensure("Wrote length correct", str1_len == len);
 	ensure("Recorded size correct", (2 * str1_len) == ba->size());
 
 	// read some data back
-	len = ba->seek(8);
-	ensure("Seek worked", 8 == len);
-
 	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, 4);
+	len = ba->read(8, buffer, 4);
 	ensure("Read length correct", 4 == len);
 	ensure("Read content correct", 'i' == buffer[0] && 'j' == buffer[1]);
 	ensure("Read content correct", 'a' == buffer[2] && 'b' == buffer[3]);
 	ensure("Read didn't overwrite", 'X' == buffer[4]);
 
 	// Read whole thing
-	len = ba->seek(0);
-	ensure("Seek worked (2)", 0 == len);
-
 	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, sizeof(buffer));
+	len = ba->read(0, buffer, sizeof(buffer));
 	ensure("Read length correct", (2 * str1_len) == len);
 	ensure("Read content correct (3)", 0 == strncmp(buffer, str1, str1_len));
 	ensure("Read content correct (4)", 0 == strncmp(&buffer[str1_len], str1, str1_len));
@@ -185,33 +176,29 @@ void BufferArrayTestObjectType::test<4>()
 	char str2[] = "ABCDEFGHIJ";
  	char buffer[256];
 	
-	size_t len = ba->write(str1, str1_len);
+	size_t len = ba->write(0, str1, str1_len);
 	ensure("Wrote length correct", str1_len == len);
 	ensure("Recorded size correct", str1_len == ba->size());
 
 	// again...
-	len = ba->write(str1, strlen(str1));
+	len = ba->write(str1_len, str1, strlen(str1));
 	ensure("Wrote length correct", str1_len == len);
 	ensure("Recorded size correct", (2 * str1_len) == ba->size());
 
 	// reposition and overwrite
-	len = ba->seek(8);
-	ensure("Seek worked", 8 == len);
-	len = ba->write(str2, 4);
+	len = ba->write(8, str2, 4);
 	ensure("Overwrite length correct", 4 == len);
 
-	// Leave position and read verifying content
+	// Leave position and read verifying content (stale really from seek() days)
 	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, 4);
+	len = ba->read(12, buffer, 4);
 	ensure("Read length correct", 4 == len);
 	ensure("Read content correct", 'c' == buffer[0] && 'd' == buffer[1]);
 	ensure("Read content correct.2", 'e' == buffer[2] && 'f' == buffer[3]);
 	ensure("Read didn't overwrite", 'X' == buffer[4]);
 
 	// reposition and check
-	len = ba->seek(6);
-	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, 8);
+	len = ba->read(6, buffer, 8);
 	ensure("Read length correct.2", 8 == len);
 	ensure("Read content correct.3", 'g' == buffer[0] && 'h' == buffer[1]);
 	ensure("Read content correct.4", 'A' == buffer[2] && 'B' == buffer[3]);
@@ -242,21 +229,18 @@ void BufferArrayTestObjectType::test<5>()
 	size_t str1_len(strlen(str1));
  	char buffer[256];
 	
-	size_t len = ba->write(str1, str1_len);
+	size_t len = ba->write(0, str1, str1_len);
 	ensure("Wrote length correct", str1_len == len);
 	ensure("Recorded size correct", str1_len == ba->size());
 
 	// again...
-	len = ba->write(str1, strlen(str1));
+	len = ba->write(str1_len, str1, str1_len);
 	ensure("Wrote length correct", str1_len == len);
 	ensure("Recorded size correct", (2 * str1_len) == ba->size());
 
 	// read some data back
-	len = ba->seek(8);
-	ensure("Seek worked", 8 == len);
-
 	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, 4);
+	len = ba->read(8, buffer, 4);
 	ensure("Read length correct", 4 == len);
 	ensure("Read content correct", 'i' == buffer[0] && 'j' == buffer[1]);
 	ensure("Read content correct.2", 'a' == buffer[2] && 'b' == buffer[3]);
@@ -264,7 +248,7 @@ void BufferArrayTestObjectType::test<5>()
 
 	// Read some more without repositioning
 	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, sizeof(buffer));
+	len = ba->read(12, buffer, sizeof(buffer));
 	ensure("Read length correct", (str1_len - 2) == len);
 	ensure("Read content correct.3", 0 == strncmp(buffer, str1+2, str1_len-2));
 	ensure("Read didn't overwrite.2", 'X' == buffer[str1_len-1]);
@@ -294,31 +278,27 @@ void BufferArrayTestObjectType::test<6>()
 	size_t str2_len(strlen(str2));
  	char buffer[256];
 	
-	size_t len = ba->write(str1, str1_len);
+	size_t len = ba->write(0, str1, str1_len);
 	ensure("Wrote length correct", str1_len == len);
 	ensure("Recorded size correct", str1_len == ba->size());
 
 	// again...
-	len = ba->write(str1, strlen(str1));
+	len = ba->write(str1_len, str1, strlen(str1));
 	ensure("Wrote length correct", str1_len == len);
 	ensure("Recorded size correct", (2 * str1_len) == ba->size());
 
 	// reposition and overwrite
-	len = ba->seek(8);
-	ensure("Seek worked", 8 == len);
-	len = ba->write(str2, str2_len);
+	len = ba->write(8, str2, str2_len);
 	ensure("Overwrite length correct", str2_len == len);
 
 	// Leave position and read verifying content
 	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, 0);
+	len = ba->read(8 + str2_len, buffer, 0);
 	ensure("Read length correct", 0 == len);
 	ensure("Read didn't overwrite", 'X' == buffer[0]);
 
 	// reposition and check
-	len = ba->seek(0);
-	memset(buffer, 'X', sizeof(buffer));
-	len = ba->read(buffer, sizeof(buffer));
+	len = ba->read(0, buffer, sizeof(buffer));
 	ensure("Read length correct.2", (str1_len + str2_len - 2) == len);
 	ensure("Read content correct", 0 == strncmp(buffer, str1, str1_len-2));
 	ensure("Read content correct.2", 0 == strncmp(buffer+str1_len-2, str2, str2_len));
@@ -350,18 +330,17 @@ void BufferArrayTestObjectType::test<7>()
  	char buffer[256];
 
 	// 2x str1
-	size_t len = ba->write(str1, str1_len);
-	len = ba->write(str1, strlen(str1));
+	size_t len = ba->write(0, str1, str1_len);
+	len = ba->write(str1_len, str1, str1_len);
 
 	// reposition and overwrite
-	len = ba->seek(6);
-	len = ba->write(str2, 2);
+	len = ba->write(6, str2, 2);
 	ensure("Overwrite length correct", 2 == len);
 
-	len = ba->write(str2, 2);
+	len = ba->write(8, str2, 2);
 	ensure("Overwrite length correct.2", 2 == len);
 
-	len = ba->write(str2, 2);
+	len = ba->write(10, str2, 2);
 	ensure("Overwrite length correct.3", 2 == len);
 
 	// append some data
@@ -373,13 +352,12 @@ void BufferArrayTestObjectType::test<7>()
 	memcpy(out_buf, str1, str1_len);
 
 	// And some final writes
-	len = ba->write(str2, 2);
+	len = ba->write(3 * str1_len + str2_len, str2, 2);
 	ensure("Write length correct.2", 2 == len);
 	
 	// Check contents
 	memset(buffer, 'X', sizeof(buffer));
-	ba->seek(0);
-	len = ba->read(buffer, sizeof(buffer));
+	len = ba->read(0, buffer, sizeof(buffer));
 	ensure("Final buffer length correct", (3 * str1_len + str2_len + 2) == len);
 	ensure("Read content correct", 0 == strncmp(buffer, str1, 6));
 	ensure("Read content correct.2", 0 == strncmp(buffer + 6, str2, 2));
@@ -417,8 +395,8 @@ void BufferArrayTestObjectType::test<8>()
  	char buffer[256];
 
 	// 2x str1
-	size_t len = ba->write(str1, str1_len);
-	len = ba->write(str1, strlen(str1));
+	size_t len = ba->write(0, str1, str1_len);
+	len = ba->write(str1_len, str1, str1_len);
 
 	// zero-length allocate (we allow this with a valid pointer returned)
 	char * out_buf(ba->appendBufferAlloc(0));
@@ -430,12 +408,11 @@ void BufferArrayTestObjectType::test<8>()
 	ensure("Two zero-length appendBufferAlloc buffers distinct", out_buf != out_buf2);
 
 	// And some final writes
-	len = ba->write(str2, str2_len);
+	len = ba->write(2 * str1_len, str2, str2_len);
 	
 	// Check contents
 	memset(buffer, 'X', sizeof(buffer));
-	ba->seek(0);
-	len = ba->read(buffer, sizeof(buffer));
+	len = ba->read(0, buffer, sizeof(buffer));
 	ensure("Final buffer length correct", (2 * str1_len + str2_len) == len);
 	ensure("Read content correct.1", 0 == strncmp(buffer, str1, str1_len));
 	ensure("Read content correct.2", 0 == strncmp(buffer + str1_len, str1, str1_len));
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index daad463e0d..e27f0aec1e 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -1255,8 +1255,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			{
 				memcpy(buffer, mFormattedImage->getData(), cur_size);
 			}
-			mHttpBufferArray->seek(0);
-			mHttpBufferArray->read((char *) buffer + cur_size, append_size);
+			mHttpBufferArray->read(0, (char *) buffer + cur_size, append_size);
 
 			// NOTE: setData releases current data and owns new data (buffer)
 			mFormattedImage->setData(buffer, total_size);
-- 
cgit v1.3


From 267ab5b417eaef64a170d69ad83334df9d566ed9 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Mon, 11 Jun 2012 17:47:04 -0400
Subject: Convert BufferArray interfaces to void * (not char *). 
 HttpRequest::update() honor time limit. Generally, opaque data operations are
 expected to be over 'void *' and have now converted interfaces to do that. 
 Update() method honors millisecond limit to dwell time.  Might want to
 homologate the millis/uSecs mix later....

---
 indra/llcorehttp/bufferarray.cpp            | 37 ++++++++++++++++-------------
 indra/llcorehttp/bufferarray.h              |  8 +++----
 indra/llcorehttp/httprequest.cpp            | 13 ++++------
 indra/llcorehttp/httprequest.h              |  2 +-
 indra/llcorehttp/tests/test_bufferarray.hpp |  6 ++---
 5 files changed, 34 insertions(+), 32 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.h')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 36a8006bce..6d5309a043 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -108,10 +108,11 @@ BufferArray::~BufferArray()
 }
 
 
-size_t BufferArray::append(const char * src, size_t len)
+size_t BufferArray::append(const void * src, size_t len)
 {
 	const size_t ret(len);
-	
+	const char * c_src(static_cast<const char *>(src));
+					  
 	// First, try to copy into the last block
 	if (len && ! mBlocks.empty())
 	{
@@ -121,11 +122,11 @@ size_t BufferArray::append(const char * src, size_t len)
 			// Some will fit...
 			const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
 
-			memcpy(&last.mData[last.mUsed], src, copy_len);
+			memcpy(&last.mData[last.mUsed], c_src, copy_len);
 			last.mUsed += copy_len;
 			llassert_always(last.mUsed <= last.mAlloced);
 			mLen += copy_len;
-			src += copy_len;
+			c_src += copy_len;
 			len -= copy_len;
 		}
 	}
@@ -140,19 +141,19 @@ size_t BufferArray::append(const char * src, size_t len)
 			mBlocks.reserve(mBlocks.size() + 5);
 		}
 		Block * block = Block::alloc(BLOCK_ALLOC_SIZE);
-		memcpy(block->mData, src, copy_len);
+		memcpy(block->mData, c_src, copy_len);
 		block->mUsed = copy_len;
 		llassert_always(block->mUsed <= block->mAlloced);
 		mBlocks.push_back(block);
 		mLen += copy_len;
-		src += copy_len;
+		c_src += copy_len;
 		len -= copy_len;
 	}
 	return ret;
 }
 
 
-char * BufferArray::appendBufferAlloc(size_t len)
+void * BufferArray::appendBufferAlloc(size_t len)
 {
 	// If someone asks for zero-length, we give them a valid pointer.
 	if (mBlocks.size() >= mBlocks.capacity())
@@ -167,8 +168,10 @@ char * BufferArray::appendBufferAlloc(size_t len)
 }
 
 
-size_t BufferArray::read(size_t pos, char * dst, size_t len)
+size_t BufferArray::read(size_t pos, void * dst, size_t len)
 {
+	char * c_dst(static_cast<char *>(dst));
+	
 	if (pos >= mLen)
 		return 0;
 	size_t len_limit(mLen - pos);
@@ -188,10 +191,10 @@ size_t BufferArray::read(size_t pos, char * dst, size_t len)
 		size_t block_limit(block.mUsed - offset);
 		size_t block_len(std::min(block_limit, len));
 		
-		memcpy(dst, &block.mData[offset], block_len);
+		memcpy(c_dst, &block.mData[offset], block_len);
 		result += block_len;
 		len -= block_len;
-		dst += block_len;
+		c_dst += block_len;
 		offset = 0;
 		++block_start;
 	}
@@ -201,8 +204,10 @@ size_t BufferArray::read(size_t pos, char * dst, size_t len)
 }
 
 
-size_t BufferArray::write(size_t pos, const char * src, size_t len)
+size_t BufferArray::write(size_t pos, const void * src, size_t len)
 {
+	const char * c_src(static_cast<const char *>(src));
+	
 	if (pos > mLen || 0 == len)
 		return 0;
 	
@@ -220,9 +225,9 @@ size_t BufferArray::write(size_t pos, const char * src, size_t len)
 			size_t block_limit(block.mUsed - offset);
 			size_t block_len(std::min(block_limit, len));
 		
-			memcpy(&block.mData[offset], src, block_len);
+			memcpy(&block.mData[offset], c_src, block_len);
 			result += block_len;
-			src += block_len;
+			c_src += block_len;
 			len -= block_len;
 			offset = 0;
 			++block_start;
@@ -240,12 +245,12 @@ size_t BufferArray::write(size_t pos, const char * src, size_t len)
 			// Some will fit...
 			const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
 
-			memcpy(&last.mData[last.mUsed], src, copy_len);
+			memcpy(&last.mData[last.mUsed], c_src, copy_len);
 			last.mUsed += copy_len;
 			result += copy_len;
 			llassert_always(last.mUsed <= last.mAlloced);
 			mLen += copy_len;
-			src += copy_len;
+			c_src += copy_len;
 			len -= copy_len;
 		}
 	}
@@ -254,7 +259,7 @@ size_t BufferArray::write(size_t pos, const char * src, size_t len)
 	{
 		// Some or all of the remaining write data will
 		// be an append.
-		result += append(src, len);
+		result += append(c_src, len);
 	}
 
 	return result;
diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index 9ccd85d4f8..72c3e1c669 100644
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -81,7 +81,7 @@ public:
 	/// position is one beyond the final byte of the buffer.
 	///
 	/// @return			Count of bytes copied to BufferArray
-	size_t append(const char * src, size_t len);
+	size_t append(const void * src, size_t len);
 
 	/// Similar to @see append(), this call guarantees a
 	/// contiguous block of memory of requested size placed
@@ -91,7 +91,7 @@ public:
 	///
 	/// @return			Pointer to contiguous region at end
 	///					of BufferArray of 'len' size.
-	char * appendBufferAlloc(size_t len);
+	void * appendBufferAlloc(size_t len);
 
 	/// Current count of bytes in BufferArray instance.
 	size_t size() const
@@ -102,13 +102,13 @@ public:
 	/// Copies data from the given position in the instance
 	/// to the caller's buffer.  Will return a short count of
 	/// bytes copied if the 'len' extends beyond the data.
-	size_t read(size_t pos, char * dst, size_t len);
+	size_t read(size_t pos, void * dst, size_t len);
 
 	/// Copies data from the caller's buffer to the instance
 	/// at the current position.  May overwrite existing data,
 	/// append data when current position is equal to the
 	/// size of the instance or do a mix of both.
-	size_t write(size_t pos, const char * src, size_t len);
+	size_t write(size_t pos, const void * src, size_t len);
 	
 protected:
 	int findBlock(size_t pos, size_t * ret_offset);
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index baa0fe1a84..2f36168f8b 100644
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -35,6 +35,8 @@
 #include "_httpopsetpriority.h"
 #include "_httpopcancel.h"
 
+#include "lltimer.h"
+
 
 namespace
 {
@@ -279,14 +281,9 @@ HttpHandle HttpRequest::requestSetPriority(HttpHandle request, priority_t priori
 
 HttpStatus HttpRequest::update(long millis)
 {
-	HttpStatus status;
-
-	// *FIXME:  need timer stuff
-	// long now(getNow());
-	// long limit(now + millis);
-	
+	const HttpTime limit(totalTime() + (1000 * HttpTime(millis)));
 	HttpOperation * op(NULL);
-	while ((op = mReplyQueue->fetchOp()))
+	while (limit >= totalTime() && (op = mReplyQueue->fetchOp()))
 	{
 		// Process operation
 		op->visitNotifier(this);
@@ -295,7 +292,7 @@ HttpStatus HttpRequest::update(long millis)
 		op->release();
 	}
 	
-	return status;
+	return HttpStatus();
 }
 
 
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 3592d5c6a3..01dbfba6dd 100644
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -259,7 +259,7 @@ public:
 	/// @param	millis			Maximum number of wallclock milliseconds to
 	///							spend in the call.  As hinted at above, this
 	///							is partly a function of application code so it's
-	///							a soft limit.  (And not currently implemented.)
+	///							a soft limit.
 	///
 	/// @return					Standard status code.
 	HttpStatus update(long millis);
diff --git a/indra/llcorehttp/tests/test_bufferarray.hpp b/indra/llcorehttp/tests/test_bufferarray.hpp
index 2ad9391d1c..3f947db967 100644
--- a/indra/llcorehttp/tests/test_bufferarray.hpp
+++ b/indra/llcorehttp/tests/test_bufferarray.hpp
@@ -348,7 +348,7 @@ void BufferArrayTestObjectType::test<7>()
 	ensure("Append length correct", str2_len == len);
 
 	// append some more
-	char * out_buf(ba->appendBufferAlloc(str1_len));
+	void * out_buf(ba->appendBufferAlloc(str1_len));
 	memcpy(out_buf, str1, str1_len);
 
 	// And some final writes
@@ -399,11 +399,11 @@ void BufferArrayTestObjectType::test<8>()
 	len = ba->write(str1_len, str1, str1_len);
 
 	// zero-length allocate (we allow this with a valid pointer returned)
-	char * out_buf(ba->appendBufferAlloc(0));
+	void * out_buf(ba->appendBufferAlloc(0));
 	ensure("Buffer from zero-length appendBufferAlloc non-NULL", NULL != out_buf);
 
 	// Do it again
-	char * out_buf2(ba->appendBufferAlloc(0));
+	void * out_buf2(ba->appendBufferAlloc(0));
 	ensure("Buffer from zero-length appendBufferAlloc non-NULL.2", NULL != out_buf2);
 	ensure("Two zero-length appendBufferAlloc buffers distinct", out_buf != out_buf2);
 
-- 
cgit v1.3


From 6193ee6a331e3dfd562400a32a961bad0b8bed12 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Sat, 16 Jun 2012 15:50:48 -0400
Subject: First round of basic tuning work (shorter sleeps, larger BufferArray
 blocks). Beefed up the metrics gathering in http_texture_load to get memory
 sizes and cpu consumption on windows (still need to implement that on Mac &
 linux). Ran runs with various idle loops with sleeps from 20 ms down to pure
 spinning, varied Block allocation size from 1504 to 2^20 bytes. 
 2ms/2ms/65540 appears to be a good spot under the test conditions (Win7, danu
 grid, client in Boston).

---
 indra/llcorehttp/_httpservice.cpp               |   2 +-
 indra/llcorehttp/bufferarray.h                  |   2 +-
 indra/llcorehttp/examples/http_texture_load.cpp | 249 +++++++++++++++++++++++-
 3 files changed, 244 insertions(+), 9 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.h')

diff --git a/indra/llcorehttp/_httpservice.cpp b/indra/llcorehttp/_httpservice.cpp
index beba8f08f4..87a78820f5 100644
--- a/indra/llcorehttp/_httpservice.cpp
+++ b/indra/llcorehttp/_httpservice.cpp
@@ -40,7 +40,7 @@
 
 
 // Tuning parameters
-static const int LOOP_SLEEP_NORMAL_MS = 10;		// Normal per-loop sleep in milliseconds
+static const int LOOP_SLEEP_NORMAL_MS = 2;		// Normal per-loop sleep in milliseconds
 
 
 namespace LLCore
diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index 72c3e1c669..d3862b45e1 100644
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -74,7 +74,7 @@ private:
 
 public:
 	// Internal magic number, may be used by unit tests.
-	static const size_t BLOCK_ALLOC_SIZE = 1504;
+	static const size_t BLOCK_ALLOC_SIZE = 65540;
 	
 	/// Appends the indicated data to the BufferArray
 	/// modifying current position and total size.  New
diff --git a/indra/llcorehttp/examples/http_texture_load.cpp b/indra/llcorehttp/examples/http_texture_load.cpp
index 6f79833cf6..1277dd3353 100644
--- a/indra/llcorehttp/examples/http_texture_load.cpp
+++ b/indra/llcorehttp/examples/http_texture_load.cpp
@@ -33,6 +33,8 @@
 #include <pthread.h>
 #endif
 
+#include "linden_common.h"
+
 #include "httpcommon.h"
 #include "httprequest.h"
 #include "httphandler.h"
@@ -43,6 +45,8 @@
 #include <curl/curl.h>
 #include <openssl/crypto.h>
 
+#include "lltimer.h"
+
 
 void init_curl();
 void term_curl();
@@ -65,6 +69,9 @@ int optind(1);
 
 #endif
 
+
+// Mostly just a container for the texture IDs and fetch
+// parameters....
 class WorkingSet : public LLCore::HttpHandler
 {
 public:
@@ -98,11 +105,46 @@ public:
 	texture_list_t				mTextures;
 	int							mErrorsApi;
 	int							mErrorsHttp;
+	int							mErrorsHttp404;
+	int							mErrorsHttp416;
+	int							mErrorsHttp500;
+	int							mErrorsHttp503;
 	int							mSuccesses;
 	long						mByteCount;
 };
 
 
+// Gather process information while we run.  Process
+// size, cpu consumed, wallclock time.
+
+class Metrics
+{
+public:
+	class MetricsImpl;
+	
+public:
+	Metrics();
+	~Metrics();
+
+	void init();
+	void sample();
+	void term();
+
+protected:
+	MetricsImpl *		mImpl;
+
+public:
+	U64					mMaxVSZ;
+	U64					mMinVSZ;
+	U64					mStartWallTime;
+	U64					mEndWallTime;
+	U64					mStartUTime;
+	U64					mEndUTime;
+	U64					mStartSTime;
+	U64					mEndSTime;
+};
+
+
 //
 //
 //
@@ -191,22 +233,38 @@ int main(int argc, char** argv)
 		return 1;
 	}
 
+	// Setup metrics
+	Metrics metrics;
+	metrics.init();
+	
 	// Run it
+	int passes(0);
 	while (! ws.reload(hr))
 	{
-		hr->update(1000);
-#if defined(WIN32)
-		Sleep(5);
-#else
-		usleep(5000);
-#endif
+		hr->update(5000);
+		ms_sleep(2);
+		if (0 == (++passes % 200))
+		{
+			metrics.sample();
+		}
 	}
+	metrics.sample();
+	metrics.term();
 
 	// Report
 	std::cout << "HTTP errors: " << ws.mErrorsHttp << "  API errors:  " << ws.mErrorsApi
 			  << "  Successes:  " << ws.mSuccesses << "  Byte count:  " << ws.mByteCount
 			  << std::endl;
-	
+	std::cout << "HTTP 404 errors: " << ws.mErrorsHttp404 << "  HTTP 416 errors: " << ws.mErrorsHttp416
+			  << "  HTTP 500 errors:  " << ws.mErrorsHttp500 << "  HTTP 503 errors: " << ws.mErrorsHttp503 
+			  << std::endl;
+	std::cout << "User CPU: " << (metrics.mEndUTime - metrics.mStartUTime)
+			  << " uS  System CPU: " << (metrics.mEndSTime - metrics.mStartSTime)
+			  << " uS  Wall Time: "  << (metrics.mEndWallTime - metrics.mStartWallTime)
+			  << " uS  Maximum VSZ: " << metrics.mMaxVSZ
+			  << " Bytes  Minimum VSZ: " << metrics.mMinVSZ << " Bytes"
+			  << std::endl;
+
 	// Clean up
 	delete hr;
 	term_curl();
@@ -250,6 +308,10 @@ WorkingSet::WorkingSet()
 	  mAt(0),
 	  mErrorsApi(0),
 	  mErrorsHttp(0),
+	  mErrorsHttp404(0),
+	  mErrorsHttp416(0),
+	  mErrorsHttp500(0),
+	  mErrorsHttp503(0),
 	  mSuccesses(0),
 	  mByteCount(0L)
 {
@@ -333,7 +395,28 @@ void WorkingSet::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * r
 			// Something in this library or libcurl
 			if (status.isHttpStatus())
 			{
+				static const LLCore::HttpStatus hs404(404);
+				static const LLCore::HttpStatus hs416(416);
+				static const LLCore::HttpStatus hs500(500);
+				static const LLCore::HttpStatus hs503(503);
+				
 				++mErrorsHttp;
+				if (hs404 == status)
+				{
+					++mErrorsHttp404;
+				}
+				else if (hs416 == status)
+				{
+					++mErrorsHttp416;
+				}
+				else if (hs500 == status)
+				{
+					++mErrorsHttp500;
+				}
+				else if (hs503 == status)
+				{
+					++mErrorsHttp503;
+				}
 			}
 			else
 			{
@@ -492,3 +575,155 @@ int getopt(int argc, char * const argv[], const char *optstring)
 
 #endif
 
+
+
+#if defined(WIN32)
+
+#define	PSAPI_VERSION	1
+#include "windows.h"
+#include "psapi.h"
+
+class Metrics::MetricsImpl
+{
+public:
+	MetricsImpl()
+		{}
+
+	~MetricsImpl()
+		{}
+
+	void MetricsImpl::init(Metrics * metrics)
+		{
+			HANDLE self(GetCurrentProcess());		// Does not have to be closed
+			FILETIME ft_dummy, ft_system, ft_user;
+			GetProcessTimes(self, &ft_dummy, &ft_dummy, &ft_system, &ft_user);
+			ULARGE_INTEGER uli;
+			uli.u.LowPart = ft_system.dwLowDateTime;
+			uli.u.HighPart = ft_system.dwHighDateTime;
+			metrics->mStartSTime = uli.QuadPart / U64L(10);		// Convert to uS
+			uli.u.LowPart = ft_user.dwLowDateTime;
+			uli.u.HighPart = ft_user.dwHighDateTime;
+			metrics->mStartUTime = uli.QuadPart / U64L(10);
+			metrics->mStartWallTime = totalTime();
+		}
+
+	void MetricsImpl::sample(Metrics * metrics)
+		{
+			PROCESS_MEMORY_COUNTERS_EX	counters;
+
+			GetProcessMemoryInfo(GetCurrentProcess(),
+								 (PROCESS_MEMORY_COUNTERS *) &counters,
+								 sizeof(counters));
+			// Okay, PrivateUsage isn't truly VSZ but it will be
+			// a good tracker for leaks and fragmentation.  Work on
+			// a better estimator later...
+			SIZE_T vsz(counters.PrivateUsage);
+			metrics->mMaxVSZ = (std::max)(metrics->mMaxVSZ, U64(vsz));
+			metrics->mMinVSZ = (std::min)(metrics->mMinVSZ, U64(vsz));
+		}
+
+	void MetricsImpl::term(Metrics * metrics)
+		{
+			HANDLE self(GetCurrentProcess());		// Does not have to be closed
+			FILETIME ft_dummy, ft_system, ft_user;
+			GetProcessTimes(self, &ft_dummy, &ft_dummy, &ft_system, &ft_user);
+			ULARGE_INTEGER uli;
+			uli.u.LowPart = ft_system.dwLowDateTime;
+			uli.u.HighPart = ft_system.dwHighDateTime;
+			metrics->mEndSTime = uli.QuadPart / U64L(10);
+			uli.u.LowPart = ft_user.dwLowDateTime;
+			uli.u.HighPart = ft_user.dwHighDateTime;
+			metrics->mEndUTime = uli.QuadPart / U64L(10);
+			metrics->mEndWallTime = totalTime();
+		}
+
+protected:
+};
+
+#elif defined(DARWIN)
+
+	
+class Metrics::MetricsImpl
+{
+public:
+	MetricsImpl()
+		{}
+
+	~MetricsImpl()
+		{}
+
+	void MetricsImpl::init(Metrics *)
+		{}
+
+	void MetricsImpl::sample(Metrics *)
+		{}
+
+	void MetricsImpl::term(Metrics *)
+		{}
+};
+
+#else
+
+class Metrics::MetricsImpl
+{
+public:
+	MetricsImpl()
+		{}
+
+	
+	~MetricsImpl()
+		{}
+
+	void MetricsImpl::init(Metrics *)
+		{}
+
+
+	void MetricsImpl::sample(Metrics *)
+		{}
+
+
+	void MetricsImpl::term(Metrics *)
+		{}
+};
+
+#endif  // defined(WIN32)
+
+Metrics::Metrics()
+	: mMaxVSZ(U64(0)),
+	  mMinVSZ(U64L(0xffffffffffffffff)),
+	  mStartWallTime(U64(0)),
+	  mEndWallTime(U64(0)),
+	  mStartUTime(U64(0)),
+	  mEndUTime(U64(0)),
+	  mStartSTime(U64(0)),
+	  mEndSTime(U64(0))
+{
+	mImpl = new MetricsImpl();
+}
+
+
+Metrics::~Metrics()
+{
+	delete mImpl;
+	mImpl = NULL;
+}
+
+
+void Metrics::init()
+{
+	mImpl->init(this);
+}
+
+
+void Metrics::sample()
+{
+	mImpl->sample(this);
+}
+
+
+void Metrics::term()
+{
+	mImpl->term(this);
+}
+
+	
-- 
cgit v1.3


From 46662a3010b2c920ae60b4ca246d56e3caee6f6f Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Mon, 18 Jun 2012 11:16:58 -0400
Subject: Move dtors for refcounted objects to protected access.

---
 indra/llcorehttp/_httpopcancel.h      | 4 +++-
 indra/llcorehttp/_httpoperation.h     | 8 +++++++-
 indra/llcorehttp/_httpoprequest.h     | 4 +++-
 indra/llcorehttp/_httpopsetget.h      | 4 +++-
 indra/llcorehttp/_httpopsetpriority.h | 2 ++
 indra/llcorehttp/_httpreplyqueue.h    | 4 +++-
 indra/llcorehttp/_httprequestqueue.h  | 4 +++-
 indra/llcorehttp/bufferarray.h        | 4 +++-
 indra/llcorehttp/httpheaders.h        | 3 ++-
 indra/llcorehttp/httpoptions.h        | 3 ++-
 indra/llcorehttp/httpresponse.h       | 3 ++-
 11 files changed, 33 insertions(+), 10 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.h')

diff --git a/indra/llcorehttp/_httpopcancel.h b/indra/llcorehttp/_httpopcancel.h
index 6d1e0f8774..4d927d1aaf 100644
--- a/indra/llcorehttp/_httpopcancel.h
+++ b/indra/llcorehttp/_httpopcancel.h
@@ -51,8 +51,10 @@ class HttpOpCancel : public HttpOperation
 {
 public:
 	HttpOpCancel(HttpHandle handle);
-	virtual ~HttpOpCancel();
 
+protected:
+	virtual ~HttpOpCancel();							// Use release()
+	
 private:
 	HttpOpCancel(const HttpOpCancel &);					// Not defined
 	void operator=(const HttpOpCancel &);				// Not defined
diff --git a/indra/llcorehttp/_httpoperation.h b/indra/llcorehttp/_httpoperation.h
index de4939a0ac..5823c08c7b 100644
--- a/indra/llcorehttp/_httpoperation.h
+++ b/indra/llcorehttp/_httpoperation.h
@@ -73,7 +73,9 @@ class HttpOperation : public LLCoreInt::RefCounted
 {
 public:
 	HttpOperation();
-	virtual ~HttpOperation();
+
+protected:
+	virtual ~HttpOperation();							// Use release()
 
 private:
 	HttpOperation(const HttpOperation &);				// Not defined
@@ -131,6 +133,8 @@ class HttpOpStop : public HttpOperation
 {
 public:
 	HttpOpStop();
+
+protected:
 	virtual ~HttpOpStop();
 
 private:
@@ -152,6 +156,8 @@ class HttpOpNull : public HttpOperation
 {
 public:
 	HttpOpNull();
+
+protected:
 	virtual ~HttpOpNull();
 
 private:
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index fc2301057c..4643cc3b75 100644
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -54,7 +54,9 @@ class HttpOpRequest : public HttpOperation
 {
 public:
 	HttpOpRequest();
-	virtual ~HttpOpRequest();
+
+protected:
+	virtual ~HttpOpRequest();							// Use release()
 
 private:
 	HttpOpRequest(const HttpOpRequest &);				// Not defined
diff --git a/indra/llcorehttp/_httpopsetget.h b/indra/llcorehttp/_httpopsetget.h
index e065eb4c30..efb24855c5 100644
--- a/indra/llcorehttp/_httpopsetget.h
+++ b/indra/llcorehttp/_httpopsetget.h
@@ -49,7 +49,9 @@ class HttpOpSetGet : public HttpOperation
 {
 public:
 	HttpOpSetGet();
-	virtual ~HttpOpSetGet();
+
+protected:
+	virtual ~HttpOpSetGet();							// Use release()
 
 private:
 	HttpOpSetGet(const HttpOpSetGet &);					// Not defined
diff --git a/indra/llcorehttp/_httpopsetpriority.h b/indra/llcorehttp/_httpopsetpriority.h
index f1e94b6e43..724293ef78 100644
--- a/indra/llcorehttp/_httpopsetpriority.h
+++ b/indra/llcorehttp/_httpopsetpriority.h
@@ -47,6 +47,8 @@ class HttpOpSetPriority : public HttpOperation
 {
 public:
 	HttpOpSetPriority(HttpHandle handle, HttpRequest::priority_t priority);
+
+protected:
 	virtual ~HttpOpSetPriority();
 
 private:
diff --git a/indra/llcorehttp/_httpreplyqueue.h b/indra/llcorehttp/_httpreplyqueue.h
index 28cb1d68b7..4220a09a3b 100644
--- a/indra/llcorehttp/_httpreplyqueue.h
+++ b/indra/llcorehttp/_httpreplyqueue.h
@@ -63,7 +63,9 @@ class HttpReplyQueue : public LLCoreInt::RefCounted
 public:
 	/// Caller acquires a Refcount on construction
 	HttpReplyQueue();
-	virtual ~HttpReplyQueue();
+
+protected:
+	virtual ~HttpReplyQueue();							// Use release()
 
 private:
 	HttpReplyQueue(const HttpReplyQueue &);				// Not defined
diff --git a/indra/llcorehttp/_httprequestqueue.h b/indra/llcorehttp/_httprequestqueue.h
index f96bd7520c..26d7d9dca6 100644
--- a/indra/llcorehttp/_httprequestqueue.h
+++ b/indra/llcorehttp/_httprequestqueue.h
@@ -51,7 +51,9 @@ class HttpRequestQueue : public LLCoreInt::RefCounted
 protected:
 	/// Caller acquires a Refcount on construction
 	HttpRequestQueue();
-	virtual ~HttpRequestQueue();
+
+protected:
+	virtual ~HttpRequestQueue();						// Use release()
 
 private:
 	HttpRequestQueue(const HttpRequestQueue &);			// Not defined
diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index d3862b45e1..d0c51d3c73 100644
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -66,7 +66,9 @@ class BufferArray : public LLCoreInt::RefCounted
 {
 public:
 	BufferArray();
-	virtual ~BufferArray();
+
+protected:
+	virtual ~BufferArray();						// Use release()
 
 private:
 	BufferArray(const BufferArray &);			// Not defined
diff --git a/indra/llcorehttp/httpheaders.h b/indra/llcorehttp/httpheaders.h
index 0b6d82561b..3449daa3a1 100644
--- a/indra/llcorehttp/httpheaders.h
+++ b/indra/llcorehttp/httpheaders.h
@@ -68,9 +68,10 @@ public:
 	/// to the instance.  A call to @see release() will destroy
 	/// the instance.
 	HttpHeaders();
-	~HttpHeaders();
 
 protected:
+	virtual ~HttpHeaders();						// Use release()
+
 	HttpHeaders(const HttpHeaders &);			// Not defined
 	void operator=(const HttpHeaders &);		// Not defined
 
diff --git a/indra/llcorehttp/httpoptions.h b/indra/llcorehttp/httpoptions.h
index 0b9dfdc1de..78d0aadb2e 100644
--- a/indra/llcorehttp/httpoptions.h
+++ b/indra/llcorehttp/httpoptions.h
@@ -61,9 +61,10 @@ class HttpOptions : public LLCoreInt::RefCounted
 public:
 	HttpOptions();
 	HttpOptions(const HttpOptions &);
-	virtual ~HttpOptions();
 
 protected:
+	virtual ~HttpOptions();						// Use release()
+	
 	void operator=(const HttpOptions &);		// Not defined
 
 public:
diff --git a/indra/llcorehttp/httpresponse.h b/indra/llcorehttp/httpresponse.h
index 5cf3a919f4..5bcd7c4eb8 100644
--- a/indra/llcorehttp/httpresponse.h
+++ b/indra/llcorehttp/httpresponse.h
@@ -58,9 +58,10 @@ class HttpResponse : public LLCoreInt::RefCounted
 {
 public:
 	HttpResponse();
-	virtual ~HttpResponse();
 
 protected:
+	virtual ~HttpResponse();							// Use release()
+	
 	HttpResponse(const HttpResponse &);					// Not defined
 	void operator=(const HttpResponse &);				// Not defined
 	
-- 
cgit v1.3


From 4da93b6ad91dff1de98c3c8dd3674c0544f2958b Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Thu, 21 Jun 2012 19:45:40 -0400
Subject: SH-3177 Add streambuf/iostream adapters to BufferArray object.
 Initial version that should have enough of the plumbing to produce a working
 adapter.  Memory test is showing 8 bytes held after one of the tests so I'm
 going to revisit that later.  But basic functionality is there going by the
 unit tests.

---
 indra/llcorehttp/CMakeLists.txt              |   3 +
 indra/llcorehttp/bufferarray.cpp             |  14 ++
 indra/llcorehttp/bufferarray.h               |   8 +
 indra/llcorehttp/bufferstream.cpp            | 285 +++++++++++++++++++++++++++
 indra/llcorehttp/bufferstream.h              |  94 +++++++++
 indra/llcorehttp/tests/llcorehttp_test.cpp   |   3 +-
 indra/llcorehttp/tests/test_bufferarray.hpp  |   2 +-
 indra/llcorehttp/tests/test_bufferstream.hpp | 252 +++++++++++++++++++++++
 8 files changed, 659 insertions(+), 2 deletions(-)
 create mode 100644 indra/llcorehttp/bufferstream.cpp
 create mode 100644 indra/llcorehttp/bufferstream.h
 create mode 100644 indra/llcorehttp/tests/test_bufferstream.hpp

(limited to 'indra/llcorehttp/bufferarray.h')

diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index acf4c0d6a3..4c00cc04e9 100644
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -24,6 +24,7 @@ include_directories(
 
 set(llcorehttp_SOURCE_FILES
     bufferarray.cpp
+    bufferstream.cpp
     httpcommon.cpp
     httpheaders.cpp
     httpoptions.cpp
@@ -47,6 +48,7 @@ set(llcorehttp_HEADER_FILES
     CMakeLists.txt
 
     bufferarray.h
+    bufferstream.h
     httpcommon.h
     httphandler.h
     httpheaders.h
@@ -105,6 +107,7 @@ if (LL_TESTS)
       tests/test_httprequestqueue.hpp
       tests/test_httpheaders.hpp
       tests/test_bufferarray.hpp
+      tests/test_bufferstream.hpp
       )
 
   set_source_files_properties(${llcorehttp_TEST_HEADER_FILES}
diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 5eaa60c9ba..5eb8f84c34 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -288,6 +288,20 @@ int BufferArray::findBlock(size_t pos, size_t * ret_offset)
 }
 
 
+bool BufferArray::getBlockStartEnd(int block, const char ** start, const char ** end)
+{
+	if (block < 0 || block >= mBlocks.size())
+	{
+		return false;
+	}
+
+	const Block & b(*mBlocks[block]);
+	*start = &b.mData[0];
+	*end = &b.mData[b.mUsed];
+	return true;
+}
+
+
 // ==================================
 // BufferArray::Block Definitions
 // ==================================
diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index d0c51d3c73..1094a435b4 100644
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -37,6 +37,7 @@
 namespace LLCore
 {
 
+class BufferArrayStreamBuf;
 
 /// A very simple scatter/gather type map for bulk data.  The motivation
 /// for this class is the writedata callback used by libcurl.  Response
@@ -65,6 +66,11 @@ namespace LLCore
 class BufferArray : public LLCoreInt::RefCounted
 {
 public:
+	// BufferArrayStreamBuf has intimate knowledge of this
+	// implementation to implement a buffer-free adapter.
+	// Changes here will likely need to be reflected there.
+	friend class BufferArrayStreamBuf;
+	
 	BufferArray();
 
 protected:
@@ -114,6 +120,8 @@ public:
 	
 protected:
 	int findBlock(size_t pos, size_t * ret_offset);
+
+	bool getBlockStartEnd(int block, const char ** start, const char ** end);
 	
 protected:
 	class Block;
diff --git a/indra/llcorehttp/bufferstream.cpp b/indra/llcorehttp/bufferstream.cpp
new file mode 100644
index 0000000000..6553900eef
--- /dev/null
+++ b/indra/llcorehttp/bufferstream.cpp
@@ -0,0 +1,285 @@
+/**
+ * @file bufferstream.cpp
+ * @brief Implements the BufferStream adapter class
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "bufferstream.h"
+
+#include "bufferarray.h"
+
+
+namespace LLCore
+{
+
+BufferArrayStreamBuf::BufferArrayStreamBuf(BufferArray * array)
+	: mBufferArray(array),
+	  mReadCurPos(0),
+	  mReadCurBlock(-1),
+	  mReadBegin(NULL),
+	  mReadCur(NULL),
+	  mReadEnd(NULL),
+	  mWriteCurPos(0)
+{
+	if (array)
+	{
+		array->addRef();
+		mWriteCurPos = array->mLen;
+	}
+}
+
+
+BufferArrayStreamBuf::~BufferArrayStreamBuf()
+{
+	if (mBufferArray)
+	{
+		mBufferArray->release();
+		mBufferArray = NULL;
+	}
+}
+
+	
+BufferArrayStreamBuf::int_type BufferArrayStreamBuf::underflow()
+{
+	if (! mBufferArray)
+	{
+		return traits_type::eof();
+	}
+
+	if (mReadCur == mReadEnd)
+	{
+		// Find the next block with actual data or leave
+		// mCurBlock/mCur/mEnd unchanged if we're at the end
+		// of any block chain.
+		const char * new_begin(NULL), * new_end(NULL);
+		int new_cur_block(mReadCurBlock + 1);
+
+		while (mBufferArray->getBlockStartEnd(new_cur_block, &new_begin, &new_end))
+		{
+			if (new_begin != new_end)
+			{
+				break;
+			}
+			++new_cur_block;
+		}
+		if (new_begin == new_end)
+		{
+			return traits_type::eof();
+		}
+
+		mReadCurBlock = new_cur_block;
+		mReadBegin = mReadCur = new_begin;
+		mReadEnd = new_end;
+	}
+
+	return traits_type::to_int_type(*mReadCur);
+}
+
+
+BufferArrayStreamBuf::int_type BufferArrayStreamBuf::uflow()
+{
+	const int_type ret(underflow());
+
+	if (traits_type::eof() != ret)
+	{
+		++mReadCur;
+		++mReadCurPos;
+	}
+	return ret;
+}
+
+
+BufferArrayStreamBuf::int_type BufferArrayStreamBuf::pbackfail(int_type ch)
+{
+	if (! mBufferArray)
+	{
+		return traits_type::eof();
+	}
+
+	if (mReadCur == mReadBegin)
+	{
+		// Find the previous block with actual data or leave
+		// mCurBlock/mBegin/mCur/mEnd unchanged if we're at the
+		// beginning of any block chain.
+		const char * new_begin(NULL), * new_end(NULL);
+		int new_cur_block(mReadCurBlock - 1);
+
+		while (mBufferArray->getBlockStartEnd(new_cur_block, &new_begin, &new_end))
+		{
+			if (new_begin != new_end)
+			{
+				break;
+			}
+			--new_cur_block;
+		}
+		if (new_begin == new_end)
+		{
+			return traits_type::eof();
+		}
+
+		mReadCurBlock = new_cur_block;
+		mReadBegin = new_begin;
+		mReadEnd = mReadCur = new_end;
+	}
+
+	if (traits_type::eof() != ch && mReadCur[-1] != ch)
+	{
+		return traits_type::eof();
+	}
+	--mReadCurPos;
+	return traits_type::to_int_type(*--mReadCur);
+}
+
+
+std::streamsize BufferArrayStreamBuf::showmanyc()
+{
+	if (! mBufferArray)
+	{
+		return -1;
+	}
+	return mBufferArray->mLen - mReadCurPos;
+}
+
+
+BufferArrayStreamBuf::int_type BufferArrayStreamBuf::overflow(int c)
+{
+	if (! mBufferArray || mWriteCurPos > mBufferArray->mLen)
+	{
+		return traits_type::eof();
+	}
+	const size_t wrote(mBufferArray->write(mWriteCurPos, &c, 1));
+	mWriteCurPos += wrote;
+	return wrote ? c : traits_type::eof();
+}
+
+
+std::streamsize BufferArrayStreamBuf::xsputn(const char * src, std::streamsize count)
+{
+	if (! mBufferArray || mWriteCurPos > mBufferArray->mLen)
+	{
+		return 0;
+	}
+	const size_t wrote(mBufferArray->write(mWriteCurPos, src, count));
+	mWriteCurPos += wrote;
+	return wrote;
+}
+
+
+std::streampos BufferArrayStreamBuf::seekoff(std::streamoff off,
+											 std::ios_base::seekdir way,
+											 std::ios_base::openmode which)
+{
+	std::streampos ret(-1);
+
+	if (! mBufferArray)
+	{
+		return ret;
+	}
+	
+	if (std::ios_base::in == which)
+	{
+		size_t pos(0);
+
+		switch (way)
+		{
+		case std::ios_base::beg:
+			pos = off;
+			break;
+			
+		case std::ios_base::cur:
+			pos = mReadCurPos += off;
+			break;
+			
+		case std::ios_base::end:
+			pos = mBufferArray->mLen - off;
+			break;
+
+		default:
+			return ret;
+		}
+
+		if (pos >= mBufferArray->size())
+		{
+			pos = (std::max)(size_t(0), mBufferArray->size() - 1);
+		}
+		size_t ba_offset(0);
+		int block(mBufferArray->findBlock(pos, &ba_offset));
+		if (block < 0)
+			return ret;
+		const char * start(NULL), * end(NULL);
+		if (! mBufferArray->getBlockStartEnd(block, &start, &end))
+			return ret;
+		mReadCurBlock = block;
+		mReadBegin = start;
+		mReadCur = start + ba_offset;
+		mReadEnd = end;
+		ret = mReadCurPos = pos;
+	}
+	else if (std::ios_base::out == which)
+	{
+		size_t pos(0);
+
+		switch (way)
+		{
+		case std::ios_base::beg:
+			pos = off;
+			break;
+			
+		case std::ios_base::cur:
+			pos = mWriteCurPos += off;
+			break;
+			
+		case std::ios_base::end:
+			pos = mBufferArray->mLen - off;
+			break;
+
+		default:
+			return ret;
+		}
+
+		if (pos < 0)
+			return ret;
+		if (pos > mBufferArray->size())
+		{
+			pos = mBufferArray->size();
+		}
+		ret = mWriteCurPos = pos;
+	}
+
+	return ret;
+}
+
+
+BufferArrayStream::BufferArrayStream(BufferArray * ba)
+	: std::iostream(&mStreamBuf),
+	  mStreamBuf(ba)
+{}
+	
+			
+BufferArrayStream::~BufferArrayStream()
+{}
+	
+
+}  // end namespace LLCore
+
+
diff --git a/indra/llcorehttp/bufferstream.h b/indra/llcorehttp/bufferstream.h
new file mode 100644
index 0000000000..60bda9ff9a
--- /dev/null
+++ b/indra/llcorehttp/bufferstream.h
@@ -0,0 +1,94 @@
+/**
+ * @file bufferstream.h
+ * @brief Public-facing declaration for the BufferStream adapter class
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef	_LLCORE_BUFFER_STREAM_H_
+#define	_LLCORE_BUFFER_STREAM_H_
+
+
+#include <sstream>
+#include <cstdlib>
+
+#include "bufferarray.h"
+
+
+namespace LLCore
+{
+
+
+class BufferArrayStreamBuf : public std::streambuf
+{
+public:
+	BufferArrayStreamBuf(BufferArray * array);
+	virtual ~BufferArrayStreamBuf();
+
+private:
+	BufferArrayStreamBuf(const BufferArrayStreamBuf &);	// Not defined
+	void operator=(const BufferArrayStreamBuf &);		// Not defined
+
+public:
+	// Input interfaces from std::streambuf
+	int_type underflow();
+	int_type uflow();
+	int_type pbackfail(int_type ch);
+	std::streamsize showmanyc();
+
+	// Output interfaces from std::streambuf
+	int_type overflow(int c);
+	std::streamsize xsputn(const char * src, std::streamsize count);
+
+	// Common/misc interfaces from std::streambuf
+	std::streampos seekoff(std::streamoff off, std::ios_base::seekdir way, std::ios_base::openmode which);
+	
+protected:
+	BufferArray *		mBufferArray;			// Ref counted
+	size_t				mReadCurPos;
+	int					mReadCurBlock;
+	const char *		mReadBegin;
+	const char *		mReadCur;
+	const char *		mReadEnd;
+	size_t				mWriteCurPos;
+	
+}; // end class BufferArrayStreamBuf
+
+
+class BufferArrayStream : public std::iostream
+{
+public:
+	BufferArrayStream(BufferArray * ba);
+	~BufferArrayStream();
+
+protected:
+	BufferArrayStream(const BufferArrayStream &);
+	void operator=(const BufferArrayStream &);
+
+protected:
+	BufferArrayStreamBuf		mStreamBuf;
+}; // end class BufferArrayStream
+
+
+}  // end namespace LLCore
+
+#endif	// _LLCORE_BUFFER_STREAM_H_
diff --git a/indra/llcorehttp/tests/llcorehttp_test.cpp b/indra/llcorehttp/tests/llcorehttp_test.cpp
index 2b36d3a982..e863ddd13f 100644
--- a/indra/llcorehttp/tests/llcorehttp_test.cpp
+++ b/indra/llcorehttp/tests/llcorehttp_test.cpp
@@ -36,12 +36,13 @@
 #include "../test/lltut.h"
 
 // Pull in each of the test sets
+#include "test_bufferarray.hpp"
+#include "test_bufferstream.hpp"
 #include "test_httpstatus.hpp"
 #include "test_refcounted.hpp"
 #include "test_httpoperation.hpp"
 #include "test_httprequest.hpp"
 #include "test_httpheaders.hpp"
-#include "test_bufferarray.hpp"
 #include "test_httprequestqueue.hpp"
 
 #include "llproxy.h"
diff --git a/indra/llcorehttp/tests/test_bufferarray.hpp b/indra/llcorehttp/tests/test_bufferarray.hpp
index 3f947db967..8a2a64d970 100644
--- a/indra/llcorehttp/tests/test_bufferarray.hpp
+++ b/indra/llcorehttp/tests/test_bufferarray.hpp
@@ -33,7 +33,7 @@
 #include "test_allocator.h"
 
 
-using namespace LLCoreInt;
+using namespace LLCore;
 
 
 
diff --git a/indra/llcorehttp/tests/test_bufferstream.hpp b/indra/llcorehttp/tests/test_bufferstream.hpp
new file mode 100644
index 0000000000..5afaba0966
--- /dev/null
+++ b/indra/llcorehttp/tests/test_bufferstream.hpp
@@ -0,0 +1,252 @@
+/** 
+ * @file test_bufferstream.hpp
+ * @brief unit tests for the LLCore::BufferArrayStreamBuf/BufferArrayStream classes
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+#ifndef TEST_LLCORE_BUFFER_STREAM_H_
+#define TEST_LLCORE_BUFFER_STREAM_H_
+
+#include "bufferstream.h"
+
+#include <iostream>
+
+#include "test_allocator.h"
+
+
+using namespace LLCore;
+
+
+namespace tut
+{
+
+struct BufferStreamTestData
+{
+	// the test objects inherit from this so the member functions and variables
+	// can be referenced directly inside of the test functions.
+	size_t mMemTotal;
+};
+
+typedef test_group<BufferStreamTestData> BufferStreamTestGroupType;
+typedef BufferStreamTestGroupType::object BufferStreamTestObjectType;
+BufferStreamTestGroupType BufferStreamTestGroup("BufferStream Tests");
+typedef BufferArrayStreamBuf::traits_type tst_traits_t;
+
+
+template <> template <>
+void BufferStreamTestObjectType::test<1>()
+{
+	set_test_name("BufferArrayStreamBuf construction with NULL BufferArray");
+
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+
+	// create a new ref counted object with an implicit reference
+	BufferArrayStreamBuf * bsb = new BufferArrayStreamBuf(NULL);
+	ensure("Memory being used", mMemTotal < GetMemTotal());
+
+	// Not much will work with a NULL
+	ensure("underflow() on NULL fails", tst_traits_t::eof() == bsb->underflow());
+	ensure("uflow() on NULL fails", tst_traits_t::eof() == bsb->uflow());
+	ensure("pbackfail() on NULL fails", tst_traits_t::eof() == bsb->pbackfail('c'));
+	ensure("showmanyc() on NULL fails", bsb->showmanyc() == -1);
+	ensure("overflow() on NULL fails", tst_traits_t::eof() == bsb->overflow('c'));
+	ensure("xsputn() on NULL fails", bsb->xsputn("blah", 4) == 0);
+	ensure("seekoff() on NULL fails", bsb->seekoff(0, std::ios_base::beg, std::ios_base::in) == std::streampos(-1));
+	
+	// release the implicit reference, causing the object to be released
+	delete bsb;
+	bsb = NULL;
+
+	// make sure we didn't leak any memory
+	ensure("Allocated memory returned", mMemTotal == GetMemTotal());
+}
+
+
+template <> template <>
+void BufferStreamTestObjectType::test<2>()
+{
+	set_test_name("BufferArrayStream construction with NULL BufferArray");
+
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+
+	// create a new ref counted object with an implicit reference
+	BufferArrayStream * bas = new BufferArrayStream(NULL);
+	ensure("Memory being used", mMemTotal < GetMemTotal());
+
+	// Not much will work with a NULL here
+	ensure("eof() is false on NULL", ! bas->eof());
+	ensure("fail() is false on NULL", ! bas->fail());
+	ensure("good() on NULL", bas->good());
+		   
+	// release the implicit reference, causing the object to be released
+	delete bas;
+	bas = NULL;
+
+	// make sure we didn't leak any memory
+	ensure("Allocated memory returned", mMemTotal == GetMemTotal());
+}
+
+
+template <> template <>
+void BufferStreamTestObjectType::test<3>()
+{
+	set_test_name("BufferArrayStreamBuf construction with empty BufferArray");
+
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+
+	// create a new ref counted BufferArray with implicit reference
+	BufferArray * ba = new BufferArray;
+	BufferArrayStreamBuf * bsb = new BufferArrayStreamBuf(ba);
+	ensure("Memory being used", mMemTotal < GetMemTotal());
+
+	// I can release my ref on the BA
+	ba->release();
+	ba = NULL;
+	
+	// release the implicit reference, causing the object to be released
+	delete bsb;
+	bsb = NULL;
+
+	// make sure we didn't leak any memory
+	ensure("Allocated memory returned", mMemTotal == GetMemTotal());
+}
+
+
+template <> template <>
+void BufferStreamTestObjectType::test<4>()
+{
+	set_test_name("BufferArrayStream construction with empty BufferArray");
+
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+
+	// create a new ref counted BufferArray with implicit reference
+	BufferArray * ba = new BufferArray;
+
+	{
+		// create a new ref counted object with an implicit reference
+		BufferArrayStream bas(ba);
+		ensure("Memory being used", mMemTotal < GetMemTotal());
+	}
+
+	// release the implicit reference, causing the object to be released
+	ba->release();
+	ba = NULL;
+	
+	// make sure we didn't leak any memory
+	ensure("Allocated memory returned", mMemTotal == GetMemTotal());
+}
+
+
+template <> template <>
+void BufferStreamTestObjectType::test<5>()
+{
+	set_test_name("BufferArrayStreamBuf construction with real BufferArray");
+
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+
+	// create a new ref counted BufferArray with implicit reference
+	BufferArray * ba = new BufferArray;
+	const char * content("This is a string.  A fragment.");
+	const size_t c_len(strlen(content));
+	ba->append(content, c_len);
+	BufferArrayStreamBuf * bsb = new BufferArrayStreamBuf(ba);
+	ensure("Memory being used", mMemTotal < GetMemTotal());
+
+	// I can release my ref on the BA
+	ba->release();
+	ba = NULL;
+	
+	// Various static state
+	ensure("underflow() returns 'T'", bsb->underflow() == 'T');
+	ensure("underflow() returns 'T' again", bsb->underflow() == 'T');
+	ensure("uflow() returns 'T'", bsb->uflow() == 'T');
+	ensure("uflow() returns 'h'", bsb->uflow() == 'h');
+	ensure("pbackfail('i') fails", tst_traits_t::eof() == bsb->pbackfail('i'));
+	ensure("pbackfail('T') fails", tst_traits_t::eof() == bsb->pbackfail('T'));
+	ensure("pbackfail('h') succeeds", bsb->pbackfail('h') == 'h');
+	ensure("showmanyc() is everything but the 'T'", bsb->showmanyc() == (c_len - 1));
+	ensure("overflow() appends", bsb->overflow('c') == 'c');
+	ensure("showmanyc() reflects append", bsb->showmanyc() == (c_len - 1 + 1));
+	ensure("xsputn() appends some more", bsb->xsputn("bla!", 4) == 4);
+	ensure("showmanyc() reflects 2nd append", bsb->showmanyc() == (c_len - 1 + 5));
+	ensure("seekoff() succeeds", bsb->seekoff(0, std::ios_base::beg, std::ios_base::in) == std::streampos(0));
+	ensure("seekoff() succeeds 2", bsb->seekoff(4, std::ios_base::cur, std::ios_base::in) == std::streampos(4));
+	ensure("showmanyc() picks up seekoff", bsb->showmanyc() == (c_len + 5 - 4));
+	ensure("seekoff() succeeds 3", bsb->seekoff(0, std::ios_base::end, std::ios_base::in) == std::streampos(c_len + 4));
+	ensure("pbackfail('!') succeeds", tst_traits_t::eof() == bsb->pbackfail('!'));
+	
+	// release the implicit reference, causing the object to be released
+	delete bsb;
+	bsb = NULL;
+
+	// make sure we didn't leak any memory
+	ensure("Allocated memory returned", mMemTotal == GetMemTotal());
+}
+
+
+template <> template <>
+void BufferStreamTestObjectType::test<6>()
+{
+	set_test_name("BufferArrayStream construction with real BufferArray");
+
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+
+	// create a new ref counted BufferArray with implicit reference
+	BufferArray * ba = new BufferArray;
+	//const char * content("This is a string.  A fragment.");
+	//const size_t c_len(strlen(content));
+	//ba->append(content, strlen(content));
+
+	{
+		// create a new ref counted object with an implicit reference
+		BufferArrayStream bas(ba);
+		ensure("Memory being used", mMemTotal < GetMemTotal());
+
+		// Basic operations
+		bas << "Hello" << 27 << ".";
+		ensure("BA length 8", ba->size() == 8);
+
+		std::string str;
+		bas >> str;
+		ensure("reads correctly", str == "Hello27.");
+	}
+
+	// release the implicit reference, causing the object to be released
+	ba->release();
+	ba = NULL;
+
+	// make sure we didn't leak any memory
+	// ensure("Allocated memory returned", mMemTotal == GetMemTotal());
+	static U64 mem = GetMemTotal();
+}
+
+
+}  // end namespace tut
+
+
+#endif  // TEST_LLCORE_BUFFER_STREAM_H_
-- 
cgit v1.3