arena.h

Go to the documentation of this file.

/*
 * Copyright 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_KERNEL_BASE_ARENA_H_
#define PAGESPEED_KERNEL_BASE_ARENA_H_

#include <vector>
#include <cstddef>

#include "base/logging.h"
#include "pagespeed/kernel/base/basictypes.h"

namespace net_instaweb {

template<typename T>
class Arena {
 public:
  static const size_t kAlign = 8;

  Arena() {
    InitEmpty();
  }

  ~Arena() {
    CHECK(chunks_.empty());
  }

  void* Allocate(size_t size) {
    size += kAlign; 
    size = ExpandToAlign(size);

    DCHECK(sizeof(void*) <= kAlign);
    DCHECK(size < Chunk::kSize);

    if (next_alloc_ + size > chunk_end_) {
      AddChunk();
    }

    char* base = next_alloc_;

    char** our_last_link_field = reinterpret_cast<char**>(base);
    *last_link_ = base;
    *our_last_link_field = NULL;
    last_link_ = our_last_link_field;

    next_alloc_ += size;

    char* out = base + kAlign;
    DCHECK((reinterpret_cast<uintptr_t>(out) & (kAlign - 1)) == 0);
    return out;
  }

  void DestroyObjects();

  static size_t ExpandToAlign(size_t in) {
    return (in + kAlign - 1) & ~(kAlign - 1);
  }

 private:
  struct Chunk {
    static const size_t kSize = 8192;
    char buf[kSize];
  };

  void AddChunk();

  void InitEmpty();

  char* next_alloc_;

  char** last_link_;

  char* chunk_end_;

  char* scratch_;

  std::vector<Chunk*> chunks_;
};

template<typename T>
void Arena<T>::AddChunk() {
  Chunk* chunk = new Chunk();
  chunks_.push_back(chunk);
  next_alloc_ = chunk->buf;
  chunk_end_ = next_alloc_ + Chunk::kSize;
  last_link_ = &scratch_;
}

template<typename T>
void Arena<T>::DestroyObjects() {
  for (int i = 0; i < static_cast<int>(chunks_.size()); ++i) {
    char* base = chunks_[i]->buf;
    while (base != NULL) {
      reinterpret_cast<T*>(base + kAlign)->~T();
      base = *reinterpret_cast<char**>(base);
    }
    delete chunks_[i];
  }
  chunks_.clear();
  InitEmpty();
}

template<typename T>
void Arena<T>::InitEmpty() {
  next_alloc_ = NULL;
  last_link_ = NULL;
  chunk_end_ = NULL;
}

}  

#endif