Swizzle Uniform Locations

gpu/command_buffer/service/program_manager.cc

 // Copyright (c) 2011 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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 namespace gpu {
 namespace gles2 {
 
 static int ShaderTypeToIndex(GLenum shader_type) {
   switch (shader_type) {
     case GL_VERTEX_SHADER:
@@ skipping 421 matching lines @@
   }
   return true;
 }
 
 static uint32 ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8*>(position) -
          static_cast<const uint8*>(start);
 }
 
 void ProgramManager::ProgramInfo::GetProgramInfo(
-    CommonDecoder::Bucket* bucket) const {
+    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) {
     const VertexAttribInfo& info = attrib_infos_[ii];
     num_locations += 1;
@@ skipping 45 matching lines @@
 
   for (size_t ii = 0; ii < uniform_infos_.size(); ++ii) {
     const UniformInfo& info = uniform_infos_[ii];
     inputs->size = info.size;
     inputs->type = info.type;
     inputs->location_offset = ComputeOffset(header, locations);
     inputs->name_offset = ComputeOffset(header, strings);
     inputs->name_length = info.name.size();
     DCHECK(static_cast<size_t>(info.size) == info.element_locations.size());
     for (size_t jj = 0; jj < info.element_locations.size(); ++jj) {
-      *locations++ = info.element_locations[jj];
+      *locations++ = manager->SwizzleLocation(info.element_locations[jj]);
     }
     memcpy(strings, info.name.c_str(), info.name.size());
     strings += info.name.size();
     ++inputs;
   }
 
   DCHECK_EQ(ComputeOffset(header, strings), size);
 }
 
 ProgramManager::ProgramInfo::~ProgramInfo() {}
 
-ProgramManager::ProgramManager() {}
+ProgramManager::ProgramManager()
+    : uniform_swizzle_(base::RandInt(0, 15)) {
+}
 
 ProgramManager::~ProgramManager() {
   DCHECK(program_infos_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   while (!program_infos_.empty()) {
     if (have_context) {
       ProgramInfo* info = program_infos_.begin()->second;
       if (!info->IsDeleted()) {
@@ skipping 79 matching lines @@
 void ProgramManager::UnuseProgram(
     ShaderManager* shader_manager,
     ProgramManager::ProgramInfo* info) {
   DCHECK(shader_manager);
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->DecUseCount();
   RemoveProgramInfoIfUnused(shader_manager, info);
 }
 
+static GLint Swizzle(GLint location) {
+  union {
+    GLint as_int;

[apatrick_chromium, 2012/02/06 21:04:44]

Is there any need to do this on an unsigned int? It looks like the right shift
is in no danger of sign extending since the value to be shifted always has zero
in the MSB.

[greggman, 2012/02/06 21:30:01]

Done.

+    GLuint as_uint;
+  } t;
+  t.as_int = location;
+  GLuint v = t.as_uint;
+  v = (v & 0xFFFF0000U) |
+      ((v & 0x0000AAAAU) >> 1) |
+      ((v & 0x00005555U) << 1);
+  t.as_uint = v;
+  return t.as_int;
+}
+
+GLint ProgramManager::SwizzleLocation(GLint unswizzled_location) const {
+  GLint v = unswizzled_location < 0 ? unswizzled_location :
+      (unswizzled_location + uniform_swizzle_);

[apatrick_chromium, 2012/02/06 21:04:44]

Why add a random number?

[greggman, 2012/02/06 21:30:01]

The random number is added because NaCl devs were found assuming locations, not
just on arrays but assuming that all drivers/GPUs would return the same
location. The random number means every run gets different locations.

+  return Swizzle(v);
+}
+
+GLint ProgramManager::UnswizzleLocation(GLint swizzled_location) const {
+  GLint v = Swizzle(swizzled_location);
+  return v < 0 ? v : (v - uniform_swizzle_);
+}
+
 }  // namespace gles2
 }  // namespace gpu