memory-manager.icc

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Contributing authors:
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *
 *  Last modified:
 *     $Date: 2008-08-20 16:23:15 +0200 (Wed, 20 Aug 2008) $ by $Author: schulte $
 *     $Revision: 7660 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be
 *  included in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

namespace Gecode {

  namespace Memory {
    namespace Config {
      const size_t hcsz_min =  2 * 1024;
      const size_t hcsz_max = 64 * 1024;
      const int hcsz_inc_ratio = 8;
      const int hcsz_dec_ratio = 2;

      const int fl_unit_size = ((sizeof(void*) == 4) ? 2 : 3);
      const int fl_size_min  = ((sizeof(void*) == 4) ? 3 : 2);
      const int fl_size_max  = ((sizeof(void*) == 4) ? 3 : 3);
      const int fl_refill = 8;
#ifndef GECODE_MEMORY_ALIGNMENT
#define GECODE_MEMORY_ALIGNMENT 8
#endif
    }
  }

  class FreeList {
  protected:
    FreeList* _next;
  public:
    FreeList(void);
    FreeList(FreeList* n);
    FreeList* next(void) const;
    void next(FreeList* n);
  };

  class MemoryManager {
  private:
    class HeapChunk {
    public:
      HeapChunk* next;
      double area[1];
    };
  public:
    MemoryManager(void);
    MemoryManager(MemoryManager& mm, size_t s_sub);
    ~MemoryManager(void);

  private:
    size_t     cur_hcsz;  
    HeapChunk* cur_hc;    
    size_t     requested; 

    char*  start; 
    size_t lsz;   

    GECODE_KERNEL_EXPORT
    void alloc_refill(size_t s);
    void alloc_fill(size_t s, bool first);

  public:
    void* alloc(size_t s);
    size_t allocated(void) const;
    void* subscriptions(void) const;

  private:
    FreeList* fl[Memory::Config::fl_size_max-Memory::Config::fl_size_min+1];
    template <size_t> void fl_refill(void);
    static size_t sz2i(size_t);
    static size_t i2sz(size_t);

  public:
    template <size_t s>
    void* fl_alloc(void);
    template <size_t> void  fl_dispose(FreeList* f, FreeList* l);

  private:
    class ReuseChunk {
    public:
      size_t      size;
      ReuseChunk* next;
    };
    ReuseChunk* slack;
  public:
    void reuse(void* p, size_t s);
  };


  /*
   * Freelists
   *
   */

  forceinline
  FreeList::FreeList(void) {}

  forceinline
  FreeList::FreeList(FreeList* n)
    : _next(n) {}

  forceinline FreeList*
  FreeList::next(void) const {
    return _next;
  }

  forceinline void
  FreeList::next(FreeList* n) {
    _next = n;
  }

  forceinline size_t
  MemoryManager::sz2i(size_t s) {
    assert(s >= (Memory::Config::fl_size_min << Memory::Config::fl_unit_size));
    assert(s <= (Memory::Config::fl_size_max << Memory::Config::fl_unit_size));
    return (s >> Memory::Config::fl_unit_size) - Memory::Config::fl_size_min;
  }

  forceinline size_t
  MemoryManager::i2sz(size_t i) {
    return (i + Memory::Config::fl_size_min) << Memory::Config::fl_unit_size;
  }


  /*
   * The active memory manager
   *
   */

  forceinline size_t
  MemoryManager::allocated(void) const {
    return requested;
  }

  forceinline void*
  MemoryManager::alloc(size_t sz) {
    // Size must be a multiple of four
    assert((sz > 0) && ((sz % 4) == 0));
    // Performs alignment to 8 bytes
    sz += sz & ((GECODE_MEMORY_ALIGNMENT >> 1) & 4);
    // Check whether sufficient memory left
    if (sz > lsz)
      alloc_refill(sz);
    lsz -= sz;
    return start + lsz;
  }

  forceinline void*
  MemoryManager::subscriptions(void) const {
    return &cur_hc->area[0];
  }

  forceinline void
  MemoryManager::alloc_fill(size_t sz, bool first) {
    // Adjust current heap chunk size
    if (((requested > Memory::Config::hcsz_inc_ratio*cur_hcsz) ||
         (sz > cur_hcsz)) &&
        (cur_hcsz < Memory::Config::hcsz_max)) {
      cur_hcsz <<= 1;
    }
    // Increment the size that it caters for the initial overhead
    size_t overhead = sizeof(HeapChunk) - sizeof(double);
    sz += overhead;
    // Round size to next multiple of current heap chunk size
    size_t allocate = ((sz > cur_hcsz) ?
                       (((size_t) (sz / cur_hcsz)) + 1) * cur_hcsz : cur_hcsz);
    // Request a chunk of size allocate
    HeapChunk* hc = static_cast<HeapChunk*>(Memory::malloc(allocate));
    start = Support::ptr_cast<char*>(&hc->area[0]);
    lsz   = allocate - overhead;
    // Link heap chunk, where the first heap chunk is kept in place
    if (first) {
      requested = allocate;
      hc->next = NULL; cur_hc = hc;
    } else {
      requested += allocate;
      hc->next = cur_hc->next; cur_hc->next = hc;
    }
#ifdef GECODE_MEMORY_CHECK
    for (char* c = start; c < (start+lsz); c++)
      *c = 0;
#endif
  }

  forceinline
  MemoryManager::MemoryManager(void)
    : cur_hcsz(Memory::Config::hcsz_min), requested(0), slack(NULL) {
    alloc_fill(cur_hcsz,true);
    for (size_t i = Memory::Config::fl_size_max-Memory::Config::fl_size_min+1;
         i--; )
      fl[i] = NULL;
  }

  forceinline
  MemoryManager::MemoryManager(MemoryManager& mm, size_t s_sub)
    : cur_hcsz(mm.cur_hcsz), requested(0), slack(NULL) {
    s_sub += s_sub & ((GECODE_MEMORY_ALIGNMENT >> 1) & 4);
    if ((mm.requested < Memory::Config::hcsz_dec_ratio*mm.cur_hcsz) &&
        (cur_hcsz > Memory::Config::hcsz_min) &&
        (s_sub*2 < cur_hcsz))
      cur_hcsz >>= 1;
    alloc_fill(cur_hcsz+s_sub,true);
    // Skip the memory area at the beginning for subscriptions
    lsz   -= s_sub;
    start += s_sub;
    for (size_t i = Memory::Config::fl_size_max-Memory::Config::fl_size_min+1;
         i--; )
      fl[i] = NULL;
  }

  forceinline
  MemoryManager::~MemoryManager(void) {
    // Release all allocated heap chunks
    HeapChunk* hc = cur_hc;
    do {
      HeapChunk* t = hc; hc = hc->next;
      Memory::free(t);
    } while (hc != NULL);
  }



  /*
   * Slack memory management
   *
   */
  forceinline void
  MemoryManager::reuse(void* p, size_t s) {
#ifdef GECODE_MEMORY_CHECK
    {
      char* c = static_cast<char*>(p);
      char* e = c + s;
      while (c < e) {
        *c = 0; c++;
      }
    }
#endif
    if (s < (Memory::Config::fl_size_min<<Memory::Config::fl_unit_size))
      return;
    if (s > (Memory::Config::fl_size_max<<Memory::Config::fl_unit_size)) {
      ReuseChunk* rc = static_cast<ReuseChunk*>(p);
      rc->next = slack;
      rc->size = s;
      slack = rc;
    } else {
      size_t i = sz2i(s);
      FreeList* f = static_cast<FreeList*>(p);
      f->next(fl[i]); fl[i]=f;
    }
  }


  /*
   * Freelist management
   *
   */

  template <size_t s>
  forceinline void*
  MemoryManager::fl_alloc(void) {
    size_t i = sz2i(s);
    FreeList* f = fl[i];
    if (f == NULL) {
      fl_refill<s>(); f = fl[i];
    }
    FreeList* n = f->next();
    fl[i] = n;
    return f;
  }

  template <size_t s>
  forceinline void
  MemoryManager::fl_dispose(FreeList* f, FreeList* l) {
    size_t i = sz2i(s);
    l->next(fl[i]); fl[i] = f;
  }

  template <size_t sz>
  void
  MemoryManager::fl_refill(void) {
    // Try to acquire memory from slack
    if (slack != NULL) {
      ReuseChunk* m = slack;
      slack = NULL;
      do {
        char*  block = Support::ptr_cast<char*>(m);
        size_t s     = m->size;
        assert(s >= sz);
        m = m->next;
        fl[sz2i(sz)] = Support::ptr_cast<FreeList*>(block);
        while (s >= 2*sz) {
          Support::ptr_cast<FreeList*>(block)->next
            (Support::ptr_cast<FreeList*>(block+sz));
          block += sz;
          s     -= sz;
        }
        Support::ptr_cast<FreeList*>(block)->next(NULL);
      } while (m != NULL);
    } else {
      char* block = static_cast<char*>(alloc(Memory::Config::fl_refill*sz));
      fl[sz2i(sz)] = Support::ptr_cast<FreeList*>(block);
      int i = Memory::Config::fl_refill-2;
      do {
        Support::ptr_cast<FreeList*>(block+i*sz)->next
          (Support::ptr_cast<FreeList*>(block+(i+1)*sz));
      } while (--i >= 0);
      Support::ptr_cast<FreeList*>(block+
                                   (Memory::Config::fl_refill-1)*sz)->next
        (Support::ptr_cast<FreeList*>(NULL));
    }
  }

}

// STATISTICS: kernel-core