Added osrm-customizer tool

src/customize/customizer.cpp

@@ -0,0 +1,47 @@
+#include "customizer/customizer.hpp"
+#include "customizer/cell_customizer.hpp"
+#include "partition/edge_based_graph_reader.hpp"
+#include "partition/io.hpp"
+
+#include "partition/cell_storage.hpp"
+#include "partition/io.hpp"
+#include "partition/multi_level_partition.hpp"
+#include "util/log.hpp"
+#include "util/timing_util.hpp"
+
+namespace osrm
+{
+namespace customize
+{
+
+int Customizer::Run(const CustomizationConfig &config)
+{
+    TIMER_START(loading_data);
+    auto edge_based_graph = partition::LoadEdgeBasedGraph(config.edge_based_graph_path.string());
+    util::Log() << "Loaded edge based graph for mapping partition ids: "
+                << edge_based_graph->GetNumberOfEdges() << " edges, "
+                << edge_based_graph->GetNumberOfNodes() << " nodes";
+
+    osrm::partition::MultiLevelPartition mlp;
+    partition::io::read(config.mld_partition_path, mlp);
+
+    partition::CellStorage storage(mlp, *edge_based_graph);
+    TIMER_STOP(loading_data);
+    util::Log() << "Loading partition data took " << TIMER_SEC(loading_data) << " seconds";
+
+    TIMER_START(cell_customize);
+    CellCustomizer customizer(mlp);
+    customizer.Customize(*edge_based_graph, storage);
+    TIMER_STOP(cell_customize);
+    util::Log() << "Cells customization took " << TIMER_SEC(cell_customize) << " seconds";
+
+    TIMER_START(writing_mld_data);
+    partition::io::write(config.mld_storage_path, storage);
+    TIMER_STOP(writing_mld_data);
+    util::Log() << "MLD customization writing took " << TIMER_SEC(writing_mld_data) << " seconds";
+
+    return 0;
+}
+
+} // namespace customize
+} // namespace osrm

src/partition/partitioner.cpp

@@ -181,14 +181,8 @@ int Partitioner::Run(const PartitionConfig &config)
     TIMER_STOP(packed_mlp);
     util::Log() << "MultiLevelPartition constructed in " << TIMER_SEC(packed_mlp) << " seconds";
 
-    TIMER_START(cell_storage);
-    CellStorage storage(mlp, *edge_based_graph);
-    TIMER_STOP(cell_storage);
-    util::Log() << "CellStorage constructed in " << TIMER_SEC(cell_storage) << " seconds";
-
     TIMER_START(writing_mld_data);
     io::write(config.mld_partition_path, mlp);
-    io::write(config.mld_storage_path, storage);
     TIMER_STOP(writing_mld_data);
     util::Log() << "MLD data writing took " << TIMER_SEC(writing_mld_data) << " seconds";
 

src/tools/customize.cpp

@@ -0,0 +1,152 @@
+#include "customizer/customizer.hpp"
+
+#include "util/log.hpp"
+#include "util/meminfo.hpp"
+#include "util/version.hpp"
+
+#include <tbb/task_scheduler_init.h>
+
+#include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
+
+#include <iostream>
+
+using namespace osrm;
+
+enum class return_code : unsigned
+{
+    ok,
+    fail,
+    exit
+};
+
+return_code
+parseArguments(int argc, char *argv[], customize::CustomizationConfig &customization_config)
+{
+    // declare a group of options that will be allowed only on command line
+    boost::program_options::options_description generic_options("Options");
+    generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message");
+
+    // declare a group of options that will be allowed both on command line
+    boost::program_options::options_description config_options("Configuration");
+    config_options.add_options()
+        //
+        ("threads,t",
+         boost::program_options::value<unsigned int>(&customization_config.requested_num_threads)
+             ->default_value(tbb::task_scheduler_init::default_num_threads()),
+         "Number of threads to use");
+
+    // hidden options, will be allowed on command line, but will not be
+    // shown to the user
+    boost::program_options::options_description hidden_options("Hidden options");
+    hidden_options.add_options()(
+        "input,i",
+        boost::program_options::value<boost::filesystem::path>(&customization_config.base_path),
+        "Input file in .osrm format");
+
+    // positional option
+    boost::program_options::positional_options_description positional_options;
+    positional_options.add("input", 1);
+
+    // combine above options for parsing
+    boost::program_options::options_description cmdline_options;
+    cmdline_options.add(generic_options).add(config_options).add(hidden_options);
+
+    const auto *executable = argv[0];
+    boost::program_options::options_description visible_options(
+        boost::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
+    visible_options.add(generic_options).add(config_options);
+
+    // parse command line options
+    boost::program_options::variables_map option_variables;
+    try
+    {
+        boost::program_options::store(boost::program_options::command_line_parser(argc, argv)
+                                          .options(cmdline_options)
+                                          .positional(positional_options)
+                                          .run(),
+                                      option_variables);
+    }
+    catch (const boost::program_options::error &e)
+    {
+        util::Log(logERROR) << e.what();
+        return return_code::fail;
+    }
+
+    if (option_variables.count("version"))
+    {
+        std::cout << OSRM_VERSION << std::endl;
+        return return_code::exit;
+    }
+
+    if (option_variables.count("help"))
+    {
+        std::cout << visible_options;
+        return return_code::exit;
+    }
+
+    boost::program_options::notify(option_variables);
+
+    if (!option_variables.count("input"))
+    {
+        std::cout << visible_options;
+        return return_code::exit;
+    }
+
+    return return_code::ok;
+}
+
+int main(int argc, char *argv[]) try
+{
+    util::LogPolicy::GetInstance().Unmute();
+    customize::CustomizationConfig customization_config;
+
+    const auto result = parseArguments(argc, argv, customization_config);
+
+    if (return_code::fail == result)
+    {
+        return EXIT_FAILURE;
+    }
+
+    if (return_code::exit == result)
+    {
+        return EXIT_SUCCESS;
+    }
+
+    // set the default in/output names
+    customization_config.UseDefaults();
+
+    if (1 > customization_config.requested_num_threads)
+    {
+        util::Log(logERROR) << "Number of threads must be 1 or larger";
+        return EXIT_FAILURE;
+    }
+
+    if (!boost::filesystem::is_regular_file(customization_config.base_path))
+    {
+        util::Log(logERROR) << "Input file " << customization_config.base_path.string()
+                            << " not found!";
+        return EXIT_FAILURE;
+    }
+
+    tbb::task_scheduler_init init(customization_config.requested_num_threads);
+
+    auto exitcode = customize::Customizer().Run(customization_config);
+
+    util::DumpMemoryStats();
+
+    return exitcode;
+}
+catch (const std::bad_alloc &e)
+{
+    util::Log(logERROR) << "[exception] " << e.what();
+    util::Log(logERROR) << "Please provide more memory or consider using a larger swapfile";
+    return EXIT_FAILURE;
+}
+#ifdef _WIN32
+catch (const std::exception &e)
+{
+    util::Log(logERROR) << "[exception] " << e.what() << std::endl;
+    return EXIT_FAILURE;
+}
+#endif