[WIP] Misc performance improvements

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

src/compiler/default_compiler_draft3.h

@@ -8,8 +8,11 @@
 
 #include <algorithm> // std::sort, std::ranges::any_of, std::ranges::all_of, std::find_if, std::ranges::none_of
 #include <cassert>   // assert
+#include <map>       // std::map
 #include <set>       // std::set
-#include <utility>   // std::move, std::to_underlying
+#include <string>    // std::string
+#include <unordered_map> // std::unordered_map
+#include <utility>       // std::move, std::to_underlying
 
 #include "compile_helpers.h"
 
@@ -104,10 +107,17 @@ compile_properties(const sourcemeta::blaze::Context &context,
   // we prefer to evaluate smaller subschemas first, in the hope of failing
   // earlier without spending a lot of time on other subschemas
   if (context.tweaks.properties_reorder) {
-    std::ranges::sort(properties, [&context](const auto &left,
-                                             const auto &right) {
-      const auto left_size{recursive_template_size(left.second)};
-      const auto right_size{recursive_template_size(right.second)};
+    std::unordered_map<std::string, std::size_t> template_sizes;
+    template_sizes.reserve(properties.size());
+    for (const auto &property : properties) {
+      template_sizes.emplace(property.first,
+                             recursive_template_size(property.second));
+    }
+
+    std::ranges::sort(properties, [&context, &template_sizes](
+                                      const auto &left, const auto &right) {
+      const auto left_size{template_sizes.at(left.first)};
+      const auto right_size{template_sizes.at(right.first)};
       if (left_size == right_size) {
         const auto left_direct_enumeration{
             defines_direct_enumeration(left.second)};
@@ -548,10 +558,11 @@ auto compiler_draft3_applicator_properties_with_options(
     ValueNamedIndexes indexes;
     Instructions children;
     std::size_t cursor = 0;
+    std::map<sourcemeta::core::JSON::String, std::size_t> child_positions;
 
     for (auto &&[name, substeps] : compile_properties(
              context, schema_context, relative_dynamic_context(), current)) {
-      indexes.emplace(name, cursor);
+      child_positions.emplace(name, cursor);
 
       if (track_evaluation) {
         substeps.push_back(make(
@@ -574,6 +585,17 @@ auto compiler_draft3_applicator_properties_with_options(
       cursor += 1;
     }
 
+    // Lay the lookup table out in schema declaration order, as instances
+    // commonly follow it, which makes scanning the table for each instance
+    // property terminate sooner on average
+    for (const auto &entry :
+         schema_context.schema.at(dynamic_context.keyword).as_object()) {
+      const auto match{child_positions.find(entry.first)};
+      if (match != child_positions.cend()) {
+        indexes.emplace(entry.first, match->second);
+      }
+    }
+
     if (context.mode == Mode::FastValidation && !track_evaluation &&
         !schema_context.schema.defines("patternProperties") &&
         schema_context.schema.defines("additionalProperties") &&

src/compiler/default_compiler_draft4.h

@@ -5,9 +5,14 @@
 #include <sourcemeta/blaze/evaluator.h>
 
 #include <algorithm> // std::ranges::any_of, std::ranges::all_of, std::ranges::none_of, std::find_if
-#include <cassert> // assert
-#include <set>     // std::set
-#include <utility> // std::move, std::to_underlying
+#include <cassert>       // assert
+#include <map>           // std::map
+#include <optional>      // std::optional, std::nullopt
+#include <set>           // std::set
+#include <string_view>   // std::string_view
+#include <unordered_set> // std::unordered_set
+#include <utility>       // std::move, std::to_underlying
+#include <vector>        // std::vector
 
 #include "compile_helpers.h"
 #include "default_compiler_draft3.h"
@@ -73,6 +78,264 @@ auto compiler_draft4_applicator_allof(const Context &context,
   }
 }
 
+// The set of facts about a disjunct that hold no matter what, used to
+// statically prove that a disjunction is a discriminated union
+struct SwitchDisjunctFacts {
+  bool object_only{false};
+  bool never_object{false};
+  std::set<sourcemeta::core::JSON::String> required;
+  std::map<sourcemeta::core::JSON::String,
+           std::vector<sourcemeta::core::JSON::String>>
+      pinned;
+};
+
+auto is_known_non_object_type_name(const sourcemeta::core::JSON &entry)
+    -> bool {
+  if (!entry.is_string()) {
+    return false;
+  }
+
+  const auto &name{entry.to_string()};
+  return name == "null" || name == "boolean" || name == "array" ||
+         name == "string" || name == "number" || name == "integer";
+}
+
+// Gather facts that necessarily hold for any instance that validates
+// against the given subschema, following static references and `allOf`
+// conjunctions. Note that when a subschema declares `$ref`, we ignore its
+// siblings: older dialects consider them inert, and on newer dialects
+// doing so only loses information, never inventing facts
+auto collect_switch_disjunct_facts(
+    const Context &context, const sourcemeta::core::JSON &subschema,
+    const sourcemeta::blaze::SchemaFrame::Location &location,
+    const std::string_view root_dialect, const Vocabularies &root_vocabularies,
+    std::unordered_set<const sourcemeta::blaze::SchemaFrame::Location *>
+        &visited,
+    SwitchDisjunctFacts &facts) -> void {
+  if (!subschema.is_object() || !visited.insert(&location).second) {
+    return;
+  }
+
+  if (subschema.defines("$ref") && subschema.at("$ref").is_string()) {
+    static const sourcemeta::core::JSON::String ref_keyword{"$ref"};
+    const auto reference{context.frame.reference(
+        sourcemeta::blaze::SchemaReferenceType::Static,
+        location.pointer.concat(make_weak_pointer(ref_keyword)))};
+    if (reference.has_value()) {
+      const auto destination{
+          context.frame.traverse(reference->get().destination)};
+      if (destination.has_value()) {
+        collect_switch_disjunct_facts(
+            context,
+            sourcemeta::core::get(context.root, destination->get().pointer),
+            destination->get(), root_dialect, root_vocabularies, visited,
+            facts);
+      }
+    }
+
+    return;
+  }
+
+  using Known = sourcemeta::blaze::Vocabularies::Known;
+  const auto vocabularies{
+      location.dialect == root_dialect
+          ? root_vocabularies
+          : context.frame.vocabularies(location, context.resolver)};
+  const auto supports_validation{
+      vocabularies.contains(Known::JSON_Schema_Draft_4) ||
+      vocabularies.contains(Known::JSON_Schema_Draft_6) ||
+      vocabularies.contains(Known::JSON_Schema_Draft_7) ||
+      vocabularies.contains(Known::JSON_Schema_2019_09_Validation) ||
+      vocabularies.contains(Known::JSON_Schema_2020_12_Validation)};
+  const auto supports_applicator{
+      vocabularies.contains(Known::JSON_Schema_Draft_4) ||
+      vocabularies.contains(Known::JSON_Schema_Draft_6) ||
+      vocabularies.contains(Known::JSON_Schema_Draft_7) ||
+      vocabularies.contains(Known::JSON_Schema_2019_09_Applicator) ||
+      vocabularies.contains(Known::JSON_Schema_2020_12_Applicator)};
+  const auto supports_const{
+      vocabularies.contains(Known::JSON_Schema_Draft_6) ||
+      vocabularies.contains(Known::JSON_Schema_Draft_7) ||
+      vocabularies.contains(Known::JSON_Schema_2019_09_Validation) ||
+      vocabularies.contains(Known::JSON_Schema_2020_12_Validation)};
+
+  if (supports_validation) {
+    if (subschema.defines("type")) {
+      const auto &type{subschema.at("type")};
+      if ((type.is_string() && type.to_string() == "object") ||
+          (type.is_array() && !type.empty() &&
+           std::ranges::all_of(type.as_array(), [](const auto &entry) {
+             return entry.is_string() && entry.to_string() == "object";
+           }))) {
+        facts.object_only = true;
+      } else if (is_known_non_object_type_name(type) ||
+                 (type.is_array() && !type.empty() &&
+                  std::ranges::all_of(type.as_array(),
+                                      is_known_non_object_type_name))) {
+        facts.never_object = true;
+      }
+    }
+
+    if (subschema.defines("enum") && subschema.at("enum").is_array() &&
+        std::ranges::none_of(
+            subschema.at("enum").as_array(),
+            [](const auto &option) { return option.is_object(); })) {
+      facts.never_object = true;
+    }
+
+    if (supports_const && subschema.defines("const") &&
+        !subschema.at("const").is_object()) {
+      facts.never_object = true;
+    }
+
+    if (subschema.defines("required") && subschema.at("required").is_array()) {
+      for (const auto &entry : subschema.at("required").as_array()) {
+        if (entry.is_string()) {
+          facts.required.insert(entry.to_string());
+        }
+      }
+    }
+  }
+
+  if (supports_applicator && subschema.defines("properties") &&
+      subschema.at("properties").is_object()) {
+    for (const auto &entry : subschema.at("properties").as_object()) {
+      if (facts.pinned.contains(entry.first) || !entry.second.is_object()) {
+        continue;
+      }
+
+      std::vector<sourcemeta::core::JSON::String> values;
+      if (supports_const && entry.second.defines("const") &&
+          entry.second.at("const").is_string()) {
+        values.push_back(entry.second.at("const").to_string());
+      } else if (supports_validation && entry.second.defines("enum") &&
+                 entry.second.at("enum").is_array() &&
+                 !entry.second.at("enum").empty() &&
+                 std::ranges::all_of(
+                     entry.second.at("enum").as_array(),
+                     [](const auto &option) { return option.is_string(); })) {
+        for (const auto &option : entry.second.at("enum").as_array()) {
+          values.push_back(option.to_string());
+        }
+      } else {
+        continue;
+      }
+
+      facts.pinned.emplace(entry.first, std::move(values));
+    }
+  }
+
+  if (supports_applicator && subschema.defines("allOf") &&
+      subschema.at("allOf").is_array()) {
+    static const sourcemeta::core::JSON::String allof_keyword{"allOf"};
+    for (std::size_t index = 0; index < subschema.at("allOf").size(); index++) {
+      collect_switch_disjunct_facts(
+          context, subschema.at("allOf").at(index),
+          context.frame.traverse(location,
+                                 make_weak_pointer(allof_keyword, index)),
+          root_dialect, root_vocabularies, visited, facts);
+    }
+  }
+}
+
+// Attempt to compile a disjunction whose disjuncts all statically pin a
+// shared discriminator property to disjoint constant strings (on top of
+// requiring it on an object instance) into a single switch instruction
+// that picks the only disjunct that can possibly match in constant time.
+// Note that the given disjuncts are left untouched unless an instruction
+// could indeed be derived
+auto compile_switch_property_string(const Context &context,
+                                    const SchemaContext &schema_context,
+                                    const DynamicContext &dynamic_context,
+                                    Instructions &disjunctors)
+    -> std::optional<Instruction> {
+  const auto &disjunction{schema_context.schema.at(dynamic_context.keyword)};
+  if (disjunction.size() < 2) {
+    return std::nullopt;
+  }
+
+  const auto &keyword_entry{static_frame_entry(context, schema_context)};
+  std::vector<SwitchDisjunctFacts> facts_list;
+  facts_list.reserve(disjunction.size());
+  // The index plus one of the only disjunct that can match non-object
+  // instances, where zero means no such disjunct exists
+  ValueUnsignedInteger otherwise{0};
+  std::vector<std::size_t> discriminated;
+  discriminated.reserve(disjunction.size());
+  for (std::size_t index = 0; index < disjunction.size(); index++) {
+    sourcemeta::core::WeakPointer disjunct_suffix;
+    disjunct_suffix.push_back(index);
+    SwitchDisjunctFacts facts;
+    std::unordered_set<const sourcemeta::blaze::SchemaFrame::Location *>
+        visited;
+    collect_switch_disjunct_facts(
+        context, disjunction.at(index),
+        context.frame.traverse(keyword_entry, disjunct_suffix),
+        keyword_entry.dialect, schema_context.vocabularies, visited, facts);
+    if (facts.never_object) {
+      if (otherwise > 0) {
+        return std::nullopt;
+      }
+
+      otherwise = index + 1;
+    } else if (facts.object_only && !facts.pinned.empty()) {
+      discriminated.push_back(index);
+    } else {
+      return std::nullopt;
+    }
+
+    facts_list.push_back(std::move(facts));
+  }
+
+  if (discriminated.size() < 2) {
+    return std::nullopt;
+  }
+
+  for (const auto &candidate : facts_list[discriminated.front()].pinned) {
+    const auto &name{candidate.first};
+    ValueNamedIndexes indexes;
+    bool valid{true};
+    for (const auto index : discriminated) {
+      const auto &facts{facts_list[index]};
+      if (!facts.required.contains(name)) {
+        valid = false;
+        break;
+      }
+
+      const auto match{facts.pinned.find(name)};
+      if (match == facts.pinned.cend()) {
+        valid = false;
+        break;
+      }
+
+      for (const auto &option : match->second) {
+        const auto hash{indexes.hash(option)};
+        if (indexes.defines(option, hash)) {
+          valid = false;
+          break;
+        }
+
+        indexes.emplace_assume_new(option, ValueUnsignedInteger{index}, hash);
+      }
+
+      if (!valid) {
+        break;
+      }
+    }
+
+    if (valid) {
+      return make(
+          sourcemeta::blaze::InstructionIndex::LogicalSwitchPropertyString,
+          context, schema_context, dynamic_context,
+          ValuePropertySwitch{make_property(name), std::move(indexes),
+                              otherwise},
+          std::move(disjunctors));
+    }
+  }
+
+  return std::nullopt;
+}
+
 auto compiler_draft4_applicator_anyof(const Context &context,
                                       const SchemaContext &schema_context,
                                       const DynamicContext &dynamic_context,
@@ -143,6 +406,15 @@ auto compiler_draft4_applicator_anyof(const Context &context,
   const auto requires_exhaustive{context.mode == Mode::Exhaustive ||
                                  requires_evaluation(context, schema_context)};
 
+  if (context.mode == Mode::FastValidation && !requires_exhaustive &&
+      !schema_context.is_property_name) {
+    auto switched{compile_switch_property_string(context, schema_context,
+                                                 dynamic_context, disjunctors)};
+    if (switched.has_value()) {
+      return {std::move(switched).value()};
+    }
+  }
+
   return {make(sourcemeta::blaze::InstructionIndex::LogicalOr, context,
                schema_context, dynamic_context,
                ValueBoolean{requires_exhaustive}, std::move(disjunctors))};
@@ -173,6 +445,18 @@ auto compiler_draft4_applicator_oneof(const Context &context,
   const auto requires_exhaustive{context.mode == Mode::Exhaustive ||
                                  requires_evaluation(context, schema_context)};
 
+  // As the discriminator property values across disjuncts are proven to be
+  // disjoint, at most one disjunct can ever match, so the exclusivity that
+  // `oneOf` demands holds statically and the switch is also valid here
+  if (context.mode == Mode::FastValidation && !requires_exhaustive &&
+      !schema_context.is_property_name) {
+    auto switched{compile_switch_property_string(context, schema_context,
+                                                 dynamic_context, disjunctors)};
+    if (switched.has_value()) {
+      return {std::move(switched).value()};
+    }
+  }
+
   return {make(sourcemeta::blaze::InstructionIndex::LogicalXor, context,
                schema_context, dynamic_context,
                ValueBoolean{requires_exhaustive}, std::move(disjunctors))};