encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-07-07 13:45:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename namespace dawn_platform to dawn::platform.

Browse Source 
But keep a namespace alias to avoid breaking project that depend on the
previous namespace name while they get updated.

Some TraceEvent.h macro were using "platform" as an argument name so
that was renamed to "platformObj" to avoid conflicting with ::platform::

Bug: dawn:824
Change-Id: Iaf14853f02b0d9fcf866ce87788f87a3fdf8f364
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/75541
Auto-Submit: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Austin Eng <enga@chromium.org>
This commit is contained in:
Corentin Wallez 2022-01-11 02:10:53 +00:00 committed by Dawn LUCI CQ
parent e53bfc561c
commit 8bf8587eb3
25 changed files with 137 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/dawn_native/AsyncTask.cpp
View File

@ -4,7 +4,7 @@
namespace dawn_native { namespace dawn_native {
AsyncTaskManager::AsyncTaskManager(dawn_platform::WorkerTaskPool* workerTaskPool) AsyncTaskManager::AsyncTaskManager(dawn::platform::WorkerTaskPool* workerTaskPool)
: mWorkerTaskPool(workerTaskPool) { : mWorkerTaskPool(workerTaskPool) {
} }

10
src/dawn_native/AsyncTask.h
View File

@ -22,10 +22,10 @@
#include "common/RefCounted.h" #include "common/RefCounted.h"
namespace dawn_platform { namespace dawn::platform {
class WaitableEvent; class WaitableEvent;
class WorkerTaskPool; class WorkerTaskPool;
} // namespace dawn_platform } // namespace dawn::platform
namespace dawn_native { namespace dawn_native {
@ -38,7 +38,7 @@ namespace dawn_native {
class AsyncTaskManager { class AsyncTaskManager {
public: public:
explicit AsyncTaskManager(dawn_platform::WorkerTaskPool* workerTaskPool); explicit AsyncTaskManager(dawn::platform::WorkerTaskPool* workerTaskPool);
void PostTask(AsyncTask asyncTask); void PostTask(AsyncTask asyncTask);
void WaitAllPendingTasks(); void WaitAllPendingTasks();
@ -49,7 +49,7 @@ namespace dawn_native {
public: public:
AsyncTask asyncTask; AsyncTask asyncTask;
AsyncTaskManager* taskManager; AsyncTaskManager* taskManager;
std::unique_ptr<dawn_platform::WaitableEvent> waitableEvent; std::unique_ptr<dawn::platform::WaitableEvent> waitableEvent;
}; };
static void DoWaitableTask(void* task); static void DoWaitableTask(void* task);
@ -57,7 +57,7 @@ namespace dawn_native {
std::mutex mPendingTasksMutex; std::mutex mPendingTasksMutex;
std::unordered_map<WaitableTask*, Ref<WaitableTask>> mPendingTasks; std::unordered_map<WaitableTask*, Ref<WaitableTask>> mPendingTasks;
dawn_platform::WorkerTaskPool* mWorkerTaskPool; dawn::platform::WorkerTaskPool* mWorkerTaskPool;
}; };
} // namespace dawn_native } // namespace dawn_native

2
src/dawn_native/DawnNative.cpp
View File

@ -262,7 +262,7 @@ namespace dawn_native {
mImpl->EnableBeginCaptureOnStartup(beginCaptureOnStartup); mImpl->EnableBeginCaptureOnStartup(beginCaptureOnStartup);
} }
void Instance::SetPlatform(dawn_platform::Platform* platform) { void Instance::SetPlatform(dawn::platform::Platform* platform) {
mImpl->SetPlatform(platform); mImpl->SetPlatform(platform);
} }

4
src/dawn_native/Device.cpp
View File

@ -595,7 +595,7 @@ namespace dawn_native {
return mAdapter; return mAdapter;
} }
dawn_platform::Platform* DeviceBase::GetPlatform() const { dawn::platform::Platform* DeviceBase::GetPlatform() const {
return GetAdapter()->GetInstance()->GetPlatform(); return GetAdapter()->GetInstance()->GetPlatform();
} }
@ -1649,7 +1649,7 @@ namespace dawn_native {
return mCallbackTaskManager.get(); return mCallbackTaskManager.get();
} }
dawn_platform::WorkerTaskPool* DeviceBase::GetWorkerTaskPool() const { dawn::platform::WorkerTaskPool* DeviceBase::GetWorkerTaskPool() const {
return mWorkerTaskPool.get(); return mWorkerTaskPool.get();
} }

10
src/dawn_native/Device.h
View File

@ -33,9 +33,9 @@
#include <mutex> #include <mutex>
#include <utility> #include <utility>
namespace dawn_platform { namespace dawn::platform {
class WorkerTaskPool; class WorkerTaskPool;
} // namespace dawn_platform } // namespace dawn::platform
namespace dawn_native { namespace dawn_native {
class AdapterBase; class AdapterBase;
@ -126,7 +126,7 @@ namespace dawn_native {
MaybeError ValidateObject(const ApiObjectBase* object) const; MaybeError ValidateObject(const ApiObjectBase* object) const;
AdapterBase* GetAdapter() const; AdapterBase* GetAdapter() const;
dawn_platform::Platform* GetPlatform() const; dawn::platform::Platform* GetPlatform() const;
// Returns the Format corresponding to the wgpu::TextureFormat or an error if the format // Returns the Format corresponding to the wgpu::TextureFormat or an error if the format
// isn't a valid wgpu::TextureFormat or isn't supported by this device. // isn't a valid wgpu::TextureFormat or isn't supported by this device.
@ -353,7 +353,7 @@ namespace dawn_native {
AsyncTaskManager* GetAsyncTaskManager() const; AsyncTaskManager* GetAsyncTaskManager() const;
CallbackTaskManager* GetCallbackTaskManager() const; CallbackTaskManager* GetCallbackTaskManager() const;
dawn_platform::WorkerTaskPool* GetWorkerTaskPool() const; dawn::platform::WorkerTaskPool* GetWorkerTaskPool() const;
void AddComputePipelineAsyncCallbackTask(Ref<ComputePipelineBase> pipeline, void AddComputePipelineAsyncCallbackTask(Ref<ComputePipelineBase> pipeline,
std::string errorMessage, std::string errorMessage,
@ -536,7 +536,7 @@ namespace dawn_native {
std::unique_ptr<PersistentCache> mPersistentCache; std::unique_ptr<PersistentCache> mPersistentCache;
std::unique_ptr<CallbackTaskManager> mCallbackTaskManager; std::unique_ptr<CallbackTaskManager> mCallbackTaskManager;
std::unique_ptr<dawn_platform::WorkerTaskPool> mWorkerTaskPool; std::unique_ptr<dawn::platform::WorkerTaskPool> mWorkerTaskPool;
std::string mLabel; std::string mLabel;
}; };

6
src/dawn_native/Instance.cpp
View File

@ -272,17 +272,17 @@ namespace dawn_native {
return mBeginCaptureOnStartup; return mBeginCaptureOnStartup;
} }
void InstanceBase::SetPlatform(dawn_platform::Platform* platform) { void InstanceBase::SetPlatform(dawn::platform::Platform* platform) {
mPlatform = platform; mPlatform = platform;
} }
dawn_platform::Platform* InstanceBase::GetPlatform() { dawn::platform::Platform* InstanceBase::GetPlatform() {
if (mPlatform != nullptr) { if (mPlatform != nullptr) {
return mPlatform; return mPlatform;
} }
if (mDefaultPlatform == nullptr) { if (mDefaultPlatform == nullptr) {
mDefaultPlatform = std::make_unique<dawn_platform::Platform>(); mDefaultPlatform = std::make_unique<dawn::platform::Platform>();
} }
return mDefaultPlatform.get(); return mDefaultPlatform.get();
} }

12
src/dawn_native/Instance.h
View File

@ -28,9 +28,9 @@
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
namespace dawn_platform { namespace dawn::platform {
class Platform; class Platform;
} // namespace dawn_platform } // namespace dawn::platform
namespace dawn_native { namespace dawn_native {
@ -73,8 +73,8 @@ namespace dawn_native {
void EnableBeginCaptureOnStartup(bool beginCaptureOnStartup); void EnableBeginCaptureOnStartup(bool beginCaptureOnStartup);
bool IsBeginCaptureOnStartupEnabled() const; bool IsBeginCaptureOnStartupEnabled() const;
void SetPlatform(dawn_platform::Platform* platform); void SetPlatform(dawn::platform::Platform* platform);
dawn_platform::Platform* GetPlatform(); dawn::platform::Platform* GetPlatform();
// Get backend-independent libraries that need to be loaded dynamically. // Get backend-independent libraries that need to be loaded dynamically.
const XlibXcbFunctions* GetOrCreateXlibXcbFunctions(); const XlibXcbFunctions* GetOrCreateXlibXcbFunctions();
@ -103,8 +103,8 @@ namespace dawn_native {
bool mBeginCaptureOnStartup = false; bool mBeginCaptureOnStartup = false;
BackendValidationLevel mBackendValidationLevel = BackendValidationLevel::Disabled; BackendValidationLevel mBackendValidationLevel = BackendValidationLevel::Disabled;
dawn_platform::Platform* mPlatform = nullptr; dawn::platform::Platform* mPlatform = nullptr;
std::unique_ptr<dawn_platform::Platform> mDefaultPlatform; std::unique_ptr<dawn::platform::Platform> mDefaultPlatform;
std::vector<std::unique_ptr<BackendConnection>> mBackends; std::vector<std::unique_ptr<BackendConnection>> mBackends;
std::vector<std::unique_ptr<AdapterBase>> mAdapters; std::vector<std::unique_ptr<AdapterBase>> mAdapters;

4
src/dawn_native/PersistentCache.cpp
View File

@ -51,11 +51,11 @@ namespace dawn_native {
mCache->StoreData(ToAPI(mDevice), key.data(), key.size(), value, size); mCache->StoreData(ToAPI(mDevice), key.data(), key.size(), value, size);
} }
dawn_platform::CachingInterface* PersistentCache::GetPlatformCache() { dawn::platform::CachingInterface* PersistentCache::GetPlatformCache() {
// TODO(dawn:549): Create a fingerprint of concatenated version strings (ex. Tint commit // TODO(dawn:549): Create a fingerprint of concatenated version strings (ex. Tint commit
// hash, Dawn commit hash). This will be used by the client so it may know when to discard // hash, Dawn commit hash). This will be used by the client so it may know when to discard
// previously cached Dawn objects should this fingerprint change. // previously cached Dawn objects should this fingerprint change.
dawn_platform::Platform* platform = mDevice->GetPlatform(); dawn::platform::Platform* platform = mDevice->GetPlatform();
if (platform != nullptr) { if (platform != nullptr) {
return platform->GetCachingInterface(/*fingerprint*/ nullptr, /*fingerprintSize*/ 0); return platform->GetCachingInterface(/*fingerprint*/ nullptr, /*fingerprintSize*/ 0);
} }

6
src/dawn_native/PersistentCache.h
View File

@ -20,7 +20,7 @@
#include <mutex> #include <mutex>
#include <vector> #include <vector>
namespace dawn_platform { namespace dawn::platform {
class CachingInterface; class CachingInterface;
} }
@ -80,12 +80,12 @@ namespace dawn_native {
ScopedCachedBlob LoadData(const PersistentCacheKey& key); ScopedCachedBlob LoadData(const PersistentCacheKey& key);
void StoreData(const PersistentCacheKey& key, const void* value, size_t size); void StoreData(const PersistentCacheKey& key, const void* value, size_t size);
dawn_platform::CachingInterface* GetPlatformCache(); dawn::platform::CachingInterface* GetPlatformCache();
DeviceBase* mDevice = nullptr; DeviceBase* mDevice = nullptr;
std::mutex mMutex; std::mutex mMutex;
dawn_platform::CachingInterface* mCache = nullptr; dawn::platform::CachingInterface* mCache = nullptr;
}; };
} // namespace dawn_native } // namespace dawn_native

10
src/dawn_platform/DawnPlatform.cpp
View File

@ -17,7 +17,7 @@
#include "common/Assert.h" #include "common/Assert.h"
namespace dawn_platform { namespace dawn::platform {
CachingInterface::CachingInterface() = default; CachingInterface::CachingInterface() = default;
@ -51,13 +51,13 @@ namespace dawn_platform {
return 0; return 0;
} }
dawn_platform::CachingInterface* Platform::GetCachingInterface(const void* fingerprint, dawn::platform::CachingInterface* Platform::GetCachingInterface(const void* fingerprint,
size_t fingerprintSize) { size_t fingerprintSize) {
return nullptr; return nullptr;
} }
std::unique_ptr<dawn_platform::WorkerTaskPool> Platform::CreateWorkerTaskPool() { std::unique_ptr<dawn::platform::WorkerTaskPool> Platform::CreateWorkerTaskPool() {
return std::make_unique<AsyncWorkerThreadPool>(); return std::make_unique<AsyncWorkerThreadPool>();
} }
} // namespace dawn_platform } // namespace dawn::platform

10
src/dawn_platform/WorkerThread.cpp
View File

@ -51,7 +51,7 @@ namespace {
bool mIsComplete; bool mIsComplete;
}; };
class AsyncWaitableEvent final : public dawn_platform::WaitableEvent { class AsyncWaitableEvent final : public dawn::platform::WaitableEvent {
public: public:
explicit AsyncWaitableEvent() explicit AsyncWaitableEvent()
: mWaitableEventImpl(std::make_shared<AsyncWaitableEventImpl>()) { : mWaitableEventImpl(std::make_shared<AsyncWaitableEventImpl>()) {
@ -75,10 +75,10 @@ namespace {
} // anonymous namespace } // anonymous namespace
namespace dawn_platform { namespace dawn::platform {
std::unique_ptr<dawn_platform::WaitableEvent> AsyncWorkerThreadPool::PostWorkerTask( std::unique_ptr<dawn::platform::WaitableEvent> AsyncWorkerThreadPool::PostWorkerTask(
dawn_platform::PostWorkerTaskCallback callback, dawn::platform::PostWorkerTaskCallback callback,
void* userdata) { void* userdata) {
std::unique_ptr<AsyncWaitableEvent> waitableEvent = std::make_unique<AsyncWaitableEvent>(); std::unique_ptr<AsyncWaitableEvent> waitableEvent = std::make_unique<AsyncWaitableEvent>();
@ -94,4 +94,4 @@ namespace dawn_platform {
return waitableEvent; return waitableEvent;
} }
} // namespace dawn_platform } // namespace dawn::platform

10
src/dawn_platform/WorkerThread.h
View File

@ -18,15 +18,15 @@
#include "common/NonCopyable.h" #include "common/NonCopyable.h"
#include "dawn_platform/DawnPlatform.h" #include "dawn_platform/DawnPlatform.h"
namespace dawn_platform { namespace dawn::platform {
class AsyncWorkerThreadPool : public dawn_platform::WorkerTaskPool, public NonCopyable { class AsyncWorkerThreadPool : public dawn::platform::WorkerTaskPool, public NonCopyable {
public: public:
std::unique_ptr<dawn_platform::WaitableEvent> PostWorkerTask( std::unique_ptr<dawn::platform::WaitableEvent> PostWorkerTask(
dawn_platform::PostWorkerTaskCallback callback, dawn::platform::PostWorkerTaskCallback callback,
void* userdata) override; void* userdata) override;
}; };
} // namespace dawn_platform } // namespace dawn::platform
#endif #endif

4
src/dawn_platform/tracing/EventTracer.cpp
View File

@ -16,7 +16,7 @@
#include "common/Assert.h" #include "common/Assert.h"
#include "dawn_platform/DawnPlatform.h" #include "dawn_platform/DawnPlatform.h"
namespace dawn_platform::tracing { namespace dawn::platform::tracing {
const unsigned char* GetTraceCategoryEnabledFlag(Platform* platform, TraceCategory category) { const unsigned char* GetTraceCategoryEnabledFlag(Platform* platform, TraceCategory category) {
static unsigned char disabled = 0; static unsigned char disabled = 0;
@ -55,4 +55,4 @@ namespace dawn_platform::tracing {
return static_cast<TraceEventHandle>(0); return static_cast<TraceEventHandle>(0);
} }
} // namespace dawn_platform::tracing } // namespace dawn::platform::tracing

4
src/dawn_platform/tracing/EventTracer.h
View File

@ -19,7 +19,7 @@
#include <cstdint> #include <cstdint>
namespace dawn_platform { namespace dawn::platform {
class Platform; class Platform;
enum class TraceCategory; enum class TraceCategory;
@ -46,6 +46,6 @@ namespace dawn_platform {
unsigned char flags); unsigned char flags);
} // namespace tracing } // namespace tracing
} // namespace dawn_platform } // namespace dawn::platform
#endif // DAWNPLATFORM_TRACING_EVENTTRACER_H_ #endif // DAWNPLATFORM_TRACING_EVENTTRACER_H_

84
src/dawn_platform/tracing/TraceEvent.h
View File

@ -645,7 +645,7 @@
// for best performance when tracing is disabled. // for best performance when tracing is disabled.
// const unsigned char* // const unsigned char*
// TRACE_EVENT_API_GET_CATEGORY_ENABLED(const char* category_name) // TRACE_EVENT_API_GET_CATEGORY_ENABLED(const char* category_name)
#define TRACE_EVENT_API_GET_CATEGORY_ENABLED dawn_platform::tracing::GetTraceCategoryEnabledFlag #define TRACE_EVENT_API_GET_CATEGORY_ENABLED dawn::platform::tracing::GetTraceCategoryEnabledFlag
// Add a trace event to the platform tracing system. // Add a trace event to the platform tracing system.
// void TRACE_EVENT_API_ADD_TRACE_EVENT( // void TRACE_EVENT_API_ADD_TRACE_EVENT(
@ -658,7 +658,7 @@
// const unsigned char* arg_types, // const unsigned char* arg_types,
// const unsigned long long* arg_values, // const unsigned long long* arg_values,
// unsigned char flags) // unsigned char flags)
#define TRACE_EVENT_API_ADD_TRACE_EVENT dawn_platform::tracing::AddTraceEvent #define TRACE_EVENT_API_ADD_TRACE_EVENT dawn::platform::tracing::AddTraceEvent
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -677,44 +677,46 @@
// Implementation detail: internal macro to create static category and add // Implementation detail: internal macro to create static category and add
// event if the category is enabled. // event if the category is enabled.
#define INTERNAL_TRACE_EVENT_ADD(platform, phase, category, name, flags, ...) \ #define INTERNAL_TRACE_EVENT_ADD(platformObj, phase, category, name, flags, ...) \
do { \ do { \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platform, ::dawn_platform::TraceCategory::category) \ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platformObj, \
if (*INTERNALTRACEEVENTUID(catstatic)) { \ ::dawn::platform::TraceCategory::category) \
dawn_platform::TraceEvent::addTraceEvent( \ if (*INTERNALTRACEEVENTUID(catstatic)) { \
platform, phase, INTERNALTRACEEVENTUID(catstatic), name, \ dawn::platform::TraceEvent::addTraceEvent( \
dawn_platform::TraceEvent::noEventId, flags, __VA_ARGS__); \ platformObj, phase, INTERNALTRACEEVENTUID(catstatic), name, \
} \ dawn::platform::TraceEvent::noEventId, flags, __VA_ARGS__); \
} \
} while (0) } while (0)
// Implementation detail: internal macro to create static category and add begin // Implementation detail: internal macro to create static category and add begin
// event if the category is enabled. Also adds the end event when the scope // event if the category is enabled. Also adds the end event when the scope
// ends. // ends.
#define INTERNAL_TRACE_EVENT_ADD_SCOPED(platform, category, name, ...) \ #define INTERNAL_TRACE_EVENT_ADD_SCOPED(platformObj, category, name, ...) \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platform, ::dawn_platform::TraceCategory::category) \ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platformObj, ::dawn::platform::TraceCategory::category) \
dawn_platform::TraceEvent::TraceEndOnScopeClose INTERNALTRACEEVENTUID(profileScope); \ dawn::platform::TraceEvent::TraceEndOnScopeClose INTERNALTRACEEVENTUID(profileScope); \
do { \ do { \
if (*INTERNALTRACEEVENTUID(catstatic)) { \ if (*INTERNALTRACEEVENTUID(catstatic)) { \
dawn_platform::TraceEvent::addTraceEvent( \ dawn::platform::TraceEvent::addTraceEvent( \
platform, TRACE_EVENT_PHASE_BEGIN, INTERNALTRACEEVENTUID(catstatic), name, \ platformObj, TRACE_EVENT_PHASE_BEGIN, INTERNALTRACEEVENTUID(catstatic), name, \
dawn_platform::TraceEvent::noEventId, TRACE_EVENT_FLAG_NONE, __VA_ARGS__); \ dawn::platform::TraceEvent::noEventId, TRACE_EVENT_FLAG_NONE, __VA_ARGS__); \
INTERNALTRACEEVENTUID(profileScope) \ INTERNALTRACEEVENTUID(profileScope) \
.initialize(platform, INTERNALTRACEEVENTUID(catstatic), name); \ .initialize(platformObj, INTERNALTRACEEVENTUID(catstatic), name); \
} \ } \
} while (0) } while (0)
// Implementation detail: internal macro to create static category and add // Implementation detail: internal macro to create static category and add
// event if the category is enabled. // event if the category is enabled.
#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(platform, phase, category, name, id, flags, ...) \ #define INTERNAL_TRACE_EVENT_ADD_WITH_ID(platformObj, phase, category, name, id, flags, ...) \
do { \ do { \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platform, ::dawn_platform::TraceCategory::category) \ INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platformObj, \
if (*INTERNALTRACEEVENTUID(catstatic)) { \ ::dawn::platform::TraceCategory::category) \
unsigned char traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \ if (*INTERNALTRACEEVENTUID(catstatic)) { \
dawn_platform::TraceEvent::TraceID traceEventTraceID(id, &traceEventFlags); \ unsigned char traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
dawn_platform::TraceEvent::addTraceEvent( \ dawn::platform::TraceEvent::TraceID traceEventTraceID(id, &traceEventFlags); \
platform, phase, INTERNALTRACEEVENTUID(catstatic), name, traceEventTraceID.data(), \ dawn::platform::TraceEvent::addTraceEvent( \
traceEventFlags, __VA_ARGS__); \ platformObj, phase, INTERNALTRACEEVENTUID(catstatic), name, \
} \ traceEventTraceID.data(), traceEventFlags, __VA_ARGS__); \
} \
} while (0) } while (0)
// Notes regarding the following definitions: // Notes regarding the following definitions:
@ -754,7 +756,7 @@
#define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6)) #define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6))
#define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7)) #define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7))
namespace dawn_platform::TraceEvent { namespace dawn::platform::TraceEvent {
// Specify these values when the corresponding argument of addTraceEvent is not // Specify these values when the corresponding argument of addTraceEvent is not
// used. // used.
@ -887,8 +889,8 @@ namespace dawn_platform::TraceEvent {
// store pointers to the internal c_str and pass through to the tracing API, the // store pointers to the internal c_str and pass through to the tracing API, the
// arg values must live throughout these procedures. // arg values must live throughout these procedures.
static inline dawn_platform::tracing::TraceEventHandle addTraceEvent( static inline dawn::platform::tracing::TraceEventHandle addTraceEvent(
dawn_platform::Platform* platform, dawn::platform::Platform* platform,
char phase, char phase,
const unsigned char* categoryEnabled, const unsigned char* categoryEnabled,
const char* name, const char* name,
@ -900,8 +902,8 @@ namespace dawn_platform::TraceEvent {
} }
template <class ARG1_TYPE> template <class ARG1_TYPE>
static inline dawn_platform::tracing::TraceEventHandle addTraceEvent( static inline dawn::platform::tracing::TraceEventHandle addTraceEvent(
dawn_platform::Platform* platform, dawn::platform::Platform* platform,
char phase, char phase,
const unsigned char* categoryEnabled, const unsigned char* categoryEnabled,
const char* name, const char* name,
@ -919,8 +921,8 @@ namespace dawn_platform::TraceEvent {
} }
template <class ARG1_TYPE, class ARG2_TYPE> template <class ARG1_TYPE, class ARG2_TYPE>
static inline dawn_platform::tracing::TraceEventHandle addTraceEvent( static inline dawn::platform::tracing::TraceEventHandle addTraceEvent(
dawn_platform::Platform* platform, dawn::platform::Platform* platform,
char phase, char phase,
const unsigned char* categoryEnabled, const unsigned char* categoryEnabled,
const char* name, const char* name,
@ -952,7 +954,7 @@ namespace dawn_platform::TraceEvent {
addEventIfEnabled(); addEventIfEnabled();
} }
void initialize(dawn_platform::Platform* platform, void initialize(dawn::platform::Platform* platform,
const unsigned char* categoryEnabled, const unsigned char* categoryEnabled,
const char* name) { const char* name) {
m_data.platform = platform; m_data.platform = platform;
@ -978,7 +980,7 @@ namespace dawn_platform::TraceEvent {
// members of this class instead, compiler warnings occur about potential // members of this class instead, compiler warnings occur about potential
// uninitialized accesses. // uninitialized accesses.
struct Data { struct Data {
dawn_platform::Platform* platform; dawn::platform::Platform* platform;
const unsigned char* categoryEnabled; const unsigned char* categoryEnabled;
const char* name; const char* name;
}; };
@ -986,6 +988,6 @@ namespace dawn_platform::TraceEvent {
Data m_data; Data m_data;
}; };
} // namespace dawn_platform::TraceEvent } // namespace dawn::platform::TraceEvent
#endif // DAWNPLATFORM_TRACING_TRACEEVENT_H_ #endif // DAWNPLATFORM_TRACING_TRACEEVENT_H_

6
src/include/dawn_native/DawnNative.h
View File

@ -22,9 +22,9 @@
#include <string> #include <string>
#include <vector> #include <vector>
namespace dawn_platform { namespace dawn::platform {
class Platform; class Platform;
} // namespace dawn_platform } // namespace dawn::platform
namespace wgpu { namespace wgpu {
struct AdapterProperties; struct AdapterProperties;
@ -193,7 +193,7 @@ namespace dawn_native {
// Enable debug capture on Dawn startup // Enable debug capture on Dawn startup
void EnableBeginCaptureOnStartup(bool beginCaptureOnStartup); void EnableBeginCaptureOnStartup(bool beginCaptureOnStartup);
void SetPlatform(dawn_platform::Platform* platform); void SetPlatform(dawn::platform::Platform* platform);
// Returns the underlying WGPUInstance object. // Returns the underlying WGPUInstance object.
WGPUInstance Get() const; WGPUInstance Get() const;

6
src/include/dawn_platform/DawnPlatform.h
View File

@ -23,7 +23,7 @@
#include <dawn/webgpu.h> #include <dawn/webgpu.h>
namespace dawn_platform { namespace dawn::platform {
enum class TraceCategory { enum class TraceCategory {
General, // General trace events General, // General trace events
@ -111,6 +111,8 @@ namespace dawn_platform {
Platform& operator=(const Platform&) = delete; Platform& operator=(const Platform&) = delete;
}; };
} // namespace dawn_platform } // namespace dawn::platform
namespace dawn_platform = dawn::platform;
#endif // DAWNPLATFORM_DAWNPLATFORM_H_ #endif // DAWNPLATFORM_DAWNPLATFORM_H_

2
src/tests/DawnTest.cpp
View File

@ -1541,7 +1541,7 @@ void DawnTestBase::ResolveExpectations() {
} }
} }
std::unique_ptr<dawn_platform::Platform> DawnTestBase::CreateTestPlatform() { std::unique_ptr<dawn::platform::Platform> DawnTestBase::CreateTestPlatform() {
return nullptr; return nullptr;
} }

4
src/tests/DawnTest.h
View File

@ -324,7 +324,7 @@ class DawnTestBase {
wgpu::Instance GetInstance() const; wgpu::Instance GetInstance() const;
dawn_native::Adapter GetAdapter() const; dawn_native::Adapter GetAdapter() const;
virtual std::unique_ptr<dawn_platform::Platform> CreateTestPlatform(); virtual std::unique_ptr<dawn::platform::Platform> CreateTestPlatform();
struct PrintToStringParamName { struct PrintToStringParamName {
PrintToStringParamName(const char* test); PrintToStringParamName(const char* test);
@ -599,7 +599,7 @@ class DawnTestBase {
dawn_native::Adapter mBackendAdapter; dawn_native::Adapter mBackendAdapter;
std::unique_ptr<dawn_platform::Platform> mTestPlatform; std::unique_ptr<dawn::platform::Platform> mTestPlatform;
}; };
#define DAWN_SKIP_TEST_IF_BASE(condition, type, reason) \ #define DAWN_SKIP_TEST_IF_BASE(condition, type, reason) \

14
src/tests/end2end/D3D12CachingTests.cpp
View File

@ -27,7 +27,7 @@
} while (0) } while (0)
// FakePersistentCache implements a in-memory persistent cache. // FakePersistentCache implements a in-memory persistent cache.
class FakePersistentCache : public dawn_platform::CachingInterface { class FakePersistentCache : public dawn::platform::CachingInterface {
public: public:
// PersistentCache API // PersistentCache API
void StoreData(const WGPUDevice device, void StoreData(const WGPUDevice device,
@ -72,24 +72,24 @@ class FakePersistentCache : public dawn_platform::CachingInterface {
}; };
// Test platform that only supports caching. // Test platform that only supports caching.
class DawnTestPlatform : public dawn_platform::Platform { class DawnTestPlatform : public dawn::platform::Platform {
public: public:
DawnTestPlatform(dawn_platform::CachingInterface* cachingInterface) DawnTestPlatform(dawn::platform::CachingInterface* cachingInterface)
: mCachingInterface(cachingInterface) { : mCachingInterface(cachingInterface) {
} }
~DawnTestPlatform() override = default; ~DawnTestPlatform() override = default;
dawn_platform::CachingInterface* GetCachingInterface(const void* fingerprint, dawn::platform::CachingInterface* GetCachingInterface(const void* fingerprint,
size_t fingerprintSize) override { size_t fingerprintSize) override {
return mCachingInterface; return mCachingInterface;
} }
dawn_platform::CachingInterface* mCachingInterface = nullptr; dawn::platform::CachingInterface* mCachingInterface = nullptr;
}; };
class D3D12CachingTests : public DawnTest { class D3D12CachingTests : public DawnTest {
protected: protected:
std::unique_ptr<dawn_platform::Platform> CreateTestPlatform() override { std::unique_ptr<dawn::platform::Platform> CreateTestPlatform() override {
return std::make_unique<DawnTestPlatform>(&mPersistentCache); return std::make_unique<DawnTestPlatform>(&mPersistentCache);
} }

14
src/tests/perf_tests/DawnPerfTest.cpp
View File

@ -37,16 +37,16 @@ namespace {
for (const DawnPerfTestPlatform::TraceEvent& traceEvent : traceEventBuffer) { for (const DawnPerfTestPlatform::TraceEvent& traceEvent : traceEventBuffer) {
const char* category = nullptr; const char* category = nullptr;
switch (traceEvent.category) { switch (traceEvent.category) {
case dawn_platform::TraceCategory::General: case dawn::platform::TraceCategory::General:
category = "general"; category = "general";
break; break;
case dawn_platform::TraceCategory::Validation: case dawn::platform::TraceCategory::Validation:
category = "validation"; category = "validation";
break; break;
case dawn_platform::TraceCategory::Recording: case dawn::platform::TraceCategory::Recording:
category = "recording"; category = "recording";
break; break;
case dawn_platform::TraceCategory::GPUWork: case dawn::platform::TraceCategory::GPUWork:
category = "gpu"; category = "gpu";
break; break;
default: default:
@ -231,7 +231,7 @@ void DawnPerfTestBase::RunTest() {
} }
void DawnPerfTestBase::DoRunLoop(double maxRunTime) { void DawnPerfTestBase::DoRunLoop(double maxRunTime) {
dawn_platform::Platform* platform = gTestEnv->GetPlatform(); dawn::platform::Platform* platform = gTestEnv->GetPlatform();
mNumStepsPerformed = 0; mNumStepsPerformed = 0;
mCpuTime = 0; mCpuTime = 0;
@ -313,11 +313,11 @@ void DawnPerfTestBase::OutputResults() {
double* totalTime = nullptr; double* totalTime = nullptr;
switch (traceEvent.category) { switch (traceEvent.category) {
case dawn_platform::TraceCategory::Validation: case dawn::platform::TraceCategory::Validation:
tracker = &validationTracker; tracker = &validationTracker;
totalTime = &totalValidationTime; totalTime = &totalValidationTime;
break; break;
case dawn_platform::TraceCategory::Recording: case dawn::platform::TraceCategory::Recording:
tracker = &recordingTracker; tracker = &recordingTracker;
totalTime = &totalRecordingTime; totalTime = &totalRecordingTime;
break; break;

30
src/tests/perf_tests/DawnPerfTestPlatform.cpp
View File

@ -25,36 +25,36 @@ namespace {
struct TraceCategoryInfo { struct TraceCategoryInfo {
unsigned char enabled; unsigned char enabled;
dawn_platform::TraceCategory category; dawn::platform::TraceCategory category;
}; };
constexpr TraceCategoryInfo gTraceCategories[4] = { constexpr TraceCategoryInfo gTraceCategories[4] = {
{1, dawn_platform::TraceCategory::General}, {1, dawn::platform::TraceCategory::General},
{1, dawn_platform::TraceCategory::Validation}, {1, dawn::platform::TraceCategory::Validation},
{1, dawn_platform::TraceCategory::Recording}, {1, dawn::platform::TraceCategory::Recording},
{1, dawn_platform::TraceCategory::GPUWork}, {1, dawn::platform::TraceCategory::GPUWork},
}; };
static_assert(static_cast<uint32_t>(dawn_platform::TraceCategory::General) == 0, ""); static_assert(static_cast<uint32_t>(dawn::platform::TraceCategory::General) == 0, "");
static_assert(static_cast<uint32_t>(dawn_platform::TraceCategory::Validation) == 1, ""); static_assert(static_cast<uint32_t>(dawn::platform::TraceCategory::Validation) == 1, "");
static_assert(static_cast<uint32_t>(dawn_platform::TraceCategory::Recording) == 2, ""); static_assert(static_cast<uint32_t>(dawn::platform::TraceCategory::Recording) == 2, "");
static_assert(static_cast<uint32_t>(dawn_platform::TraceCategory::GPUWork) == 3, ""); static_assert(static_cast<uint32_t>(dawn::platform::TraceCategory::GPUWork) == 3, "");
} // anonymous namespace } // anonymous namespace
DawnPerfTestPlatform::DawnPerfTestPlatform() DawnPerfTestPlatform::DawnPerfTestPlatform()
: dawn_platform::Platform(), mTimer(utils::CreateTimer()) { : dawn::platform::Platform(), mTimer(utils::CreateTimer()) {
} }
DawnPerfTestPlatform::~DawnPerfTestPlatform() = default; DawnPerfTestPlatform::~DawnPerfTestPlatform() = default;
const unsigned char* DawnPerfTestPlatform::GetTraceCategoryEnabledFlag( const unsigned char* DawnPerfTestPlatform::GetTraceCategoryEnabledFlag(
dawn_platform::TraceCategory category) { dawn::platform::TraceCategory category) {
switch (category) { switch (category) {
case dawn_platform::TraceCategory::General: case dawn::platform::TraceCategory::General:
case dawn_platform::TraceCategory::Validation: case dawn::platform::TraceCategory::Validation:
case dawn_platform::TraceCategory::Recording: case dawn::platform::TraceCategory::Recording:
case dawn_platform::TraceCategory::GPUWork: case dawn::platform::TraceCategory::GPUWork:
break; break;
default: default:
UNREACHABLE(); UNREACHABLE();

8
src/tests/perf_tests/DawnPerfTestPlatform.h
View File

@ -27,7 +27,7 @@ namespace utils {
class Timer; class Timer;
} }
class DawnPerfTestPlatform : public dawn_platform::Platform { class DawnPerfTestPlatform : public dawn::platform::Platform {
public: public:
// These are trace events according to Google's "Trace Event Format". // These are trace events according to Google's "Trace Event Format".
// See https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU // See https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU
@ -36,7 +36,7 @@ class DawnPerfTestPlatform : public dawn_platform::Platform {
TraceEvent() { TraceEvent() {
} }
TraceEvent(char phaseIn, TraceEvent(char phaseIn,
dawn_platform::TraceCategory categoryIn, dawn::platform::TraceCategory categoryIn,
const char* nameIn, const char* nameIn,
uint64_t idIn, uint64_t idIn,
double timestampIn) double timestampIn)
@ -44,7 +44,7 @@ class DawnPerfTestPlatform : public dawn_platform::Platform {
} }
char phase = 0; char phase = 0;
dawn_platform::TraceCategory category; dawn::platform::TraceCategory category;
const char* name = nullptr; const char* name = nullptr;
uint64_t id = 0; uint64_t id = 0;
std::string threadId; std::string threadId;
@ -59,7 +59,7 @@ class DawnPerfTestPlatform : public dawn_platform::Platform {
private: private:
const unsigned char* GetTraceCategoryEnabledFlag( const unsigned char* GetTraceCategoryEnabledFlag(
dawn_platform::TraceCategory category) override; dawn::platform::TraceCategory category) override;
double MonotonicallyIncreasingTime() override; double MonotonicallyIncreasingTime() override;

4
src/tests/unittests/AsyncTaskTests.cpp
View File

@ -64,8 +64,8 @@ class AsyncTaskTest : public testing::Test {};
// Emulate the basic usage of worker thread pool in Create*PipelineAsync(). // Emulate the basic usage of worker thread pool in Create*PipelineAsync().
TEST_F(AsyncTaskTest, Basic) { TEST_F(AsyncTaskTest, Basic) {
dawn_platform::Platform platform; dawn::platform::Platform platform;
std::unique_ptr<dawn_platform::WorkerTaskPool> pool = platform.CreateWorkerTaskPool(); std::unique_ptr<dawn::platform::WorkerTaskPool> pool = platform.CreateWorkerTaskPool();
dawn_native::AsyncTaskManager taskManager(pool.get()); dawn_native::AsyncTaskManager taskManager(pool.get());
ConcurrentTaskResultQueue taskResultQueue; ConcurrentTaskResultQueue taskResultQueue;

4
src/tests/unittests/ConcurrentCacheTests.cpp
View File

@ -53,8 +53,8 @@ class ConcurrentCacheTest : public testing::Test {
} }
protected: protected:
dawn_platform::Platform mPlatform; dawn::platform::Platform mPlatform;
std::unique_ptr<dawn_platform::WorkerTaskPool> mPool; std::unique_ptr<dawn::platform::WorkerTaskPool> mPool;
dawn_native::AsyncTaskManager mTaskManager; dawn_native::AsyncTaskManager mTaskManager;
ConcurrentCache<SimpleCachedObject> mCache; ConcurrentCache<SimpleCachedObject> mCache;
}; };