1 // Copyright 2013 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_HYDROGEN_UNIQUE_H_ 6 #define V8_HYDROGEN_UNIQUE_H_ 7 8 #include "src/handles.h" 9 #include "src/objects.h" 10 #include "src/utils.h" 11 #include "src/zone.h" 12 13 namespace v8 { 14 namespace internal { 15 16 17 template <typename T> 18 class UniqueSet; 19 20 21 // Represents a handle to an object on the heap, but with the additional 22 // ability of checking for equality and hashing without accessing the heap. 23 // 24 // Creating a Unique<T> requires first dereferencing the handle to obtain 25 // the address of the object, which is used as the hashcode and the basis for 26 // comparison. The object can be moved later by the GC, but comparison 27 // and hashing use the old address of the object, without dereferencing it. 28 // 29 // Careful! Comparison of two Uniques is only correct if both were created 30 // in the same "era" of GC or if at least one is a non-movable object. 31 template <typename T> 32 class Unique V8_FINAL { 33 public: 34 // TODO(titzer): make private and introduce a uniqueness scope. 35 explicit Unique(Handle<T> handle) { 36 if (handle.is_null()) { 37 raw_address_ = NULL; 38 } else { 39 // This is a best-effort check to prevent comparing Unique<T>'s created 40 // in different GC eras; we require heap allocation to be disallowed at 41 // creation time. 42 // NOTE: we currently consider maps to be non-movable, so no special 43 // assurance is required for creating a Unique<Map>. 44 // TODO(titzer): other immortable immovable objects are also fine. 45 ASSERT(!AllowHeapAllocation::IsAllowed() || handle->IsMap()); 46 raw_address_ = reinterpret_cast<Address>(*handle); 47 ASSERT_NE(raw_address_, NULL); // Non-null should imply non-zero address. 48 } 49 handle_ = handle; 50 } 51 52 // TODO(titzer): this is a hack to migrate to Unique<T> incrementally. 53 Unique(Address raw_address, Handle<T> handle) 54 : raw_address_(raw_address), handle_(handle) { } 55 56 // Constructor for handling automatic up casting. 57 // Eg. Unique<JSFunction> can be passed when Unique<Object> is expected. 58 template <class S> Unique(Unique<S> uniq) { 59 #ifdef DEBUG 60 T* a = NULL; 61 S* b = NULL; 62 a = b; // Fake assignment to enforce type checks. 63 USE(a); 64 #endif 65 raw_address_ = uniq.raw_address_; 66 handle_ = uniq.handle_; 67 } 68 69 template <typename U> 70 inline bool operator==(const Unique<U>& other) const { 71 ASSERT(IsInitialized() && other.IsInitialized()); 72 return raw_address_ == other.raw_address_; 73 } 74 75 template <typename U> 76 inline bool operator!=(const Unique<U>& other) const { 77 ASSERT(IsInitialized() && other.IsInitialized()); 78 return raw_address_ != other.raw_address_; 79 } 80 81 inline intptr_t Hashcode() const { 82 ASSERT(IsInitialized()); 83 return reinterpret_cast<intptr_t>(raw_address_); 84 } 85 86 inline bool IsNull() const { 87 ASSERT(IsInitialized()); 88 return raw_address_ == NULL; 89 } 90 91 inline bool IsKnownGlobal(void* global) const { 92 ASSERT(IsInitialized()); 93 return raw_address_ == reinterpret_cast<Address>(global); 94 } 95 96 inline Handle<T> handle() const { 97 return handle_; 98 } 99 100 template <class S> static Unique<T> cast(Unique<S> that) { 101 return Unique<T>(that.raw_address_, Handle<T>::cast(that.handle_)); 102 } 103 104 inline bool IsInitialized() const { 105 return raw_address_ != NULL || handle_.is_null(); 106 } 107 108 // TODO(titzer): this is a hack to migrate to Unique<T> incrementally. 109 static Unique<T> CreateUninitialized(Handle<T> handle) { 110 return Unique<T>(reinterpret_cast<Address>(NULL), handle); 111 } 112 113 static Unique<T> CreateImmovable(Handle<T> handle) { 114 return Unique<T>(reinterpret_cast<Address>(*handle), handle); 115 } 116 117 friend class UniqueSet<T>; // Uses internal details for speed. 118 template <class U> 119 friend class Unique; // For comparing raw_address values. 120 121 private: 122 Unique<T>() : raw_address_(NULL) { } 123 124 Address raw_address_; 125 Handle<T> handle_; 126 127 friend class SideEffectsTracker; 128 }; 129 130 131 template <typename T> 132 class UniqueSet V8_FINAL : public ZoneObject { 133 public: 134 // Constructor. A new set will be empty. 135 UniqueSet() : size_(0), capacity_(0), array_(NULL) { } 136 137 // Capacity constructor. A new set will be empty. 138 UniqueSet(int capacity, Zone* zone) 139 : size_(0), capacity_(capacity), 140 array_(zone->NewArray<Unique<T> >(capacity)) { 141 ASSERT(capacity <= kMaxCapacity); 142 } 143 144 // Singleton constructor. 145 UniqueSet(Unique<T> uniq, Zone* zone) 146 : size_(1), capacity_(1), array_(zone->NewArray<Unique<T> >(1)) { 147 array_[0] = uniq; 148 } 149 150 // Add a new element to this unique set. Mutates this set. O(|this|). 151 void Add(Unique<T> uniq, Zone* zone) { 152 ASSERT(uniq.IsInitialized()); 153 // Keep the set sorted by the {raw_address} of the unique elements. 154 for (int i = 0; i < size_; i++) { 155 if (array_[i] == uniq) return; 156 if (array_[i].raw_address_ > uniq.raw_address_) { 157 // Insert in the middle. 158 Grow(size_ + 1, zone); 159 for (int j = size_ - 1; j >= i; j--) array_[j + 1] = array_[j]; 160 array_[i] = uniq; 161 size_++; 162 return; 163 } 164 } 165 // Append the element to the the end. 166 Grow(size_ + 1, zone); 167 array_[size_++] = uniq; 168 } 169 170 // Remove an element from this set. Mutates this set. O(|this|) 171 void Remove(Unique<T> uniq) { 172 for (int i = 0; i < size_; i++) { 173 if (array_[i] == uniq) { 174 while (++i < size_) array_[i - 1] = array_[i]; 175 size_--; 176 return; 177 } 178 } 179 } 180 181 // Compare this set against another set. O(|this|). 182 bool Equals(const UniqueSet<T>* that) const { 183 if (that->size_ != this->size_) return false; 184 for (int i = 0; i < this->size_; i++) { 185 if (this->array_[i] != that->array_[i]) return false; 186 } 187 return true; 188 } 189 190 // Check whether this set contains the given element. O(|this|) 191 // TODO(titzer): use binary search for large sets to make this O(log|this|) 192 template <typename U> 193 bool Contains(const Unique<U> elem) const { 194 for (int i = 0; i < this->size_; ++i) { 195 Unique<T> cand = this->array_[i]; 196 if (cand.raw_address_ >= elem.raw_address_) { 197 return cand.raw_address_ == elem.raw_address_; 198 } 199 } 200 return false; 201 } 202 203 // Check if this set is a subset of the given set. O(|this| + |that|). 204 bool IsSubset(const UniqueSet<T>* that) const { 205 if (that->size_ < this->size_) return false; 206 int j = 0; 207 for (int i = 0; i < this->size_; i++) { 208 Unique<T> sought = this->array_[i]; 209 while (true) { 210 if (sought == that->array_[j++]) break; 211 // Fail whenever there are more elements in {this} than {that}. 212 if ((this->size_ - i) > (that->size_ - j)) return false; 213 } 214 } 215 return true; 216 } 217 218 // Returns a new set representing the intersection of this set and the other. 219 // O(|this| + |that|). 220 UniqueSet<T>* Intersect(const UniqueSet<T>* that, Zone* zone) const { 221 if (that->size_ == 0 || this->size_ == 0) return new(zone) UniqueSet<T>(); 222 223 UniqueSet<T>* out = new(zone) UniqueSet<T>( 224 Min(this->size_, that->size_), zone); 225 226 int i = 0, j = 0, k = 0; 227 while (i < this->size_ && j < that->size_) { 228 Unique<T> a = this->array_[i]; 229 Unique<T> b = that->array_[j]; 230 if (a == b) { 231 out->array_[k++] = a; 232 i++; 233 j++; 234 } else if (a.raw_address_ < b.raw_address_) { 235 i++; 236 } else { 237 j++; 238 } 239 } 240 241 out->size_ = k; 242 return out; 243 } 244 245 // Returns a new set representing the union of this set and the other. 246 // O(|this| + |that|). 247 UniqueSet<T>* Union(const UniqueSet<T>* that, Zone* zone) const { 248 if (that->size_ == 0) return this->Copy(zone); 249 if (this->size_ == 0) return that->Copy(zone); 250 251 UniqueSet<T>* out = new(zone) UniqueSet<T>( 252 this->size_ + that->size_, zone); 253 254 int i = 0, j = 0, k = 0; 255 while (i < this->size_ && j < that->size_) { 256 Unique<T> a = this->array_[i]; 257 Unique<T> b = that->array_[j]; 258 if (a == b) { 259 out->array_[k++] = a; 260 i++; 261 j++; 262 } else if (a.raw_address_ < b.raw_address_) { 263 out->array_[k++] = a; 264 i++; 265 } else { 266 out->array_[k++] = b; 267 j++; 268 } 269 } 270 271 while (i < this->size_) out->array_[k++] = this->array_[i++]; 272 while (j < that->size_) out->array_[k++] = that->array_[j++]; 273 274 out->size_ = k; 275 return out; 276 } 277 278 // Returns a new set representing all elements from this set which are not in 279 // that set. O(|this| * |that|). 280 UniqueSet<T>* Subtract(const UniqueSet<T>* that, Zone* zone) const { 281 if (that->size_ == 0) return this->Copy(zone); 282 283 UniqueSet<T>* out = new(zone) UniqueSet<T>(this->size_, zone); 284 285 int i = 0, j = 0; 286 while (i < this->size_) { 287 Unique<T> cand = this->array_[i]; 288 if (!that->Contains(cand)) { 289 out->array_[j++] = cand; 290 } 291 i++; 292 } 293 294 out->size_ = j; 295 return out; 296 } 297 298 // Makes an exact copy of this set. O(|this|). 299 UniqueSet<T>* Copy(Zone* zone) const { 300 UniqueSet<T>* copy = new(zone) UniqueSet<T>(this->size_, zone); 301 copy->size_ = this->size_; 302 memcpy(copy->array_, this->array_, this->size_ * sizeof(Unique<T>)); 303 return copy; 304 } 305 306 void Clear() { 307 size_ = 0; 308 } 309 310 inline int size() const { 311 return size_; 312 } 313 314 inline Unique<T> at(int index) const { 315 ASSERT(index >= 0 && index < size_); 316 return array_[index]; 317 } 318 319 private: 320 // These sets should be small, since operations are implemented with simple 321 // linear algorithms. Enforce a maximum size. 322 static const int kMaxCapacity = 65535; 323 324 uint16_t size_; 325 uint16_t capacity_; 326 Unique<T>* array_; 327 328 // Grow the size of internal storage to be at least {size} elements. 329 void Grow(int size, Zone* zone) { 330 CHECK(size < kMaxCapacity); // Enforce maximum size. 331 if (capacity_ < size) { 332 int new_capacity = 2 * capacity_ + size; 333 if (new_capacity > kMaxCapacity) new_capacity = kMaxCapacity; 334 Unique<T>* new_array = zone->NewArray<Unique<T> >(new_capacity); 335 if (size_ > 0) { 336 memcpy(new_array, array_, size_ * sizeof(Unique<T>)); 337 } 338 capacity_ = new_capacity; 339 array_ = new_array; 340 } 341 } 342 }; 343 344 345 } } // namespace v8::internal 346 347 #endif // V8_HYDROGEN_UNIQUE_H_ 348