Implement shrink_to_fit on memblock and vector containers

Change margin allocation strategy to pow2 growth from +64
reserve will now use margin allocation by default, resize is still exact

Author: msharov

bvt/bvt02.cc

@@ -67,6 +67,9 @@ void TestMB (void)
     WriteCML (a);
     a.resize (strTestLen + strTestLen / 2);
     WriteCML (a);
+    cout << "Capacity " << a.capacity();
+    a.shrink_to_fit();
+    cout << ", shrunk " << a.capacity() << endl;
 }
 
 StdBvtMain (TestMB)

bvt/bvt02.std

@@ -7,3 +7,4 @@ memblock{28}: ab---TESTTESTTESTpqrs=======
 memblock{50}: ab---TESTTESTTESTpqrs=====-+=-+=-+=-+=-+=-+=-+=-+=
 memblock{0}: 
 memblock{39}: ab---TESTTESTTESTpqrs=====-+=-+=-+=-+=-
+Capacity 64, shrunk 39

bvt/bvt04.std

@@ -1,5 +1,5 @@
 (1)
-Reserved to capacity() == 20 (1 used, SIZE_MAX/elsize max)
+Reserved to capacity() == 32 (1 used, SIZE_MAX/elsize max)
 (1,2,3,4,5,6,7,8,9,10,11,12,13,13,14,15,16,17,18)
 front() = 1, back() = 18
 (2,3,4,5,6,7,8,9,10,11,12,13,13,14,15,16,17)

bvt/bvt07.std

@@ -2,7 +2,7 @@
 abcdefghijklmnopqrstuvwxyz
 123456789012345678901234567890
 12345678901234567890
-s3.size() = 20, max_size() = (SIZE_MAX/elsize)-1, capacity() = 48
+s3.size() = 20, max_size() = (SIZE_MAX/elsize)-1, capacity() = 63
 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$
 HelloWorld
 Concatenated HelloWorld string.

memblock.cc

@@ -88,7 +88,7 @@ void memblock::reserve (size_type newSize, bool bExact)
     if ((newSize += minimumFreeCapacity()) <= m_Capacity)
 	return;
     pointer oldBlock (is_linked() ? NULL : data());
-    const size_t alignedSize (Align (newSize, 64));
+    const size_t alignedSize (NextPow2 (newSize));
     if (!bExact)
 	newSize = alignedSize;
     pointer newBlock = (pointer) realloc (oldBlock, newSize);
@@ -100,6 +100,17 @@ void memblock::reserve (size_type newSize, bool bExact)
     m_Capacity = newSize;
 }
 
+/// Reduces capacity to match size
+void memblock::shrink_to_fit (void)
+{
+    if (is_linked())
+	return;
+    pointer newBlock = (pointer) realloc (begin(), size());
+    if (!newBlock)
+	throw bad_alloc (size());
+    m_Capacity = size();
+}
+
 /// Shifts the data in the linked block from \p start to \p start + \p n.
 memblock::iterator memblock::insert (iterator start, size_type n)
 {

memblock.h

@@ -34,7 +34,7 @@ class memblock : public memlink {
     inline const memblock&	operator= (const memblock& l)	{ assign (l); return (*this); }
     inline void			swap (memblock& l)		{ memlink::swap (l); ::ustl::swap (m_Capacity, l.m_Capacity); }
     void			assign (const void* p, size_type n);
-    void			reserve (size_type newSize, bool bExact = true);
+    void			reserve (size_type newSize, bool bExact = false);
     void			resize (size_type newSize, bool bExact = true);
     iterator			insert (iterator start, size_type size);
     iterator			erase (iterator start, size_type size);
@@ -44,6 +44,7 @@ class memblock : public memlink {
     inline size_type		max_size (void) const		{ return (is_linked() ? memlink::max_size() : SIZE_MAX); }
     inline void			manage (memlink& l)		{ manage (l.begin(), l.size()); }
     void			deallocate (void) noexcept;
+    void			shrink_to_fit (void);
     void			manage (void* p, size_type n);
     void			copy_link (void);
     void			read (istream& is);

uvector.h

@@ -47,7 +47,7 @@ class vector {
     inline			operator cmemlink (void) const	{ return (cmemlink (m_Data)); }
     inline			operator cmemlink (void)	{ return (cmemlink (m_Data)); }
     inline			operator memlink (void)		{ return (memlink (m_Data)); }
-    inline void			reserve (size_type n, bool bExact = true);
+    inline void			reserve (size_type n, bool bExact = false);
     inline void			resize (size_type n, bool bExact = true);
     inline size_type		capacity (void) const		{ return (m_Data.capacity() / sizeof(T));	}
     inline size_type		size (void) const		{ return (m_Data.size() / sizeof(T));		}
@@ -57,10 +57,14 @@ class vector {
     inline const_iterator	begin (void) const		{ return (const_iterator (m_Data.begin()));	}
     inline iterator		end (void)			{ return (iterator (m_Data.end()));		}
     inline const_iterator	end (void) const		{ return (const_iterator (m_Data.end()));	}
-    inline reverse_iterator		rbegin (void)		{ return (reverse_iterator (end()));		}
-    inline const_reverse_iterator	rbegin (void) const	{ return (const_reverse_iterator (end()));	}
-    inline reverse_iterator		rend (void)		{ return (reverse_iterator (begin()));		}
-    inline const_reverse_iterator	rend (void) const	{ return (const_reverse_iterator (begin()));	}
+    inline const_iterator	cbegin (void) const		{ return (begin()); }
+    inline const_iterator	cend (void) const		{ return (end()); }
+    inline reverse_iterator	rbegin (void)			{ return (reverse_iterator (end()));		}
+  inline const_reverse_iterator	rbegin (void) const		{ return (const_reverse_iterator (end()));	}
+    inline reverse_iterator	rend (void)			{ return (reverse_iterator (begin()));		}
+  inline const_reverse_iterator	rend (void) const		{ return (const_reverse_iterator (begin()));	}
+  inline const_reverse_iterator	crbegin (void) const		{ return (rbegin()); }
+  inline const_reverse_iterator	crend (void) const		{ return (rend()); }
     inline iterator		iat (size_type i)		{ assert (i <= size()); return (begin() + i); }
     inline const_iterator	iat (size_type i) const		{ assert (i <= size()); return (begin() + i); }
     inline reference		at (size_type i)		{ assert (i < size()); return (begin()[i]); }
@@ -74,6 +78,7 @@ class vector {
     inline void			push_back (const T& v = T());
     inline void			pop_back (void)			{ m_Data.memlink::resize (m_Data.size() - sizeof(T)); }
     inline void			clear (void)			{ m_Data.clear(); }
+    inline void			shrink_to_fit (void)		{ m_Data.shrink_to_fit(); }
     inline void			deallocate (void) noexcept;
     inline void			assign (const_iterator i1, const_iterator i2);
     inline void			assign (size_type n, const T& v);