MiraclePtr: Rewrite dawn/common (linux)
1. Run the clang rewriter:
./tools/clang/rewrite_raw_ptr_fields/rewrite.sh
2. Add manually the missing AllowPtrArithmetic and DanglingUntriaged.
3. Split the patch
This is step 6 of using MiraclePtr in third_party/dawn project:
https://docs.google.com/document/d/1wz45t0alQthsIU9P7_rQcfQyqnrBMXzrOjSzdQo-V-A/edit#heading=h.vn4i6wy373x7
Bug: chromium:1464560
Change-Id: I3bb837fb517fbb39ee3c58528651c0c74e76110d
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/165501
Commit-Queue: Arthur Sonzogni <arthursonzogni@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
diff --git a/src/dawn/common/BUILD.gn b/src/dawn/common/BUILD.gn
index 775fde7..48f594b 100644
--- a/src/dawn/common/BUILD.gn
+++ b/src/dawn/common/BUILD.gn
@@ -305,6 +305,7 @@
public_deps = [
":dawn_gpu_info_gen",
":dawn_version_gen",
+ "${dawn_root}/src/dawn/partition_alloc:raw_ptr",
]
if (is_apple) {
diff --git a/src/dawn/common/CMakeLists.txt b/src/dawn/common/CMakeLists.txt
index cfbcce8..740d5e3 100644
--- a/src/dawn/common/CMakeLists.txt
+++ b/src/dawn/common/CMakeLists.txt
@@ -122,7 +122,11 @@
)
endif()
-target_link_libraries(dawn_common PUBLIC dawncpp_headers PRIVATE dawn_internal_config)
+target_link_libraries(dawn_common
+ PUBLIC dawncpp_headers
+ PUBLIC partition_alloc
+ PRIVATE dawn_internal_config
+)
# TODO Android Log support
# TODO Vulkan headers support
diff --git a/src/dawn/common/ContentLessObjectCache.h b/src/dawn/common/ContentLessObjectCache.h
index 2f6b8fe..8a7a755 100644
--- a/src/dawn/common/ContentLessObjectCache.h
+++ b/src/dawn/common/ContentLessObjectCache.h
@@ -40,6 +40,7 @@
#include "dawn/common/RefCounted.h"
#include "dawn/common/StackContainer.h"
#include "dawn/common/WeakRef.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -55,7 +56,7 @@
template <typename RefCountedT>
struct ForErase {
explicit ForErase(RefCountedT* value) : mValue(value) {}
- RefCountedT* mValue;
+ raw_ptr<RefCountedT> mValue;
};
// All cached WeakRefs must have an immutable hash value determined at insertion. This ensures that
@@ -165,7 +166,7 @@
return result;
}
- ContentLessObjectCache<RefCountedT>* mCache = nullptr;
+ raw_ptr<ContentLessObjectCache<RefCountedT>> mCache = nullptr;
};
};
@@ -284,7 +285,7 @@
// deadlocks on the mutex. Since the default max_load_factor of most std::unordered_set
// implementations should be 1.0 (roughly 1 element per bucket), a StackVector of length 4
// should be enough space in most cases. See dawn:1993 for more details.
- StackVector<Ref<RefCountedT>, 4>* mTemporaryRefs = nullptr;
+ raw_ptr<StackVector<Ref<RefCountedT>, 4>> mTemporaryRefs = nullptr;
};
} // namespace dawn
diff --git a/src/dawn/common/ContentLessObjectCacheable.h b/src/dawn/common/ContentLessObjectCacheable.h
index e732e3d..e19d39c 100644
--- a/src/dawn/common/ContentLessObjectCacheable.h
+++ b/src/dawn/common/ContentLessObjectCacheable.h
@@ -29,6 +29,7 @@
#define SRC_DAWN_COMMON_CONTENTLESSOBJECTCACHEABLE_H_
#include "dawn/common/WeakRefSupport.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -68,7 +69,7 @@
// Pointer to the owning cache if we were inserted at any point. This is set via the
// Insert/Erase functions on the cache.
- ContentLessObjectCache<RefCountedT>* mCache = nullptr;
+ raw_ptr<ContentLessObjectCache<RefCountedT>> mCache = nullptr;
};
} // namespace dawn
diff --git a/src/dawn/common/Enumerator.h b/src/dawn/common/Enumerator.h
index 7227ca1..1121e4f 100644
--- a/src/dawn/common/Enumerator.h
+++ b/src/dawn/common/Enumerator.h
@@ -31,6 +31,8 @@
#include <type_traits>
#include <utility>
+#include "partition_alloc/pointers/raw_ptr.h"
+
namespace dawn {
// An iterator over a range that gives both the index and the value. It can be used like so:
@@ -59,17 +61,17 @@
private:
Index mIndex;
- Value* mValue;
+ raw_ptr<Value, AllowPtrArithmetic> mValue;
};
- Iterator begin() const { return Iterator(Index{}, mBegin); }
+ Iterator begin() const { return Iterator(Index{}, mBegin.get()); }
// Note that iterator comparison only uses mIndex, so we can save the computation of mValue for
// the end() iterator.
Iterator end() const { return Iterator(mSize, nullptr); }
private:
Index mSize;
- Value* mBegin;
+ raw_ptr<Value> mBegin;
};
template <typename T,
diff --git a/src/dawn/common/HashUtils.h b/src/dawn/common/HashUtils.h
index 9bf5c1a..1fb679e 100644
--- a/src/dawn/common/HashUtils.h
+++ b/src/dawn/common/HashUtils.h
@@ -34,6 +34,7 @@
#include "dawn/common/Platform.h"
#include "dawn/common/TypedInteger.h"
#include "dawn/common/ityp_bitset.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -44,6 +45,11 @@
return std::hash<T>()(value);
}
+template <typename T, partition_alloc::internal::RawPtrTraits Traits>
+size_t Hash(const raw_ptr<T, Traits>& value) {
+ return Hash(value.get());
+}
+
// Add hashing of TypedIntegers
template <typename Tag, typename T>
size_t Hash(const TypedInteger<Tag, T>& value) {
diff --git a/src/dawn/common/LinkedList.h b/src/dawn/common/LinkedList.h
index 16c710a..02ef59c 100644
--- a/src/dawn/common/LinkedList.h
+++ b/src/dawn/common/LinkedList.h
@@ -12,6 +12,7 @@
#define SRC_DAWN_COMMON_LINKEDLIST_H_
#include "dawn/common/Assert.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -171,8 +172,8 @@
private:
friend class LinkedList<T>;
- LinkNode<T>* previous_;
- LinkNode<T>* next_;
+ raw_ptr<LinkNode<T>> previous_;
+ raw_ptr<LinkNode<T>> next_;
};
template <typename T>
@@ -233,8 +234,8 @@
LinkNode<T>* operator*() const { return current_; }
private:
- LinkNode<T>* current_;
- LinkNode<T>* next_;
+ raw_ptr<LinkNode<T>> current_;
+ raw_ptr<LinkNode<T>> next_;
};
template <typename T>
diff --git a/src/dawn/common/Math.h b/src/dawn/common/Math.h
index 88083cc..7ef28b5 100644
--- a/src/dawn/common/Math.h
+++ b/src/dawn/common/Math.h
@@ -37,6 +37,7 @@
#include <type_traits>
#include "dawn/common/Assert.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -105,6 +106,11 @@
~(alignment - 1));
}
+template <typename T, partition_alloc::internal::RawPtrTraits Traits>
+DAWN_FORCE_INLINE T* AlignPtr(raw_ptr<T, Traits> ptr, size_t alignment) {
+ return AlignPtr(ptr.get(), alignment);
+}
+
template <typename T>
DAWN_FORCE_INLINE const T* AlignPtr(const T* ptr, size_t alignment) {
DAWN_ASSERT(IsPowerOfTwo(alignment));
diff --git a/src/dawn/common/MutexProtected.h b/src/dawn/common/MutexProtected.h
index 051822e..171c3c6 100644
--- a/src/dawn/common/MutexProtected.h
+++ b/src/dawn/common/MutexProtected.h
@@ -33,6 +33,7 @@
#include "dawn/common/Mutex.h"
#include "dawn/common/Ref.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -73,8 +74,8 @@
using ReturnType = typename UnwrapRef<T>::type;
// It's the programmer's burden to not save the pointer/reference and reuse it without the lock.
- ReturnType* operator->() { return Traits::GetObj(mObj); }
- ReturnType& operator*() { return *Traits::GetObj(mObj); }
+ ReturnType* operator->() { return Traits::GetObj(mObj.get()); }
+ ReturnType& operator*() { return *Traits::GetObj(mObj.get()); }
const ReturnType* operator->() const { return Traits::GetObj(mObj); }
const ReturnType& operator*() const { return *Traits::GetObj(mObj); }
@@ -85,7 +86,7 @@
Guard(T* obj, typename Traits::MutexType& mutex) : mLock(Traits::GetMutex(mutex)), mObj(obj) {}
typename Traits::LockType mLock;
- T* const mObj;
+ const raw_ptr<T> mObj;
};
} // namespace detail
diff --git a/src/dawn/common/SerialStorage.h b/src/dawn/common/SerialStorage.h
index 13b6c7d..f7dc526 100644
--- a/src/dawn/common/SerialStorage.h
+++ b/src/dawn/common/SerialStorage.h
@@ -32,6 +32,7 @@
#include <utility>
#include "dawn/common/Assert.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -62,7 +63,7 @@
// Special case the mSerialIterator when it should be equal to mStorageIterator.begin()
// otherwise we could ask mStorageIterator.begin() when mStorageIterator is mStorage.end()
// which is invalid. mStorageIterator.begin() is tagged with a nullptr.
- Value* mSerialIterator;
+ raw_ptr<Value, AllowPtrArithmetic> mSerialIterator;
};
class ConstIterator {
@@ -76,7 +77,7 @@
private:
ConstStorageIterator mStorageIterator;
- const Value* mSerialIterator;
+ raw_ptr<const Value, AllowPtrArithmetic> mSerialIterator;
};
class BeginEnd {
diff --git a/src/dawn/common/SlabAllocator.h b/src/dawn/common/SlabAllocator.h
index 4b73524..a20718f 100644
--- a/src/dawn/common/SlabAllocator.h
+++ b/src/dawn/common/SlabAllocator.h
@@ -34,6 +34,7 @@
#include "dawn/common/Numeric.h"
#include "dawn/common/PlacementAllocated.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -98,10 +99,16 @@
void Splice();
- char* allocation;
- IndexLinkNode* freeList;
- Slab* prev;
- Slab* next;
+ // TODO(crbug.com/dawn/2341): Both pointer are dangling in
+ // `dawn_perf_tests`, and `this` is not released before the end of the
+ // test. A side effect from one test to the next might cause difficult
+ // to reproduce flakes. Test:
+ // DrawCallPerf.Run/Vulkan_llvmpipe__LLVM_16_0_6__256_bits__MultipleVertexBuffers
+ raw_ptr<char, LeakedDanglingUntriaged> allocation;
+ raw_ptr<IndexLinkNode, LeakedDanglingUntriaged> freeList;
+
+ raw_ptr<Slab, DanglingUntriaged> prev;
+ raw_ptr<Slab, DanglingUntriaged> next;
Index blocksInUse;
};
diff --git a/src/dawn/common/StackContainer.h b/src/dawn/common/StackContainer.h
index 2e03749..19d6806 100644
--- a/src/dawn/common/StackContainer.h
+++ b/src/dawn/common/StackContainer.h
@@ -12,6 +12,7 @@
#include <vector>
#include "dawn/common/Compiler.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -113,7 +114,7 @@
}
private:
- Source* source_;
+ raw_ptr<Source> source_;
};
// A wrapper around STL containers that maintains a stack-sized buffer that the
diff --git a/src/dawn/common/WeakRefSupport.cpp b/src/dawn/common/WeakRefSupport.cpp
index 7bbb79b..35f89bd 100644
--- a/src/dawn/common/WeakRefSupport.cpp
+++ b/src/dawn/common/WeakRefSupport.cpp
@@ -38,7 +38,7 @@
if (!mValue || !mValue->mRefCount.TryIncrement()) {
return nullptr;
}
- return AcquireRef(mValue);
+ return AcquireRef(mValue.get());
}
RefCounted* WeakRefData::UnsafeGet() const {
diff --git a/src/dawn/common/WeakRefSupport.h b/src/dawn/common/WeakRefSupport.h
index 173222b..b318fc5 100644
--- a/src/dawn/common/WeakRefSupport.h
+++ b/src/dawn/common/WeakRefSupport.h
@@ -30,6 +30,7 @@
#include "dawn/common/Compiler.h"
#include "dawn/common/Ref.h"
+#include "partition_alloc/pointers/raw_ptr.h"
namespace dawn {
@@ -54,7 +55,7 @@
private:
std::mutex mMutex;
- RefCounted* mValue = nullptr;
+ raw_ptr<RefCounted> mValue = nullptr;
};
// Interface base class used to enable compile-time verification of WeakRefSupport functions.
diff --git a/src/dawn/partition_alloc/partition_alloc/pointers/raw_ptr.h b/src/dawn/partition_alloc/partition_alloc/pointers/raw_ptr.h
index fd19b53..f61f04f 100644
--- a/src/dawn/partition_alloc/partition_alloc/pointers/raw_ptr.h
+++ b/src/dawn/partition_alloc/partition_alloc/pointers/raw_ptr.h
@@ -348,6 +348,7 @@
using partition_alloc::internal::RawPtrTraits;
constexpr RawPtrTraits DisableDanglingPtrDetection = 0;
constexpr RawPtrTraits DanglingUntriaged = 0;
+constexpr RawPtrTraits LeakedDanglingUntriaged = 0;
constexpr RawPtrTraits AllowPtrArithmetic = 0;
namespace std {
