Flutter Impeller
runtime_stage_data.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
6 
7 #include <array>
8 #include <cstdint>
9 #include <memory>
10 #include <optional>
11 
12 #include "fml/backtrace.h"
14 #include "inja/inja.hpp"
15 
17 #include "impeller/runtime_stage/runtime_stage_flatbuffers.h"
18 #include "runtime_stage_types_flatbuffers.h"
19 
20 namespace impeller {
21 namespace compiler {
22 
24 
26 
27 void RuntimeStageData::AddShader(const std::shared_ptr<Shader>& data) {
28  FML_DCHECK(data);
29  FML_DCHECK(data_.find(data->backend) == data_.end());
30  data_[data->backend] = data;
31 }
32 
33 static std::optional<fb::Stage> ToStage(spv::ExecutionModel stage) {
34  switch (stage) {
35  case spv::ExecutionModel::ExecutionModelVertex:
36  return fb::Stage::kVertex;
37  case spv::ExecutionModel::ExecutionModelFragment:
38  return fb::Stage::kFragment;
39  case spv::ExecutionModel::ExecutionModelGLCompute:
40  return fb::Stage::kCompute;
41  default:
42  return std::nullopt;
43  }
44  FML_UNREACHABLE();
45 }
46 
47 static std::optional<fb::Stage> ToJsonStage(spv::ExecutionModel stage) {
48  switch (stage) {
49  case spv::ExecutionModel::ExecutionModelVertex:
50  return fb::Stage::kVertex;
51  case spv::ExecutionModel::ExecutionModelFragment:
52  return fb::Stage::kFragment;
53  case spv::ExecutionModel::ExecutionModelGLCompute:
54  return fb::Stage::kCompute;
55  default:
56  return std::nullopt;
57  }
58  FML_UNREACHABLE();
59 }
60 
61 static std::optional<fb::UniformDataType> ToUniformType(
62  spirv_cross::SPIRType::BaseType type) {
63  switch (type) {
64  case spirv_cross::SPIRType::Float:
66  case spirv_cross::SPIRType::SampledImage:
68  case spirv_cross::SPIRType::Struct:
70  case spirv_cross::SPIRType::Boolean:
71  case spirv_cross::SPIRType::SByte:
72  case spirv_cross::SPIRType::UByte:
73  case spirv_cross::SPIRType::Short:
74  case spirv_cross::SPIRType::UShort:
75  case spirv_cross::SPIRType::Int:
76  case spirv_cross::SPIRType::UInt:
77  case spirv_cross::SPIRType::Int64:
78  case spirv_cross::SPIRType::UInt64:
79  case spirv_cross::SPIRType::Half:
80  case spirv_cross::SPIRType::Double:
81  case spirv_cross::SPIRType::AccelerationStructure:
82  case spirv_cross::SPIRType::AtomicCounter:
83  case spirv_cross::SPIRType::Char:
84  case spirv_cross::SPIRType::ControlPointArray:
85  case spirv_cross::SPIRType::Image:
86  case spirv_cross::SPIRType::Interpolant:
87  case spirv_cross::SPIRType::RayQuery:
88  case spirv_cross::SPIRType::Sampler:
89  case spirv_cross::SPIRType::Unknown:
90  case spirv_cross::SPIRType::Void:
91  return std::nullopt;
92  }
93  FML_UNREACHABLE();
94 }
95 static std::optional<fb::InputDataType> ToInputType(
96  spirv_cross::SPIRType::BaseType type) {
97  switch (type) {
98  case spirv_cross::SPIRType::Boolean:
99  return fb::InputDataType::kBoolean;
100  case spirv_cross::SPIRType::SByte:
101  return fb::InputDataType::kSignedByte;
102  case spirv_cross::SPIRType::UByte:
103  return fb::InputDataType::kUnsignedByte;
104  case spirv_cross::SPIRType::Short:
105  return fb::InputDataType::kSignedShort;
106  case spirv_cross::SPIRType::UShort:
107  return fb::InputDataType::kUnsignedShort;
108  case spirv_cross::SPIRType::Int:
109  return fb::InputDataType::kSignedInt;
110  case spirv_cross::SPIRType::UInt:
111  return fb::InputDataType::kUnsignedInt;
112  case spirv_cross::SPIRType::Int64:
113  return fb::InputDataType::kSignedInt64;
114  case spirv_cross::SPIRType::UInt64:
115  return fb::InputDataType::kUnsignedInt64;
116  case spirv_cross::SPIRType::Float:
118  case spirv_cross::SPIRType::Double:
119  return fb::InputDataType::kDouble;
120  case spirv_cross::SPIRType::Unknown:
121  case spirv_cross::SPIRType::Void:
122  case spirv_cross::SPIRType::Half:
123  case spirv_cross::SPIRType::AtomicCounter:
124  case spirv_cross::SPIRType::Struct:
125  case spirv_cross::SPIRType::Image:
126  case spirv_cross::SPIRType::SampledImage:
127  case spirv_cross::SPIRType::Sampler:
128  case spirv_cross::SPIRType::AccelerationStructure:
129  case spirv_cross::SPIRType::RayQuery:
130  case spirv_cross::SPIRType::ControlPointArray:
131  case spirv_cross::SPIRType::Interpolant:
132  case spirv_cross::SPIRType::Char:
133  return std::nullopt;
134  }
135  FML_UNREACHABLE();
136 }
137 
138 static std::optional<uint32_t> ToJsonType(
139  spirv_cross::SPIRType::BaseType type) {
140  switch (type) {
141  case spirv_cross::SPIRType::Boolean:
142  return 0; // fb::UniformDataType::kBoolean;
143  case spirv_cross::SPIRType::SByte:
144  return 1; // fb::UniformDataType::kSignedByte;
145  case spirv_cross::SPIRType::UByte:
146  return 2; // fb::UniformDataType::kUnsignedByte;
147  case spirv_cross::SPIRType::Short:
148  return 3; // fb::UniformDataType::kSignedShort;
149  case spirv_cross::SPIRType::UShort:
150  return 4; // fb::UniformDataType::kUnsignedShort;
151  case spirv_cross::SPIRType::Int:
152  return 5; // fb::UniformDataType::kSignedInt;
153  case spirv_cross::SPIRType::UInt:
154  return 6; // fb::UniformDataType::kUnsignedInt;
155  case spirv_cross::SPIRType::Int64:
156  return 7; // fb::UniformDataType::kSignedInt64;
157  case spirv_cross::SPIRType::UInt64:
158  return 8; // fb::UniformDataType::kUnsignedInt64;
159  case spirv_cross::SPIRType::Half:
160  return 9; // b::UniformDataType::kHalfFloat;
161  case spirv_cross::SPIRType::Float:
162  return 10; // fb::UniformDataType::kFloat;
163  case spirv_cross::SPIRType::Double:
164  return 11; // fb::UniformDataType::kDouble;
165  case spirv_cross::SPIRType::SampledImage:
166  return 12; // fb::UniformDataType::kSampledImage;
167  case spirv_cross::SPIRType::Struct:
168  return 13;
169  case spirv_cross::SPIRType::AccelerationStructure:
170  case spirv_cross::SPIRType::AtomicCounter:
171  case spirv_cross::SPIRType::Char:
172  case spirv_cross::SPIRType::ControlPointArray:
173  case spirv_cross::SPIRType::Image:
174  case spirv_cross::SPIRType::Interpolant:
175  case spirv_cross::SPIRType::RayQuery:
176  case spirv_cross::SPIRType::Sampler:
177  case spirv_cross::SPIRType::Unknown:
178  case spirv_cross::SPIRType::Void:
179  return std::nullopt;
180  }
181  FML_UNREACHABLE();
182 }
183 
184 static const char* kStageKey = "stage";
185 static const char* kTargetPlatformKey = "target_platform";
186 static const char* kEntrypointKey = "entrypoint";
187 static const char* kUniformsKey = "uniforms";
188 static const char* kShaderKey = "shader";
189 static const char* kUniformNameKey = "name";
190 static const char* kUniformLocationKey = "location";
191 static const char* kUniformTypeKey = "type";
192 static const char* kUniformRowsKey = "rows";
193 static const char* kUniformColumnsKey = "columns";
194 static const char* kUniformBitWidthKey = "bit_width";
195 static const char* kUniformArrayElementsKey = "array_elements";
196 
198  switch (backend) {
200  return "sksl";
202  return "metal";
204  return "opengles";
206  return "vulkan";
208  return "opengles3";
209  }
210 }
211 
212 std::shared_ptr<fml::Mapping> RuntimeStageData::CreateJsonMapping() const {
213  // Runtime Stage Data JSON format
214  // {
215  // "sksl": {
216  // "stage": 0,
217  // "entrypoint": "",
218  // "shader": "",
219  // "uniforms": [
220  // {
221  // "name": "..",
222  // "location": 0,
223  // "type": 0,
224  // "rows": 0,
225  // "columns": 0,
226  // "bit_width": 0,
227  // "array_elements": 0,
228  // }
229  // ]
230  // },
231  // "metal": ...
232  // },
233  nlohmann::json root;
234 
235  for (const auto& kvp : data_) {
236  nlohmann::json platform_object;
237 
238  const auto stage = ToJsonStage(kvp.second->stage);
239  if (!stage.has_value()) {
240  VALIDATION_LOG << "Invalid runtime stage.";
241  return nullptr;
242  }
243  platform_object[kStageKey] = static_cast<uint32_t>(stage.value());
244  platform_object[kEntrypointKey] = kvp.second->entrypoint;
245 
246  if (kvp.second->shader->GetSize() > 0u) {
247  std::string shader(
248  reinterpret_cast<const char*>(kvp.second->shader->GetMapping()),
249  kvp.second->shader->GetSize());
250  platform_object[kShaderKey] = shader.c_str();
251  }
252 
253  auto& uniforms = platform_object[kUniformsKey] = nlohmann::json::array_t{};
254  for (const auto& uniform : kvp.second->uniforms) {
255  nlohmann::json uniform_object;
256  uniform_object[kUniformNameKey] = uniform.name.c_str();
257  uniform_object[kUniformLocationKey] = uniform.location;
258  uniform_object[kUniformRowsKey] = uniform.rows;
259  uniform_object[kUniformColumnsKey] = uniform.columns;
260 
261  auto uniform_type = ToJsonType(uniform.type);
262  if (!uniform_type.has_value()) {
263  VALIDATION_LOG << "Invalid uniform type for runtime stage.";
264  return nullptr;
265  }
266 
267  uniform_object[kUniformTypeKey] = uniform_type.value();
268  uniform_object[kUniformBitWidthKey] = uniform.bit_width;
269  uniform_object[kUniformArrayElementsKey] =
270  uniform.array_elements.value_or(0);
271 
272  uniforms.push_back(uniform_object);
273  }
274 
275  root[RuntimeStageBackendToString(kvp.first)] = platform_object;
276  }
277 
278  auto json_string = std::make_shared<std::string>(root.dump(2u));
279 
280  return std::make_shared<fml::NonOwnedMapping>(
281  reinterpret_cast<const uint8_t*>(json_string->data()),
282  json_string->size(), [json_string](auto, auto) {});
283 }
284 
285 std::unique_ptr<fb::RuntimeStageT> RuntimeStageData::CreateStageFlatbuffer(
286  impeller::RuntimeStageBackend backend) const {
287  auto kvp = data_.find(backend);
288  if (kvp == data_.end()) {
289  return nullptr;
290  }
291 
292  auto runtime_stage = std::make_unique<fb::RuntimeStageT>();
293  runtime_stage->entrypoint = kvp->second->entrypoint;
294  const auto stage = ToStage(kvp->second->stage);
295  if (!stage.has_value()) {
296  VALIDATION_LOG << "Invalid runtime stage.";
297  return nullptr;
298  }
299  runtime_stage->stage = stage.value();
300  if (!kvp->second->shader) {
301  VALIDATION_LOG << "No shader specified for runtime stage.";
302  return nullptr;
303  }
304  if (kvp->second->shader->GetSize() > 0u) {
305  runtime_stage->shader = {
306  kvp->second->shader->GetMapping(),
307  kvp->second->shader->GetMapping() + kvp->second->shader->GetSize()};
308  }
309  for (const auto& uniform : kvp->second->uniforms) {
310  auto desc = std::make_unique<fb::UniformDescriptionT>();
311 
312  desc->name = uniform.name;
313  if (desc->name.empty()) {
314  VALIDATION_LOG << "Uniform name cannot be empty.";
315  return nullptr;
316  }
317  desc->location = uniform.location;
318  desc->rows = uniform.rows;
319  desc->columns = uniform.columns;
320  auto uniform_type = ToUniformType(uniform.type);
321  if (!uniform_type.has_value()) {
322  VALIDATION_LOG << "Invalid uniform type for runtime stage.";
323  return nullptr;
324  }
325  desc->type = uniform_type.value();
326  desc->bit_width = uniform.bit_width;
327  if (uniform.array_elements.has_value()) {
328  desc->array_elements = uniform.array_elements.value();
329  }
330 
331  for (const auto& byte_type : uniform.struct_layout) {
332  desc->struct_layout.push_back(static_cast<fb::StructByteType>(byte_type));
333  }
334  desc->struct_float_count = uniform.struct_float_count;
335 
336  runtime_stage->uniforms.emplace_back(std::move(desc));
337  }
338 
339  for (const auto& input : kvp->second->inputs) {
340  auto desc = std::make_unique<fb::StageInputT>();
341 
342  desc->name = input.name;
343 
344  if (desc->name.empty()) {
345  VALIDATION_LOG << "Stage input name cannot be empty.";
346  return nullptr;
347  }
348  desc->location = input.location;
349  desc->set = input.set;
350  desc->binding = input.binding;
351  auto input_type = ToInputType(input.type);
352  if (!input_type.has_value()) {
353  VALIDATION_LOG << "Invalid uniform type for runtime stage.";
354  return nullptr;
355  }
356  desc->type = input_type.value();
357  desc->bit_width = input.bit_width;
358  desc->vec_size = input.vec_size;
359  desc->columns = input.columns;
360  desc->offset = input.offset;
361 
362  runtime_stage->inputs.emplace_back(std::move(desc));
363  }
364 
365  return runtime_stage;
366 }
367 
368 std::unique_ptr<fb::RuntimeStagesT>
370  // The high level object API is used here for writing to the buffer. This is
371  // just a convenience.
372  auto runtime_stages = std::make_unique<fb::RuntimeStagesT>();
373 
374  for (const auto& kvp : data_) {
375  auto runtime_stage = CreateStageFlatbuffer(kvp.first);
376  switch (kvp.first) {
378  runtime_stages->sksl = std::move(runtime_stage);
379  break;
381  runtime_stages->metal = std::move(runtime_stage);
382  break;
384  runtime_stages->opengles = std::move(runtime_stage);
385  break;
387  runtime_stages->vulkan = std::move(runtime_stage);
388  break;
390  runtime_stages->opengles3 = std::move(runtime_stage);
391  break;
392  }
393  }
394  return runtime_stages;
395 }
396 
397 std::shared_ptr<fml::Mapping> RuntimeStageData::CreateMapping() const {
398  auto runtime_stages = CreateMultiStageFlatbuffer();
399  if (!runtime_stages) {
400  return nullptr;
401  }
402 
403  auto builder = std::make_shared<flatbuffers::FlatBufferBuilder>();
404  builder->Finish(fb::RuntimeStages::Pack(*builder.get(), runtime_stages.get()),
405  fb::RuntimeStagesIdentifier());
406  return std::make_shared<fml::NonOwnedMapping>(builder->GetBufferPointer(),
407  builder->GetSize(),
408  [builder](auto, auto) {});
409 }
410 
411 } // namespace compiler
412 } // namespace impeller
GLenum type
std::unique_ptr< fb::RuntimeStagesT > CreateMultiStageFlatbuffer() const
std::shared_ptr< fml::Mapping > CreateMapping() const
std::unique_ptr< fb::RuntimeStageT > CreateStageFlatbuffer(impeller::RuntimeStageBackend backend) const
void AddShader(const std::shared_ptr< Shader > &data)
std::shared_ptr< fml::Mapping > CreateJsonMapping() const
static std::optional< fb::Stage > ToStage(spv::ExecutionModel stage)
static std::optional< fb::UniformDataType > ToUniformType(spirv_cross::SPIRType::BaseType type)
static const char * kUniformLocationKey
static const char * kUniformNameKey
static std::optional< fb::InputDataType > ToInputType(spirv_cross::SPIRType::BaseType type)
static std::optional< fb::Stage > ToJsonStage(spv::ExecutionModel stage)
static const char * kEntrypointKey
static const char * kUniformColumnsKey
static std::optional< uint32_t > ToJsonType(spirv_cross::SPIRType::BaseType type)
static std::string RuntimeStageBackendToString(RuntimeStageBackend backend)
static const char * kUniformTypeKey
static const char * kStageKey
static const char * kUniformsKey
static const char * kUniformRowsKey
static const char * kShaderKey
static const char * kUniformArrayElementsKey
static const char * kTargetPlatformKey
static const char * kUniformBitWidthKey
std::shared_ptr< const fml::Mapping > data
Definition: texture_gles.cc:68
#define VALIDATION_LOG
Definition: validation.h:91