Implement glGetUniformBlocksCHROMIUM: service side data packing

gpu/command_buffer/service/program_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 89 matching lines @@
 }
 
 bool IsBuiltInInvariant(
     const VaryingMap& varyings, const std::string& name) {
   VaryingMap::const_iterator hit = varyings.find(name);
   if (hit == varyings.end())
     return false;
   return hit->second.isInvariant;
 }
 
+uint32 ComputeOffset(const void* start, const void* position) {
+  return static_cast<const uint8*>(position) -
+         static_cast<const uint8*>(start);
+}
+
 }  // anonymous namespace.
 
 Program::UniformInfo::UniformInfo()
     : size(0),
       type(GL_NONE),
       fake_location_base(0),
       is_array(false) {
 }
 
 Program::UniformInfo::UniformInfo(GLsizei _size,
@@ skipping 1074 matching lines @@
     variables[index].type = iter->second.type;
     variables[index].size = iter->second.size;
     ++index;
   }
   return ShCheckVariablesWithinPackingLimits(
       static_cast<int>(manager_->max_varying_vectors()),
       variables.get(),
       combined_map.size());
 }
 
-static uint32 ComputeOffset(const void* start, const void* position) {
-  return static_cast<const uint8*>(position) -
-         static_cast<const uint8*>(start);
-}
-
 void Program::GetProgramInfo(
     ProgramManager* manager, CommonDecoder::Bucket* bucket) const {
   // NOTE: It seems to me the math in here does not need check for overflow
   // because the data being calucated from has various small limits. The max
   // number of attribs + uniforms is somewhere well under 1024. The maximum size
   // of an identifier is 256 characters.
   uint32 num_locations = 0;
   uint32 total_string_size = 0;
 
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
@@ skipping 64 matching lines @@
       }
       memcpy(strings, info.name.c_str(), info.name.size());
       strings += info.name.size();
       ++inputs;
     }
   }
 
   DCHECK_EQ(ComputeOffset(header, strings), size);
 }
 
+void Program::GetUniformBlocks(CommonDecoder::Bucket* bucket) const {
+  // The data is packed into the bucket in the following order
+  //   1) header
+  //   2) N entries of block data (except for name and indices)
+  //   3) name1, indices1, name2, indices2, ..., nameN, indicesN
+  //
+  // We query all the data directly through GL calls, assuming they are
+  // cheap through MANGLE.
+  //
+  // Security wise, the math in here does not need check for overflow
+  // because the data being calucated from has various small limits.
+  // See: MAX_VERTEX/FRAGMENT_UNIFORM_COMPONENTS (sample value: 896),
+  //      MAX_VERTEX/FRAGMENT_UNIFORM_BLOCKS (sample value: 12),
+  //      max size of an idenfifier: 1024.

[piman, 2015/01/28 23:29:42]

We haven't checked all drivers though, including future ones. Drivers are
allowed to have those limits beyond the minimum required. They could be
UINT_MAX.

We could enforce these in the command buffer, by failing compiles if some of the
values are over limits that we define and are safe for this code, but I don't
think we do that anywhere (beyond hashing uniform names).

[Zhenyao Mo, 2015/01/29 01:45:36]

OK, I'll use CheckedNumeric instead then.

+
+  DCHECK(bucket);
+  GLuint program = service_id();
+
+  size_t header_size = sizeof(UniformBlocksHeader);
+
+  GLuint num_uniform_blocks = 0;
+  GLint param = GL_FALSE;
+  // We assume program is a valid program service id.
+  glGetProgramiv(program, GL_LINK_STATUS, &param);
+  if (param == GL_TRUE) {
+    param = 0;
+    glGetProgramiv(program, GL_ACTIVE_UNIFORM_BLOCKS, &param);
+    num_uniform_blocks = static_cast<GLuint>(param);
+  }
+  if (num_uniform_blocks == 0) {
+    // Although spec allows an implementation to return uniform block info
+    // even if a link fails, for consistency, we disallow that.
+    bucket->SetSize(header_size);
+    UniformBlocksHeader* header =
+        bucket->GetDataAs<UniformBlocksHeader*>(0, header_size);
+    header->num_uniform_blocks = 0;
+    return;
+  }
+
+  std::vector<UniformBlockInfo> blocks(num_uniform_blocks);
+  size_t entry_size = sizeof(UniformBlockInfo) * num_uniform_blocks;
+  size_t total_size = header_size + entry_size;
+  for (GLuint ii = 0; ii < num_uniform_blocks; ++ii) {
+    param = 0;
+    glGetActiveUniformBlockiv(program, ii, GL_UNIFORM_BLOCK_BINDING, &param);
+    blocks[ii].binding = static_cast<uint32_t>(param);
+
+    param = 0;
+    glGetActiveUniformBlockiv(program, ii, GL_UNIFORM_BLOCK_DATA_SIZE, &param);
+    blocks[ii].data_size = static_cast<uint32_t>(param);
+
+    blocks[ii].name_offset = static_cast<uint32_t>(total_size);
+    param = 0;
+    glGetActiveUniformBlockiv(
+        program, ii, GL_UNIFORM_BLOCK_NAME_LENGTH, &param);
+    blocks[ii].name_length = static_cast<uint32_t>(param);
+    total_size += blocks[ii].name_length;

[piman, 2015/01/28 23:29:42]

Do we need to deal with remapped uniform names, when the translator is on and
hashes uniform names?

[Zhenyao Mo, 2015/01/29 01:45:36]

Done.

+
+    param = 0;
+    glGetActiveUniformBlockiv(
+        program, ii, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &param);
+    blocks[ii].active_uniforms = static_cast<uint32_t>(param);
+    blocks[ii].active_uniform_offset = static_cast<uint32_t>(total_size);
+    total_size += sizeof(uint32_t) * blocks[ii].active_uniforms;
+
+    param = 0;
+    glGetActiveUniformBlockiv(
+        program, ii, GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, &param);
+    blocks[ii].referenced_by_vertex_shader = static_cast<uint32_t>(param);
+
+    param = 0;
+    glGetActiveUniformBlockiv(
+        program, ii, GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, &param);
+    blocks[ii].referenced_by_fragment_shader = static_cast<uint32_t>(param);
+  }
+  DCHECK_LE(header_size + entry_size, total_size);
+  size_t data_size = total_size - header_size - entry_size;
+
+  bucket->SetSize(total_size);
+  UniformBlocksHeader* header =
+      bucket->GetDataAs<UniformBlocksHeader*>(0, total_size);
+  UniformBlockInfo* entries = bucket->GetDataAs<UniformBlockInfo*>(
+      header_size, entry_size);
+  char* data = bucket->GetDataAs<char*>(header_size + entry_size, data_size);
+  DCHECK(header);
+  DCHECK(entries);
+  DCHECK(data);
+
+  // Copy over data for the header and entries.
+  header->num_uniform_blocks = static_cast<uint32_t>(num_uniform_blocks);
+  memcpy(entries, &blocks[0], entry_size);
+
+  std::vector<GLint> params;
+  GLsizei length;
+  for (size_t ii = 0; ii < num_uniform_blocks; ++ii) {
+    // Get active uniform name.
+    size_t num_bytes = static_cast<size_t>(blocks[ii].name_length);
+    memset(data, 0, num_bytes);
+    length = 0;
+    glGetActiveUniformBlockName(
+        program, ii, static_cast<GLsizei>(num_bytes), &length, data);
+    DCHECK_EQ(num_bytes, static_cast<size_t>(length) + 1);
+    data += num_bytes;
+
+    // Get active uniform indices.
+    if (params.size() < blocks[ii].active_uniforms)
+      params.resize(blocks[ii].active_uniforms);
+    num_bytes =
+        static_cast<size_t>(blocks[ii].active_uniforms) * sizeof(GLint);
+    memset(&params[0], 0, num_bytes);
+    glGetActiveUniformBlockiv(
+        program, ii, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, &params[0]);
+    uint32_t* indices = reinterpret_cast<uint32_t*>(data);
+    for (uint32_t uu = 0; uu < blocks[ii].active_uniforms; ++uu) {
+      indices[uu] = static_cast<uint32_t>(params[uu]);
+    }
+    data += num_bytes;
+  }
+  DCHECK_EQ(ComputeOffset(header, data), total_size);
+}
+
 Program::~Program() {
   if (manager_) {
     if (manager_->have_context_) {
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
@@ skipping 112 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu