encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-07-07 05:36:04 +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 {
AsyncTaskManager::AsyncTaskManager(dawn_platform::WorkerTaskPool* workerTaskPool)
AsyncTaskManager::AsyncTaskManager(dawn::platform::WorkerTaskPool* workerTaskPool)
: mWorkerTaskPool(workerTaskPool) {
}

10
src/dawn_native/AsyncTask.h
View File

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

2
src/dawn_native/DawnNative.cpp
View File

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

4
src/dawn_native/Device.cpp
View File

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

10
src/dawn_native/Device.h
View File

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

6
src/dawn_native/Instance.cpp
View File

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

12
src/dawn_native/Instance.h
View File

@ -28,9 +28,9 @@
#include <unordered_map>
#include <vector>
namespace dawn_platform {
namespace dawn::platform {
class Platform;
} // namespace dawn_platform
} // namespace dawn::platform
namespace dawn_native {
@ -73,8 +73,8 @@ namespace dawn_native {
void EnableBeginCaptureOnStartup(bool beginCaptureOnStartup);
bool IsBeginCaptureOnStartupEnabled() const;
void SetPlatform(dawn_platform::Platform* platform);
dawn_platform::Platform* GetPlatform();
void SetPlatform(dawn::platform::Platform* platform);
dawn::platform::Platform* GetPlatform();
// Get backend-independent libraries that need to be loaded dynamically.
const XlibXcbFunctions* GetOrCreateXlibXcbFunctions();
@ -103,8 +103,8 @@ namespace dawn_native {
bool mBeginCaptureOnStartup = false;
BackendValidationLevel mBackendValidationLevel = BackendValidationLevel::Disabled;
dawn_platform::Platform* mPlatform = nullptr;
std::unique_ptr<dawn_platform::Platform> mDefaultPlatform;
dawn::platform::Platform* mPlatform = nullptr;
std::unique_ptr<dawn::platform::Platform> mDefaultPlatform;
std::vector<std::unique_ptr<BackendConnection>> mBackends;
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);
}
dawn_platform::CachingInterface* PersistentCache::GetPlatformCache() {
dawn::platform::CachingInterface* PersistentCache::GetPlatformCache() {
// 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
// previously cached Dawn objects should this fingerprint change.
dawn_platform::Platform* platform = mDevice->GetPlatform();
dawn::platform::Platform* platform = mDevice->GetPlatform();
if (platform != nullptr) {
return platform->GetCachingInterface(/*fingerprint*/ nullptr, /*fingerprintSize*/ 0);
}

6
src/dawn_native/PersistentCache.h
View File

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

10
src/dawn_platform/DawnPlatform.cpp
View File

@ -17,7 +17,7 @@
#include "common/Assert.h"
namespace dawn_platform {
namespace dawn::platform {
CachingInterface::CachingInterface() = default;
@ -51,13 +51,13 @@ namespace dawn_platform {
return 0;
}
dawn_platform::CachingInterface* Platform::GetCachingInterface(const void* fingerprint,
size_t fingerprintSize) {
dawn::platform::CachingInterface* Platform::GetCachingInterface(const void* fingerprint,
size_t fingerprintSize) {
return nullptr;
}
std::unique_ptr<dawn_platform::WorkerTaskPool> Platform::CreateWorkerTaskPool() {
std::unique_ptr<dawn::platform::WorkerTaskPool> Platform::CreateWorkerTaskPool() {
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;
};
class AsyncWaitableEvent final : public dawn_platform::WaitableEvent {
class AsyncWaitableEvent final : public dawn::platform::WaitableEvent {
public:
explicit AsyncWaitableEvent()
: mWaitableEventImpl(std::make_shared<AsyncWaitableEventImpl>()) {
@ -75,10 +75,10 @@ namespace {
} // anonymous namespace
namespace dawn_platform {
namespace dawn::platform {
std::unique_ptr<dawn_platform::WaitableEvent> AsyncWorkerThreadPool::PostWorkerTask(
dawn_platform::PostWorkerTaskCallback callback,
std::unique_ptr<dawn::platform::WaitableEvent> AsyncWorkerThreadPool::PostWorkerTask(
dawn::platform::PostWorkerTaskCallback callback,
void* userdata) {
std::unique_ptr<AsyncWaitableEvent> waitableEvent = std::make_unique<AsyncWaitableEvent>();
@ -94,4 +94,4 @@ namespace dawn_platform {
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 "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:
std::unique_ptr<dawn_platform::WaitableEvent> PostWorkerTask(
dawn_platform::PostWorkerTaskCallback callback,
std::unique_ptr<dawn::platform::WaitableEvent> PostWorkerTask(
dawn::platform::PostWorkerTaskCallback callback,
void* userdata) override;
};
} // namespace dawn_platform
} // namespace dawn::platform
#endif

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

@ -16,7 +16,7 @@
#include "common/Assert.h"
#include "dawn_platform/DawnPlatform.h"
namespace dawn_platform::tracing {
namespace dawn::platform::tracing {
const unsigned char* GetTraceCategoryEnabledFlag(Platform* platform, TraceCategory category) {
static unsigned char disabled = 0;
@ -55,4 +55,4 @@ namespace dawn_platform::tracing {
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>
namespace dawn_platform {
namespace dawn::platform {
class Platform;
enum class TraceCategory;
@ -46,6 +46,6 @@ namespace dawn_platform {
unsigned char flags);
} // namespace tracing
} // namespace dawn_platform
} // namespace dawn::platform
#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.
// const unsigned char*
// 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.
// void TRACE_EVENT_API_ADD_TRACE_EVENT(
@ -658,7 +658,7 @@
// const unsigned char* arg_types,
// const unsigned long long* arg_values,
// 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
// event if the category is enabled.
#define INTERNAL_TRACE_EVENT_ADD(platform, phase, category, name, flags, ...) \
do { \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platform, ::dawn_platform::TraceCategory::category) \
if (*INTERNALTRACEEVENTUID(catstatic)) { \
dawn_platform::TraceEvent::addTraceEvent( \
platform, phase, INTERNALTRACEEVENTUID(catstatic), name, \
dawn_platform::TraceEvent::noEventId, flags, __VA_ARGS__); \
} \
#define INTERNAL_TRACE_EVENT_ADD(platformObj, phase, category, name, flags, ...) \
do { \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platformObj, \
::dawn::platform::TraceCategory::category) \
if (*INTERNALTRACEEVENTUID(catstatic)) { \
dawn::platform::TraceEvent::addTraceEvent( \
platformObj, phase, INTERNALTRACEEVENTUID(catstatic), name, \
dawn::platform::TraceEvent::noEventId, flags, __VA_ARGS__); \
} \
} while (0)
// 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
// ends.
#define INTERNAL_TRACE_EVENT_ADD_SCOPED(platform, category, name, ...) \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platform, ::dawn_platform::TraceCategory::category) \
dawn_platform::TraceEvent::TraceEndOnScopeClose INTERNALTRACEEVENTUID(profileScope); \
do { \
if (*INTERNALTRACEEVENTUID(catstatic)) { \
dawn_platform::TraceEvent::addTraceEvent( \
platform, TRACE_EVENT_PHASE_BEGIN, INTERNALTRACEEVENTUID(catstatic), name, \
dawn_platform::TraceEvent::noEventId, TRACE_EVENT_FLAG_NONE, __VA_ARGS__); \
INTERNALTRACEEVENTUID(profileScope) \
.initialize(platform, INTERNALTRACEEVENTUID(catstatic), name); \
} \
#define INTERNAL_TRACE_EVENT_ADD_SCOPED(platformObj, category, name, ...) \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platformObj, ::dawn::platform::TraceCategory::category) \
dawn::platform::TraceEvent::TraceEndOnScopeClose INTERNALTRACEEVENTUID(profileScope); \
do { \
if (*INTERNALTRACEEVENTUID(catstatic)) { \
dawn::platform::TraceEvent::addTraceEvent( \
platformObj, TRACE_EVENT_PHASE_BEGIN, INTERNALTRACEEVENTUID(catstatic), name, \
dawn::platform::TraceEvent::noEventId, TRACE_EVENT_FLAG_NONE, __VA_ARGS__); \
INTERNALTRACEEVENTUID(profileScope) \
.initialize(platformObj, INTERNALTRACEEVENTUID(catstatic), name); \
} \
} while (0)
// Implementation detail: internal macro to create static category and add
// event if the category is enabled.
#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(platform, phase, category, name, id, flags, ...) \
do { \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platform, ::dawn_platform::TraceCategory::category) \
if (*INTERNALTRACEEVENTUID(catstatic)) { \
unsigned char traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
dawn_platform::TraceEvent::TraceID traceEventTraceID(id, &traceEventFlags); \
dawn_platform::TraceEvent::addTraceEvent( \
platform, phase, INTERNALTRACEEVENTUID(catstatic), name, traceEventTraceID.data(), \
traceEventFlags, __VA_ARGS__); \
} \
#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(platformObj, phase, category, name, id, flags, ...) \
do { \
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(platformObj, \
::dawn::platform::TraceCategory::category) \
if (*INTERNALTRACEEVENTUID(catstatic)) { \
unsigned char traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
dawn::platform::TraceEvent::TraceID traceEventTraceID(id, &traceEventFlags); \
dawn::platform::TraceEvent::addTraceEvent( \
platformObj, phase, INTERNALTRACEEVENTUID(catstatic), name, \
traceEventTraceID.data(), traceEventFlags, __VA_ARGS__); \
} \
} while (0)
// Notes regarding the following definitions:
@ -754,7 +756,7 @@
#define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6))
#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
// used.
@ -887,8 +889,8 @@ namespace dawn_platform::TraceEvent {
// store pointers to the internal c_str and pass through to the tracing API, the
// arg values must live throughout these procedures.
static inline dawn_platform::tracing::TraceEventHandle addTraceEvent(
dawn_platform::Platform* platform,
static inline dawn::platform::tracing::TraceEventHandle addTraceEvent(
dawn::platform::Platform* platform,
char phase,
const unsigned char* categoryEnabled,
const char* name,
@ -900,8 +902,8 @@ namespace dawn_platform::TraceEvent {
}
template <class ARG1_TYPE>
static inline dawn_platform::tracing::TraceEventHandle addTraceEvent(
dawn_platform::Platform* platform,
static inline dawn::platform::tracing::TraceEventHandle addTraceEvent(
dawn::platform::Platform* platform,
char phase,
const unsigned char* categoryEnabled,
const char* name,
@ -919,8 +921,8 @@ namespace dawn_platform::TraceEvent {
}
template <class ARG1_TYPE, class ARG2_TYPE>
static inline dawn_platform::tracing::TraceEventHandle addTraceEvent(
dawn_platform::Platform* platform,
static inline dawn::platform::tracing::TraceEventHandle addTraceEvent(
dawn::platform::Platform* platform,
char phase,
const unsigned char* categoryEnabled,
const char* name,
@ -952,7 +954,7 @@ namespace dawn_platform::TraceEvent {
addEventIfEnabled();
}
void initialize(dawn_platform::Platform* platform,
void initialize(dawn::platform::Platform* platform,
const unsigned char* categoryEnabled,
const char* name) {
m_data.platform = platform;
@ -978,7 +980,7 @@ namespace dawn_platform::TraceEvent {
// members of this class instead, compiler warnings occur about potential
// uninitialized accesses.
struct Data {
dawn_platform::Platform* platform;
dawn::platform::Platform* platform;
const unsigned char* categoryEnabled;
const char* name;
};
@ -986,6 +988,6 @@ namespace dawn_platform::TraceEvent {
Data m_data;
};
} // namespace dawn_platform::TraceEvent
} // namespace dawn::platform::TraceEvent
#endif // DAWNPLATFORM_TRACING_TRACEEVENT_H_

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

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

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

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

4
src/tests/DawnTest.h
View File

@ -324,7 +324,7 @@ class DawnTestBase {
wgpu::Instance GetInstance() const;
dawn_native::Adapter GetAdapter() const;
virtual std::unique_ptr<dawn_platform::Platform> CreateTestPlatform();
virtual std::unique_ptr<dawn::platform::Platform> CreateTestPlatform();
struct PrintToStringParamName {
PrintToStringParamName(const char* test);
@ -599,7 +599,7 @@ class DawnTestBase {
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) \

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

@ -27,7 +27,7 @@
} while (0)
// FakePersistentCache implements a in-memory persistent cache.
class FakePersistentCache : public dawn_platform::CachingInterface {
class FakePersistentCache : public dawn::platform::CachingInterface {
public:
// PersistentCache API
void StoreData(const WGPUDevice device,
@ -72,24 +72,24 @@ class FakePersistentCache : public dawn_platform::CachingInterface {
};
// Test platform that only supports caching.
class DawnTestPlatform : public dawn_platform::Platform {
class DawnTestPlatform : public dawn::platform::Platform {
public:
DawnTestPlatform(dawn_platform::CachingInterface* cachingInterface)
DawnTestPlatform(dawn::platform::CachingInterface* cachingInterface)
: mCachingInterface(cachingInterface) {
}
~DawnTestPlatform() override = default;
dawn_platform::CachingInterface* GetCachingInterface(const void* fingerprint,
size_t fingerprintSize) override {
dawn::platform::CachingInterface* GetCachingInterface(const void* fingerprint,
size_t fingerprintSize) override {
return mCachingInterface;
}
dawn_platform::CachingInterface* mCachingInterface = nullptr;
dawn::platform::CachingInterface* mCachingInterface = nullptr;
};
class D3D12CachingTests : public DawnTest {
protected:
std::unique_ptr<dawn_platform::Platform> CreateTestPlatform() override {
std::unique_ptr<dawn::platform::Platform> CreateTestPlatform() override {
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) {
const char* category = nullptr;
switch (traceEvent.category) {
case dawn_platform::TraceCategory::General:
case dawn::platform::TraceCategory::General:
category = "general";
break;
case dawn_platform::TraceCategory::Validation:
case dawn::platform::TraceCategory::Validation:
category = "validation";
break;
case dawn_platform::TraceCategory::Recording:
case dawn::platform::TraceCategory::Recording:
category = "recording";
break;
case dawn_platform::TraceCategory::GPUWork:
case dawn::platform::TraceCategory::GPUWork:
category = "gpu";
break;
default:
@ -231,7 +231,7 @@ void DawnPerfTestBase::RunTest() {
}
void DawnPerfTestBase::DoRunLoop(double maxRunTime) {
dawn_platform::Platform* platform = gTestEnv->GetPlatform();
dawn::platform::Platform* platform = gTestEnv->GetPlatform();
mNumStepsPerformed = 0;
mCpuTime = 0;
@ -313,11 +313,11 @@ void DawnPerfTestBase::OutputResults() {
double* totalTime = nullptr;
switch (traceEvent.category) {
case dawn_platform::TraceCategory::Validation:
case dawn::platform::TraceCategory::Validation:
tracker = &validationTracker;
totalTime = &totalValidationTime;
break;
case dawn_platform::TraceCategory::Recording:
case dawn::platform::TraceCategory::Recording:
tracker = &recordingTracker;
totalTime = &totalRecordingTime;
break;

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

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

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

@ -27,7 +27,7 @@ namespace utils {
class Timer;
}
class DawnPerfTestPlatform : public dawn_platform::Platform {
class DawnPerfTestPlatform : public dawn::platform::Platform {
public:
// These are trace events according to Google's "Trace Event Format".
// See https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU
@ -36,7 +36,7 @@ class DawnPerfTestPlatform : public dawn_platform::Platform {
TraceEvent() {
}
TraceEvent(char phaseIn,
dawn_platform::TraceCategory categoryIn,
dawn::platform::TraceCategory categoryIn,
const char* nameIn,
uint64_t idIn,
double timestampIn)
@ -44,7 +44,7 @@ class DawnPerfTestPlatform : public dawn_platform::Platform {
}
char phase = 0;
dawn_platform::TraceCategory category;
dawn::platform::TraceCategory category;
const char* name = nullptr;
uint64_t id = 0;
std::string threadId;
@ -59,7 +59,7 @@ class DawnPerfTestPlatform : public dawn_platform::Platform {
private:
const unsigned char* GetTraceCategoryEnabledFlag(
dawn_platform::TraceCategory category) override;
dawn::platform::TraceCategory category) 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().
TEST_F(AsyncTaskTest, Basic) {
dawn_platform::Platform platform;
std::unique_ptr<dawn_platform::WorkerTaskPool> pool = platform.CreateWorkerTaskPool();
dawn::platform::Platform platform;
std::unique_ptr<dawn::platform::WorkerTaskPool> pool = platform.CreateWorkerTaskPool();
dawn_native::AsyncTaskManager taskManager(pool.get());
ConcurrentTaskResultQueue taskResultQueue;

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

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