Applied our coding style, but all clases into the BPrivate namespace.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@11953 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/kernel/libroot/posix/malloc/arch-specific.cpp

@@ -33,6 +33,7 @@ extern "C" {
 #include <OS.h>
 #include <unistd.h>
 
+using namespace BPrivate;
 
 static area_id heap_region = -1;
 static addr_t brk;

src/kernel/libroot/posix/malloc/block.h

@@ -24,22 +24,24 @@
 
 //#include <assert.h>
 
+namespace BPrivate {
 
 class superblock;
 
 class block {
 	public:
-
 		block(superblock * sb)
 			:
 #if HEAP_DEBUG
 			_magic(FREE_BLOCK_MAGIC),
 #endif
-      _next (NULL),
+			_next(NULL), _mySuperblock(sb)
-      _mySuperblock (sb)
+		{
-    {}
+		}
 
-  block& operator= (const block& b) {
+		block &
+		operator=(const block & b)
+		{
 #if HEAP_DEBUG
 			_magic = b._magic;
 #endif
@@ -51,8 +53,10 @@ public:
 			return *this;
 		}
 
-  enum { ALLOCATED_BLOCK_MAGIC = 0xcafecafe,
+		enum {
-	 FREE_BLOCK_MAGIC = 0xbabebabe };
+			ALLOCATED_BLOCK_MAGIC = 0xcafecafe,
+			FREE_BLOCK_MAGIC = 0xbabebabe
+		};
 
 		// Mark this block as free.
 		inline void markFree(void);
@@ -68,26 +72,46 @@ public:
 		inline superblock *getSuperblock(void);
 
 #if HEAP_FRAG_STATS
-  void setRequestedSize (size_t s)
+		void
+		setRequestedSize(size_t s)
 		{
 			_requestedSize = s;
 		}
 
-  size_t getRequestedSize (void) { return _requestedSize; }
+		size_t
+		getRequestedSize(void)
+		{
+			return _requestedSize;
+		}
 #endif
 
 #if USE_PRIVATE_HEAPS
-  void setActualSize (size_t s) { _actualSize = s; }
+		void
-  size_t getActualSize (void) { return _actualSize; }
+		setActualSize(size_t s)
-#endif
+		{
+			_actualSize = s;
+		}
 
-  void setNext (block * b) { _next = b; }
+		size_t
-  block * getNext (void) { return _next; }
+		getActualSize(void)
+		{
+			return _actualSize;
+		}
+#endif
+		void
+		setNext(block * b)
+		{
+			_next = b;
+		}
+
+		block *
+		getNext(void)
+		{
+			return _next;
+		}
 
 	private:
-
 #if USE_PRIVATE_HEAPS
-
 #if HEAP_DEBUG
 		union {
 			unsigned long _magic;
@@ -102,8 +126,6 @@ private:
 			double _d2;				// For alignment.
 			superblock *_mySuperblock;	// A pointer to my superblock.
 		};
-
-
 #else // ! USE_PRIVATE_HEAPS
 
 #if HEAP_DEBUG
@@ -115,7 +137,6 @@ private:
 
 		block *_next;				// The next block in a linked-list of blocks.
 		superblock *_mySuperblock;	// A pointer to my superblock.
-
 #endif // USE_PRIVATE_HEAPS
 
 #if HEAP_FRAG_STATS
@@ -126,21 +147,23 @@ private:
 #endif
 
 		// Disable copying.
-
 		block(const block &);
 };
 
 
-superblock * block::getSuperblock (void)
+superblock *
+block::getSuperblock(void)
 {
 #if HEAP_DEBUG
 	assert(isValid());
 #endif
+
 	return _mySuperblock;
 }
 
 
-void block::markFree (void)
+void
+block::markFree(void)
 {
 #if HEAP_DEBUG
 	assert(_magic == ALLOCATED_BLOCK_MAGIC);
@@ -149,7 +172,8 @@ void block::markFree (void)
 }
 
 
-void block::markAllocated (void)
+void
+block::markAllocated(void)
 {
 #if HEAP_DEBUG
 	assert(_magic == FREE_BLOCK_MAGIC);
@@ -158,14 +182,17 @@ void block::markAllocated (void)
 }
 
 
-const int block::isValid (void) const
+const int
+block::isValid(void) const
 {
 #if HEAP_DEBUG
-  return ((_magic == FREE_BLOCK_MAGIC)
+	return _magic == FREE_BLOCK_MAGIC
-	  || (_magic == ALLOCATED_BLOCK_MAGIC));
+		|| _magic == ALLOCATED_BLOCK_MAGIC;
 #else
 	return 1;
 #endif
 }
 
+}	// namespace BPrivate
+
 #endif // _BLOCK_H_

src/kernel/libroot/posix/malloc/config.h

@@ -89,4 +89,3 @@ enum { SUPERBLOCK_FULLNESS_GROUP = 9 };
 
 
 #endif // _CONFIG_H_
-

src/kernel/libroot/posix/malloc/heap.cpp

@@ -16,6 +16,7 @@
 // Library General Public License for more details.
 //
 //////////////////////////////////////////////////////////////////////////////
+
 #include "config.h"
 
 #include "heap.h"
@@ -23,7 +24,7 @@
 #include "processheap.h"
 #include "superblock.h"
 
-static const char version[] = "The Hoard memory allocator, version 2.0 (http://www.hoard.org). Copyright (C) 1998, 1999, 2000 The University of Texas at Austin. $Id: heap.cpp,v 1.2 2005/02/10 18:47:16 axeld Exp $";
+using namespace BPrivate;
 
 // NB: Use maketable.cpp to update this
 //     if SIZE_CLASSES, ALIGNMENT, SIZE_CLASS_BASE, MAX_EMPTY_SUPERBLOCKS,
@@ -31,21 +32,68 @@ static const char version[] = "The Hoard memory allocator, version 2.0 (http://w
 
 #if (MAX_INTERNAL_FRAGMENTATION == 2)
 
-size_t hoardHeap::_sizeTable[hoardHeap::SIZE_CLASSES] = {8UL, 16UL, 24UL, 32UL, 40UL, 48UL, 56UL, 72UL, 80UL, 96UL, 120UL, 144UL, 168UL, 200UL, 240UL, 288UL, 344UL, 416UL, 496UL, 592UL, 712UL, 856UL, 1024UL, 1232UL, 1472UL, 1768UL, 2120UL, 2544UL, 3048UL, 3664UL, 4392UL, 5272UL, 6320UL, 7584UL, 9104UL, 10928UL, 13112UL, 15728UL, 18872UL, 22648UL, 27176UL, 32616UL, 39136UL, 46960UL, 56352UL, 67624UL, 81144UL, 97376UL, 116848UL, 140216UL, 168256UL, 201904UL, 242288UL, 290744UL, 348896UL, 418672UL, 502408UL, 602888UL, 723464UL, 868152UL, 1041784UL, 1250136UL, 1500160UL, 1800192UL, 2160232UL, 2592280UL, 3110736UL, 3732880UL, 4479456UL, 5375344UL, 6450408UL, 7740496UL, 9288592UL, 11146312UL, 13375568UL, 16050680UL, 19260816UL, 23112984UL, 27735576UL, 33282688UL, 39939224UL, 47927072UL, 57512488UL, 69014984UL, 82817976UL, 99381576UL, 119257888UL, 143109472UL, 171731360UL, 206077632UL, 247293152UL, 296751776UL, 356102144UL, 427322560UL, 512787072UL, 615344512UL, 738413376UL, 886096064UL, 1063315264UL}; 
+size_t hoardHeap::_sizeTable[hoardHeap::SIZE_CLASSES] = {
+	8UL, 16UL, 24UL, 32UL, 40UL, 48UL, 56UL, 72UL, 80UL, 96UL, 120UL, 144UL,
+	168UL, 200UL, 240UL, 288UL, 344UL, 416UL, 496UL, 592UL, 712UL, 856UL,
+	1024UL, 1232UL, 1472UL, 1768UL, 2120UL, 2544UL, 3048UL, 3664UL,
+	4392UL, 5272UL, 6320UL, 7584UL, 9104UL, 10928UL, 13112UL, 15728UL,
+	18872UL, 22648UL, 27176UL, 32616UL, 39136UL, 46960UL, 56352UL,
+	67624UL, 81144UL, 97376UL, 116848UL, 140216UL, 168256UL, 201904UL,
+	242288UL, 290744UL, 348896UL, 418672UL, 502408UL, 602888UL, 723464UL,
+	868152UL, 1041784UL, 1250136UL, 1500160UL, 1800192UL, 2160232UL,
+	2592280UL, 3110736UL, 3732880UL, 4479456UL, 5375344UL, 6450408UL,
+	7740496UL, 9288592UL, 11146312UL, 13375568UL, 16050680UL, 19260816UL,
+	23112984UL, 27735576UL, 33282688UL, 39939224UL, 47927072UL,
+	57512488UL, 69014984UL, 82817976UL, 99381576UL, 119257888UL,
+	143109472UL, 171731360UL, 206077632UL, 247293152UL, 296751776UL,
+	356102144UL, 427322560UL, 512787072UL, 615344512UL, 738413376UL,
+	886096064UL, 1063315264UL
+};
 
-size_t hoardHeap::_threshold[hoardHeap::SIZE_CLASSES] = {4096UL, 2048UL, 1364UL, 1024UL, 816UL, 680UL, 584UL, 452UL, 408UL, 340UL, 272UL, 224UL, 192UL, 160UL, 136UL, 112UL, 92UL, 76UL, 64UL, 52UL, 44UL, 36UL, 32UL, 24UL, 20UL, 16UL, 12UL, 12UL, 8UL, 8UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL}; 
+size_t hoardHeap::_threshold[hoardHeap::SIZE_CLASSES] = {
+	4096UL, 2048UL, 1364UL, 1024UL, 816UL, 680UL, 584UL, 452UL, 408UL,
+	340UL, 272UL, 224UL, 192UL, 160UL, 136UL, 112UL, 92UL, 76UL, 64UL,
+	52UL, 44UL, 36UL, 32UL, 24UL, 20UL, 16UL, 12UL, 12UL, 8UL, 8UL, 4UL,
+	4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL,
+	4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL,
+	4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL,
+	4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL,
+	4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL
+};
 
 #elif (MAX_INTERNAL_FRAGMENTATION == 6)
 
-size_t hoardHeap::_sizeTable[hoardHeap::SIZE_CLASSES] = {8UL, 16UL, 24UL, 32UL, 48UL, 72UL, 112UL, 176UL, 288UL, 456UL, 728UL, 1160UL, 1848UL, 2952UL, 4728UL, 7560UL, 12096UL, 19344UL, 30952UL, 49520UL, 79232UL, 126768UL, 202832UL, 324520UL, 519232UL, 830768UL, 1329232UL, 2126768UL, 3402824UL, 5444520UL, 8711232UL, 13937968UL, 22300752UL, 35681200UL, 57089912UL, 91343856UL, 146150176UL, 233840256UL, 374144416UL, 598631040UL, 957809728UL, 1532495488UL}; 
+size_t hoardHeap::_sizeTable[hoardHeap::SIZE_CLASSES] = {
+	8UL, 16UL, 24UL, 32UL, 48UL, 72UL, 112UL, 176UL, 288UL, 456UL, 728UL,
+	1160UL, 1848UL, 2952UL, 4728UL, 7560UL, 12096UL, 19344UL, 30952UL,
+	49520UL, 79232UL, 126768UL, 202832UL, 324520UL, 519232UL, 830768UL,
+	1329232UL, 2126768UL, 3402824UL, 5444520UL, 8711232UL, 13937968UL,
+	22300752UL, 35681200UL, 57089912UL, 91343856UL, 146150176UL,
+	233840256UL, 374144416UL, 598631040UL, 957809728UL, 1532495488UL
+};
 
-size_t hoardHeap::_threshold[hoardHeap::SIZE_CLASSES] = {4096UL, 2048UL, 1364UL, 1024UL, 680UL, 452UL, 292UL, 184UL, 112UL, 68UL, 44UL, 28UL, 16UL, 8UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL}; 
+size_t hoardHeap::_threshold[hoardHeap::SIZE_CLASSES] = {
+	4096UL, 2048UL, 1364UL, 1024UL, 680UL, 452UL, 292UL, 184UL, 112UL, 68UL,
+	44UL, 28UL, 16UL, 8UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL,
+	4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL,
+	4UL, 4UL, 4UL, 4UL, 4UL
+};
 
 #elif (MAX_INTERNAL_FRAGMENTATION == 10)
 
-size_t hoardHeap::_sizeTable[hoardHeap::SIZE_CLASSES] = {8UL, 16UL, 32UL, 64UL, 128UL, 256UL, 512UL, 1024UL, 2048UL, 4096UL, 8192UL, 16384UL, 32768UL, 65536UL, 131072UL, 262144UL, 524288UL, 1048576UL, 2097152UL, 4194304UL, 8388608UL, 16777216UL, 33554432UL, 67108864UL, 134217728UL, 268435456UL, 536870912UL, 1073741824UL, 2147483648UL}; 
+size_t hoardHeap::_sizeTable[hoardHeap::SIZE_CLASSES] = {
+	8UL, 16UL, 32UL, 64UL, 128UL, 256UL, 512UL, 1024UL, 2048UL, 4096UL,
+	8192UL, 16384UL, 32768UL, 65536UL, 131072UL, 262144UL, 524288UL,
+	1048576UL, 2097152UL, 4194304UL, 8388608UL, 16777216UL, 33554432UL,
+	67108864UL, 134217728UL, 268435456UL, 536870912UL, 1073741824UL,
+	2147483648UL
+};
 
-size_t hoardHeap::_threshold[hoardHeap::SIZE_CLASSES] = {4096UL, 2048UL, 1024UL, 512UL, 256UL, 128UL, 64UL, 32UL, 16UL, 8UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL}; 
+size_t hoardHeap::_threshold[hoardHeap::SIZE_CLASSES] = {
+	4096UL, 2048UL, 1024UL, 512UL, 256UL, 128UL, 64UL, 32UL, 16UL, 8UL, 4UL,
+	4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL, 4UL,
+	4UL, 4UL, 4UL, 4UL
+};
 
 #else
 #	error "Undefined size class base."
@@ -53,30 +101,31 @@ size_t hoardHeap::_threshold[hoardHeap::SIZE_CLASSES] = {4096UL, 2048UL, 1024UL,
 
 
 hoardHeap::hoardHeap(void)
-  : _index (0),
+	:
-    _reusableSuperblocks (NULL),
+	_index(0), _reusableSuperblocks(NULL), _reusableSuperblocksCount(0)
-    _reusableSuperblocksCount (0)
 #if HEAP_DEBUG
 	, _magic(HEAP_MAGIC)
 #endif
 {
 	// Initialize the per-heap lock.
 	hoardLockInit(_lock, "hoard heap");
+
 	for (int i = 0; i < SUPERBLOCK_FULLNESS_GROUP; i++) {
 		for (int j = 0; j < SIZE_CLASSES; j++) {
 			// Initialize all superblocks lists to empty.
 			_superblocks[i][j] = NULL;
 		}
 	}
+
 	for (int k = 0; k < SIZE_CLASSES; k++) {
 		_leastEmptyBin[k] = 0;
 	}
 }
 
 
-void hoardHeap::insertSuperblock (int sizeclass,
+void
-				  superblock * sb,
+hoardHeap::insertSuperblock(int sizeclass,
-				  processHeap * pHeap)
+	superblock *sb, processHeap *pHeap)
 {
 	assert(sb->isValid());
 	assert(sb->getBlockSizeClass() == sizeclass);
@@ -93,38 +142,38 @@ void hoardHeap::insertSuperblock (int sizeclass,
 	int fullness = sb->getFullness();
 
 	// Update the stats.
-  incStats (sizeclass,
+	incStats(sizeclass, sb->getNumBlocks() - sb->getNumAvailable(),
-	    sb->getNumBlocks() - sb->getNumAvailable(),
 		sb->getNumBlocks());
 
-  if ((fullness == 0) &&
+	if (fullness == 0
-      (sb->getNumBlocks() > 1) &&
+		&& sb->getNumBlocks() > 1
-      (sb->getNumBlocks() == sb->getNumAvailable())) {
+		&& sb->getNumBlocks() == sb->getNumAvailable()) {
 		// Recycle this superblock.
 #if 0
 		removeSuperblock(sb, sizeclass);
 		// Update the stats.
 		decStats(sizeclass,
-	      sb->getNumBlocks() - sb->getNumAvailable(),
+				 sb->getNumBlocks() - sb->getNumAvailable(), sb->getNumBlocks());
-	      sb->getNumBlocks());
 		// Free it immediately.
 		const size_t s = sizeFromClass(sizeclass);
 		const int blksize = align(sizeof(block) + s);
 #if HEAP_LOG
 		// Record the memory deallocation.
 		MemoryRequest m;
-    m.deallocate ((int) sb->getNumBlocks() * (int) sizeFromClass(sb->getBlockSizeClass()));
+		m.deallocate((int)sb->getNumBlocks() *
+					 (int)sizeFromClass(sb->getBlockSizeClass()));
 		pHeap->getLog(getIndex()).append(m);
 #endif
 #if HEAP_FRAG_STATS
+
 		pHeap->setDeallocated(0, sb->getNumBlocks() * sizeFromClass(sb->getBlockSizeClass()));
 #endif
+
 		hoardUnsbrk(sb, align(sizeof(superblock) + blksize));
 #else
 		recycle(sb);
 #endif
 	} else {
-
 		// Insert it into the appropriate list.
 		superblock *&head = _superblocks[fullness][sizeclass];
 		sb->insertBefore(head);
@@ -137,7 +186,8 @@ void hoardHeap::insertSuperblock (int sizeclass,
 }
 
 
-superblock * hoardHeap::removeMaxSuperblock (int sizeclass)
+superblock *
+hoardHeap::removeMaxSuperblock(int sizeclass)
 {
 	assert(_magic == HEAP_MAGIC);
 
@@ -169,15 +219,14 @@ superblock * hoardHeap::removeMaxSuperblock (int sizeclass)
 	// we never need to check it. But for robustness, we leave it in.
 	while (i < SUPERBLOCK_FULLNESS_GROUP) {
 		head = _superblocks[i][sizeclass];
-    if (head) {
+		if (head)
 			break;
-    }
+
 		i++;
 	}
 
-  if (!head) {
+	if (!head)
 		return NULL;
-  }
 
 	// Make sure that this superblock is at least 1/EMPTY_FRACTION
 	// empty.
@@ -192,8 +241,8 @@ superblock * hoardHeap::removeMaxSuperblock (int sizeclass)
 }
 
 
-void hoardHeap::removeSuperblock (superblock * sb,
+void
-				  int sizeclass)
+hoardHeap::removeSuperblock(superblock *sb, int sizeclass)
 {
 	assert(_magic == HEAP_MAGIC);
 
@@ -212,14 +261,14 @@ void hoardHeap::removeSuperblock (superblock * sb,
 	}
 
 	sb->remove();
-  decStats (sizeclass, sb->getNumBlocks() - sb->getNumAvailable(), sb->getNumBlocks());
+	decStats(sizeclass, sb->getNumBlocks() - sb->getNumAvailable(),
+		sb->getNumBlocks());
 }
 
 
-void hoardHeap::moveSuperblock (superblock * sb,
+void
-				int sizeclass,
+hoardHeap::moveSuperblock(superblock *sb,
-				int fromBin,
+	int sizeclass, int fromBin, int toBin)
-				int toBin)
 {
 	assert(_magic == HEAP_MAGIC);
 	assert(sb->isValid());
@@ -253,10 +302,9 @@ void hoardHeap::moveSuperblock (superblock * sb,
 
 // The heap lock must be held when this procedure is called.
 
-int hoardHeap::freeBlock (block *& b,
+int
-			   superblock *& sb,
+hoardHeap::freeBlock(block * &b, superblock * &sb,
-			   int sizeclass,
+	int sizeclass, processHeap *pHeap)
-			   processHeap * pHeap)
 {
 	assert(sb->isValid());
 	assert(b->isValid());
@@ -275,11 +323,13 @@ int hoardHeap::freeBlock (block *& b,
 #if HEAP_LOG
 		// Record the memory deallocation.
 		MemoryRequest m;
-    m.deallocate ((int) sb->getNumBlocks() * (int) sizeFromClass(sb->getBlockSizeClass()));
+		m.deallocate((int)sb->getNumBlocks()
+			* (int)sizeFromClass(sb->getBlockSizeClass()));
 		pHeap->getLog(getIndex()).append(m);
 #endif
 #if HEAP_FRAG_STATS
-    pHeap->setDeallocated (0, sb->getNumBlocks() * sizeFromClass(sb->getBlockSizeClass()));
+		pHeap->setDeallocated(0,
+			sb->getNumBlocks() * sizeFromClass(sb->getBlockSizeClass()));
 #endif
 		hoardUnsbrk(sb, align(sizeof(superblock) + blksize));
 		return 1;
@@ -301,8 +351,7 @@ int hoardHeap::freeBlock (block *& b,
 
 	// If the superblock is now empty, recycle it.
 
-  if ((newFullness == 0) &&
+	if ((newFullness == 0) && (sb->getNumBlocks() == sb->getNumAvailable())) {
-      (sb->getNumBlocks() == sb->getNumAvailable())) {
 		removeSuperblock(sb, sizeclass);
 #if 0
 		// Free it immediately.
@@ -311,12 +360,15 @@ int hoardHeap::freeBlock (block *& b,
 #if HEAP_LOG
 		// Record the memory deallocation.
 		MemoryRequest m;
-    m.deallocate ((int) sb->getNumBlocks() * (int) sizeFromClass(sb->getBlockSizeClass()));
+		m.deallocate((int)sb->getNumBlocks()
+			* (int)sizeFromClass(sb->getBlockSizeClass()));
 		pHeap->getLog(getIndex()).append(m);
 #endif
 #if HEAP_FRAG_STATS
-    pHeap->setDeallocated (0, sb->getNumBlocks() * sizeFromClass(sb->getBlockSizeClass()));
+		pHeap->setDeallocated(0,
+			sb->getNumBlocks() * sizeFromClass(sb->getBlockSizeClass()));
 #endif
+
 		hoardUnsbrk(sb, align(sizeof(superblock) + blksize));
 		return 1;
 #else
@@ -324,15 +376,13 @@ int hoardHeap::freeBlock (block *& b,
 		// Update the stats.  This restores the stats to their state
 		// before the call to removeSuperblock, above.
 		incStats(sizeclass,
-	      sb->getNumBlocks() - sb->getNumAvailable(),
+			sb->getNumBlocks() - sb->getNumAvailable(), sb->getNumBlocks());
-	      sb->getNumBlocks());
 #endif
 	}
 
 	// If this is the process heap, then we're done.
-  if (this == (hoardHeap *) pHeap) {
+	if (this == (hoardHeap *)pHeap)
 		return 0;
-  }
 
 	//
 	// Release a superblock, if necessary.
@@ -350,7 +400,8 @@ int hoardHeap::freeBlock (block *& b,
 		int inUse, allocated;
 		getStats(sizeclass, inUse, allocated);
 		if ((inUse < allocated - getReleaseThreshold(sizeclass))
-	&& (EMPTY_FRACTION * inUse < EMPTY_FRACTION * allocated - allocated)) {
+			&& (EMPTY_FRACTION * inUse <
+				EMPTY_FRACTION * allocated - allocated)) {
 
 			// We've crossed the magical threshold. Find the superblock with
 			// the most free blocks and give it to the process heap.
@@ -363,7 +414,6 @@ int hoardHeap::freeBlock (block *& b,
 
 			// Give the superblock back to the process heap.
 			pHeap->release(maxSb);
-      
 		}
 	}
 
@@ -378,7 +428,8 @@ int hoardHeap::_numProcessorsMask;
 hoardHeap::_initNumProcs::_initNumProcs(void)
 {
 	hoardHeap::_numProcessors = hoardGetNumProcessors();
-  hoardHeap::_numProcessorsMask = (1 << (lg(hoardGetNumProcessors()) + 1)) - 1;
+	hoardHeap::_numProcessorsMask =
+		(1 << (lg(hoardGetNumProcessors()) + 1)) - 1;
 }
 
 static hoardHeap::_initNumProcs initProcs;

src/kernel/libroot/posix/malloc/heap.h

@@ -30,13 +30,13 @@
 #include "superblock.h"
 #include "heapstats.h"
 
-class processHeap; // forward declaration
 
+namespace BPrivate {
+
+class processHeap;
 
 class hoardHeap {
-
 	public:
-
 		hoardHeap(void);
 
 		// A superblock that holds more than one object must hold at least
@@ -105,17 +105,14 @@ public:
 #endif
 
 		// Insert a superblock into our list.
-  void insertSuperblock (int sizeclass,
+		void insertSuperblock(int sizeclass, superblock *sb, processHeap *pHeap);
-			 superblock * sb,
-			 processHeap * pHeap);
 
 		// Remove the superblock with the most free space.
 		superblock *removeMaxSuperblock(int sizeclass);
 
 		// Find an available superblock (i.e., with some space in it).
 		inline superblock *findAvailableSuperblock(int sizeclass,
-					       block *& b,
+								block * &b, processHeap * pHeap);
-					       processHeap * pHeap);
 
 		// Lock this heap.
 		inline void lock(void);
@@ -132,9 +129,7 @@ public:
 		// Free a block into a superblock.
 		// This is used by processHeap::free().
 		// Returns 1 iff the superblock was munmapped.
-  int freeBlock (block *& b,
+		int freeBlock(block * &b, superblock * &sb, int sizeclass,
-		 superblock *& sb,
-		 int sizeclass,
 				processHeap * pHeap);
 
 		//// Utility functions ////
@@ -155,7 +150,6 @@ public:
 		inline static size_t align(const size_t sz);
 
 	private:
-
 		// Disable copying and assignment.
 
 		hoardHeap(const hoardHeap &);
@@ -172,9 +166,7 @@ private:
 
 		// Move a particular superblock from one bin to another.
 		void moveSuperblock(superblock *,
-		       int sizeclass,
+							int sizeclass, int fromBin, int toBin);
-		       int fromBin,
-		       int toBin);
 
 		// Update memory in-use and allocated statistics.
 		// (*UStats = just update U.)
@@ -226,6 +218,7 @@ public:
 		};
 
 		friend class _initNumProcs;
+
 	protected:
 		// number of CPUs, cached
 		static int _numProcessors;
@@ -234,7 +227,9 @@ protected:
 
 
 
-void hoardHeap::incStats (int sizeclass, int updateU, int updateA) {
+void
+hoardHeap::incStats(int sizeclass, int updateU, int updateA)
+{
 	assert(_magic == HEAP_MAGIC);
 	assert(updateU >= 0);
 	assert(updateA >= 0);
@@ -244,8 +239,9 @@ void hoardHeap::incStats (int sizeclass, int updateU, int updateA) {
 }
 
 
-
+void
-void hoardHeap::incUStats (int sizeclass) {
+hoardHeap::incUStats(int sizeclass)
+{
 	assert(_magic == HEAP_MAGIC);
 	assert(sizeclass >= 0);
 	assert(sizeclass < SIZE_CLASSES);
@@ -253,7 +249,9 @@ void hoardHeap::incUStats (int sizeclass) {
 }
 
 
-void hoardHeap::decStats (int sizeclass, int updateU, int updateA) {
+void
+hoardHeap::decStats(int sizeclass, int updateU, int updateA)
+{
 	assert(_magic == HEAP_MAGIC);
 	assert(updateU >= 0);
 	assert(updateA >= 0);
@@ -263,7 +261,8 @@ void hoardHeap::decStats (int sizeclass, int updateU, int updateA) {
 }
 
 
-void hoardHeap::decUStats (int sizeclass)
+void
+hoardHeap::decUStats(int sizeclass)
 {
 	assert(_magic == HEAP_MAGIC);
 	assert(sizeclass >= 0);
@@ -272,7 +271,9 @@ void hoardHeap::decUStats (int sizeclass)
 }
 
 
-void hoardHeap::getStats (int sizeclass, int& U, int& A) {
+void
+hoardHeap::getStats(int sizeclass, int &U, int &A)
+{
 	assert(_magic == HEAP_MAGIC);
 	assert(sizeclass >= 0);
 	assert(sizeclass < SIZE_CLASSES);
@@ -281,22 +282,26 @@ void hoardHeap::getStats (int sizeclass, int& U, int& A) {
 
 
 #if HEAP_STATS
-int hoardHeap::maxInUse (int sizeclass) {
+int
+hoardHeap::maxInUse(int sizeclass)
+{
 	assert(_magic == HEAP_MAGIC);
 	return _stats[sizeclass].getUmax();
 }
 
 
-int hoardHeap::maxAllocated (int sizeclass) {
+int
+hoardHeap::maxAllocated(int sizeclass)
+{
 	assert(_magic == HEAP_MAGIC);
 	return _stats[sizeclass].getAmax();
 }
-#endif
+#endif	// HEAP_STATS
 
 
-superblock * hoardHeap::findAvailableSuperblock (int sizeclass,
+superblock *
-						 block *& b,
+hoardHeap::findAvailableSuperblock(int sizeclass,
-						 processHeap * pHeap)
+	block * &b, processHeap * pHeap)
 {
 	assert(this);
 	assert(_magic == HEAP_MAGIC);
@@ -373,7 +378,6 @@ superblock * hoardHeap::findAvailableSuperblock (int sizeclass,
 			}
 		}
 	}
-
 	// Either we didn't find a superblock or we did and got a block.
 	assert((sb == NULL) || (b != NULL));
 	// Either we didn't get a block or we did and we also got a superblock.
@@ -383,12 +387,13 @@ superblock * hoardHeap::findAvailableSuperblock (int sizeclass,
 }
 
 
-int hoardHeap::sizeClass (const size_t sz) {
+int
+hoardHeap::sizeClass(const size_t sz)
+{
 	// Find the size class for a given object size
 	// (the smallest i such that _sizeTable[i] >= sz).
 	int sizeclass = 0;
-  while (_sizeTable[sizeclass] < sz)
+	while (_sizeTable[sizeclass] < sz) {
-    {
 		sizeclass++;
 		assert(sizeclass < SIZE_CLASSES);
 	}
@@ -396,21 +401,27 @@ int hoardHeap::sizeClass (const size_t sz) {
 }
 
 
-size_t hoardHeap::sizeFromClass (const int sizeclass) {
+size_t
+hoardHeap::sizeFromClass(const int sizeclass)
+{
 	assert(sizeclass >= 0);
 	assert(sizeclass < SIZE_CLASSES);
 	return _sizeTable[sizeclass];
 }
 
 
-int hoardHeap::getReleaseThreshold (const int sizeclass) {
+int
+hoardHeap::getReleaseThreshold(const int sizeclass)
+{
 	assert(sizeclass >= 0);
 	assert(sizeclass < SIZE_CLASSES);
 	return _threshold[sizeclass];
 }
 
 
-int hoardHeap::numBlocks (const int sizeclass) {
+int
+hoardHeap::numBlocks(const int sizeclass)
+{
 	assert(sizeclass >= 0);
 	assert(sizeclass < SIZE_CLASSES);
 	const size_t s = sizeFromClass(sizeclass);
@@ -422,20 +433,24 @@ int hoardHeap::numBlocks (const int sizeclass) {
 }
 
 
-void hoardHeap::lock (void)
+void
+hoardHeap::lock(void)
 {
 	assert(_magic == HEAP_MAGIC);
 	hoardLock(_lock);
 }
 
 
-void hoardHeap::unlock (void) {
+void
+hoardHeap::unlock(void)
+{
 	assert(_magic == HEAP_MAGIC);
 	hoardUnlock(_lock);
 }
 
 
-size_t hoardHeap::align (const size_t sz)
+size_t
+hoardHeap::align(const size_t sz)
 {
 	// Align sz up to the nearest multiple of ALIGNMENT.
 	// This is much faster than using multiplication
@@ -444,21 +459,22 @@ size_t hoardHeap::align (const size_t sz)
 }
 
 
-void hoardHeap::setIndex (int i)
+void
+hoardHeap::setIndex(int i)
 {
 	_index = i;
 }
 
 
-int hoardHeap::getIndex (void)
+int
+hoardHeap::getIndex(void)
 {
 	return _index;
 }
 
 
-
+void
-
+hoardHeap::recycle(superblock *sb)
-void hoardHeap::recycle (superblock * sb)
 {
 	assert(sb != NULL);
 	assert(sb->getOwner() == this);
@@ -473,17 +489,16 @@ void hoardHeap::recycle (superblock * sb)
 }
 
 
-superblock * hoardHeap::reuse (int sizeclass)
+superblock *
+hoardHeap::reuse(int sizeclass)
 {
-  if (_reusableSuperblocks == NULL) {
+	if (_reusableSuperblocks == NULL)
 		return NULL;
-  }
 
 	// Make sure that we aren't using a sizeclass
 	// that is too big for a 'normal' superblock.
-  if (hoardHeap::numBlocks(sizeclass) <= 1) {
+	if (hoardHeap::numBlocks(sizeclass) <= 1)
 		return NULL;
-  }
 
 	// Pop off a superblock from the reusable-superblock list.
 	assert(_reusableSuperblocksCount > 0);
@@ -499,7 +514,8 @@ superblock * hoardHeap::reuse (int sizeclass)
 			sb->getNumBlocks() - sb->getNumAvailable(),
 			sb->getNumBlocks());
 
-    sb = new ((char *) sb) superblock (numBlocks(sizeclass), sizeclass, this);
+		sb = new((char *)sb) superblock(numBlocks(sizeclass),
+			sizeclass, this);
 
 		incStats(sizeclass,
 			sb->getNumBlocks() - sb->getNumAvailable(),
@@ -511,4 +527,6 @@ superblock * hoardHeap::reuse (int sizeclass)
 	return sb;
 }
 
+}	// namespace BPrivate
+
 #endif // _HEAP_H_

src/kernel/libroot/posix/malloc/heapstats.h

@@ -27,16 +27,13 @@
 
 class heapStats {
 	public:
-
 		heapStats(void)
-    :
+			: U(0), A(0)
-    U (0),
-    A (0)
 #if HEAP_STATS
-    ,Umax (0),
+			, Umax(0), Amax(0)
-    Amax (0)
 #endif
-  {}
+		{
+		}
 
 		inline const heapStats & operator=(const heapStats & p);
 
@@ -49,17 +46,12 @@ public:
 
 		inline void getStats(int &Uout, int &Aout);
 
-
 #if HEAP_STATS
-
 		inline int getUmax(void);
 		inline int getAmax(void);
-
 #endif
 
-
 	private:
-
 		// U and A *must* be the first items in this class --
 		// we will depend on this to atomically update them.
 
@@ -73,7 +65,8 @@ private:
 };
 
 
-inline void heapStats::incStats (int updateU, int updateA)
+inline void
+heapStats::incStats(int updateU, int updateA)
 {
 	assert(updateU >= 0);
 	assert(updateA >= 0);
@@ -82,31 +75,37 @@ inline void heapStats::incStats (int updateU, int updateA)
 	assert(A >= 0);
 	U += updateU;
 	A += updateA;
+
 #if HEAP_STATS
 	Amax = MAX(Amax, A);
 	Umax = MAX(Umax, U);
 #endif
+
 	assert(U <= A);
 	assert(U >= 0);
 	assert(A >= 0);
 }
 
 
-inline void heapStats::incUStats (void)
+inline void
+heapStats::incUStats(void)
 {
 	assert(U < A);
 	assert(U >= 0);
 	assert(A >= 0);
 	U++;
+
 #if HEAP_STATS
 	Umax = MAX(Umax, U);
 #endif
+
 	assert(U >= 0);
 	assert(A >= 0);
 }
 
 
-inline void heapStats::decStats (int updateU, int updateA)
+inline void
+heapStats::decStats(int updateU, int updateA)
 {
 	assert(updateU >= 0);
 	assert(updateA >= 0);
@@ -121,7 +120,8 @@ inline void heapStats::decStats (int updateU, int updateA)
 }
 
 
-inline void heapStats::decUStats (int& Uout, int& Aout)
+inline void
+heapStats::decUStats(int &Uout, int &Aout)
 {
 	assert(U <= A);
 	assert(U > 0);
@@ -134,7 +134,8 @@ inline void heapStats::decUStats (int& Uout, int& Aout)
 }
 
 
-inline void heapStats::decUStats (void)
+inline void
+heapStats::decUStats(void)
 {
 	assert(U <= A);
 	assert(U > 0);
@@ -143,7 +144,8 @@ inline void heapStats::decUStats (void)
 }
 
 
-inline void heapStats::getStats (int& Uout, int& Aout)
+inline void
+heapStats::getStats(int &Uout, int &Aout)
 {
 	assert(U >= 0);
 	assert(A >= 0);
@@ -156,18 +158,18 @@ inline void heapStats::getStats (int& Uout, int& Aout)
 
 
 #if HEAP_STATS
-inline int heapStats::getUmax (void)
+inline int
+heapStats::getUmax(void)
 {
 	return Umax;
 }
 
 
-inline int heapStats::getAmax (void)
+inline int
+heapStats::getAmax(void)
 {
 	return Amax;
 }
 #endif // HEAP_STATS
 
-
-
 #endif // _HEAPSTATS_H_

src/kernel/libroot/posix/malloc/processheap.cpp

@@ -32,16 +32,15 @@
 
 #include "processheap.h"
 
+using namespace BPrivate;
+
 
 processHeap::processHeap(void)
-  : _buffer (NULL),
+	: _buffer(NULL), _bufferCount(0)
-    _bufferCount (0)
 #if HEAP_FRAG_STATS
 	, _currentAllocated(0),
 	_currentRequested(0),
-  _maxAllocated (0),
+	_maxAllocated(0), _inUseAtMaxAllocated(0), _maxRequested(0)
-  _inUseAtMaxAllocated (0),
-  _maxRequested (0)
 #endif
 {
 	int i;
@@ -69,7 +68,9 @@ processHeap::processHeap (void)
 
 
 // Print out statistics information.
-void processHeap::stats (void) {
+void
+processHeap::stats(void)
+{
 #if HEAP_STATS
 	int umax = 0;
 	int amax = 0;
@@ -80,16 +81,20 @@ void processHeap::stats (void) {
 		}
 	}
 	printf("Amax <= %d, Umax <= %d\n", amax, umax);
+
 #if HEAP_FRAG_STATS
 	amax = getMaxAllocated();
 	umax = getMaxRequested();
-  printf ("Maximum allocated = %d\nMaximum in use = %d\nIn use at max allocated = %d\n", amax, umax, getInUseAtMaxAllocated());
+	printf
+	("Maximum allocated = %d\nMaximum in use = %d\nIn use at max allocated = %d\n",
+	 amax, umax, getInUseAtMaxAllocated());
 	printf("Still in use = %d\n", _currentRequested);
-  printf ("Fragmentation (3) = %f\n", (float) amax / (float) getInUseAtMaxAllocated());
+	printf("Fragmentation (3) = %f\n",
+		   (float)amax / (float)getInUseAtMaxAllocated());
 	printf("Fragmentation (4) = %f\n", (float)amax / (float)umax);
 #endif
-
 #endif // HEAP_STATS
+
 #if HEAP_LOG
 	printf("closing logs.\n");
 	fflush(stdout);
@@ -100,10 +105,9 @@ void processHeap::stats (void) {
 }
 
 
-
 #if HEAP_FRAG_STATS
-void processHeap::setAllocated (int requestedSize,
+void
-				int actualSize)
+processHeap::setAllocated(int requestedSize, int actualSize)
 {
 	hoardLock(_statsLock);
 	_currentRequested += requestedSize;
@@ -119,15 +123,15 @@ void processHeap::setAllocated (int requestedSize,
 }
 
 
-void processHeap::setDeallocated (int requestedSize,
+void
-				  int actualSize)
+processHeap::setDeallocated(int requestedSize, int actualSize)
 {
 	hoardLock(_statsLock);
 	_currentRequested -= requestedSize;
 	_currentAllocated -= actualSize;
 	hoardUnlock(_statsLock);
 }
-#endif
+#endif	// HEAP_FRAG_STATS
 
 
 // free (ptr, pheap):
@@ -136,14 +140,13 @@ void processHeap::setDeallocated (int requestedSize,
 //                 updates the thread heap's statistics;
 //                 may release the superblock to the process heap.
 
-void processHeap::free (void * ptr)
+void
+processHeap::free(void *ptr)
 {
-
 	// Return if ptr is 0.
 	// This is the behavior prescribed by the standard.
-  if (ptr == 0) {
+	if (ptr == 0)
 		return;
-  }
 
 	// Find the block and superblock corresponding to this ptr.
 
@@ -203,7 +206,6 @@ void processHeap::free (void * ptr)
 	int sbUnmapped = owner->freeBlock(b, sb, sizeclass, this);
 
 	owner->unlock();
-  if (!sbUnmapped) {
+	if (!sbUnmapped)
 		sb->upUnlock();
 }
-}

src/kernel/libroot/posix/malloc/processheap.h

@@ -42,22 +42,22 @@
 #	include "log.h"
 #endif
 
+
+namespace BPrivate {
+
 class processHeap : public hoardHeap {
-
 	public:
-
 		// Always grab at least this many superblocks' worth of memory which
 		// we parcel out.
 		enum { REFILL_NUMBER_OF_SUPERBLOCKS = 16 };
 
 		processHeap(void);
-
+		~processHeap(void)
-  ~processHeap (void) {
+		{
 #if HEAP_STATS
 			stats();
 #endif
 		}
-
 		// Memory deallocation routines.
 		void free(void *ptr);
 
@@ -71,8 +71,7 @@ public:
 		inline HEAPTYPE & getHeap(int i);
 
 		// Extract a superblock.
-  inline superblock * acquire (const int c,
+		inline superblock *acquire(const int c, hoardHeap * dest);
-			       hoardHeap * dest);
 
 		// Get space for a superblock.
 		inline char *getSuperblockBuffer(void);
@@ -87,40 +86,45 @@ public:
 
 #if HEAP_FRAG_STATS
 		// Declare that we have allocated an object.
-  void setAllocated (int requestedSize,
+		void setAllocated(int requestedSize, int actualSize);
-		     int actualSize);
 
 		// Declare that we have deallocated an object.
-  void setDeallocated (int requestedSize,
+		void setDeallocated(int requestedSize, int actualSize);
-		       int actualSize);
 
 		// Return the number of wasted bytes at the high-water mark
 		// (maxAllocated - maxRequested)
 		inline int getFragmentation(void);
 
-  int getMaxAllocated (void) {
+		int
+		getMaxAllocated(void)
+		{
 			return _maxAllocated;
 		}
 
-  int getInUseAtMaxAllocated (void) {
+		int
+		getInUseAtMaxAllocated(void)
+		{
 			return _inUseAtMaxAllocated;
 		}
 
-  int getMaxRequested (void) {
+		int
+		getMaxRequested(void)
+		{
 			return _maxRequested;
 		}
-
 #endif
 
 	private:
-
 		// Hide the lock & unlock methods.
-
+		void
-  void lock (void) {
+		lock(void)
+		{
 			hoardHeap::lock();
 		}
 
-  void unlock (void) {
+		void
+		unlock(void)
+		{
 			hoardHeap::unlock();
 		}
 
@@ -159,7 +163,8 @@ private:
 };
 
 
-HEAPTYPE& processHeap::getHeap (int i)
+HEAPTYPE &
+processHeap::getHeap(int i)
 {
 	assert(i >= 0);
 	assert(i < MAX_HEAPS);
@@ -168,7 +173,8 @@ HEAPTYPE& processHeap::getHeap (int i)
 
 
 #if HEAP_LOG
-Log<MemoryRequest>& processHeap::getLog (int i)
+Log<MemoryRequest > &
+processHeap::getLog(int i)
 {
 	assert(i >= 0);
 	assert(i < MAX_HEAPS + 1);
@@ -180,7 +186,8 @@ Log<MemoryRequest>& processHeap::getLog (int i)
 #ifdef NEED_LG
 // Return ceil(log_2(num)).
 // num must be positive.
-static int lg (int num)
+static int
+lg(int num)
 {
 	assert(num > 0);
 	int power = 0;
@@ -195,7 +202,10 @@ static int lg (int num)
 #endif /* NEED_LG */
 
 // Hash out the thread id to a heap and return an index to that heap.
-int processHeap::getHeapIndex (void) {
+
+int
+processHeap::getHeapIndex(void)
+{
 	// Here we use the number of processors as the maximum number of heaps.
 	// In fact, for efficiency, we just round up to the highest power of two,
 	// times two.
@@ -205,16 +215,15 @@ int processHeap::getHeapIndex (void) {
 }
 
 
-superblock * processHeap::acquire (const int sizeclass,
+superblock *
-				   hoardHeap * dest)
+processHeap::acquire(const int sizeclass, hoardHeap * dest)
 {
 	lock();
 
 	// Remove the superblock with the most free space.
 	superblock *maxSb = removeMaxSuperblock(sizeclass);
-  if (maxSb) {
+	if (maxSb)
 		maxSb->setOwner(dest);
-  }
 
 	unlock();
 
@@ -222,24 +231,30 @@ superblock * processHeap::acquire (const int sizeclass,
 }
 
 
-inline char * processHeap::getSuperblockBuffer (void)
+inline char *
+processHeap::getSuperblockBuffer(void)
 {
 	char *buf;
 	hoardLock(_bufferLock);
 	if (_bufferCount == 0) {
-    _buffer = (char *) hoardSbrk (SUPERBLOCK_SIZE * REFILL_NUMBER_OF_SUPERBLOCKS);
+		_buffer = (char *)hoardSbrk(SUPERBLOCK_SIZE
+			* REFILL_NUMBER_OF_SUPERBLOCKS);
 		_bufferCount = REFILL_NUMBER_OF_SUPERBLOCKS;
 	}
+
 	buf = _buffer;
 	_buffer += SUPERBLOCK_SIZE;
 	_bufferCount--;
 	hoardUnlock(_bufferLock);
+
 	return buf;
 }
 
 
 // Put a superblock back into our list of superblocks.
-void processHeap::release (superblock * sb)
+
+void
+processHeap::release(superblock *sb)
 {
 	assert(EMPTY_FRACTION * sb->getNumAvailable() > sb->getNumBlocks());
 
@@ -251,6 +266,6 @@ void processHeap::release (superblock * sb)
 	unlock();
 }
 
+}	// namespace BPrivate
 
 #endif // _PROCESSHEAP_H_
-

src/kernel/libroot/posix/malloc/superblock.cpp

@@ -22,7 +22,7 @@
   The superblock class controls a number of blocks (which are
   allocatable units of memory).
   ------------------------------------------------------------------------
-  @(#) $Id: superblock.cpp,v 1.2 2005/02/10 18:47:16 axeld Exp $
+  @(#) $Id$
   ------------------------------------------------------------------------
   Emery Berger                    | <http://www.cs.utexas.edu/users/emery>
   Department of Computer Sciences |             <http://www.cs.utexas.edu>
@@ -39,6 +39,8 @@
 #include "processheap.h"
 #include "superblock.h"
 
+using namespace BPrivate;
+
 
 superblock::superblock(int numBlocks,	// The number of blocks in the sb.
                        int szclass,		// The size class of the blocks.
@@ -50,24 +52,19 @@ superblock::superblock (int numBlocks,	// The number of blocks in the sb.
 	_sizeClass(szclass),
 	_numBlocks(numBlocks),
 	_numAvailable(0),
-    _fullness (0),
+	_fullness(0), _freeList(NULL), _owner(o), _next(NULL), _prev(NULL)
-    _freeList (NULL),
-    _owner (o),
-    _next (NULL),
-    _prev (NULL)
 {
 	assert(_numBlocks >= 1);
 
 	// Determine the size of each block.
-  const int blksize =
+	const int blksize = hoardHeap::align(sizeof(block)
-    hoardHeap::align (sizeof(block) + hoardHeap::sizeFromClass(_sizeClass));
+		+ hoardHeap::sizeFromClass(_sizeClass));
 
 	// Make sure this size is in fact aligned.
 	assert((blksize & hoardHeap::ALIGNMENT_MASK) == 0);
 
 	// Set the first block to just past this superblock header.
-  block * b
+	block *b = (block *) hoardHeap::align((unsigned long)(this + 1));
-    = (block *) hoardHeap::align ((unsigned long) (this + 1));
 
 	// Initialize all the blocks,
 	// and insert the block pointers into the linked list.
@@ -80,15 +77,18 @@ superblock::superblock (int numBlocks,	// The number of blocks in the sb.
 		_freeList = b;
 		b = (block *)((char *)b + blksize);
 	}
+
 	_numAvailable = _numBlocks;
 	computeFullness();
-  assert ((unsigned long) b <= hoardHeap::align (sizeof(superblock) + blksize * _numBlocks) + (unsigned long) this);
+	assert((unsigned long)b <= hoardHeap::align(sizeof(superblock) + blksize * _numBlocks)
+		+ (unsigned long)this);
 
 	hoardLockInit(_upLock, "hoard superblock");
 }
 
-superblock * superblock::makeSuperblock (int sizeclass,
+
-					 processHeap * pHeap)
+superblock *
+superblock::makeSuperblock(int sizeclass, processHeap * pHeap)
 {
 	// We need to get more memory.
 
@@ -99,16 +99,18 @@ superblock * superblock::makeSuperblock (int sizeclass,
 	unsigned long moreMemory;
 	if (numBlocks > 1) {
 		moreMemory = hoardHeap::SUPERBLOCK_SIZE;
-    assert (moreMemory >= hoardHeap::align(sizeof(superblock) + (hoardHeap::align (sizeof(block) + hoardHeap::sizeFromClass(sizeclass))) * numBlocks));
+		assert(moreMemory >= hoardHeap::align(sizeof(superblock)
+			+ (hoardHeap::align(sizeof(block)
+			+ hoardHeap::sizeFromClass(sizeclass))) * numBlocks));
 
 		// Get some memory from the process heap.
 		buf = (char *)pHeap->getSuperblockBuffer();
-
 	} else {
 		// One object.
 		assert(numBlocks == 1);
 
-    size_t blksize = hoardHeap::align (sizeof(block) + hoardHeap::sizeFromClass(sizeclass));
+		size_t blksize = hoardHeap::align(sizeof(block)
+			+ hoardHeap::sizeFromClass(sizeclass));
 		moreMemory = hoardHeap::align(sizeof(superblock) + blksize);
 
 		// Get space from the system.
@@ -116,9 +118,9 @@ superblock * superblock::makeSuperblock (int sizeclass,
 	}
 
 	// Make sure that we actually got the memory.
-  if (buf == NULL) {
+	if (buf == NULL)
 		return 0;
-  }
+
 	buf = (char *)hoardHeap::align((unsigned long)buf);
 
 	// Make sure this buffer is double-word aligned.
@@ -126,7 +128,5 @@ superblock * superblock::makeSuperblock (int sizeclass,
 	assert((((unsigned long)buf) & hoardHeap::ALIGNMENT_MASK) == 0);
 
 	// Instantiate the new superblock in the buffer.
-  superblock * sb = new (buf) superblock (numBlocks, sizeclass, NULL);
+	return new(buf) superblock(numBlocks, sizeclass, NULL);
-
-  return sb;
 }

src/kernel/libroot/posix/malloc/superblock.h

@@ -23,7 +23,7 @@
   The superblock class controls a number of blocks (which are
   allocatable units of memory).
   ------------------------------------------------------------------------
-  @(#) $Id: superblock.h,v 1.1 2002/10/05 17:13:30 axeld Exp $
+  @(#) $Id$
   ------------------------------------------------------------------------
   Emery Berger                    | <http://www.cs.utexas.edu/users/emery>
   Department of Computer Sciences |             <http://www.cs.utexas.edu>
@@ -44,21 +44,18 @@
 #include "arch-specific.h"
 #include "block.h"
 
+
+namespace BPrivate {
+
 class hoardHeap;				// forward declaration
 class processHeap;				// forward declaration
 
 class superblock {
-
 	public:
-
 		// Construct a superblock for a given size class and set the heap
 		// owner.
-  superblock (int numblocks,
+		superblock(int numblocks, int sizeclass, hoardHeap *owner);
-	      int sizeclass,
+		~superblock(void) {}
-	      hoardHeap * owner);
-
-  ~superblock (void)
-    {}
 
 		// Make (allocate or re-use) a superblock for a given size class.
 		static superblock *makeSuperblock(int sizeclass, processHeap *pHeap);
@@ -111,16 +108,19 @@ public:
 		// does it have the right magic number?)
 		inline int isValid(void);
 
-  void upLock (void) {
+		void
+		upLock(void)
+		{
 			hoardLock(_upLock);
 		}
 
-  void upUnlock (void) {
+		void
+		upUnlock(void)
+		{
 			hoardUnlock(_upLock);
 		}
 
 	private:
-
 		// Disable copying and assignment.
 
 		superblock(const superblock &);
@@ -147,12 +147,12 @@ private:
 
 		// We insert a cache pad here to prevent false sharing with the
 		// first block (which immediately follows the superblock).
-
 		double _pad[CACHE_LINE / sizeof(double)];
 };
 
 
-hoardHeap * superblock::getOwner (void)
+hoardHeap *
+superblock::getOwner(void)
 {
 	assert(isValid());
 	hoardHeap *o = _owner;
@@ -160,14 +160,16 @@ hoardHeap * superblock::getOwner (void)
 }
 
 
-void superblock::setOwner (hoardHeap * o)
+void
+superblock::setOwner(hoardHeap *o)
 {
 	assert(isValid());
 	_owner = o;
 }
 
 
-block * superblock::getBlock (void)
+block *
+superblock::getBlock(void)
 {
 	assert(isValid());
 	// Pop off a block from this superblock's freelist,
@@ -177,6 +179,7 @@ block * superblock::getBlock (void)
 		assert(getNumAvailable() == 0);
 		return NULL;
 	}
+
 	assert(getNumAvailable() > 0);
 	block *b = _freeList;
 	_freeList = _freeList->getNext();
@@ -185,12 +188,12 @@ block * superblock::getBlock (void)
 	b->setNext(NULL);
 
 	computeFullness();
-
 	return b;
 }
 
 
-void superblock::putBlock (block * b)
+void
+superblock::putBlock(block *b)
 {
 	assert(isValid());
 	// Push a block onto the superblock's freelist.
@@ -203,41 +206,49 @@ void superblock::putBlock (block * b)
 	computeFullness();
 }
 
-int superblock::getNumAvailable (void)
+
+int
+superblock::getNumAvailable(void)
 {
 	assert(isValid());
 	return _numAvailable;
 }
 
 
-int superblock::getNumBlocks (void)
+int
+superblock::getNumBlocks(void)
 {
 	assert(isValid());
 	return _numBlocks;
 }
 
 
-int superblock::getBlockSizeClass (void)
+int
+superblock::getBlockSizeClass(void)
 {
 	assert(isValid());
 	return _sizeClass;
 }
 
 
-superblock * const superblock::getNext (void)
+superblock * const
+superblock::getNext(void)
 {
 	assert(isValid());
 	return _next;
 }
 
-superblock * const superblock::getPrev (void)
+superblock * const
+superblock::getPrev(void)
 {
 	assert(isValid());
 	return _prev;
 }
 
 
-void superblock::insertBefore (superblock * nextSb) {
+void
+superblock::insertBefore(superblock * nextSb)
+{
 	assert(isValid());
 	// Insert this superblock before the next one (nextSb).
 	assert(nextSb != this);
@@ -249,20 +260,22 @@ void superblock::insertBefore (superblock * nextSb) {
 }
 
 
-void superblock::remove (void) {
+void
+superblock::remove(void)
+{
 	// Remove this superblock from a doubly-linked list.
-  if (_next) {
+	if (_next)
 		_next->_prev = _prev;
-  }
+	if (_prev)
-  if (_prev) {
 		_prev->_next = _next;
-  }
+
 	_prev = NULL;
 	_next = NULL;
 }
 
 
-int superblock::isValid (void)
+int
+superblock::isValid(void)
 {
 	assert(_numBlocks > 0);
 	assert(_numAvailable <= _numBlocks);
@@ -271,17 +284,22 @@ int superblock::isValid (void)
 }
 
 
-void superblock::computeFullness (void)
+void
+superblock::computeFullness(void)
 {
 	assert(isValid());
 	_fullness = (((SUPERBLOCK_FULLNESS_GROUP - 1)
 		* (getNumBlocks() - getNumAvailable())) / getNumBlocks());
 }
 
-int superblock::getFullness (void)
+
+int
+superblock::getFullness(void)
 {
 	assert(isValid());
 	return _fullness;
 }
 
+}	// namespace BPrivate
+
 #endif // _SUPERBLOCK_H_

src/kernel/libroot/posix/malloc/threadheap.cpp

@@ -26,10 +26,13 @@
 #include "threadheap.h"
 #include "processheap.h"
 
+using namespace BPrivate;
+
 
 threadHeap::threadHeap(void)
 	:_pHeap(0)
-{}
+{
+}
 
 
 // malloc (sz):
@@ -38,7 +41,8 @@ threadHeap::threadHeap (void)
 //   side effects: allocates a block from a superblock;
 //                 may call sbrk() (via makeSuperblock).
 
-void * threadHeap::malloc (const size_t size)
+void *
+threadHeap::malloc(const size_t size)
 {
 	const int sizeclass = sizeClass(size);
 	block *b = NULL;
@@ -52,7 +56,6 @@ void * threadHeap::malloc (const size_t size)
 	superblock *sb = findAvailableSuperblock(sizeclass, b, _pHeap);
 
 	if (sb == NULL) {
-
 		// We don't have memory locally.
 		// Try to get more from the process heap.
 
@@ -71,14 +74,15 @@ void * threadHeap::malloc (const size_t size)
 #if HEAP_LOG
 			// Record the memory allocation.
 			MemoryRequest m;
-      m.allocate ((int) sb->getNumBlocks() * (int) sizeFromClass(sb->getBlockSizeClass()));
+			m.allocate((int)sb->getNumBlocks() *
+				(int)sizeFromClass(sb->getBlockSizeClass()));
 			_pHeap->getLog(getIndex()).append(m);
 #endif
 #if HEAP_FRAG_STATS
-      _pHeap->setAllocated (0, sb->getNumBlocks() * sizeFromClass(sb->getBlockSizeClass()));
+			_pHeap->setAllocated(0,
+				sb->getNumBlocks() * sizeFromClass(sb->getBlockSizeClass()));
 #endif
 		}
-
 		// Get a block from the superblock.
 		b = sb->getBlock();
 		assert(b != NULL);

src/kernel/libroot/posix/malloc/threadheap.h

@@ -26,6 +26,8 @@
 
 #include "heap.h"
 
+namespace BPrivate {
+
 class processHeap;		 // forward declaration
 
 //
@@ -33,9 +35,7 @@ class processHeap; // forward declaration
 //
 
 class threadHeap : public hoardHeap {
-
 	public:
-
 		threadHeap(void);
 
 		// Memory allocation routines.
@@ -49,7 +49,6 @@ public:
 		inline void setpHeap(processHeap *p);
 
 	private:
-
 		// Prevent copying and assignment.
 		threadHeap(const threadHeap &);
 		const threadHeap &operator=(const threadHeap &);
@@ -64,8 +63,8 @@ private:
 };
 
 
-void * threadHeap::memalign (size_t alignment,
+void *
-			     size_t size)
+threadHeap::memalign(size_t alignment, size_t size)
 {
 	// Calculate the amount of space we need
 	// to satisfy the alignment requirements.
@@ -74,13 +73,11 @@ void * threadHeap::memalign (size_t alignment,
 
 	// If the alignment is less than the required alignment,
 	// just call malloc.
-  if (alignment <= ALIGNMENT) {
+	if (alignment <= ALIGNMENT)
 		return this->malloc(size);
-  }
 
-  if (alignment < sizeof(block)) {
+	if (alignment < sizeof(block))
 		alignment = sizeof(block);
-  }
 
 	// Alignment must be a power of two!
 	assert((alignment & (alignment - 1)) == 0);
@@ -96,18 +93,15 @@ void * threadHeap::memalign (size_t alignment,
 		// ptr is already aligned, so return it.
 		assert(((unsigned long) ptr % alignment) == 0);
 		return ptr;
-
 	} else {
-
 		// Align ptr.
-    char * newptr = (char *)
+		char *newptr = (char *)(((unsigned long)ptr + alignment - 1) & -((long)alignment));
-      (((unsigned long) ptr + alignment - 1) & -((long) alignment));
 
 		// If there's not enough room for the block header, skip to the
 		// next aligned space within the block..
-    if ((unsigned long) newptr - (unsigned long) ptr < sizeof(block)) {
+		if ((unsigned long)newptr - (unsigned long)ptr < sizeof(block))
 			newptr += alignment;
-    }
+
 		assert(((unsigned long)newptr % alignment) == 0);
 
 		// Copy the block from the start of the allocated memory.
@@ -117,7 +111,8 @@ void * threadHeap::memalign (size_t alignment,
 		assert(b->getSuperblock()->isValid());
 
 		// Make sure there's enough room for the block header.
-    assert (((unsigned long) newptr - (unsigned long) ptr) >= sizeof(block));
+		assert(((unsigned long)newptr - (unsigned long)ptr) >=
+		       sizeof(block));
 
 		block *p = ((block *)newptr - 1);
 
@@ -134,21 +129,20 @@ void * threadHeap::memalign (size_t alignment,
 			// Set the next pointer to point to b with the 1 bit set.
 			// When this block is freed, it will be treated specially.
 			p->setNext((block *)((unsigned long)b | 1));
-
+		} else
-    } else {
 			assert(ptr != newptr);
-    }
 
-    assert (((unsigned long) ptr + newSize) >= ((unsigned long) newptr + size));
+		assert(((unsigned long)ptr + newSize) >=
+		       ((unsigned long)newptr + size));
 		return newptr;
 	}
 }
 
 
-size_t threadHeap::objectSize (void * ptr)
+size_t
+threadHeap::objectSize(void *ptr)
 {
 	// Find the superblock pointer.
-
 	block *b = ((block *)ptr - 1);
 	assert(b->isValid());
 	superblock *sb = b->getSuperblock();
@@ -164,5 +158,6 @@ void threadHeap::setpHeap (processHeap * p)
 	_pHeap = p;
 }
 
-#endif // _THREADHEAP_H_
+}	// namespace BPrivate
 
+#endif				 // _THREADHEAP_H_

src/kernel/libroot/posix/malloc/wrapper.cpp

@@ -23,11 +23,14 @@
  */
 
 #include <string.h>
+
 #include "config.h"
 #include "threadheap.h"
 #include "processheap.h"
 #include "arch-specific.h"
 
+using namespace BPrivate;
+
 
 inline static processHeap *
 getAllocator(void)
@@ -38,21 +41,7 @@ getAllocator(void)
 	return theAllocator;
 }
 
-#define HOARD_MALLOC(x) malloc(x)
+#if 0
-#define HOARD_FREE(x) free(x)
-#define HOARD_REALLOC(x,y) realloc(x,y)
-#define HOARD_CALLOC(x,y) calloc(x,y)
-#define HOARD_MEMALIGN(x,y) memalign(x,y)
-#define HOARD_VALLOC(x) valloc(x)
-
-extern "C" void * HOARD_MALLOC(size_t);
-extern "C" void HOARD_FREE(void *);
-extern "C" void * HOARD_REALLOC(void *, size_t);
-extern "C" void * HOARD_CALLOC(size_t, size_t);
-extern "C" void * HOARD_MEMALIGN(size_t, size_t);
-extern "C" void * HOARD_VALLOC(size_t);
-
-
 void * operator new (size_t size)
 {
   return HOARD_MALLOC (size);
@@ -80,6 +69,7 @@ void operator delete[] (void * ptr)
 {
   HOARD_FREE (ptr);
 }
+#endif
 
 
 extern "C" void *
@@ -133,7 +123,7 @@ extern "C" void *
 realloc(void *ptr, size_t sz)
 {
 	if (ptr == NULL)
-		return HOARD_MALLOC (sz);
+		return malloc(sz);
 
 	if (sz == 0) {
 		free(ptr);
@@ -148,7 +138,6 @@ realloc(void *ptr, size_t sz)
 		return ptr;
 
 	// Allocate a new block of size sz.
-
 	void *buffer = malloc(sz);
 
 	// Copy the contents of the original object
@@ -158,7 +147,6 @@ realloc(void *ptr, size_t sz)
 	memcpy(buffer, ptr, minSize);
 
 	// Free the old block.
-
 	free(ptr);
 
 	// Return a pointer to the new one.