Adding bindless variants mailbox produce/consume

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/env python
 # 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.
 
 """code generator for GLES2 command buffers."""
 
 import itertools
 import os
 import os.path
@@ skipping 1365 matching lines @@
     'decoder_func': 'DoConsumeTextureCHROMIUM',
     'impl_func': False,
     'type': 'PUT',
     'count': 64,  # GL_MAILBOX_SIZE_CHROMIUM
     'unit_test': False,
     'client_test': False,
     'extension': True,
     'chromium': True,
     'trace_level': 1,
   },
+  'CreateAndConsumeTextureCHROMIUM': {
+    'decoder_func': 'DoCreateAndConsumeTextureCHROMIUM',
+    'impl_func': False,
+    'type': 'CreateAndConsume',

[piman, 2014/05/22 21:53:58]

I'm not convinced it's worth creating a new type just for one function,
especially if there's still manual implementations anyway.

+    'count': 64,  # GL_MAILBOX_SIZE_CHROMIUM
+    'unit_test': False,
+    'client_test': False,
+    'extension': True,
+    'chromium': True,
+    'trace_level': 1,
+  },
   'ClearStencil': {
     'type': 'StateSet',
     'state': 'ClearStencil',
   },
   'EnableFeatureCHROMIUM': {
     'type': 'Custom',
     'immediate': False,
     'decoder_func': 'DoEnableFeatureCHROMIUM',
     'expectation': False,
     'cmd_args': 'GLuint bucket_id, GLint* result',
@@ skipping 573 matching lines @@
     'decoder_func': 'DoProduceTextureCHROMIUM',
     'impl_func': False,
     'type': 'PUT',
     'count': 64,  # GL_MAILBOX_SIZE_CHROMIUM
     'unit_test': False,
     'client_test': False,
     'extension': True,
     'chromium': True,
     'trace_level': 1,
   },
+  'ProduceTextureBindlessCHROMIUM': {
+    'decoder_func': 'DoProduceTextureBindlessCHROMIUM',
+    'impl_func': False,
+    'type': 'PUT',
+    'count': 64,  # GL_MAILBOX_SIZE_CHROMIUM
+    'unit_test': False,
+    'client_test': False,
+    'extension': True,
+    'chromium': True,
+    'trace_level': 1,
+  },
   'RenderbufferStorage': {
     'decoder_func': 'DoRenderbufferStorage',
     'gl_test_func': 'glRenderbufferStorageEXT',
     'expectation': False,
   },
   'RenderbufferStorageMultisampleCHROMIUM': {
     'cmd_comment':
         '// GL_CHROMIUM_framebuffer_multisample\n',
     'decoder_func': 'DoRenderbufferStorageMultisampleCHROMIUM',
     'gl_test_func': 'glRenderbufferStorageMultisampleCHROMIUM',
@@ skipping 2244 matching lines @@
     file.Write("            cmd.header.size * 4u);\n")
     file.Write("  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);\n");
     file.Write("  CheckBytesWrittenMatchesExpectedSize(\n")
     file.Write("      next_cmd, sizeof(cmd) +\n")
     file.Write("      RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));\n")
     file.Write("  // TODO(gman): Check that ids were inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
-class CreateHandler(TypeHandler):
-  """Handler for glCreate___ type functions."""
+class ArrayArgTypeHandler(TypeHandler):
+  """Base class for type handlers that handle args that are arrays"""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
+  def GetArrayType(self, func):
+    """Returns the type of the element in the element array being PUT to."""
+    for arg in func.GetOriginalArgs():
+      if arg.IsPointer():
+        element_type = arg.GetPointedType()
+        return element_type
+
+    # Special case: array type handler is used for a function that is forwarded
+    # to the actual array type implementation
+    element_type = func.GetOriginalArgs()[-1].type
+    assert all(arg.type == element_type \
+               for arg in func.GetOriginalArgs()[-self.GetArrayCount(func):])
+    return element_type
+
+  def GetArrayCount(self, func):
+    """Returns the count of the elements in the array being PUT to."""
+    return func.GetInfo('count')
+
+
+class CreateHandler(ArrayArgTypeHandler):
+  """Handler for glCreate___ type functions."""
+
+  def __init__(self):
+    ArrayArgTypeHandler.__init__(self)
+
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
     func.AddCmdArg(Argument("client_id", 'uint32_t'))
 
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
       .WillOnce(Return(kNewServiceId));
@@ skipping 49 matching lines @@
     file.Write("      MakeIds(this, 0, 1, &client_id);\n")
     file.Write("  helper_->%s(%s);\n" %
                (func.name, func.MakeCmdArgString("")))
     file.Write('  GPU_CLIENT_LOG("returned " << client_id);\n')
     file.Write("  CheckGLError();\n")
     file.Write("  return client_id;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
+class CreateAndConsumeHandler(CreateHandler):
+  """Handler for glCreateAndConsumeTextureCHROMIUM."""
+
+  def __init__(self):
+    CreateHandler.__init__(self)
+
+  def WriteGLES2Implementation(self, func, file):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteHandlerImplementation (self, func, file):
+    """Overrriden from TypeHandler."""
+    file.Write("  uint32_t client_id = c.client_id;\n")
+    file.Write("  %s(%s, client_id);\n" %
+               (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+
+  def WriteImmediateHandlerImplementation (self, func, file):
+    """Overrriden from TypeHandler."""
+    file.Write("  uint32_t client_id = c.client_id;\n")
+    file.Write("  %s(%s, client_id);\n" %
+               (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+
+  def WriteImmediateServiceImplementation(self, func, file):
+    """Writes the service implementation for an immediate version of command."""
+    file.Write(
+        "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
+    file.Write(
+        "    uint32_t immediate_data_size, const gles2::cmds::%s& c) {\n" %
+        func.name)
+    self.WriteHandlerExtensionCheck(func, file)
+    self.WriteHandlerDeferReadWrite(func, file);
+    last_arg = func.GetLastOriginalArg()
+    all_but_last_arg = func.GetOriginalArgs()[:-1]
+    for arg in all_but_last_arg:
+      arg.WriteGetCode(file)
+    self.WriteGetDataSizeCode(func, file)
+    last_arg.WriteGetCode(file)
+    func.WriteHandlerValidation(file)
+    func.WriteHandlerImplementation(file)
+    file.Write("  return error::kNoError;\n")
+    file.Write("}\n")
+    file.Write("\n")
+
+  def WriteGetDataSizeCode(self, func, file):
+    """Overrriden from TypeHandler."""
+    code = """  uint32_t data_size;
+  if (!ComputeDataSize(1, sizeof(%s), %d, &data_size)) {
+    return error::kOutOfBounds;
+  }
+"""
+    file.Write(code % (self.GetArrayType(func), self.GetArrayCount(func)))
+    if func.IsImmediate():
+      file.Write("  if (data_size > immediate_data_size) {\n")
+      file.Write("    return error::kOutOfBounds;\n")
+      file.Write("  }\n")
+
+  def WriteImmediateCmdComputeSize(self, func, file):
+    """Overrriden from TypeHandler."""
+    file.Write("  static uint32_t ComputeDataSize() {\n")
+    file.Write("    return static_cast<uint32_t>(\n")
+    file.Write("        sizeof(%s) * %d);  // NOLINT\n" %
+               (self.GetArrayType(func), self.GetArrayCount(func)))
+    file.Write("  }\n")
+    file.Write("\n")
+    file.Write("  static uint32_t ComputeSize() {\n")
+    file.Write("    return static_cast<uint32_t>(\n")
+    file.Write(
+        "        sizeof(ValueType) + ComputeDataSize());  // NOLINT\n")
+    file.Write("  }\n")
+    file.Write("\n")
+
+  def WriteImmediateCmdInit(self, func, file):
+    """Overrriden from TypeHandler."""
+    last_arg = func.GetLastOriginalArg()
+    file.Write("  void Init(%s, %s _%s) {\n" %
+               (func.MakeTypedCmdArgString("_"),
+                last_arg.type, last_arg.name))
+    file.Write("    SetHeader(ComputeSize());\n")
+    args = func.GetCmdArgs()
+    for arg in args:
+      file.Write("    %s = _%s;\n" % (arg.name, arg.name))
+    file.Write("    memcpy(ImmediateDataAddress(this),\n")
+    file.Write("           _%s, ComputeDataSize());\n" % last_arg.name)
+    file.Write("  }\n")
+    file.Write("\n")
+
+  def WriteImmediateCmdSet(self, func, file):
+    """Overrriden from TypeHandler."""
+    last_arg = func.GetLastOriginalArg()
+    copy_args = func.MakeCmdArgString("_", False)
+    file.Write("  void* Set(void* cmd%s, %s _%s) {\n" %
+               (func.MakeTypedCmdArgString("_", True),
+                last_arg.type, last_arg.name))
+    file.Write("    static_cast<ValueType*>(cmd)->Init(%s, _%s);\n" %
+               (copy_args, last_arg.name))
+    file.Write("    const uint32_t size = ComputeSize();\n")
+    file.Write("    return NextImmediateCmdAddressTotalSize<ValueType>("
+               "cmd, size);\n")
+    file.Write("  }\n")
+    file.Write("\n")
+
+  def WriteImmediateCmdHelper(self, func, file):
+    """Writes the cmd helper definition for the immediate version of a cmd."""
+    code = """  void %(name)s(%(typed_args)s) {
+    const uint32_t size = gles2::cmds::%(name)s::ComputeSize();
+    gles2::cmds::%(name)s* c =
+        GetImmediateCmdSpaceTotalSize<gles2::cmds::%(name)s>(size);
+    if (c) {
+      c->Init(%(args)s);
+    }
+  }
+
+"""
+    last_arg = func.GetLastOriginalArg()
+    file.Write(code % {
+           "name": func.name,
+           "typed_args": '%s, %s _%s' % (func.MakeTypedCmdArgString(""),
+                last_arg.type, last_arg.name),
+           "args": '%s, _%s' % (func.MakeCmdArgString(""), last_arg.name),
+        })
+
 class DeleteHandler(TypeHandler):
   """Handler for glDelete___ single resource type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
@@ skipping 455 matching lines @@
       static_cast<cmds::%(name)s::Result*>(shared_memory_address_);
   result->size = 0;
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));
   EXPECT_EQ(0u, result->size);%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test)
 
-class ArrayArgTypeHandler(TypeHandler):
-  """Base class for type handlers that handle args that are arrays"""
-
-  def __init__(self):
-    TypeHandler.__init__(self)
-
-  def GetArrayType(self, func):
-    """Returns the type of the element in the element array being PUT to."""
-    for arg in func.GetOriginalArgs():
-      if arg.IsPointer():
-        element_type = arg.GetPointedType()
-        return element_type
-
-    # Special case: array type handler is used for a function that is forwarded
-    # to the actual array type implementation
-    element_type = func.GetOriginalArgs()[-1].type
-    assert all(arg.type == element_type \
-               for arg in func.GetOriginalArgs()[-self.GetArrayCount(func):])
-    return element_type
-
-  def GetArrayCount(self, func):
-    """Returns the count of the elements in the array being PUT to."""
-    return func.GetInfo('count')
 
 class PUTHandler(ArrayArgTypeHandler):
   """Handler for glTexParameter_v, glVertexAttrib_v functions."""
 
   def __init__(self):
     ArrayArgTypeHandler.__init__(self)
 
   def WriteServiceUnitTest(self, func, file):
     """Writes the service unit test for a command."""
     expected_call = "EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));"
@@ skipping 1774 matching lines @@
     return ("kInvalidClientId", "kNoError", "GL_INVALID_VALUE")
 
 
 class Function(object):
   """A class that represents a function."""
 
   type_handlers = {
     '': TypeHandler(),
     'Bind': BindHandler(),
     'Create': CreateHandler(),
+    'CreateAndConsume': CreateAndConsumeHandler(),
     'Custom': CustomHandler(),
     'Data': DataHandler(),
     'Delete': DeleteHandler(),
     'DELn': DELnHandler(),
     'GENn': GENnHandler(),
     'GETn': GETnHandler(),
     'GLchar': GLcharHandler(),
     'GLcharN': GLcharNHandler(),
     'HandWritten': HandWrittenHandler(),
     'Is': IsHandler(),
@@ skipping 1717 matching lines @@
       "ppapi/shared_impl/ppb_opengles2_shared.cc"])
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))