From 5a9b207757997cf85e8b4b8bde2acf6ee4f8eae2 Mon Sep 17 00:00:00 2001 From: skidd13 Date: Sun, 28 Feb 2010 00:26:08 +0100 Subject: [PATCH 04/17] -Codechange: Rename Blob internals --- src/misc/blob.hpp | 133 +++++++++++++++++++++++----------------------- src/misc/dbg_helpers.cpp | 2 +- 2 files changed, 68 insertions(+), 67 deletions(-) diff --git a/src/misc/blob.hpp b/src/misc/blob.hpp index 3c9a1c2..fdafe6d 100644 --- a/src/misc/blob.hpp +++ b/src/misc/blob.hpp @@ -28,95 +28,96 @@ * * Internal member layout: * 1. The only class member is pointer to the first item (see union). - * 2. Allocated block contains the blob header (see CHdr) followed by the raw byte data. + * 2. Allocated block contains the blob header (see BlobHeader) followed by the raw byte data. * Always, when it allocates memory the allocated size is: - * sizeof(CHdr) + - * 3. Two 'virtual' members (m_size and m_max_size) are stored in the CHdr at beginning + * sizeof(BlobHeader) + + * 3. Two 'virtual' members (items and capacity) are stored in the BlobHeader at beginning * of the alloated block. * 4. The pointer of the union pobsize_ts behind the header (to the first data byte). - * When memory block is allocated, the sizeof(CHdr) it added to it. + * When memory block is allocated, the sizeof(BlobHeader) it added to it. * 5. Benefits of this layout: * - items are accessed in the simplest possible way - just dereferencing the pointer, * which is good for performance (assuming that data are accessed most often). * - sizeof(blob) is the same as the size of any other pointer * 6. Drawbacks of this layout: - * - the fact, that pointer to the alocated block is adjusted by sizeof(CHdr) before + * - the fact, that pointer to the alocated block is adjusted by sizeof(BlobHeader) before * it is stored can lead to several confusions: * - it is not common pattern so the implementation code is bit harder to read * - valgrind can generate warning that allocated block is lost (not accessible) */ -class CBlobBaseSimple { +class ByteBlob { protected: /** header of the allocated memory block */ - struct CHdr { - uint m_size; ///< actual blob size in bytes - uint m_max_size; ///< maximum (allocated) size in bytes + struct BlobHeader { + uint items; ///< actual blob size in bytes + uint capacity; ///< maximum (allocated) size in bytes }; /** type used as class member */ union { - byte *m_pData; ///< ptr to the first byte of data - CHdr *m_pHdr_1; ///< ptr just after the CHdr holding m_size and m_max_size + byte *data; ///< ptr to the first byte of data + BlobHeader *header; ///< ptr just after the BlobHeader holding items and capacity }; private: /** * Just to silence an unsilencable GCC 4.4+ warning - * Note: This cannot be 'const' as we do a lot of 'hdrEmpty[0]->m_size += 0;' and 'hdrEmpty[0]->m_max_size += 0;' + * Note: This cannot be 'const' as we do a lot of 'hdrEmpty[0]->items += 0;' and 'hdrEmpty[0]->capacity += 0;' * after const_casting. */ - static CHdr hdrEmpty[]; + static BlobHeader hdrEmpty[]; public: - static const uint Ttail_reserve = 4; ///< four extra bytes will be always allocated and zeroed at the end + static const uint tail_reserve = 4; ///< four extra bytes will be always allocated and zeroed at the end + static const uint header_size = sizeof(BlobHeader); /** default constructor - initializes empty blob */ - FORCEINLINE CBlobBaseSimple() { InitEmpty(); } + FORCEINLINE ByteBlob() { InitEmpty(); } /** move constructor - take ownership of blob data */ - FORCEINLINE CBlobBaseSimple(CHdr * const & pHdr_1) + FORCEINLINE ByteBlob(BlobHeader * const & src) { - assert(pHdr_1 != NULL); - m_pHdr_1 = pHdr_1; - *const_cast(&pHdr_1) = NULL; + assert(src != NULL); + header = src; + *const_cast(&src) = NULL; } /** destructor */ - FORCEINLINE ~CBlobBaseSimple() + FORCEINLINE ~ByteBlob() { Free(); } protected: - /** initialize the empty blob by setting the m_pHdr_1 pointer to the static CHdr with - * both m_size and m_max_size containing zero */ + /** initialize the empty blob by setting the header pointer to the static BlobHeader with + * both items and capacity containing zero */ FORCEINLINE void InitEmpty() { - m_pHdr_1 = const_cast(&CBlobBaseSimple::hdrEmpty[1]); + header = const_cast(&ByteBlob::hdrEmpty[1]); } /** initialize blob by attaching it to the given header followed by data */ - FORCEINLINE void Init(CHdr *hdr) + FORCEINLINE void Init(BlobHeader *src) { - m_pHdr_1 = &hdr[1]; + header = &src[1]; } /** blob header accessor - use it rather than using the pointer arithmetics directly - non-const version */ - FORCEINLINE CHdr& Hdr() + FORCEINLINE BlobHeader& Hdr() { - return *(m_pHdr_1 - 1); + return *(header - 1); } /** blob header accessor - use it rather than using the pointer arithmetics directly - const version */ - FORCEINLINE const CHdr& Hdr() const + FORCEINLINE const BlobHeader& Hdr() const { - return *(m_pHdr_1 - 1); + return *(header - 1); } /** return reference to the actual blob size - used when the size needs to be modified */ FORCEINLINE uint& RawSizeRef() { - return Hdr().m_size; + return Hdr().items; }; public: @@ -129,25 +130,25 @@ public: /** return the number of valid data bytes in the blob */ FORCEINLINE uint RawSize() const { - return Hdr().m_size; + return Hdr().items; }; /** return the current blob capacity in bytes */ FORCEINLINE uint MaxRawSize() const { - return Hdr().m_max_size; + return Hdr().capacity; }; /** return pointer to the first byte of data - non-const version */ FORCEINLINE byte *RawData() { - return m_pData; + return data; } /** return pointer to the first byte of data - const version */ FORCEINLINE const byte *RawData() const { - return m_pData; + return data; } /** return the 32 bit CRC of valid data in the blob */ @@ -181,7 +182,7 @@ public: } /** append bytes from given source blob to the end of existing data bytes - reallocates if necessary */ - FORCEINLINE void AppendRaw(const CBlobBaseSimple& src) + FORCEINLINE void AppendRaw(const ByteBlob& src) { if (!src.IsEmpty()) memcpy(GrowRawSize(src.RawSize()), src.RawData(), src.RawSize()); @@ -193,7 +194,7 @@ public: { uint new_size = RawSize() + num_bytes; if (new_size > MaxRawSize()) SmartAlloc(new_size); - return m_pData + RawSize(); + return data + RawSize(); } /** Increase RawSize() by num_bytes. @@ -211,20 +212,20 @@ public: uint old_max_size = MaxRawSize(); if (old_max_size >= new_size) return; /* calculate minimum block size we need to allocate */ - uint min_alloc_size = sizeof(CHdr) + new_size + Ttail_reserve; + uint min_alloc_size = header_size + new_size + tail_reserve; /* ask allocation policy for some reasonable block size */ uint alloc_size = AllocPolicy(min_alloc_size); /* allocate new block */ - CHdr *pNewHdr = RawAlloc(alloc_size); + BlobHeader *tmp = RawAlloc(alloc_size); /* setup header */ - pNewHdr->m_size = RawSize(); - pNewHdr->m_max_size = alloc_size - (sizeof(CHdr) + Ttail_reserve); + tmp->items = RawSize(); + tmp->capacity = alloc_size - (header_size + tail_reserve); /* copy existing data */ if (RawSize() > 0) - memcpy(pNewHdr + 1, m_pData, pNewHdr->m_size); + memcpy(tmp + 1, data, tmp->items); /* replace our block with new one */ - CHdr *pOldHdr = &Hdr(); - Init(pNewHdr); + BlobHeader *pOldHdr = &Hdr(); + Init(tmp); if (old_max_size > 0) RawFree(pOldHdr); } @@ -249,16 +250,16 @@ public: } /** all allocation should happen here */ - static FORCEINLINE CHdr *RawAlloc(uint num_bytes) + static FORCEINLINE BlobHeader *RawAlloc(uint num_bytes) { - return (CHdr*)MallocT(num_bytes); + return (BlobHeader*)MallocT(num_bytes); } /** all deallocations should happen here */ - static FORCEINLINE void RawFree(CHdr *p) + static FORCEINLINE void RawFree(BlobHeader *p) { /* Just to silence an unsilencable GCC 4.4+ warning. */ - assert(p != CBlobBaseSimple::hdrEmpty); + assert(p != ByteBlob::hdrEmpty); /* In case GCC warns about the following, see GCC's PR38509 why it is bogus. */ free(p); @@ -267,8 +268,8 @@ public: FORCEINLINE void FixTail() const { if (MaxRawSize() > 0) { - byte *p = &m_pData[RawSize()]; - for (uint i = 0; i < Ttail_reserve; i++) { + byte *p = &data[RawSize()]; + for (uint i = 0; i < tail_reserve; i++) { p[i] = 0; } } @@ -283,18 +284,18 @@ public: * 3. Takes care about the actual data size (number of used items). * 4. Dynamically constructs only used items (as opposite of static array which constructs all items) */ template -class CBlobT : public CBlobBaseSimple { +class CBlobT : public ByteBlob { /* make template arguments public: */ public: - typedef CBlobBaseSimple base; + typedef ByteBlob base; static const uint type_size = sizeof(T); struct OnTransfer { - typename base::CHdr *m_pHdr_1; - OnTransfer(const OnTransfer& src) : m_pHdr_1(src.m_pHdr_1) {assert(src.m_pHdr_1 != NULL); *const_cast(&src.m_pHdr_1) = NULL;} - OnTransfer(CBlobT& src) : m_pHdr_1(src.m_pHdr_1) {src.InitEmpty();} - ~OnTransfer() {assert(m_pHdr_1 == NULL);} + typename base::BlobHeader *header; + OnTransfer(const OnTransfer& src) : header(src.header) {assert(src.header != NULL); *const_cast(&src.header) = NULL;} + OnTransfer(CBlobT& src) : header(src.header) {src.InitEmpty();} + ~OnTransfer() {assert(header == NULL);} }; /** Default constructor - makes new Blob ready to accept any data */ @@ -304,7 +305,7 @@ public: /** Take ownership constructor */ FORCEINLINE CBlobT(const OnTransfer& ot) - : base(ot.m_pHdr_1) + : base(ot.header) {} /** Destructor - ensures that allocated memory (if any) is freed */ @@ -314,9 +315,9 @@ public: } /** Check the validity of item index (only in debug mode) */ - FORCEINLINE void CheckIdx(uint idx) const + FORCEINLINE void CheckIdx(uint index) const { - assert(idx < Size()); + assert(index < Size()); } /** Return pointer to the first data item - non-const version */ @@ -331,18 +332,18 @@ public: return (const T*)base::RawData(); } - /** Return pointer to the idx-th data item - non-const version */ - FORCEINLINE T *Data(uint idx) + /** Return pointer to the index-th data item - non-const version */ + FORCEINLINE T *Data(uint index) { - CheckIdx(idx); - return (Data() + idx); + CheckIdx(index); + return (Data() + index); } - /** Return pointer to the idx-th data item - const version */ - FORCEINLINE const T *Data(uint idx) const + /** Return pointer to the index-th data item - const version */ + FORCEINLINE const T *Data(uint index) const { - CheckIdx(idx); - return (Data() + idx); + CheckIdx(index); + return (Data() + index); } /** Return number of items in the Blob */ diff --git a/src/misc/dbg_helpers.cpp b/src/misc/dbg_helpers.cpp index c6018f0..78b2ec4 100644 --- a/src/misc/dbg_helpers.cpp +++ b/src/misc/dbg_helpers.cpp @@ -177,4 +177,4 @@ void DumpTarget::EndStruct() } /** Just to silence an unsilencable GCC 4.4+ warning */ -/* static */ CBlobBaseSimple::CHdr CBlobBaseSimple::hdrEmpty[] = {{0, 0}, {0, 0}}; +/* static */ ByteBlob::BlobHeader ByteBlob::hdrEmpty[] = {{0, 0}, {0, 0}}; -- 1.6.6.1