Simplify segfaulting code

Author: daniel-j-h

example/index.js

@@ -92,25 +92,15 @@ MbxClient.getDistances(locations, {profile: profile}, function(err, results) {
   var demands = new Array(results.durations.length);
 
   // made up values that trigger segfault
-  var Pickups = [ 6, 5, 5, 1, 0, 6, 5];
+  var Pickups =    [ 6, 5, 5, 1, 5, 6, 5];
   var Deliveries = [ 4, 4, 3, 2, 2, 4, 7];
 
   for (let from = 0; from < results.durations.length; ++from) {
     demands[from] = new Array(results.durations.length);
-    if (Pickups && Deliveries) {
-        demands[from].fill(0);
-        for (let it = 0; it < Pickups.length; ++it) {
-            if (Pickups[it] === from) {
-                let to = Deliveries[it];
-                demands[from][to] = demands[from][to] ? demands[from][to] + 1 : 1;
-            }
-        }
-    } else {
       // Dummy demands of one except at the depot
       for (var to = 0; to < results.durations.length; ++to) {
         demands[from][to] = (from === depotIndex) ? 0 : 1;
       }
-    }
   }
 
   // No route locks per vehicle, let solver decide freely

package.json

@@ -30,7 +30,9 @@
     "tap": "^10.3",
     "mapbox-sdk-js": "git://github.com/mapbox/mapbox-sdk-js.git#758572e9d5287023451f91a4b76e7e85c785189d"
   },
-  "bundledDependencies": ["node-pre-gyp"],
+  "bundledDependencies": [
+    "node-pre-gyp"
+  ],
   "binary": {
     "module_name": "node_or_tools",
     "module_path": "./lib/binding/",

src/tsp.cc

@@ -34,9 +34,6 @@ NAN_METHOD(TSP::New) try {
 
   TSPSolverParams userParams{info};
 
-  const auto bytesChange = getBytes(userParams.costs);
-  Nan::AdjustExternalMemory(bytesChange);
-
   auto* self = new TSP{std::move(userParams.costs)};
 
   self->Wrap(info.This());

src/types.h

@@ -10,17 +10,9 @@
 
 // Convenience types. Sshould be good enough for most of TSP / VRP related problems.
 
-// Newtype via phantom type scheme. Allows type system to distinguish between tagged types.
-// Note: NewType<T, struct Tag0>::Type != NewType<T, struct Tag1>::Type
-template <typename T, typename Tag> struct NewType {
-  struct Type : T {
-    using T::T;
-  };
-};
-
-using CostMatrix = NewType<Matrix<std::int32_t>, struct CostMatrixTag>::Type;
-using DurationMatrix = NewType<Matrix<std::int32_t>, struct DurationMatrixTag>::Type;
-using DemandMatrix = NewType<Matrix<std::int32_t>, struct DemandMatrixTag>::Type;
+using CostMatrix = Matrix<std::int32_t>;
+using DurationMatrix = Matrix<std::int32_t>;
+using DemandMatrix = Matrix<std::int32_t>;
 
 struct Interval {
   Interval() : start{0}, stop{0} {}
@@ -34,7 +26,7 @@ struct Interval {
   std::int32_t stop;
 };
 
-using TimeWindows = NewType<Vector<Interval>, struct TimeWindowsTag>::Type;
+using TimeWindows = Vector<Interval>;
 
 namespace ort = operations_research;
 
@@ -66,48 +58,7 @@ using RouteLocks = std::vector<LockChain>;
 // e.g. pickups: [1, 2], deliveries: [5, 6] means
 //  - pick up at node 1 and deliver to node 5
 //  - pick up at node 2 and deliver to node 6
-using Pickups = NewType<Vector<NodeIndex>, struct PickupsTag>::Type;
-using Deliveries = NewType<Vector<NodeIndex>, struct DeliveriesTag>::Type;
-
-// Bytes in our type used for internal caching
-
-template <typename T> struct Bytes;
-
-template <> struct Bytes<CostMatrix> {
-  std::int32_t operator()(const CostMatrix& v) const { return v.size() * sizeof(CostMatrix::Value); }
-};
-
-template <> struct Bytes<DurationMatrix> {
-  std::int32_t operator()(const DurationMatrix& v) const { return v.size() * sizeof(DurationMatrix::Value); }
-};
-
-template <> struct Bytes<DemandMatrix> {
-  std::int32_t operator()(const DemandMatrix& v) const { return v.size() * sizeof(DemandMatrix::Value); }
-};
-
-template <> struct Bytes<TimeWindows> {
-  std::int32_t operator()(const TimeWindows& v) const { return v.size() * sizeof(TimeWindows::Value); }
-};
-
-template <> struct Bytes<RouteLocks> {
-  std::int32_t operator()(const RouteLocks& v) const {
-    std::int32_t bytes = 0;
-
-    for (const auto& lockChain : v)
-      bytes += lockChain.size() * sizeof(LockChain::value_type);
-
-    return bytes;
-  }
-};
-
-template <> struct Bytes<Pickups> {
-  std::int32_t operator()(const Pickups& v) const { return v.size() * sizeof(Pickups::Value); }
-};
-
-template <> struct Bytes<Deliveries> {
-  std::int32_t operator()(const Deliveries& v) const { return v.size() * sizeof(Deliveries::Value); }
-};
-
-template <typename T> std::int32_t getBytes(const T& v) { return Bytes<T>{}(v); }
+using Pickups = Vector<NodeIndex>;
+using Deliveries = Vector<NodeIndex>;
 
 #endif

src/vrp.cc

@@ -33,13 +33,6 @@ NAN_METHOD(VRP::New) try {
 
   VRPSolverParams userParams{info};
 
-  const auto bytesChange = getBytes(userParams.costs)         //
-                           + getBytes(userParams.durations)   //
-                           + getBytes(userParams.timeWindows) //
-                           + getBytes(userParams.demands);    //
-
-  Nan::AdjustExternalMemory(bytesChange);
-
   auto* self = new VRP{std::move(userParams.costs),       //
                        std::move(userParams.durations),   //
                        std::move(userParams.timeWindows), //
@@ -58,9 +51,6 @@ NAN_METHOD(VRP::Solve) try {
 
   VRPSearchParams userParams(info);
 
-  const auto bytesChange = getBytes(userParams.routeLocks);
-  Nan::AdjustExternalMemory(bytesChange);
-
   // See routing_parameters.proto and routing_enums.proto
   auto modelParams = RoutingModel::DefaultModelParameters();
   auto searchParams = RoutingModel::DefaultSearchParameters();