libsanitizer/tsan/tsan_vector.h

   1 //===-- tsan_vector.h -------------------------------------------*- C++ -*-===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of ThreadSanitizer (TSan), a race detector.
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 // Low-fat STL-like vector container.
  13
  14 #ifndef TSAN_VECTOR_H
  15 #define TSAN_VECTOR_H
  16
  17 #include "tsan_defs.h"
  18 #include "tsan_mman.h"
  19
  20 namespace __tsan {
  21
  22 template<typename T>
  23 class Vector {
  24  public:
  25   explicit Vector(MBlockType typ)
  26       : typ_(typ)
  27       , begin_()
  28       , end_()
  29       , last_() {
  30   }
  31
  32   ~Vector() {
  33     if (begin_)
  34       internal_free(begin_);
  35   }
  36
  37   void Reset() {
  38     if (begin_)
  39       internal_free(begin_);
  40     begin_ = 0;
  41     end_ = 0;
  42     last_ = 0;
  43   }
  44
  45   uptr Size() const {
  46     return end_ - begin_;
  47   }
  48
  49   T &operator[](uptr i) {
  50     DCHECK_LT(i, end_ - begin_);
  51     return begin_[i];
  52   }
  53
  54   const T &operator[](uptr i) const {
  55     DCHECK_LT(i, end_ - begin_);
  56     return begin_[i];
  57   }
  58
  59   T *PushBack() {
  60     EnsureSize(Size() + 1);
  61     T *p = &end_[-1];
  62     internal_memset(p, 0, sizeof(*p));
  63     return p;
  64   }
  65
  66   T *PushBack(const T& v) {
  67     EnsureSize(Size() + 1);
  68     T *p = &end_[-1];
  69     internal_memcpy(p, &v, sizeof(*p));
  70     return p;
  71   }
  72
  73   void PopBack() {
  74     DCHECK_GT(end_, begin_);
  75     end_--;
  76   }
  77
  78   void Resize(uptr size) {
  79     uptr old_size = Size();
  80     EnsureSize(size);
  81     if (old_size < size) {
  82       for (uptr i = old_size; i < size; i++)
  83         internal_memset(&begin_[i], 0, sizeof(begin_[i]));
  84     }
  85   }
  86
  87  private:
  88   const MBlockType typ_;
  89   T *begin_;
  90   T *end_;
  91   T *last_;
  92
  93   void EnsureSize(uptr size) {
  94     if (size <= Size())
  95       return;
  96     if (size <= (uptr)(last_ - begin_)) {
  97       end_ = begin_ + size;
  98       return;
  99     }
 100     uptr cap0 = last_ - begin_;
 101     uptr cap = 2 * cap0;
 102     if (cap == 0)
 103       cap = 16;
 104     if (cap < size)
 105       cap = size;
 106     T *p = (T*)internal_alloc(typ_, cap * sizeof(T));
 107     if (cap0) {
 108       internal_memcpy(p, begin_, cap0 * sizeof(T));
 109       internal_free(begin_);
 110     }
 111     begin_ = p;
 112     end_ = begin_ + size;
 113     last_ = begin_ + cap;
 114   }
 115
 116   Vector(const Vector&);
 117   void operator=(const Vector&);
 118 };
 119 }  // namespace __tsan
 120
 121 #endif  // #ifndef TSAN_VECTOR_H