encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-20 18:29:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

transform: API cleanup

Browse Source 
Transforms are meant to be reusable. Those that hold state cannot be used concurrently.
State leakage between runs is dangerous.
To fix this:
* Add transform::Data - A new base class for extra information emitted by transforms.
* Add transform::DataMap - A container of Data, keyed by type.
* Add a transform::DataMap field to Transform::Output.
* Have FirstIndexOffset emit a FirstIndexOffset::Data.
* Deprecate the getters on the transform.

Mutability of the transform config is also dangerous as setters can be called while a transform is actively running on another thread.
To fix:
* Expose a VertexPulling::Config structure and add a constructor that accepts this.
* Deprecate the setters on VertexPulling.

Also deprecate Transform::Output::diagnostics.
Put all the transform diagnostics into the returned Program. Reduces error handling of the client.

Change-Id: Ibd228dc2fbf004ede4720e2d6019c024bc5934d1
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/42264
Reviewed-by: dan sinclair <dsinclair@chromium.org>
Reviewed-by: Ryan Harrison <rharrison@chromium.org>
Commit-Queue: Ben Clayton <bclayton@google.com>
This commit is contained in:
Ben Clayton
2021-02-24 15:55:24 +00:00
committed by Commit Bot service account
parent 94b36c3e86
commit eb496d0a4d
20 changed files with 437 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
src/transform/vertex_pulling_test.cc
View File

@@ -30,26 +30,25 @@ TEST_F(VertexPullingTest, Error_NoVertexState) {
fn main() -> void {}
)";
auto* expect = R"(manager().Run() errored:
error: SetVertexState not called)";
auto* expect = "error: SetVertexState not called";
auto got = Transform<VertexPulling>(src);
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, Error_NoEntryPoint) {
auto* src = "";
auto* expect = R"(manager().Run() errored:
error: Vertex stage entry point not found)";
auto* expect = "error: Vertex stage entry point not found";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState({});
VertexPulling::Config cfg;
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, Error_InvalidEntryPoint) {
@@ -58,16 +57,16 @@ TEST_F(VertexPullingTest, Error_InvalidEntryPoint) {
fn main() -> void {}
)";
auto* expect = R"(manager().Run() errored:
error: Vertex stage entry point not found)";
auto* expect = "error: Vertex stage entry point not found";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState({});
transform->SetEntryPoint("_");
VertexPulling::Config cfg;
cfg.entry_point_name = "_";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, Error_EntryPointWrongStage) {
@@ -76,16 +75,16 @@ TEST_F(VertexPullingTest, Error_EntryPointWrongStage) {
fn main() -> void {}
)";
auto* expect = R"(manager().Run() errored:
error: Vertex stage entry point not found)";
auto* expect = "error: Vertex stage entry point not found";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState({});
transform->SetEntryPoint("main");
VertexPulling::Config cfg;
cfg.entry_point_name = "main";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, BasicModule) {
@@ -109,13 +108,14 @@ fn main() -> void {
}
)";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState({});
transform->SetEntryPoint("main");
VertexPulling::Config cfg;
cfg.entry_point_name = "main";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, OneAttribute) {
@@ -149,14 +149,16 @@ fn main() -> void {
}
)";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState(
{{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}}}});
transform->SetEntryPoint("main");
VertexPulling::Config cfg;
cfg.vertex_state = {
{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}}}};
cfg.entry_point_name = "main";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, OneInstancedAttribute) {
@@ -190,14 +192,16 @@ fn main() -> void {
}
)";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState(
{{{4, InputStepMode::kInstance, {{VertexFormat::kF32, 0, 0}}}}});
transform->SetEntryPoint("main");
VertexPulling::Config cfg;
cfg.vertex_state = {
{{4, InputStepMode::kInstance, {{VertexFormat::kF32, 0, 0}}}}};
cfg.entry_point_name = "main";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, OneAttributeDifferentOutputSet) {
@@ -231,15 +235,17 @@ fn main() -> void {
}
)";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState(
{{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}}}});
transform->SetPullingBufferBindingSet(5);
transform->SetEntryPoint("main");
VertexPulling::Config cfg;
cfg.vertex_state = {
{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}}}};
cfg.pulling_group = 5;
cfg.entry_point_name = "main";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
// We expect the transform to use an existing builtin variables if it finds them
@@ -285,15 +291,26 @@ fn main() -> void {
}
)";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState(
{{{4, InputStepMode::kVertex, {{VertexFormat::kF32, 0, 0}}},
{4, InputStepMode::kInstance, {{VertexFormat::kF32, 0, 1}}}}});
transform->SetEntryPoint("main");
VertexPulling::Config cfg;
cfg.vertex_state = {{
{
4,
InputStepMode::kVertex,
{{VertexFormat::kF32, 0, 0}},
},
{
4,
InputStepMode::kInstance,
{{VertexFormat::kF32, 0, 1}},
},
}};
cfg.entry_point_name = "main";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, TwoAttributesSameBuffer) {
@@ -332,16 +349,18 @@ fn main() -> void {
}
)";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState(
{{{16,
InputStepMode::kVertex,
{{VertexFormat::kF32, 0, 0}, {VertexFormat::kVec4F32, 0, 1}}}}});
transform->SetEntryPoint("main");
VertexPulling::Config cfg;
cfg.vertex_state = {
{{16,
InputStepMode::kVertex,
{{VertexFormat::kF32, 0, 0}, {VertexFormat::kVec4F32, 0, 1}}}}};
cfg.entry_point_name = "main";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
TEST_F(VertexPullingTest, FloatVectorAttributes) {
@@ -389,16 +408,19 @@ fn main() -> void {
}
)";
auto transform = std::make_unique<VertexPulling>();
transform->SetVertexState(
{{{8, InputStepMode::kVertex, {{VertexFormat::kVec2F32, 0, 0}}},
{12, InputStepMode::kVertex, {{VertexFormat::kVec3F32, 0, 1}}},
{16, InputStepMode::kVertex, {{VertexFormat::kVec4F32, 0, 2}}}}});
transform->SetEntryPoint("main");
VertexPulling::Config cfg;
cfg.vertex_state = {{
{8, InputStepMode::kVertex, {{VertexFormat::kVec2F32, 0, 0}}},
{12, InputStepMode::kVertex, {{VertexFormat::kVec3F32, 0, 1}}},
{16, InputStepMode::kVertex, {{VertexFormat::kVec4F32, 0, 2}}},
}};
cfg.entry_point_name = "main";
auto transform = std::make_unique<VertexPulling>(cfg);
auto got = Transform(src, std::move(transform));
EXPECT_EQ(expect, got);
EXPECT_EQ(expect, str(got));
}
} // namespace