Initial commit with a clean history

Author: schulzchristian

CMakeLists.txt

@@ -0,0 +1,125 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(dynwmis C CXX)
+enable_language(CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# debugging
+#set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address -fno-omit-frame-pointer")
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+
+include_directories(${INTERFACE_INCLUDE_DIRECTORIES})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/extern/argtable3-3.0.3)
+
+
+#set(GUROBI_LIBRARY /home/cschulz/local/opt/gurobi912/lib)
+#find_package(Gurobi REQUIRED)
+
+#MESSAGE("Gurobi: include header files: ${GUROBI_INCLUDE_DIRS}")
+#include_directories(${GUROBI_INCLUDE_DIRS})
+
+#add_definitions(-g -pg)
+SET(DYNWMIS_INCLUDE_DIRS
+        lib
+        lib/algorithms
+        lib/data_structure
+        lib/io
+        lib/tools
+        extern/sparsehash/src
+        extern/argtable3-3.0.3/
+        )
+include_directories(${DYNWMIS_INCLUDE_DIRS})
+add_definitions(-w)
+        
+set(KAMIS_DIR extern/wmis)
+include_directories(
+        ${KAMIS_DIR}/app
+        ${KAMIS_DIR}/lib
+        ${KAMIS_DIR}/lib/io
+        ${KAMIS_DIR}/lib/mis
+        ${KAMIS_DIR}/lib/mis/hils
+        ${KAMIS_DIR}/lib/mis/ils
+        ${KAMIS_DIR}/lib/mis/initial_mis
+        ${KAMIS_DIR}/lib/mis/kernel
+        ${KAMIS_DIR}/lib/partition
+        ${KAMIS_DIR}/lib/partition/uncoarsening/refinement/quotient_graph_refinement/flow_refinement
+        ${KAMIS_DIR}/lib/tools
+        ${KAMIS_DIR}/extern
+        ${KAMIS_DIR}/extern/KaHIP
+        ${KAMIS_DIR}/extern/KaHIP/lib
+        ${KAMIS_DIR}/extern/KaHIP/lib/io
+        ${KAMIS_DIR}/extern/KaHIP/lib/partition
+        ${KAMIS_DIR}/extern/KaHIP/lib/partition/uncoarsening/refinement/quotient_graph_refinement/flow_refinement
+        ${KAMIS_DIR}/extern/KaHIP/lib/tools
+        ${KAMIS_DIR}/extern/KaHIP/lib
+        ${KAMIS_DIR}/extern/KaHIP/lib/data_structure
+        ${KAMIS_DIR}/extern/KaHIP/lib/data_structure/matrix
+        ${KAMIS_DIR}/extern/KaHIP/lib/data_structure/priority_queues)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/extern/onlinemis)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/extern/onlinemis/ils)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/extern/onlinemis/initial_mis)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/extern/onlinemis/data_structure)
+
+
+# add source files of wmis
+add_subdirectory(${KAMIS_DIR})
+
+
+
+# VARS
+SET(DYNWMIS dynwmis)
+#SET(CMAKE_BUILD_TYPE Debug)
+MESSAGE("${CMAKE_BUILD_TYPE}")
+
+add_definitions(-O3 -DNDEBUG -fpermissive -march=native)
+
+
+SET(DYNWMIS_CXX_FILES
+        lib/data_structure/dyn_graph_access.cpp
+        lib/io/mwis_graph_io.cpp
+        lib/tools/timer.cpp
+        lib/algorithms/dyn_wmis_simple.cpp
+        lib/algorithms/dyn_wmis_greedy.cpp
+        lib/algorithms/dyn_wmis_greedy_deg.cpp
+        lib/algorithms/dyn_wmis_bfs.cpp
+        lib/algorithms/dyn_wmis_static.cpp
+        lib/algorithms/solve_static_wmis.cpp
+        lib/algorithms/mis_branch_and_reduce_algorithm.cpp
+        lib/algorithms/modified.cpp
+        extern/onlinemis/ils/local_search_online.cpp
+        extern/onlinemis/ils/online_ils.cpp
+        extern/onlinemis/tools/mis_log.cpp
+        extern/onlinemis/initial_mis/greedy_mis_online.cpp
+        extern/onlinemis/data_structure/candidate_list.cpp
+        extern/onlinemis/data_structure/mis_permutation_online.cpp
+        extern/onlinemis/data_structure/priority_queues/bucket_array.cpp
+        )
+
+set(LIBCONVERT_SOURCE_FILES
+./lib/io/mwis_graph_io.cpp
+./lib/data_structure/dyn_graph_access.cpp
+./lib/tools/random_functions.cpp
+  extern/argtable3-3.0.3/argtable3.c)
+add_library(libconvert OBJECT ${LIBCONVERT_SOURCE_FILES})
+
+# Obejct Library
+set(DYNWMIS_LIB dynwmis_lib)
+add_library(${DYNWMIS_LIB} OBJECT ${DYNWMIS_CXX_FILES})
+
+
+# build settings
+# debugging is activated if NDEBUG is not set
+# logging
+
+# Executables
+add_executable(${DYNWMIS} app/${DYNWMIS}.cpp $<TARGET_OBJECTS:libkaffpa> $<TARGET_OBJECTS:libsources> $<TARGET_OBJECTS:${DYNWMIS_LIB}>)
+
+add_executable(convert_metis_seq app/metis_to_sequence.cpp $<TARGET_OBJECTS:libconvert> )
+install(TARGETS convert_metis_seq DESTINATION ./)
+
+# install
+set(CMAKE_INSTALL_PREFIX ../deploy)
+install(TARGETS ${DYNWMIS} DESTINATION ./)

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dynamic Graph Algorithms Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,95 @@
+# Dynamic (Weighted) Independent Set [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A dynamic graph algorithm is a data structure that supports edge insertions, deletions, and problem specific queries. While extensive research exists on dynamic algorithms for graph problems solvable in polynomial time, most of these algorithms have not been implemented or empirically evaluated.  The open source framework  addresses the NP-complete maximum weight as well as the maximum cardinality independent set problem in a dynamic setting, applicable to areas like dynamic map-labeling and vehicle routing. Specifically we introduce a novel local search technique called optimal neighborhood exploration. This technique creates independent subproblems that are solved to optimality, leading to improved overall solutions. Through numerous experiments, we assess the effectiveness of our approach and compare it with other state-of-the-art dynamic solvers. Our algorithm features a parameter, the subproblem size, that balances running time and solution quality. 
+
+Installation Notes
+=====
+## Downloading: 
+You can download the project with the following command line:
+
+```console
+git clone https://github.com/DynGraphLab/DynWMIS
+```
+
+## Compiling: 
+Just type in the main directory of the project: 
+```console
+./compile_withcmake.sh 
+```
+In this case, all binaries, libraries and headers are in the folder ./deploy/ 
+
+Note that this script detects the amount of available cores on your machine and uses all of them for the compilation process. If you don't want that, set the variable NCORES to the number of cores that you would like to use for compilation. 
+
+Alternatively use the standard cmake build process:
+```console 
+mkdir build
+cd build 
+cmake ../ -DCMAKE_BUILD_TYPE=Release     
+make 
+cd ..
+```
+In this case, the binaries, libraries and headers are in the folder ./build
+
+
+
+Graph Format
+=====
+The graph format used is a simple edge list. The first line is a # followed by two numbers `n` and `m` which specify the number of nodes of your input `n` and the number of edges/updates your perform. If there is a third number that equals `1` in this line, then the graph is weighted. If the graph is weighted, then the next `n` lines will specify vertex weights (one line per vertex). In both cases the `m` lines that follow, each line specifies an update. An update is either an edge insertion or deletion. An edge insertion is specified by a `1` followed by two numbers `u` and `v` which specify the edge `{u,v}` to be inserted. An edge deletion is specified by a `0` followed by two numbers `u` and `v` which specify the edge `{u,v}` to be deleted. In general, vertex IDs start at 1. Updates of vertex weights are in principle also possible, but not supported by the current implementation.
+
+To convert a METIS graph file (like the ones available here https://dimacs10.github.io/) into the graph sequence format used by our program, you can use the following command:
+```console
+./deploy/convert_metis_seq nameofgraphfile.graph 
+```
+The output will be store `nameofgraphfile.graph.seq`; For example, 
+```console
+./deploy/convert_metis_seq examples/3elt.graph
+```
+Creates the file `examples/3elt.graph.seq`; Note, however, that this results in insertion only sequences.
+
+
+Running Programs
+=====
+Running the algorithm is done as follows: 
+
+Running the algorithm on a graph file `3elt.graph.seq` with the algorithm `DynamicOneFast`:
+```console
+./deploy/dynwmis examples/3elt.graph.seq --algorithm=DynamicOneFast
+```
+
+Running the algorithm on a graph file `3elt.graph.seq` with the algorithm `DynamicOneFast`:
+```console
+./deploy/dynwmis examples/4elt.graph.seq --algorithm=DynamicOneFast
+```
+
+The following commands should reproduce the values of the `4elt` instance in Table 1 of our paper:
+
+```console
+for g in `seq 1 10`; do ./deploy/dynwmis examples/4elt.graph.seq --algorithm=DynamicOneFast --seed=$g | grep weight | grep -v spec; done  | awk '{if($NF>max){max=$NF}}END{print max}'
+```
+
+```console
+for g in `seq 1 10`; do ./deploy/dynwmis examples/4elt.graph.seq --algorithm=DynamicOneStrong --seed=$g | grep weight | grep -v spec; done  | awk '{if($NF>max){max=$NF}}END{print max}'
+```
+
+
+
+Licence
+=====
+The program is licenced under MIT licence.
+If you publish results using our algorithms, please acknowledge our work by quoting the following paper:
+
+
+```
+@misc{borowitz2024optimalneighborhoodexplorationdynamic,
+      title={Optimal Neighborhood Exploration for Dynamic Independent Sets}, 
+      author={Jannick Borowitz and Ernestine Großmann and Christian Schulz},
+      year={2024},
+      eprint={2407.06912},
+      archivePrefix={arXiv},
+      primaryClass={cs.DS},
+      url={https://arxiv.org/abs/2407.06912}, 
+}
+```
+
+
+

app/dynwmis.cpp

@@ -0,0 +1,111 @@
+//
+// Created by Jannick Borowitz on 18.04.22.
+//
+
+#include <random_functions.h>
+
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <iomanip>
+
+#include "parse_parameters.h"
+#include "DynamicAlgorithmMeta.h"
+#include "DynWMISConfig.h"
+#include "algorithm_factory.h"
+#include "mwis_graph_io.h"
+#include "timer.h"
+
+int main(int argc, char** argv) {
+
+
+        DynWMISConfig config;
+
+        std::string graph_filename;
+        int ret_code = parse_parameters(argc, argv, config, graph_filename);
+
+        if(ret_code) {
+                return 0;
+        }
+
+
+        srand(config.seed);
+        random_functions::setSeed(config.seed);
+
+        // read sequence
+        auto graphIO = mwis_graph_io();
+        timer t; t.restart();
+
+        std::vector<std::pair<int, std::pair<NodeID, NodeID> > > edge_sequence; 
+        bool has_node_weights = false;
+        std::vector< NodeWeight > node_weights;
+        std::pair<int,int> p = graphIO.readEdgeSequence( graph_filename, edge_sequence, node_weights, has_node_weights);
+        int n = p.first;
+        std::cout <<  "io took " <<  t.elapsed()  << std::endl; 
+
+        //configure algorithm based on input parameters
+        std::shared_ptr<dyn_graph_access> G = std::make_shared<dyn_graph_access>(n);
+
+        std::shared_ptr<dyn_wmis_algorithm> algorithm = getdyn_wmis_instance(config.algorithmType, G, config);
+        config.local_algorithmType = MIS_BRANCH_AND_REDUCE;
+        if(has_node_weights) {
+                forall_nodes((*G), node) {
+                        G->setNodeWeight(node, node_weights[node]);
+                } endfor
+                config.local_algorithmType = BRANCH_AND_REDUCE;
+        } else {
+                forall_nodes((*G), node) {
+                        G->setNodeWeight(node, 1);
+                } endfor
+        }
+
+        t.restart();
+        // run algorithm
+        if(algorithm != NULL) 
+                run_dynamic_algorithm(G, edge_sequence, algorithm);
+
+        std::cout <<  "time \t\t " <<  t.elapsed()  << std::endl;
+        std::cout <<  "weight \t\t " <<  algorithm->weight()  << std::endl;
+
+        //call some postprocessing
+        algorithm->end();
+
+        std::vector< bool > mis;
+        mis = algorithm->getMIS();
+        std::shared_ptr<dyn_graph_access> G_bar = std::make_shared<dyn_graph_access>(n);
+        int mis_size = 0;
+        for (size_t i = 0; i < edge_sequence.size(); ++i) { 
+                std::pair<NodeID, NodeID> & edge = edge_sequence[i].second;
+
+                if (edge_sequence.at(i).first) {
+                        G->new_edge(edge.first, edge.second);
+                        G->new_edge(edge.second, edge.first);
+                } else {
+                        G->remove_edge(edge.first, edge.second);
+                        G->remove_edge(edge.second, edge.first);
+                }
+
+
+
+        } 
+
+        forall_nodes((*G), node) {
+                if( mis[node] ) {
+                        //std::cout <<  "degree of is node " <<  G->getNodeDegree(node)  << std::endl;
+                        mis_size += G->getNodeWeight(node);
+                        forall_out_edges((*G), e, node) {
+                                NodeID target = G->getEdgeTarget(node, e);
+                                if( mis[target] ) {
+                                        std::cout <<  "NOT AN INDEPENDENT SET (" << node << "," << target << ")"  << std::endl;
+                                        exit(0);
+                                }
+                        } endfor
+                } else {
+                        //std::cout <<  "degree of non-is node " <<  G->getNodeDegree(node)  << std::endl;
+                }
+        } endfor
+
+        std::cout <<  "mis size checked is " <<  mis_size  << std::endl;
+
+        return 0;
+}