SERVER-82832 Stop creating and destroying vectors unnecessarily in checkAndAssertTypes

Author: kauboy26

buildscripts/idl/idl/generator.py

@@ -107,10 +107,18 @@ def _access_member(field):
     return member_name
 
 
+def _std_array_expr(value_type, elems):
+    # type: (str, List[str]) -> str
+    """Return a std::array<value_type, N>{elems} expression."""
+    elem_str = ', '.join(elems)
+    return f'std::array<{value_type}, {len(elems)}>{{{elem_str}}}'
+
+
 def _get_bson_type_check(bson_element, ctxt_name, ast_type):
     # type: (str, str, ast.Type) -> str
     """Get the C++ bson type check for a Type."""
-    bson_types = ast_type.bson_serialization_type
+    # Deduplicate the types in the array.
+    bson_types = list(set(ast_type.bson_serialization_type))
     if len(bson_types) == 1:
         if bson_types[0] in ['any', 'chain']:
             # Skip BSON validation for 'any' types since they are required to validate the
@@ -120,13 +128,14 @@ def _get_bson_type_check(bson_element, ctxt_name, ast_type):
             return None
 
         if not bson_types[0] == 'bindata':
-            return '%s.checkAndAssertType(%s, %s)' % (ctxt_name, bson_element,
-                                                      bson.cpp_bson_type_name(bson_types[0]))
-        return '%s.checkAndAssertBinDataType(%s, %s)' % (
+            return 'MONGO_likely(%s.checkAndAssertType(%s, %s))' % (
+                ctxt_name, bson_element, bson.cpp_bson_type_name(bson_types[0]))
+        return 'MONGO_likely(%s.checkAndAssertBinDataType(%s, %s))' % (
             ctxt_name, bson_element, bson.cpp_bindata_subtype_type_name(ast_type.bindata_subtype))
     else:
-        type_list = '{%s}' % (', '.join([bson.cpp_bson_type_name(b) for b in bson_types]))
-        return '%s.checkAndAssertTypes(%s, %s)' % (ctxt_name, bson_element, type_list)
+        return (
+            f'MONGO_likely({ctxt_name}.checkAndAssertTypes({bson_element}, '
+            f'{_std_array_expr("BSONType", [bson.cpp_bson_type_name(b) for b in bson_types])}))')
 
 
 def _get_required_fields(struct):
@@ -1383,7 +1392,6 @@ def _gen_array_deserializer(self, field, bson_element, ast_type, tenant):
 
             with self._predicate('MONGO_likely(arrayFieldName == expectedFieldNumber)'):
                 check = _get_bson_type_check('arrayElement', 'arrayCtxt', ast_type)
-                check = "MONGO_likely(%s)" % (check) if check is not None else check
 
                 with self._predicate(check):
                     if ast_type.is_variant:
@@ -1456,11 +1464,12 @@ def _gen_variant_deserializer(self, field, bson_element, tenant):
 
                 self._writer.write_line('default:')
                 self._writer.indent()
-                expected_types = ', '.join(
-                    'BSONType::%s' % bson.cpp_bson_type_name(t.bson_serialization_type[0])
-                    for t in array_types)
+                expected_types = [
+                    bson.cpp_bson_type_name(t.bson_serialization_type[0]) for t in array_types
+                ]
                 self._writer.write_line(
-                    'ctxt.throwBadType(%s, {%s});' % (bson_element, expected_types))
+                    f'ctxt.throwBadType({bson_element},  {_std_array_expr("BSONType", expected_types)});'
+                )
                 self._writer.write_line('break;')
                 self._writer.unindent()
                 # End of inner switch.
@@ -1497,10 +1506,11 @@ def _gen_variant_deserializer(self, field, bson_element, tenant):
 
         self._writer.write_line('default:')
         self._writer.indent()
-        expected_types = ', '.join(
-            'BSONType::%s' % bson.cpp_bson_type_name(t.bson_serialization_type[0])
-            for t in scalar_types)
-        self._writer.write_line('ctxt.throwBadType(%s, {%s});' % (bson_element, expected_types))
+        expected_types = [
+            bson.cpp_bson_type_name(t.bson_serialization_type[0]) for t in array_types
+        ]
+        self._writer.write_line(f'ctxt.throwBadType({bson_element}, '
+                                f'{_std_array_expr("BSONType", expected_types)});')
         self._writer.write_line('break;')
         self._writer.unindent()
 
@@ -1615,8 +1625,6 @@ def validate_and_assign_or_uassert(field, expression):
             predicate = None
             if check_type:
                 predicate = _get_bson_type_check(bson_element, 'ctxt', field_type)
-                if predicate:
-                    predicate = "MONGO_likely(%s)" % (predicate)
 
             with self._predicate(predicate):
 

src/mongo/idl/idl_parser.cpp

@@ -33,6 +33,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
+#include <span>
 #include <stack>
 #include <string>
 
@@ -50,7 +51,7 @@ namespace {
  *
  * Example: "string, bool, numberDouble"
  */
-std::string toCommaDelimitedList(const std::vector<BSONType>& types) {
+std::string toCommaDelimitedList(std::span<const BSONType> types) {
     str::stream builder;
 
     for (std::size_t i = 0; i < types.size(); ++i) {
@@ -104,7 +105,7 @@ bool IDLParserContext::checkAndAssertBinDataTypeSlowPath(const BSONElement& elem
 }
 
 bool IDLParserContext::checkAndAssertTypes(const BSONElement& element,
-                                           const std::vector<BSONType>& types) const {
+                                           std::span<const BSONType> types) const {
     auto elementType = element.type();
 
     auto pos = std::find(types.begin(), types.end(), elementType);
@@ -220,7 +221,7 @@ void IDLParserContext::throwBadEnumValue(StringData enumValue) const {
 }
 
 void IDLParserContext::throwBadType(const BSONElement& element,
-                                    const std::vector<BSONType>& types) const {
+                                    std::span<const BSONType> types) const {
     std::string path = getElementPath(element);
     std::string type_str = toCommaDelimitedList(types);
     uasserted(ErrorCodes::TypeMismatch,

src/mongo/idl/idl_parser.h

@@ -34,6 +34,7 @@
 #include <boost/optional.hpp>
 #include <boost/optional/optional.hpp>
 #include <cstdint>
+#include <span>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -359,7 +360,7 @@ class IDLParserContext {
      * processed.
      * Throws an exception if the BSON element's type is wrong.
      */
-    bool checkAndAssertTypes(const BSONElement& element, const std::vector<BSONType>& types) const;
+    bool checkAndAssertTypes(const BSONElement& element, std::span<const BSONType> types) const;
 
     /**
      * Throw an error message about the BSONElement being a duplicate field.
@@ -397,7 +398,7 @@ class IDLParserContext {
      * Throw an error about a field having the wrong type.
      */
     MONGO_COMPILER_NORETURN void throwBadType(const BSONElement& element,
-                                              const std::vector<BSONType>& types) const;
+                                              std::span<const BSONType> types) const;
 
     /**
      * Throw an 'APIStrictError' if the user command has 'apiStrict' field as true.

src/mongo/idl/idl_parser_bm.cpp

@@ -317,5 +317,21 @@ void BM_ARRAY_BSON(benchmark::State& state) {
 
 BENCHMARK(BM_ARRAY_BSON)->Arg(10)->Arg(1000)->Arg(10000)->Unit(benchmark::kNanosecond);
 
+void BM_CHECK_AND_ASSERT_TYPES(benchmark::State& state) {
+    // Perform setup here.
+    // We construct a WriteCommandRequestBase with just the "bypassDocumentValidation"
+    // field set, which is of type safeBool, to run the generated checkAndAssertTypes()
+    // function.
+    auto request = BSON("bypassDocumentValidation" << 1);
+
+    for (auto _ : state) {
+        // This code gets timed
+        benchmark::DoNotOptimize(
+            write_ops::WriteCommandRequestBase::parse(IDLParserContext("test"), request));
+    }
+}
+
+BENCHMARK(BM_CHECK_AND_ASSERT_TYPES);
+
 }  // namespace
 }  // namespace mongo