updates

Author: tlively

src/support/delta_debugging.h

@@ -37,6 +37,13 @@ namespace wasm {
 // `partition` items.
 template<typename T, typename F>
 std::vector<T> deltaDebugging(std::vector<T> items, F&& tryPartition) {
+  if (items.empty()) {
+    return items;
+  }
+  // First try removing everything.
+  if (tryPartition(0, 1, {})) {
+    return {};
+  }
   size_t numPartitions = 2;
   while (numPartitions <= items.size()) {
     // Partition the items.
@@ -98,12 +105,13 @@ std::vector<T> deltaDebugging(std::vector<T> items, F&& tryPartition) {
       }
     }
 
-    // Otherwise, make the partitions finer grained.
-    if (numPartitions < items.size()) {
-      numPartitions = std::min(items.size(), 2 * numPartitions);
-    } else {
+    if (numPartitions == items.size()) {
+      // Cannot further refine the partitions. We're done.
       break;
     }
+
+    // Otherwise, make the partitions finer grained.
+    numPartitions = std::min(items.size(), 2 * numPartitions);
   }
   return items;
 }

src/tools/wasm-reduce/wasm-reduce.cpp

@@ -894,43 +894,103 @@ struct Reducer
     }
   }
 
+  bool isEmptyBody(Expression* body) {
+    if (body->is<Nop>() || body->is<Unreachable>()) {
+      return true;
+    }
+    if (auto* block = body->dynCast<Block>()) {
+      return block->list.empty();
+    }
+    return false;
+  }
+
   void reduceFunctionBodies() {
     std::cerr << "|    try to remove function bodies\n";
     // Use function indices to speed up finding the complement of the kept
     // partition.
-    std::vector<Index> funcs;
-    funcs.reserve(module->functions.size());
+    std::vector<Index> nontrivialFuncIndices;
+    nontrivialFuncIndices.reserve(module->functions.size());
     for (Index i = 0; i < module->functions.size(); ++i) {
-      funcs.push_back(i);
-    }
-    deltaDebugging(
-      std::move(funcs),
-      [&](Index partitionIndex,
-          Index numPartitions,
-          const std::vector<Index>& partition) {
-        std::cerr << "|     try partition " << partitionIndex + 1 << " / "
-                  << numPartitions << " (size " << partition.size() << ")\n";
-        std::vector<Name> removed;
-        removed.reserve(module->functions.size() - partition.size());
-        Index i = 0;
-        for (Index j : partition) {
-          while (i < j) {
-            removed.push_back(module->functions[i++]->name);
+      auto& func = module->functions[i];
+      // Skip functions that already have trivial bodies.
+      if (func->imported() || isEmptyBody(func->body)) {
+        continue;
+      }
+      nontrivialFuncIndices.push_back(i);
+    }
+    // TODO: Use something other than an exception to implement early return.
+    struct EarlyReturn {};
+    try {
+      deltaDebugging(
+        nontrivialFuncIndices,
+        [&](Index partitionIndex,
+            Index numPartitions,
+            const std::vector<Index>& partition) {
+          // Stop early if the partition size is less than the square root of
+          // the remaining set. We don't want to waste time on very fine-grained
+          // partitions when we could switch to another reduction strategy
+          // instead.
+          if (partition.size() > 0 &&
+              partition.size() < std::sqrt(nontrivialFuncIndices.size())) {
+            throw EarlyReturn{};
           }
-          ++i;
-        }
-        while (i < module->functions.size()) {
-          removed.push_back(module->functions[i++]->name);
-        }
-        if (tryToEmptyFunctions(removed)) {
-          // TODO: Consider doing this just once after the delta debugging since
-          // we never need to restore from the working copy while removing
-          // function bodies.
-          noteReduction(removed.size());
+
+          std::cerr << "|     try partition " << partitionIndex + 1 << " / "
+                    << numPartitions << " (size " << partition.size() << ")\n";
+          Index removedSize = nontrivialFuncIndices.size() - partition.size();
+          std::vector<Expression*> oldBodies(removedSize);
+
+          // We first need to remove each non-kept function body, and later we
+          // might need to restore the same function bodies. Abstract the logic
+          // for iterating over these function bodies. `f` takes a Function* and
+          // Expression*& for the stashed body.
+          auto forEachRemovedFuncBody = [&](auto f) {
+            Index bodyIndex = 0;
+            Index nontrivialIndex = 0;
+            Index partitionIndex = 0;
+            while (nontrivialIndex < nontrivialFuncIndices.size()) {
+              if (partitionIndex < partition.size() &&
+                  nontrivialFuncIndices[nontrivialIndex] ==
+                    partition[partitionIndex]) {
+                // Kept, skip it.
+                nontrivialIndex++;
+                partitionIndex++;
+              } else {
+                // Removed, process it
+                Index funcIndex = nontrivialFuncIndices[nontrivialIndex++];
+                f(module->functions[funcIndex].get(), oldBodies[bodyIndex++]);
+              }
+            }
+            assert(bodyIndex == removedSize);
+            assert(partitionIndex == partition.size());
+          };
+
+          // Stash the bodies.
+          forEachRemovedFuncBody([&](Function* func, Expression*& oldBody) {
+            oldBody = func->body;
+            Builder builder(*module);
+            if (func->getResults() == Type::none) {
+              func->body = builder.makeNop();
+            } else {
+              func->body = builder.makeUnreachable();
+            }
+          });
+
+          if (!writeAndTestReduction()) {
+            // Failure. Restore the bodies.
+            forEachRemovedFuncBody([](Function* func, Expression*& oldBody) {
+              func->body = oldBody;
+            });
+            return false;
+          }
+
+          // Success!
+          noteReduction(removedSize);
+          nontrivialFuncIndices = partition;
           return true;
-        }
-        return false;
-      });
+        });
+    } catch (EarlyReturn) {
+    }
   }
 
   bool reduceFunctions() {
@@ -1085,41 +1145,6 @@ struct Reducer
     }
   }
 
-  // Try to empty out the bodies of some functions.
-  bool tryToEmptyFunctions(std::vector<Name> names) {
-    std::vector<Expression*> oldBodies;
-    size_t actuallyEmptied = 0;
-    for (auto name : names) {
-      auto* func = module->getFunction(name);
-      auto* oldBody = func->body;
-      oldBodies.push_back(oldBody);
-      // Nothing to do for imported functions (body is nullptr) or for bodies
-      // that have already been as reduced as we can make them.
-      if (func->imported() || oldBody->is<Unreachable>() ||
-          oldBody->is<Nop>()) {
-        continue;
-      }
-      actuallyEmptied++;
-      bool useUnreachable = func->getResults() != Type::none;
-      if (useUnreachable) {
-        func->body = builder->makeUnreachable();
-      } else {
-        func->body = builder->makeNop();
-      }
-    }
-    if (actuallyEmptied > 0 && writeAndTestReduction()) {
-      std::cerr << "|        emptied " << actuallyEmptied << " / "
-                << names.size() << " functions\n";
-      return true;
-    } else {
-      // Restore the bodies.
-      for (size_t i = 0; i < names.size(); i++) {
-        module->getFunction(names[i])->body = oldBodies[i];
-      }
-      return false;
-    }
-  }
-
   // Try to actually remove functions. If they are somehow referred to, we will
   // get a validation error and undo it.
   bool tryToRemoveFunctions(std::vector<Name> names) {
@@ -1542,10 +1567,20 @@ More documentation can be found at
 
   bool stopping = false;
 
+  bool first = true;
   while (1) {
     Reducer reducer(
       command, test, working, binary, deNan, verbose, debugInfo, options);
 
+    // For extremely large modules with slow reproduction commands, reducing
+    // function bodies first can be more effective than running passes. TODO:
+    // clean this up and reconsider the order of reducers.
+    if (first) {
+      reducer.loadWorking();
+      reducer.reduceFunctionBodies();
+      first = false;
+    }
+
     // run binaryen optimization passes to reduce. passes are fast to run
     // and can often reduce large amounts of code efficiently, as opposed
     // to detructive reduction (i.e., that doesn't preserve correctness as

test/gtest/delta_debugging.cpp

@@ -80,3 +80,10 @@ TEST(DeltaDebuggingTest, DifferentTypes) {
   std::vector<std::string> expected = {"banana", "date"};
   EXPECT_EQ(result, expected);
 }
+
+TEST(DeltaDebuggingTest, UnconditionallyTrue) {
+  std::vector<int> items = {0, 1, 2, 3};
+  auto result = deltaDebugging(
+    items, [](size_t, size_t, const std::vector<int>&) { return true; });
+  EXPECT_TRUE(result.empty());
+}