Flutter Impeller
pipeline_library_gles.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 <sstream>
8 #include <string>
9 
10 #include "flutter/fml/trace_event.h"
11 #include "fml/closure.h"
12 #include "impeller/base/promise.h"
16 
17 namespace impeller {
18 
19 PipelineLibraryGLES::PipelineLibraryGLES(std::shared_ptr<ReactorGLES> reactor)
20  : reactor_(std::move(reactor)) {}
21 
22 static std::string GetShaderInfoLog(const ProcTableGLES& gl, GLuint shader) {
23  GLint log_length = 0;
24  gl.GetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
25  if (log_length == 0) {
26  return "";
27  }
28  auto log_buffer =
29  reinterpret_cast<char*>(std::calloc(log_length, sizeof(char)));
30  gl.GetShaderInfoLog(shader, log_length, &log_length, log_buffer);
31  auto log_string = std::string(log_buffer, log_length);
32  std::free(log_buffer);
33  return log_string;
34 }
35 
36 static std::string GetShaderSource(const ProcTableGLES& gl, GLuint shader) {
37  // Arbitrarily chosen size that should be larger than most shaders.
38  // Since this only fires on compilation errors the performance shouldn't
39  // matter.
40  auto data = static_cast<char*>(malloc(10240));
41  GLsizei length;
42  gl.GetShaderSource(shader, 10240, &length, data);
43 
44  auto result = std::string{data, static_cast<size_t>(length)};
45  free(data);
46  return result;
47 }
48 
50  GLuint shader,
51  std::string_view name,
52  const fml::Mapping& source_mapping,
53  ShaderStage stage) {
54  std::stringstream stream;
55  stream << "Failed to compile ";
56  switch (stage) {
57  case ShaderStage::kUnknown:
58  stream << "unknown";
59  break;
60  case ShaderStage::kVertex:
61  stream << "vertex";
62  break;
63  case ShaderStage::kFragment:
64  stream << "fragment";
65  break;
66  case ShaderStage::kCompute:
67  stream << "compute";
68  break;
69  }
70  stream << " shader for '" << name << "' with error:" << std::endl;
71  stream << GetShaderInfoLog(gl, shader) << std::endl;
72  stream << "Shader source was: " << std::endl;
73  stream << GetShaderSource(gl, shader) << std::endl;
74  VALIDATION_LOG << stream.str();
75 }
76 
77 static bool LinkProgram(
78  const ReactorGLES& reactor,
79  const std::shared_ptr<PipelineGLES>& pipeline,
80  const std::shared_ptr<const ShaderFunction>& vert_function,
81  const std::shared_ptr<const ShaderFunction>& frag_function) {
82  TRACE_EVENT0("impeller", __FUNCTION__);
83 
84  const auto& descriptor = pipeline->GetDescriptor();
85 
86  auto vert_mapping =
87  ShaderFunctionGLES::Cast(*vert_function).GetSourceMapping();
88  auto frag_mapping =
89  ShaderFunctionGLES::Cast(*frag_function).GetSourceMapping();
90 
91  const auto& gl = reactor.GetProcTable();
92 
93  auto vert_shader = gl.CreateShader(GL_VERTEX_SHADER);
94  auto frag_shader = gl.CreateShader(GL_FRAGMENT_SHADER);
95 
96  if (vert_shader == 0 || frag_shader == 0) {
97  VALIDATION_LOG << "Could not create shader handles.";
98  return false;
99  }
100 
101  gl.SetDebugLabel(DebugResourceType::kShader, vert_shader,
102  SPrintF("%s Vertex Shader", descriptor.GetLabel().data()));
103  gl.SetDebugLabel(DebugResourceType::kShader, frag_shader,
104  SPrintF("%s Fragment Shader", descriptor.GetLabel().data()));
105 
106  fml::ScopedCleanupClosure delete_vert_shader(
107  [&gl, vert_shader]() { gl.DeleteShader(vert_shader); });
108  fml::ScopedCleanupClosure delete_frag_shader(
109  [&gl, frag_shader]() { gl.DeleteShader(frag_shader); });
110 
111  gl.ShaderSourceMapping(vert_shader, *vert_mapping,
112  descriptor.GetSpecializationConstants());
113  gl.ShaderSourceMapping(frag_shader, *frag_mapping,
114  descriptor.GetSpecializationConstants());
115 
116  gl.CompileShader(vert_shader);
117  gl.CompileShader(frag_shader);
118 
119  GLint vert_status = GL_FALSE;
120  GLint frag_status = GL_FALSE;
121 
122  gl.GetShaderiv(vert_shader, GL_COMPILE_STATUS, &vert_status);
123  gl.GetShaderiv(frag_shader, GL_COMPILE_STATUS, &frag_status);
124 
125  if (vert_status != GL_TRUE) {
126  LogShaderCompilationFailure(gl, vert_shader, descriptor.GetLabel(),
127  *vert_mapping, ShaderStage::kVertex);
128  return false;
129  }
130 
131  if (frag_status != GL_TRUE) {
132  LogShaderCompilationFailure(gl, frag_shader, descriptor.GetLabel(),
133  *frag_mapping, ShaderStage::kFragment);
134  return false;
135  }
136 
137  auto program = reactor.GetGLHandle(pipeline->GetProgramHandle());
138  if (!program.has_value()) {
139  VALIDATION_LOG << "Could not get program handle from reactor.";
140  return false;
141  }
142 
143  gl.AttachShader(*program, vert_shader);
144  gl.AttachShader(*program, frag_shader);
145 
146  fml::ScopedCleanupClosure detach_vert_shader(
147  [&gl, program = *program, vert_shader]() {
148  gl.DetachShader(program, vert_shader);
149  });
150  fml::ScopedCleanupClosure detach_frag_shader(
151  [&gl, program = *program, frag_shader]() {
152  gl.DetachShader(program, frag_shader);
153  });
154 
155  for (const auto& stage_input :
156  descriptor.GetVertexDescriptor()->GetStageInputs()) {
157  gl.BindAttribLocation(*program, //
158  static_cast<GLuint>(stage_input.location), //
159  stage_input.name //
160  );
161  }
162 
163  gl.LinkProgram(*program);
164 
165  GLint link_status = GL_FALSE;
166  gl.GetProgramiv(*program, GL_LINK_STATUS, &link_status);
167 
168  if (link_status != GL_TRUE) {
169  VALIDATION_LOG << "Could not link shader program: "
170  << gl.GetProgramInfoLogString(*program)
171  << "\nVertex Shader:\n"
172  << GetShaderSource(gl, vert_shader) << "\nFragment Shader:\n"
173  << GetShaderSource(gl, frag_shader);
174  return false;
175  }
176  return true;
177 }
178 
179 // |PipelineLibrary|
180 bool PipelineLibraryGLES::IsValid() const {
181  return reactor_ != nullptr;
182 }
183 
184 std::shared_ptr<PipelineGLES> PipelineLibraryGLES::CreatePipeline(
185  const std::weak_ptr<PipelineLibrary>& weak_library,
186  const PipelineDescriptor& desc,
187  const std::shared_ptr<const ShaderFunction>& vert_function,
188  const std::shared_ptr<const ShaderFunction>& frag_function) {
189  auto strong_library = weak_library.lock();
190 
191  if (!strong_library) {
192  VALIDATION_LOG << "Library was collected before a pending pipeline "
193  "creation could finish.";
194  return nullptr;
195  }
196 
197  auto& library = PipelineLibraryGLES::Cast(*strong_library);
198 
199  const auto& reactor = library.GetReactor();
200 
201  if (!reactor) {
202  return nullptr;
203  }
204 
205  auto program_key = ProgramKey{vert_function, frag_function,
206  desc.GetSpecializationConstants()};
207 
208  auto cached_program = library.GetProgramForKey(program_key);
209 
210  const auto has_cached_program = !!cached_program;
211 
212  auto pipeline = std::shared_ptr<PipelineGLES>(new PipelineGLES(
213  reactor, //
214  weak_library, //
215  desc, //
216  has_cached_program
217  ? std::move(cached_program)
218  : std::make_shared<UniqueHandleGLES>(UniqueHandleGLES::MakeUntracked(
219  reactor, HandleType::kProgram))));
220 
221  auto program = reactor->GetGLHandle(pipeline->GetProgramHandle());
222 
223  if (!program.has_value()) {
224  VALIDATION_LOG << "Could not obtain program handle.";
225  return nullptr;
226  }
227 
228  const auto link_result = !has_cached_program ? LinkProgram(*reactor, //
229  pipeline, //
230  vert_function, //
231  frag_function //
232  )
233  : true;
234 
235  if (!link_result) {
236  VALIDATION_LOG << "Could not link pipeline program.";
237  return nullptr;
238  }
239 
240  if (!pipeline->BuildVertexDescriptor(reactor->GetProcTable(),
241  program.value())) {
242  VALIDATION_LOG << "Could not build pipeline vertex descriptors.";
243  return nullptr;
244  }
245 
246  if (!pipeline->IsValid()) {
247  VALIDATION_LOG << "Pipeline validation checks failed.";
248  return nullptr;
249  }
250 
251  if (!has_cached_program) {
252  library.SetProgramForKey(program_key, pipeline->GetSharedHandle());
253  }
254 
255  return pipeline;
256 }
257 
258 // |PipelineLibrary|
259 PipelineFuture<PipelineDescriptor> PipelineLibraryGLES::GetPipeline(
260  PipelineDescriptor descriptor,
261  bool async) {
262  if (auto found = pipelines_.find(descriptor); found != pipelines_.end()) {
263  return found->second;
264  }
265 
266  if (!reactor_) {
267  return {
268  descriptor,
269  RealizedFuture<std::shared_ptr<Pipeline<PipelineDescriptor>>>(nullptr)};
270  }
271 
272  auto vert_function = descriptor.GetEntrypointForStage(ShaderStage::kVertex);
273  auto frag_function = descriptor.GetEntrypointForStage(ShaderStage::kFragment);
274 
275  if (!vert_function || !frag_function) {
277  << "Could not find stage entrypoint functions in pipeline descriptor.";
278  return {
279  descriptor,
280  RealizedFuture<std::shared_ptr<Pipeline<PipelineDescriptor>>>(nullptr)};
281  }
282 
283  auto promise = std::make_shared<
284  std::promise<std::shared_ptr<Pipeline<PipelineDescriptor>>>>();
285  auto pipeline_future =
286  PipelineFuture<PipelineDescriptor>{descriptor, promise->get_future()};
287  pipelines_[descriptor] = pipeline_future;
288 
289  const auto result = reactor_->AddOperation([promise, //
290  weak_this = weak_from_this(), //
291  descriptor, //
292  vert_function, //
293  frag_function //
294  ](const ReactorGLES& reactor) {
295  promise->set_value(
296  CreatePipeline(weak_this, descriptor, vert_function, frag_function));
297  });
298  FML_CHECK(result);
299 
300  return pipeline_future;
301 }
302 
303 // |PipelineLibrary|
304 PipelineFuture<ComputePipelineDescriptor> PipelineLibraryGLES::GetPipeline(
305  ComputePipelineDescriptor descriptor,
306  bool async) {
307  auto promise = std::make_shared<
308  std::promise<std::shared_ptr<Pipeline<ComputePipelineDescriptor>>>>();
309  promise->set_value(nullptr);
310  return {descriptor, promise->get_future()};
311 }
312 
313 // |PipelineLibrary|
314 bool PipelineLibraryGLES::HasPipeline(const PipelineDescriptor& descriptor) {
315  return pipelines_.find(descriptor) != pipelines_.end();
316 }
317 
318 // |PipelineLibrary|
319 void PipelineLibraryGLES::RemovePipelinesWithEntryPoint(
320  std::shared_ptr<const ShaderFunction> function) {
321  Lock lock(programs_mutex_);
322 
323  PipelineMap::iterator it = pipelines_.begin();
324  while (it != pipelines_.end()) {
325  const PipelineDescriptor& desc = it->first;
326  if (desc.GetEntrypointForStage(function->GetStage())->IsEqual(*function)) {
327  const std::shared_ptr<const ShaderFunction>& vert_function =
328  desc.GetEntrypointForStage(ShaderStage::kVertex);
329  const std::shared_ptr<const ShaderFunction>& frag_function =
330  desc.GetEntrypointForStage(ShaderStage::kFragment);
331  ProgramKey program_key{vert_function, frag_function,
332  desc.GetSpecializationConstants()};
333  programs_.erase(program_key);
334  it = pipelines_.erase(it);
335  } else {
336  it++;
337  }
338  }
339 }
340 
341 // |PipelineLibrary|
342 PipelineLibraryGLES::~PipelineLibraryGLES() = default;
343 
344 const std::shared_ptr<ReactorGLES>& PipelineLibraryGLES::GetReactor() const {
345  return reactor_;
346 }
347 
348 std::shared_ptr<UniqueHandleGLES> PipelineLibraryGLES::GetProgramForKey(
349  const ProgramKey& key) {
350  Lock lock(programs_mutex_);
351  auto found = programs_.find(key);
352  if (found != programs_.end()) {
353  return found->second;
354  }
355  return nullptr;
356 }
357 
358 void PipelineLibraryGLES::SetProgramForKey(
359  const ProgramKey& key,
360  std::shared_ptr<UniqueHandleGLES> program) {
361  Lock lock(programs_mutex_);
362  programs_[key] = std::move(program);
363 }
364 
365 } // namespace impeller
PipelineLibraryGLES(const PipelineLibraryGLES &)=delete
The reactor attempts to make thread-safe usage of OpenGL ES easier to reason about.
Definition: reactor_gles.h:57
std::optional< GLuint > GetGLHandle(const HandleGLES &handle) const
Returns the OpenGL handle for a reactor handle if one is available. This is typically only safe to ca...
const ProcTableGLES & GetProcTable() const
Get the OpenGL proc. table the reactor uses to manage handles.
std::vector< std::pair< uint64_t, std::unique_ptr< GenericRenderPipelineHandle > > > pipelines_
static void LogShaderCompilationFailure(const ProcTableGLES &gl, GLuint shader, std::string_view name, const fml::Mapping &source_mapping, ShaderStage stage)
static std::string GetShaderSource(const ProcTableGLES &gl, GLuint shader)
std::string SPrintF(const char *format,...)
Definition: strings.cc:12
static std::string GetShaderInfoLog(const ProcTableGLES &gl, GLuint shader)
static bool LinkProgram(const ReactorGLES &reactor, const std::shared_ptr< PipelineGLES > &pipeline, const std::shared_ptr< const ShaderFunction > &vert_function, const std::shared_ptr< const ShaderFunction > &frag_function)
Definition: comparable.h:95
std::shared_ptr< const fml::Mapping > data
Definition: texture_gles.cc:68
#define VALIDATION_LOG
Definition: validation.h:91