EST_Chunk.h

Go to the documentation of this file.

 /************************************************************************/
 /*                                                                      */
 /*                Centre for Speech Technology Research                 */
 /*                     University of Edinburgh, UK                      */
 /*                        Copyright (c) 1997                            */
 /*                        All Rights Reserved.                          */
 /*                                                                      */
 /*  Permission is hereby granted, free of charge, to use and distribute */
 /*  this software and its documentation without restriction, including  */
 /*  without limitation the rights to use, copy, modify, merge, publish, */
 /*  distribute, sublicense, and/or sell copies of this work, and to     */
 /*  permit persons to whom this work is furnished to do so, subject to  */
 /*  the following conditions:                                           */
 /*   1. The code must retain the above copyright notice, this list of   */
 /*      conditions and the following disclaimer.                        */
 /*   2. Any modifications must be clearly marked as such.               */
 /*   3. Original authors' names are not deleted.                        */
 /*   4. The authors' names are not used to endorse or promote products  */
 /*      derived from this software without specific prior written       */
 /*      permission.                                                     */
 /*                                                                      */
 /*  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK       */
 /*  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING     */
 /*  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT  */
 /*  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE    */
 /*  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   */
 /*  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN  */
 /*  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,         */
 /*  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF      */
 /*  THIS SOFTWARE.                                                      */
 /*                                                                      */
 /************************************************************************/
 /*                                                                      */
 /*                 Author: Richard Caley (rjc@cstr.ed.ac.uk)            */
 /*                   Date: February 1997                                */
 /* -------------------------------------------------------------------- */
 /*                                                                      */
 /* Use counted memory chunks and smart pointers to them.                */
 /*                                                                      */
 /************************************************************************/

#if ! defined(__EST_CHUNK_H__)
#define __EST_CHUNK_H__

#include <iostream>

#include <climits>
#include <sys/types.h>

// Warn when getting a writable version of a shared chunk --
// useful for minimising copies.

/* #define __INCLUDE_CHUNK_WARNINGS__ (1) */

#if defined(__INCLUDE_CHUNK_WARNINGS__)
#    define CHUNK_WARN(WHAT) do { cerr << "chunk: " <<WHAT << "\n";} while (0)
#else
#    define CHUNK_WARN(WHAT) // empty
#endif

#define __CHUNK_INLINE_AGGRESSIVELY__ (1)

#if defined(__CHUNK_INLINE_AGGRESSIVELY__)
#    define CII(BODY) BODY
#else
#    define CII(BODY) /* empty */
#endif


#include "EST_walloc.h"

using std::ostream;

 /************************************************************************/
 /*                                                                      */
 /* EST_Chunk is a use-counted chunk of memory. You shouldn't be able    */
 /* to do anything to it except create it and manipulate it via          */
 /* EST_ChunkPtr. The private operator::new takes a placement argument   */
 /* which is actually the number of bytes of memory in the body of the   */
 /* chunk.                                                               */
 /*                                                                      */
 /* If the use counter overflows, it sticks. Anything with more than     */
 /* SHRT_MAX references to it is probably permanent.                     */
 /*                                                                      */
 /************************************************************************/

class EST_ChunkPtr;

class EST_Chunk  {
  public:
    typedef  unsigned short use_counter;
#       define MAX_CHUNK_COUNT (USHRT_MAX)
    typedef  int EST_chunk_size;
#       define MAX_CHUNK_SIZE  (INT_MAX)

  private:
    use_counter count;
    EST_chunk_size size;
    int malloc_flag; // set if this was got from malloc (rather than new)
    char  memory[1];

    EST_Chunk(void);
    ~EST_Chunk();

    EST_Chunk *operator & ();
    void *operator new (size_t size, size_t bytes);
    void operator delete (void *it);
    
    void operator ++ ()
        CII({if (count < MAX_CHUNK_COUNT) ++count; });

    void operator -- ()
        CII({if (count < MAX_CHUNK_COUNT) if (--count == 0) delete this;});

  public:
    friend class EST_ChunkPtr;

    friend EST_ChunkPtr chunk_allocate(size_t bytes);
    friend EST_ChunkPtr chunk_allocate(size_t bytes, const char *initial, size_t initial_len);
    friend EST_ChunkPtr chunk_allocate(size_t bytes, const EST_ChunkPtr &initial, size_t initial_start, size_t initial_len);

    friend void cp_make_updatable(EST_ChunkPtr &shared, EST_chunk_size inuse);
    friend void cp_make_updatable(EST_ChunkPtr &shared);

    friend void grow_chunk(EST_ChunkPtr &shared, EST_chunk_size inuse, EST_chunk_size newsize);
    friend void grow_chunk(EST_ChunkPtr &shared, EST_chunk_size newsize);

    friend ostream &operator << (ostream &s, const EST_Chunk &chp);
    friend void tester(void);
};

 /************************************************************************/
 /*                                                                      */
 /* Pointers to chunks. Initialising them and assigning them around      */
 /* keeps track of use counts. We allow them to be cast to char * as a   */
 /* way of letting people work on them with standard functions,          */
 /* however it is bad voodoo to hold on to such a cast chunk for more    */
 /* than a trivial amount of time.                                       */
 /*                                                                      */
 /************************************************************************/

class EST_ChunkPtr {
  private:
    EST_Chunk *ptr;

    EST_ChunkPtr(EST_Chunk *chp) CII({
      if ((ptr=chp))
    ++ *ptr;
    });
  public:
    EST_ChunkPtr(void) { ptr = (EST_Chunk *)NULL; };
    
    EST_ChunkPtr(const EST_ChunkPtr &cp) CII({
      ptr=cp.ptr;
      if (ptr)
    ++ *ptr;
    });

    ~EST_ChunkPtr(void) CII({ if (ptr) -- *ptr; });

    int size(void) const { return ptr?ptr->size:0; };
    int shareing(void) const { return ptr?(ptr->count >1):0; };
    int count(void) const { return ptr?(ptr->count):-1; };

    EST_ChunkPtr &operator = (EST_ChunkPtr cp) CII({
      // doing it in this order means self assignment is safe.
      if (cp.ptr)
    ++ *(cp.ptr);
      if (ptr)
    -- *ptr;
      ptr=cp.ptr;
      return *this;
    });

    // If they manage to get hold of one...
    // Actually usually used to assign NULL and so (possibly) deallocate
    // the chunk currently pointed to.
    EST_ChunkPtr &operator = (EST_Chunk *chp) CII({
      // doing it in this order means self assignment is safe.
      if (chp)
    ++ *chp;
      if (ptr)
    -- *ptr;
      ptr=chp;
      return *this;
    });
 
    // Casting to a non-const pointer causes a
    // warning to stderr if the chunk is shared.
    operator char*() CII({
      if (ptr && ptr->count > 1) 
    { 
      CHUNK_WARN("getting writable version of shared chunk\n");
      cp_make_updatable(*this);
    }
      return ptr?&(ptr->memory[0]):(char *)NULL;
    });
    operator const char*() const CII({
      return ptr?&(ptr->memory[0]):(const char *)NULL;
    });
    operator const char*() CII({
      return ptr?&(ptr->memory[0]):(const char *)NULL;
    });


    char operator [] (size_t i) const { return ptr->memory[i]; };
    char &operator () (size_t i) CII({ 
      if (ptr->count>1) 
    {
      CHUNK_WARN("getting writable version of shared chunk\n");
      cp_make_updatable(*this); 
    }
      return ptr->memory[i]; 
    });

    // Creating a new one
    friend EST_ChunkPtr chunk_allocate(size_t size);
    friend EST_ChunkPtr chunk_allocate(size_t bytes, const char *initial, size_t initial_len);
    friend EST_ChunkPtr chunk_allocate(size_t bytes, const EST_ChunkPtr &initial, size_t initial_start, size_t initial_len);

    // Make sure the memory isn`t shared.
    friend void cp_make_updatable(EST_ChunkPtr &shared, EST_Chunk::EST_chunk_size inuse);
    friend void cp_make_updatable(EST_ChunkPtr &shared);

    // Make sure there is enough room (also makes updatable)
    friend void grow_chunk(EST_ChunkPtr &shared, EST_Chunk::EST_chunk_size inuse, EST_Chunk::EST_chunk_size newsize);
    friend void grow_chunk(EST_ChunkPtr &shared, EST_Chunk::EST_chunk_size newsize);

    // we print it by just printing the chunk
    friend ostream &operator << (ostream &s, const EST_ChunkPtr &cp) { return (s<< *cp.ptr); };

    friend void tester(void);
};

EST_ChunkPtr chunk_allocate(size_t bytes);
EST_ChunkPtr chunk_allocate(size_t bytes, const char *initial, size_t initial_len);
EST_ChunkPtr chunk_allocate(size_t bytes, const EST_ChunkPtr &initial, size_t initial_start, size_t initial_len);


#endif