don't bump allocate the omnisimplex

chriselrod · chriselrod · commit 8ec207aa5d7d · 2023-05-25T14:48:31.000-04:00
diff --git a/include/LoopBlock.hpp b/include/LoopBlock.hpp
@@ -1034,11 +1034,10 @@ class LinearProgramLoopBlock {
   /// w: bounding offsets, independent of symbolic variables
   /// u: bounding offsets, dependent on symbolic variables
   auto instantiateOmniSimplex(const Graph &g, size_t d, bool satisfyDeps)
-    -> Optional<Simplex *> {
-    auto omniSimplex =
-      Simplex::create(allocator, numConstraints + numSlack,
-                      numBounding + numActiveEdges + numPhiCoefs +
-                        numOmegaCoefs + numSlack + numLambda);
+    -> std::unique_ptr<Simplex> {
+    auto omniSimplex = Simplex::create(
+      numConstraints + numSlack, numBounding + numActiveEdges + numPhiCoefs +
+                                   numOmegaCoefs + numSlack + numLambda);
     auto C{omniSimplex->getConstraints()};
     C << 0;
     // layout of omniSimplex:
@@ -1160,8 +1159,8 @@ class LinearProgramLoopBlock {
     }
     invariant(size_t(l), size_t(1 + numLambda));
     invariant(size_t(c), size_t(numConstraints));
-    addIndependentSolutionConstraints(omniSimplex, g, d);
-    return omniSimplex->initiateFeasible() ? nullptr : (Simplex *)omniSimplex;
+    addIndependentSolutionConstraints(omniSimplex.get(), g, d);
+    return omniSimplex;
   }
   static void updateConstraints(MutPtrMatrix<int64_t> C,
                                 const ScheduledNode &node,
@@ -1188,9 +1187,8 @@ class LinearProgramLoopBlock {
       setSchedulesIndependent(g, depth);
       return checkEmptySatEdges(g, depth);
     }
-    auto p = allocator.scope();
     auto omniSimplex = instantiateOmniSimplex(g, depth, satisfyDeps);
-    if (!omniSimplex) return std::nullopt;
+    if (omniSimplex->initiateFeasible()) return std::nullopt;
     auto sol = omniSimplex->rLexMinStop(numLambda + numSlack);
     assert(sol.size() ==
            numBounding + numActiveEdges + numPhiCoefs + numOmegaCoefs);
@@ -1574,7 +1572,7 @@ class LinearProgramLoopBlock {
     std::swap(g.nodeIds, nodeIds);
     g.activeEdges = activeEdges; // undo such that g.getEdges(d) is correct
     for (auto &&e : g.getEdges(d)) e.popSatLevel();
-    g.activeEdges = oldEdges; // restore backup
+    g.activeEdges = oldEdges;    // restore backup
     auto *oldNodeIter = oldSchedules.begin();
     for (auto &&n : g) n.getSchedule() = *(oldNodeIter++);
     std::swap(carriedDeps, oldCarriedDeps);
diff --git a/include/Math/Simplex.hpp b/include/Math/Simplex.hpp
@@ -16,6 +16,7 @@
 #include <llvm/ADT/ArrayRef.h>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/Support/raw_ostream.h>
+#include <new>
 #include <tuple>
 
 // #define VERBOSESIMPLEX
@@ -880,6 +881,32 @@ class Simplex {
     return mem;
   }
 
+  static auto operator new(size_t count, unsigned conCap, unsigned varCap)
+    -> void * {
+    size_t memNeeded = tableauOffset(conCap, varCap) +
+                       sizeof(value_type) * reservedTableau(conCap, varCap);
+    // void *p = ::operator new(count + memNeeded);
+    return ::operator new(count + memNeeded,
+                          std::align_val_t(alignof(Simplex)));
+  }
+  static void operator delete(void *ptr, size_t) {
+    ::operator delete(ptr, std::align_val_t(alignof(Simplex)));
+  }
+
+  static auto create(unsigned numCon, unsigned numVar)
+    -> std::unique_ptr<Simplex> {
+    return create(numCon, numVar, numCon, numVar + numCon);
+  }
+  static auto create(unsigned numCon, unsigned numVar, unsigned conCap,
+                     unsigned varCap) -> std::unique_ptr<Simplex> {
+    auto *ret = new (conCap, varCap) Simplex;
+    ret->numConstraints = numCon;
+    ret->numVars = numVar;
+    ret->constraintCapacity = conCap;
+    ret->varCapacity = varCap;
+    return std::unique_ptr<Simplex>(ret);
+  }
+
   static constexpr auto
   create(BumpAlloc<> &alloc, unsigned numCon,
          unsigned numVar, // NOLINT(bugprone-easily-swappable-parameters)
