StampedPtr.h

Go to the documentation of this file.

/*
 * Copyright 2017-present Facebook, 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.
 */

#pragma once

#include <folly/lang/SafeAssert.h>

#include <stdint.h>

namespace folly {

template <typename T>
struct StampedPtr {
  uint64_t raw;

  /* IMPORTANT: default initialization doesn't result in a sane state */

  T* ptr() const {
    return unpackPtr(raw);
  }

  uint16_t stamp() const {
    return unpackStamp(raw);
  }

  void set(T* ptr, uint16_t stamp) {
    raw = pack(ptr, stamp);
  }

  void setPtr(T* ptr) {
    raw = pack(ptr, unpackStamp(raw));
  }

  void setStamp(uint16_t stamp) {
    raw = pack(unpackPtr(raw), stamp);
  }

  static T* unpackPtr(uint64_t raw) {
    // Canonical form means we need to extend bit 47 of the pointer to
    // bits 48..63 (unless the operating system never hands those pointers
    // to us, which is difficult to prove).  Signed right-shift of a
    // negative number is implementation-defined in C++ (not undefined!),
    // but actually does the right thing on all the platforms I can find.
    auto extended = static_cast<int64_t>(raw) >> kInternalStampBits;
    return reinterpret_cast<T*>(static_cast<intptr_t>(extended));
  }

  static uint16_t unpackStamp(uint64_t raw) {
    return static_cast<uint16_t>(raw);
  }

  static uint64_t pack(T* ptr, uint16_t stamp) {
    auto shifted = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(ptr))
        << kInternalStampBits;
    uint64_t raw = shifted | stamp;
    FOLLY_SAFE_DCHECK(unpackPtr(raw) == ptr, "ptr mismatch.");
    FOLLY_SAFE_DCHECK(unpackStamp(raw) == stamp, "stamp mismatch.");
    return raw;
  }

 private:
  // On 32-bit platforms it works okay to store a ptr in the top 48
  // bits of a 64-bit value, but it will result in unnecessary work.
  // If we align the pointer part at word granularity when we have the
  // space then no shifting will ever be needed.
  static constexpr unsigned kInternalStampBits = sizeof(void*) == 4 ? 32 : 16;
};

template <typename T>
StampedPtr<T> makeStampedPtr(T* ptr, uint16_t stamp) {
  return StampedPtr<T>{StampedPtr<T>::pack(ptr, stamp)};
}

} // namespace folly