Design and analysis of sequential and parallel single-source shortest-paths algorithms

We study the performance of algorithms for the Single-Source Shortest-Paths (SSSP) problem on graphs with n nodes and m edges with nonnegative random weights. All previously known SSSP algorithms for directed graphs required superlinear time. Wie give the first SSSP algorithms that provably achieve linear O(n-m)average-case execution time on arbitrary directed graphs with random edge weights. For independent edge weights, the linear-time bound holds with high probability, too. Additionally, our result implies improved average-case bounds for the All-Pairs Shortest-Paths (APSP) problem on sparse graphs, and it yields the first theoretical average-case analysis for the "Approximate Bucket Implementation" of Dijkstra\u27s SSSP algorithm (ABI-Dijkstra). Futhermore, we give constructive proofs for the existence of graph classes with random edge weights on which ABI-Dijkstra and several other well-known SSSP algorithms require superlinear average-case time. Besides the classical sequential (single processor) model of computation we also consider parallel computing: we give the currently fastest average-case linear-work parallel SSSP algorithms for large graph classes with random edge weights, e.g., sparse rondom graphs and graphs modeling the WWW, telephone calls or social networks.In dieser Arbeit untersuchen wir die Laufzeiten von Algorithmen für das Kürzeste-Wege Problem (Single-Source Shortest-Paths, SSSP) auf Graphen mit n Knoten, M Kanten und nichtnegativen zufälligen Kantengewichten. Alle bisherigen SSSP Algorithmen benötigen auf gerichteten Graphen superlineare Zeit. Wir stellen den ersten SSSP Algorithmus vor, der auf beliebigen gerichteten Graphen mit zufälligen Kantengewichten eine beweisbar lineare average-case-Komplexität O(n+m)aufweist. Sind die Kantengewichte unabhängig, so wird die lineare Zeitschranke auch mit hoher Wahrscheinlichkeit eingehalten. Außerdem impliziert unser Ergebnis verbesserte average-case-Schranken für das All-Pairs Shortest-Paths (APSP) Problem auf dünnen Graphen und liefert die erste theoretische average-case-Analyse für die "Approximate Bucket Implementierung" von Dijkstras SSSP Algorithmus (ABI-Dijkstra). Weiterhin führen wir konstruktive Existenzbeweise für Graphklassen mit zufälligen Kantengewichten, auf denen ABI-Dijkstra und mehrere andere bekannte SSSP Algorithmen durchschnittlich superlineare Zeit benötigen. Neben dem klassischen seriellen (Ein-Prozessor) Berechnungsmodell betrachten wir auch Parallelverarbeitung; für umfangreiche Graphklassen mit zufälligen Kantengewichten wie z.B. dünne Zufallsgraphen oder Modelle für das WWW, Telefonanrufe oder soziale Netzwerke stellen wir die derzeit schnellsten parallelen SSSP Algorithmen mit durchschnittlich linearer Arbeit vor

Méthodes de décomposition pour la parallélisation du simplexe en nombres entiers

RÉSUMÉ: Le SPP est un problème de la programmation linéaire en nombres entiers qui est utilisé pour modéliser des problèmes industriels dans de nombreux domaines comme la planification des horaires du personnel, la logistique et la reconnaissance de formes. Dans l’industrie de transport, il consiste à partitionner un ensemble de tâches (ex : vols d’avion, segments de trajet d’autobus...) en sous-ensembles (routes de véhicules ou rotations de personnel navigant) de sorte que les sous-ensembles sélectionnés aient un coût total minimal et que chaque tâche appartienne à un seul et unique sous-ensemble. Souvent, il est résolu par la méthode ”branch and bound” ou ses variantes. Ces méthodes s’avèrent lentes dans le cas de problèmes denses de grande taille. Cependant, en industrie, il est apprécié d’avoir une solution rapidement et de tenir compte des informations disponibles telles que l’existence d’une solution initiale notamment lors de la ré-optimisation par exemple. Cet aspect est fourni aisément par les méthodes primales qui, à partir d’une solution initiale, produisent une suite de solutions à coûts décroissants qui converge vers une solution optimale. L’algorithme du simplexe en nombres entiers avec décomposition (ISUD) est une méthode primale qui, à chaque itération, décompose le problème original en deux sous-problèmes. Un premier sous-problème, appelé problème réduit, qui ne considère que les colonnes dites compatibles avec la solution courante, i.e., s’écrivant comme combinaison linéaire de colonnes/variables non dégénérées de la solution courante. Un deuxième sous-problème, appelé problème complémentaire, qui contient seulement les colonnes incompatibles avec la solution courante. Le problème complémentaire permet de trouver une direction de descente composée de plusieurs variables garantissant une solution meilleure, mais pas nécessairement entière. Dans le cas de solutions fractionnaires, un branchement en profondeur permet souvent d’aboutir rapidement à une solution entière. De nos jours, l’informatique connaît des évolutions frappantes. Les transformations que connaît le matériel informatique en termes de vitesse et de puissance sont impressionnantes : un ordinateur portable contemporain est l’équivalent des plus grosses machines des années 1970. Cette évolution induit une transformation du logiciel et des algorithmes aussi profonde, en termes de qualité et de complexité. Par conséquent, la tendance actuelle est de produire des processeurs multicoeurs assimilables à des machines parallèles et de concevoir et implémenter des algorithmes parallèles. L’objectif général de cette thèse est d’étudier les apports du parallélisme à l’algorithme d’ISUD. Le but est de proposer des implémentations parallèles d’ISUD afin d’améliorer ses performances et tirer profit des évolutions contemporaines de l’informatique. Pour concevoir ces algorithmes parallèles, nous avons exploité le parallélisme à l’intérieur d’ISUD et nous avons introduit des décompositions spécifiques au SPP. Dans un premier temps, notre démarche est de grouper les colonnes de la solution courante en clusters afin de décomposer le problème initial en sous-problèmes indépendants. Ces derniers sont résolus en parallèle afin d’améliorer la solution courante par combinaison des solutions optimales des sous-problèmes. Pour cela, nous construisons un graphe dont les noeuds sont les colonnes de la solution courante. Nous attribuons aux arêtes des poids calculés par des fonctions de densité qui utilisent les informations issues du problème original comme le nombre de colonnes qui couvrent des tâches des colonnes Ai et Aj de la solution courante. Le graphe construit est scindé en sous-graphes et par la suite nous obtenons des clusters de la solution courante. Ainsi, nous avons ajouté une deuxième décomposition dynamique à celle qui est déjà intrinsèque à ISUD. Le résultat est un algorithme parallèle, le simplexe en nombres entiers avec double décomposition, baptisé ISU2D. Nous avons testé ce nouvel algorithme sur des instances d’horaires de chauffeurs d’autobus ayant 1600 contraintes et 570000 variables. L’algorithme réduit le temps d’exécution d’ISUD par un facteur de 3, voire 4 pour certaines instances. Il atteint la solution optimale, ou une solution assez proche, pour la majorité de ces instances en moins de 10 min alors que le solveur commercial CPLEX ne parvient pas à trouver une solution réalisable avec un gap moins de 10% après une durée de plus d’une heure d’exécution. L’algorithme ISU2D, dans sa première version, représente une première implémentation parallèle de l’algorithme du simplexe en nombres entiers. Cependant, ISU2D souffre encore de la limitation qui est l’utilisation d’une seule décomposition de la solution courante à la fois. Dans un deuxième temps, nous améliorons ISU2D en généralisant certains aspects de son concept. Notre objectif dans cette étape est d’utiliser plusieurs décompositions dynamiques simultanément. Nous proposons un algorithme, nommé DISUD, distribué à base d’ISUD et du paradigme du système multi-agent (SMA). Chaque agent est une entité qui est, au moins partiellement, autonome et caractérisée par la décomposition dynamique de la solution courante qu’elle applique. Les agents peuvent être indépendants ou coopérants suivant la stratégie adoptée. Ainsi, nous augmentons les performances d’ISU2D et nous tirons profit d’avantage des nouveautés en matériel informatique. Les tests faits sur des instances issues de l’optimisation des horaires du personnel navigant de compagnies aériennes montrent que DISUD fonctionne mieux que DCPLEX, la version distribuée du solveur commercial de pointe CPLEX. Il atteint des solutions de qualité meilleure que le DCPLEX en réduisant le temps d’exécution par un facteur de 4 en moyenne. De plus, il a résolu des instances de grande taille que le DCPLEX n’a pu amélioré après une heure d’exécution. Dans un troisième travail, nous réalisons l’objectif d’intégrer le DISUD dans un environnement de génération de colonnes (GC). Ce choix se justifie par le fait que l’intégration de la méthode de génération de colonnes avec les méthodes d’énumération telle le ”branch and price” est largement utilisé dans l’industrie. ISUD présente du potentiel pour remplacer les méthodes d’énumération usuelles pour résoudre le SPP. Par conséquent, il y a du potentiel à intégrer GC et DISUD pour traiter des problèmes de l’industrie. Nous développons donc DICG la version distribuée de génération de colonnes qui utilise DISUD. Les résultats que nous avons obtenus lors de nos tests ont montré que DICG permet d’avoir des solutions de bonne qualité et réduit le temps de calcul d’un facteur de 2 voire 4 par comparaison avec la DRMH, version distribuée de ” Restricted Master Heuristic”. Avec ces trois travaux, nous pensons avoir réalisé des apports intéressants et amélioré les performances d’ISUD. En outre, nous ouvrons la voie pour des travaux futurs afin d’élargir les utilisations de la version distribuée d’ISUD comme par exemple, rendre les agents plus intelligents via des algorithmes d’apprentissage.----------ABSTRACT: SPP is an integer linear programming problem that is used to model many industrial problems such as personnel scheduling, logistics and pattern recognition. In the transport industry, it consists of partitioning a set of tasks ( plane flights, bus itinerary segments, ...) into subsets (rotation of navigating personnel) so that the selected subsets have a minimum total cost and each task belongs exactly to one subset. Usually, SPP is solved by the branch and bound method or its variants. These methods are known to be slow in the case of large and difficult problems. However, in industry it is appreciated to have a solution as quickly as possible and to consider available information such as the existence of an initial solution, especially in the re-optimization case. This aspect is easily provided by the primal methods which from an initial solution produce a sequence of decreasing cost solutions that converge towards an optimal or near optimal solution. The Integral Simplex Using Decomposition, ISUD, is a primal method dedicated to solve SPP. At each iteration, it decomposes the original problem into two sub-problems. The first, called the reduced problem (RP), only considers the so-called compatible columns with the current solution. The second, called the complementary problem (CP), deals only with the columns that are incompatible with the current solution. The complementary problem makes it possible to find a descent direction composed of several variables that could be fractional or integer solution. In the case of fractional solutions, a branching often leads to an integer solution. Nowadays, computing science evolves impressively. The transformation of computer hardware into speedy machines is spectacular : a current laptop is equivalent to the 1970s biggest machines. The current trend is to produce multi-core processors and to design and implement parallel computing techniques. The general objective of this thesis is to study and apply parallel computing techniques to ISUD.We propose parallel implementations of ISUD in order to improve its performances and to profit from the contemporary evolution of the computer science. To design these algorithms we have exploited parallelism within ISUD and introduced specific decompositions. At first, we group the columns of the current solution into clusters in order to decompose the initial problem into independent sub-problems. These will be solved in parallel to get an improving solution by combining the sub-problems optimal solutions. To do so, we construct a graph whose nodes are the current solution columns. The edge (i, j) weight is computed by weighting functions that use the information from the original problem such as the number of columns that span two columns Ai and Aj of the current solution. Then, the constructed graph is split into sub graphs and as a result to a set of the current solution clusters. Thus, we add a second dynamic decomposition to the RP-CP one which is intrinsic to ISUD.We obtain a parallel algorithm, The Integral Simplex Using Double Decomposition, called ISU2D. We tested it on instances of bus drivers having up to 1600 constraints and 570000 variables. The ISU2D reduces the computing time of ISUD by a factor of 3, even 4 for some instances. It reaches an optimal or near optimal solution for the majority of these instances in less than 10 min while the commercial solver CPLEX cannot even find a feasible solution with a gap that is less than 10 % after a one-hour time limit. But, ISU2D suffers of the limitation which is the use of a single decomposition of the current solution at a time. In a second step, we improve our algorithm by generalizing the second decomposition concept. Indeed, our goal is to use multiple dynamic decompositions simultaneously. We propose an algorithm, called DISUD, a distributed algorithm based on ISUD and the multi-agent system (MAS). Each agent is an entity that is, at least partially, autonomous and characterized by the dynamic decomposition that it applies. We implemented two variants where agents can be independent or cooperating according to the strategy adopted. Thus, we increase the performance of ISU2D and benefit more from computing hardware evolution. We tested DISUD on airplane flight scheduling problems. The obtained results show that DISUD is better than DCPLEX, the distributed version of the advanced CPLEX commercial solver on our test instances. It achieves better quality solutions than the DCPLEX and reduces the computing time by an average factor of 4 to 5 for some instances. In addition, it solved large instances that the DCPLEX could not improve after a one-hour time limit. In a third work, we integrate the DISUD in a column generation context (GC). This choice is justified by the fact that the coupling of the method of generating columns with enumeration methods such as branch and price is widely used in industry. ISUD has potential to replace the usual enumeration methods to solve the SPP. As a result, there is potential to integrate GC and DISUD to address industry issues. We develop DICG a column generation algorithm which uses DISUD instead of enumeration methods. The results that we obtained during our tests showed that DICG solutions are of good quality (less than 1%). Moreover, it reduces the time of computation by a factor of 2 or even 4 compared to the DRMH, a distributed version of the Restricted Master heuristic. Thus, we have contributed to ISUD evolution. In addition, we improved the performances of ISUD and reduced its computing time. Furthermore, we paved the way for future work to expand the uses of the distributed version of ISUD

-

We study the performance of algorithms for the Single-Source Shortest-Paths (SSSP) problem on graphs with n nodes and m edges with nonnegative random weights. All previously known SSSP algorithms for directed graphs required superlinear time. Wie give the first SSSP algorithms that provably achieve linear O(n-m)average-case execution time on arbitrary directed graphs with random edge weights. For independent edge weights, the linear-time bound holds with high probability, too. Additionally, our result implies improved average-case bounds for the All-Pairs Shortest-Paths (APSP) problem on sparse graphs, and it yields the first theoretical average-case analysis for the "Approximate Bucket Implementation" of Dijkstra's SSSP algorithm (ABI-Dijkstra). Futhermore, we give constructive proofs for the existence of graph classes with random edge weights on which ABI-Dijkstra and several other well-known SSSP algorithms require superlinear average-case time. Besides the classical sequential (single processor) model of computation we also consider parallel computing: we give the currently fastest average-case linear-work parallel SSSP algorithms for large graph classes with random edge weights, e.g., sparse rondom graphs and graphs modeling the WWW, telephone calls or social networks.In dieser Arbeit untersuchen wir die Laufzeiten von Algorithmen für das Kürzeste-Wege Problem (Single-Source Shortest-Paths, SSSP) auf Graphen mit n Knoten, M Kanten und nichtnegativen zufälligen Kantengewichten. Alle bisherigen SSSP Algorithmen benötigen auf gerichteten Graphen superlineare Zeit. Wir stellen den ersten SSSP Algorithmus vor, der auf beliebigen gerichteten Graphen mit zufälligen Kantengewichten eine beweisbar lineare average-case-Komplexität O(n+m)aufweist. Sind die Kantengewichte unabhängig, so wird die lineare Zeitschranke auch mit hoher Wahrscheinlichkeit eingehalten. Außerdem impliziert unser Ergebnis verbesserte average-case-Schranken für das All-Pairs Shortest-Paths (APSP) Problem auf dünnen Graphen und liefert die erste theoretische average-case-Analyse für die "Approximate Bucket Implementierung" von Dijkstras SSSP Algorithmus (ABI-Dijkstra). Weiterhin führen wir konstruktive Existenzbeweise für Graphklassen mit zufälligen Kantengewichten, auf denen ABI-Dijkstra und mehrere andere bekannte SSSP Algorithmen durchschnittlich superlineare Zeit benötigen. Neben dem klassischen seriellen (Ein-Prozessor) Berechnungsmodell betrachten wir auch Parallelverarbeitung; für umfangreiche Graphklassen mit zufälligen Kantengewichten wie z.B. dünne Zufallsgraphen oder Modelle für das WWW, Telefonanrufe oder soziale Netzwerke stellen wir die derzeit schnellsten parallelen SSSP Algorithmen mit durchschnittlich linearer Arbeit vor