Colonies d abeilles et SAT parallèle

Colonies d abeilles et SAT parallèle MÉMOIRE présenté le 3 juillet 2014 pour l obtention du Master Deuxième Année de l Université d Artois Spécialité Informatique par Nicolas SZCZEPANSKI Encadrants : Gilles Audemard Professeur à l Université d Artois Jean-Marie Lagniez Chercheur Post-Doctorant au CRIL Laurent Simon Professeur à l Université de Bordeaux Sébastien Tabary Maître de conférence à l Université d Artois CENTRE DE RECHERCHE EN INFORMATIQUE DE LENS CNRS UMR 8188 Université d Artois, rue Jean Souvraz, S.P. 18 F-62307, Lens Cedex France Secrétariat : Tél.: +33 (0)3 21 79 17 23 Fax : +33 (0)3 21 79 17 70 http://www.cril.univ-artois.fr

Mise en page avec memcril (B. Mazure, CRIL) et thloria (D. Roegel, LORIA).

Table des matières Table des figures Liste des Algorithmes iv vi Remerciements 2 Introduction générale État de l art Chapitre 1 Le probleme SAT La logique propositionnelle 6 1.1 Syntaxe de la logique propositionnelle......................... 6 1.1.1 Syntaxe.................................... 6 1.1.2 Formules bien formées............................ 7 1.2 Sémantique de la logique propositionnelle...................... 7 1.2.1 Sémantique.................................. 7 1.2.2 Définitions et théorèmes............................ 7 1.3 Formes normales.................................... 8 1.4 Le problème SAT.................................... 9 i

Table des matières Chapitre 2 SAT en parallèle 10 2.1 Modèles parallèles................................... 11 2.1.1 Préliminaires.................................. 11 2.1.2 Modèles d exécution.............................. 12 2.1.3 Modèles de programmation.......................... 14 2.2 Résoudre SAT en parallèle............................... 14 2.2.1 Le modèle concurrentiel............................ 14 2.2.2 Les solveurs concurrentiels.......................... 15 2.2.3 Le solveur PENELOPE............................. 16 2.2.4 Le modèle collaboratif............................. 16 2.2.5 Le chemin de guidage............................. 17 2.2.6 Le chemin de guidage : le rééquilibrage des charges............. 18 2.2.7 Les solveurs de type chemin de guidage................... 21 2.3 Cube And Conquer................................... 21 2.3.1 Algorithme................................... 22 2.3.2 L heuristique de coupure........................... 23 2.3.3 L heuristique de choix de variables...................... 24 2.3.4 La résolution des cubes............................ 24 2.4 Conclusion....................................... 25 Chapitre 3 Les problèmes de bandits 26 3.1 Le problème de bandits classique........................... 26 3.1.1 Multi-armed bandit.............................. 26 3.1.2 La stratégie d allocation et regret....................... 27 3.2 La stratégie UCB.................................... 28 3.2.1 Définition et exemple............................. 28 3.2.2 Exemple d application............................. 29 3.3 L algorithme UCT................................... 30 3.3.1 Squelette de l algorithme........................... 30 3.3.2 Explication................................... 31 3.3.3 Conclusion................................... 33 Contribution ii

Chapitre 4 Une méta-heuristique des colonies d abeilles butineuses pour SAT 36 4.1 Une méta-heuristique massivement parallélisable................... 37 4.1.1 Le choix du comportement à adopter..................... 37 4.1.2 La communication............................... 37 4.1.3 Hiérarchie................................... 37 4.2 Déroulement de l algorithme mémétique....................... 39 4.3 Conclusion....................................... 40 Chapitre 5 Une adaptation d UCT pour SAT : l algorithme SCOUT 41 5.1 Le choix d UCT pour générer des cubes........................ 42 5.2 Description de l algorithme SCOUT.......................... 42 5.2.1 La descente.................................. 43 5.2.2 La descente : Les valeurs UCB......................... 45 5.2.3 La descente : la création de nouveaux fils................... 46 5.2.4 La descente : les conflits et littéraux déjà affectés............... 47 5.2.5 La sélection.................................. 48 5.2.6 La simulation................................. 49 5.2.7 La remontée.................................. 50 5.3 La récupération des cubes............................... 50 5.4 Conclusion....................................... 51 Chapitre 6 Résultats 53 6.1 Le programme..................................... 53 6.2 Expérience sur les variables des cubes......................... 54 6.3 Expérimentation.................................... 56 6.4 Conclusion....................................... 59 Conclusion 60 Bibliographie 62 iii

Table des figures 1.1 Connecteurs logiques usuels de la logique propositionnelle................. 7 2.1 Schémas de processeurs................................... 11 2.2 Parallélisme concurrentiel................................. 15 2.3 Diagramme des clauses apprises dans PENELOPE..................... 17 2.4 Parallélisme «diviser pour régner»............................ 17 2.5 Chemin de guidage..................................... 18 2.6 rééquilibrage des charges : état initial, F etg travaillent.................. 19 2.7 rééquilibrage des charges : F a terminé son sous-arbre,g travaille............. 19 2.8 rééquilibrage des charges : F informe le maître,g travaille................. 19 2.9 rééquilibrage des charges : F récupère un chemin de guidage depuis le maître....... 20 2.10 rééquilibrage des charges : le maître n a plus de chemin à fournir, il stoppeg...... 20 2.11 rééquilibrage des charges : G envoie son chemin de guidage................ 20 2.12 rééquilibrage des charges : les chemins de guidage sont rééquilibrés........... 21 2.13 Cube And Conquer..................................... 21 3.1 Des bandits manchots.................................... 27 3.2 Étape de l algorithme UCT.................................. 30 4.1 Hiérarchie des tâches de chaque solveur SAT inspirée des colonies d abeilles butineuses. 38 4.2 Déroulement de l algorithme mémétique.......................... 40 5.1 Structure des nœuds dans notre algorithme SCOUT..................... 43 5.2 La descente dans notre algorithme SCOUT......................... 44 5.3 Calcul des valeurs UCB dans SCOUT............................ 45 5.4 Conflit ou littéral déjà affecté à une valeur opposée lors de la descente dans notre algorithme SCOUT....................................... 47 5.5 Littéral déjà affecté lors de la descente dans notre algorithme SCOUT.......... 48 5.6 La sélection dans notre algorithme SCOUT........................ 49 5.7 La remontée dans notre algorithme SCOUT........................ 50 5.8 Affinage de l arbre de SCOUT par un algorithme de colonie d abeilles.......... 51 6.1 Fichier.cubes....................................... 54 6.2 Nombre de variables dans les cubes (partie 1)....................... 55 6.3 Nombre de variables dans les cubes (partie 2)....................... 56 6.4 Nombre de variables dans les cubes (partie 3) : UTI-20-5p1 : 1195016 clauses et 225926 variables........................................... 56 6.5 Information sur la création des cubes............................ 57 iv

6.6 Résultat : Informations sur tous les cubes.......................... 57 6.7 Information sur les cubes uniquement satisfiables...................... 58 6.8 Informations sur le meilleur cube satisfiable uniquement.................. 58 6.9 Numéro des cubes satisfiables des instances en possédant.................. 59 v

Liste des Algorithmes 1 CC.............................................. 22 2 UCT............................................. 31 3 descenteselectionuct(r)............................. 31 4 remontéeuct(p,r)................................... 33 5 descentescoutv1(r)................................. 43 6 descentescoutv2(r)................................. 47 7 récupcube(r)...................................... 51 vi

LISTE DES ALGORITHMES 1

Remerciements En premier lieu, je tiens à remercier Eric Grégoire de m avoir permis d effectuer ce stage au sein du CRIL. Je remercie aussi mes encadrants Gilles Audemard, Jean-Marie Lagniez, Laurent Simon et Sébastien Tabary pour leurs nombreuses relectures ainsi que leurs précieux conseilles. Je tiens également à remercier mes camarades de promotion pour leur sympathie et pour leur convivialité. Ma famille et plus particulièrement, Élodie, pour ces nombreuses corrections. 2

Introduction générale LE PROBLÈME DE SATISFAISABILITÉ BOOLÉENNE, abrégé par SAT, est un problème de décision visant à savoir s il existe un assignement qui satisfait une formule de la logique propositionnelle, ou qui détermine qu un tel assignement n existe pas. Nous classons respectivement ces formules comme satifiables ou insatifiables. SAT est un problème théoriquement important car il a été le premier problème à être prouvé NP-Complet [Coo71]. Malgré une complexité théorique difficile, les solveurs SAT modernes sont devenus étonnamment efficaces et permettent de résoudre de nombreux problèmes venant d applications industrielles (planification, vérification formelle, bio-informatique, etc.). Deux raisons essentielles peuvent justifier cette performance. La première est algorithmique et, est due à l envol des solveurs SAT modernes de type CDCL (apprentissage, VSIDS, watched literal,...). Tandis que la seconde est technologique et, est intrinsèquement liée à un doublement des fréquences de fonctionnement des microprocesseurs qui a lieu tous les dix-huit mois (ce phénomène est nommé la loi de Moore). Ainsi, jusqu à 2005, les solveurs SAT modernes pouvaient profiter de ce gain technologique afin de résoudre des problèmes de plus en plus difficiles. Cependant, à l heure actuelle, à cause de l échauffement important des microprocesseurs à des fréquences avoisinant les 4 GHz, il n a plus été envisageable d accroître les performances des solveurs de cette manière. En effet, les constructeurs ont donc décidé d opter pour une multiplication des unités de calcul afin de toujours doubler la puissance des ordinateurs. De ce fait, le problème SAT doit être repensé par les développeurs de manière à s adapter à un modèle de programmation parallèle. Le problème SAT a longtemps été pensé et codé sur un modèle séquentiel. Une adaptation conséquente est donc nécessaire afin de pouvoir bénéficier du parallélisme. A ce jour, deux méthodes permettent la résolution d un problème SAT en parallèle : une méthode collaborative et une autre concurrentielle exposées au chapitre 2. Ces méthodes peuvent rencontrer deux problèmes technologiques freinant le calcul. Le premier, appelé le goulot d étranglement de Von Neumann, est une surcharge du bus entre les processeurs et la mémoire. Le deuxième est un coût de communication dans les algorithmes parallèles pouvant être trop important. Les tentatives de parallélisation pour SAT ont en majeure partie échouées. En effet, les approches parallèles actuelles limitent au maximum le partage des informations et n arrivent pas à suivre entièrement la loi de Moore comme il était possible dans le passé. De plus, les méthodes ne passent pas à l échelle : le fait d augmenter le nombre de cœurs dégrade les performances [ABK13]. Actuellement, un des meilleurs solveur parallèle est un simple outil lançant en concurrence les meilleurs solveurs de l état de l art [Rou12]. Dans un but massivement parallèle, nous nous inspirons du comportement de la nature (essaim d abeilles, colonie de fourmis, génétique,...) afin de définir un nouveau schéma de parallélisation. En effet, dans la nature, nous retrouvons beaucoup de situations où des tâches doivent être réalisées en collaboration. Par exemple, la coopération des fourmis via des phéromones leur permet de pouvoir faire des tâches complexes comme la recherche de nourriture à plusieurs endroits distincts (tâche qui ne pourrait pas être réalisée pas une seule fourmi). Ainsi, ces fourmis sont capables d obtenir rapidement une bonne 3

Introduction générale solution sur le problème du voyageur de commerce [DG97]. Ces algorithmes, nommés algorithmes mémétiques, font partie des d algorithmes d optimisations (algorithme de colonie de fourmis, algorithme d essaim d abeilles,...). Grâce à une adaptation face au problème concerné, ces algorithmes proposent une série de concepts pouvant être exploités afin de définir des algorithmes massivement parallèles. Dans ce manuscrit, nous proposons d utiliser les algorithmes de colonies d abeilles pour résoudre SAT sur une architecture massivement parallèle. Tout d abord, après une présentation de la logique propositionnelle, nous exposons le problème SAT accompagné d un exemple (chapitre 1). Puis, nous expliquons les notions de la parallélisation pour exposer un état de l art des solveurs SAT parallèles. Nous distinguons alors les deux méthodes générales pour paralléliser le problème SAT : le modèle concurrentiel et modèle collaboratif (chapitre 2). Nous abordons ensuite des notions qui sont essentielles dans nos travaux : le dilemme exploitation/exploration ainsi que l algorithme UCB (chapitre 3). Nos contributions commencent par une subtile adaptation de l algorithme des colonies d abeilles butineuses pour une parallélisation massive du problème SAT. Ce modèle nécessite la mise en place de nombreux concepts tournant autour de l organisation des abeilles butineuses. En effet, dans leur recherche de nectar, les abeilles ont chacune leurs propres rôles à exécuter (abeilles scouts, abeilles butineuses, abeilles recrues). De plus, ces abeilles sont de deux types différents : celles sans mémoire et celles en possédant (abeilles expérimentées). Les fonctionnalités nombreuses des abeilles butineuses mettent donc en jeu autant de méta-heuristiques à adapter dans notre contexte. Ce modèle est exposé dans le chapitre 4, il définit chaque rôle distinct des abeilles, et chaque liaison entres elles dans le cadre d une parallélisation massive du problème SAT. Dû aux multiples tâches que représentent ce modèle, nous nous sommes dans un premier temps concentré sur la création d une abeille de type scout. Les abeilles scouts ont pour fonction d explorer les alentours afin de trouver des fleurs possédant un maximum de nectars. Dans le contexte de SAT, nous avons défini qu il s agit d avoir une méthode générant des cubes. Nous entendons par un cube, une interprétation partielle en SAT : une conjonction de littéraux. Sachant que, par la suite, d autres abeilles butineuses pourront toujours affiner ces cubes via notre modèle de colonie d abeilles. Notre deuxième contribution exposée dans le chapitre 5 a donc pour objectif de créer un ensemble de cubes : nous avons nommé cette méthode SCOUT. De plus, nous souhaitons ordonner les cubes du meilleur au moins bon. Néanmoins, estimer la qualité d une interprétation partielle est aussi difficile que de résoudre l instance initiale. À l intérieur du chapitre 2, nous avons choisi de décrire en détail la méthode Cube And Conquer (CC) [HKWB12] pour une bonne raison. Il se trouve que celle-ci possède un point commun avec nos travaux : elle effectue aussi une division en millions de cubes. De plus, dans l optique de choisir les meilleurs cubes dans un arbre de recherche, nous avons été confrontés au dilemme exploitation/exploration : fautil exploiter un cube déjà considéré comme bon en lui rajoutant des littéraux ou retenter notre chance avec un nouveau cube. Récemment, la naissance d un algorithme pour les jeux à deux joueurs nommé UCT traite ce problème : exploiter un état de la partie qui semble être bon, ou explorer d autres états moins bons. Nous avons donc adapté l algorithme UCT afin de générer des cubes dans notre méthode SCOUT. Avant de conclure, nous exposons les résultats apportés par quelques expérimentations afin d étudier la qualité des cubes générés par notre méthode SCOUT. La méthode SCOUT n est qu une première brique utilisée dans notre modèle de colonie d abeilles pour SAT dans un but massivement parallèle. Une thèse suivant ces travaux aura pour acquis le travail fourni pendant ce stage. 4

État de l art 5

Chapitre 1 Le probleme SAT La logique propositionnelle Sommaire 1.1 Syntaxe de la logique propositionnelle...................... 6 1.1.1 Syntaxe................................... 6 1.1.2 Formules bien formées........................... 7 1.2 Sémantique de la logique propositionnelle.................... 7 1.2.1 Sémantique................................. 7 1.2.2 Définitions et théorèmes.......................... 7 1.3 Formes normales.................................. 8 1.4 Le problème SAT.................................. 9 CE CHAPITRE a pour objectif de présenter brièvement le problème SAT pour boolean SATisfiability problem d une formule propositionnelle. Nous rappelons tout d abord la syntaxe puis la sémantique de la logique propositionnelle. Après quelques définitions et propriétés sur cette logique, nous exposerons ce qu est le problème SAT en l accompagnant d un exemple. Ce chapitre, représentant des notions de base connues dans la littérature, est destiné aux lecteurs ne connaissant pas le problème SAT. 1.1 Syntaxe de la logique propositionnelle 1.1.1 Syntaxe Définition (Vocabulaire de la logique propositionnelle). La base de la syntaxe du calcul des propositions sont les variables propositionnelles ou propositions atomiques, notées p, q, x,... qui constituent généralement un ensemble infini dénombrable. Cette syntaxe contient aussi des symboles de ponctuation qui sont souvent notées "(", ")", "[" et "]". De plus, les deux constantes propositionnelles et représentent respectivement le "faux" et le "vrai". Pour finir, elle est constituée de l ensemble des connecteurs logiques usuels, présentés dans la figure 1.1. 6

1.2. Sémantique de la logique propositionnelle Nom Négation Conjonction Disjonction Implication Equivalence Ou exclusif Arité Unaire Binaire Binaire Binaire Binaire Binaire Symbole FIGURE 1.1 Connecteurs logiques usuels de la logique propositionnelle. 1.1.2 Formules bien formées La syntaxe permet de distinguer les formules bien formées parmi les assemblages quelconques de symboles. Définition (Formules de la logique propositionnelle). Les phrases du langage de la logique propositionnelle sont obtenues récursivement à partir des propositions et d un ensemble de règles syntaxiques. Ces phrases sont appelées formules : Toute propositionxest une formule (règle de base) ; SiF etg sont des formules, alors F, (F G), (F G), (F G), (F G) et (F G) sont des formules (règle d induction) ; Une formule s obtient uniquement à partir des règles de base et d induction (règle de fermeture). 1.2 Sémantique de la logique propositionnelle 1.2.1 Sémantique La sémantique de la logique propositionnelle est compositionnelle : c est-à-dire que la signification d une formule sera en fonction de celle de ses constituants. La valeur de vérité d une formule dépendra uniquement de sa composition. Définition (Sémantique de la logique propositionnelle). Chaque variable propositionnelle (x 1,x 2,...,x n ) est interprétée comme vraie ou fausse ; sif est une formule, alors F est vraie si et seulement sif est fausse ; sif etg sont des formules, alors : (F G) est vraie si et seulement sif etg sont vraies ; (F G) est vraie si et seulement sif oug est vraie ; (F G) est vraie si et seulement sif est fausse oug est vraie ; (F G) est vraie si et seulement sif etg sont soit toutes deux vraies, soit toutes deux fausses ; (F G) est vraie si et seulement si seul F ou seulg est vraie (pas les deux en même temps). 1.2.2 Définitions et théorèmes Définition (Interprétation). Une interprétation est une fonction qui associe à toute variable propositionnelle une valeur de vérité. Cette fonction, dont le domaine est l ensemble des propositions, est prolongée à l ensemble des formules au moyen des règles de la sémantique. Le prolongement correspondant est encore appelé interprétation. 7

Chapitre 1. Le probleme SAT La logique propositionnelle Définition (Modèle). Un modèle d une formule est une interprétation de cette formule qui la vérifie, c est-à-dire, qui lui associe la valeur vraie. Définition (Falsifie). Par opposition, on dit qu une interprétation falsifie une formule lorsqu elle lui associe la valeur faux. Définition (Satisfiable, Insatisfiable). On dit qu une formule est satisfiable ou consistante si et seulement si il existe au moins un modèle qui la vérifie, sinon elle est insatisfiable. Définition (Conséquence logique). Si tout modèle d une formulef est modèle d une formuleg alors G est une conséquence logique de F, notéf = G. Définition (Logiquement équivalentes). Les formules F et Gsont logiquement équivalentes, si F = G etg = F, noté F G. Définition (Formule valide, Tautologie). Lorsque la formule F est vérifiée par toutes ses interprétations, F est une tautologie. On dit aussi que F est valide et on notera cette assertion F. Définition (Théorème de la déduction). Soit F et G deux formules propositionnelles, on a F = G si et seulement si F G est une formule insatisfiable. Exemple. Voici quelques tautologie de la logique propositionnelle : Nom Expressions Définition de F G F G Définition de (F G) ((F G) (G F)) (( F G) ( G F)) Modus ponens ((F G) F) G Modus tollens ((F G) G) F Contraposition (F G) ( G F) 1.3 Formes normales Définition (Littéral, Clause, Terme). Un littéral est une variable propositionnelle ou bien sa négation : x et x sont des littéraux ; Une clause est une disjonction de littéraux : une formule de la forme (x 1 x 2... x n ) où chaque x n représente un littéral ; Un terme (ou cube) est une conjonction de littéraux : une formule de la forme (x 1 x 2... x n ) où chaque x n représente un littéral. Définition (NNF, DNF, CNF). Nous distinguons trois formes normales particulières : Une formule propositionnelle est dite sous forme normale négative (NNF pour Negative Normal Form) si elle est exclusivement constituée de conjonctions, de disjonctions et de littéraux ; Une formule propositionnelle est dite sous forme normale disjonctive (DNF pour Disjonctive Normal Form) si c est une disjonction de termes ; Une formule propositionnelle est dite sous forme normale conjonctive (CNF pour Conjonctive Normal Form) si c est une conjonction de clauses. 8

1.4. Le problème SAT Pour toute formule de la logique propositionnelle, il existe une formule équivalente sous forme normale. 1.4 Le problème SAT Définition (Le problème SAT). Le problème SAT est le problème de décision qui consiste à savoir si une formule sous forme normale conjonctive possède ou pas un modèle (si elle est satisfiable). Le problème SAT occupe un rôle très important en théorie de la complexité puisqu il représente le problème NP-Complet de référence [Coo71]. C est donc un problème théoriquement difficile pour un ordinateur, mais il possède des méthodes de résolution très efficaces en pratique. On peut citer les solveurs SAT modernes de type CDCL qui sont une grande avancée dans l histoire de ces solveurs. De nombreux problèmes s y rapportent naturellement ou le contiennent. Grâce à la performance des solveurs SAT moderne, certains problèmes préfèrent être traduits en SAT (CNF) afin de bénéficier d une efficacité plus accrue comparée à leurs propres méthodes de résolutions. Le problème SAT contient de nombreuses applications en planification classique (ordonnancement de tâches, robot sur mars,...), vérification (model checking,...), diagnostic (d erreurs dans les circuits électroniques,...), bio-informatique, CSP, etc. À présent, nous allons exposer un petit exemple de traduction d un problème CSP en SAT. Exemple. Soit un petit problème ne contenant que deux variables x et y, avec une seule contrainte : x+y = 3. Ces deux variables ont respectivement les domaines suivants : {1,2,3} et {0,1,4}. Le problème consiste à savoir comment attribuer les variables sur leurs domaines respectifs tout en respectant la contrainte. Sachant qu il existe des méthodes de résolutions propres à CSP, nous choisissons de l encoder en CNF afin de comprendre le mécanisme de SAT. Il existe plusieurs encodages possibles, nous choisissons l encodage direct. Tout d abord, nous encodons les variables et leurs domaines en clauses, pour cela, nous aurons de nouvelles variables propositionnelles : x i et y i correspond respectivement à x = i et y = i. x 1 x 2 x 3 représente le domaine dex ; x 1 x 2 la variablexne peut pas prendre pour valeur en même temps 1 et 2 ; x 1 x 3 la variablexne peut pas prendre pour valeur en même temps 1 et 3 ; x 2 x 3 la variablexne peut pas prendre pour valeur en même temps 2 et 3 ; y 0 y 1 y 4 représente le domaine dey ; y 0 y 1 la variabley ne peut pas prendre pour valeur en même temps 0 et 1 ; y 0 y 4 la variabley ne peut pas prendre pour valeur en même temps 0 et 4 ; y 1 y 4 la variabley ne peut pas prendre pour valeur en même temps 1 et 4. Puis nous codons les couples de valeursxety impossibles à cause de la contrainte : x 1 y 0, x 1 y 1, x 1 y 4, x 2 y 0, x 2 y 4, x 3 y 1, x 3 y 4. Toutes ces clauses forment une CNF. Un solveur SAT peut donc trouver un modèle comme : x 2 =, y 1 = et le reste des variables propositionnelles à faux. La solution associée en CSP est x = 2 et y = 1. 9

Chapitre 2 SAT en parallèle Sommaire 2.1 Modèles parallèles................................. 11 2.1.1 Préliminaires................................ 11 2.1.2 Modèles d exécution............................ 12 2.1.3 Modèles de programmation......................... 14 2.2 Résoudre SAT en parallèle............................. 14 2.2.1 Le modèle concurrentiel.......................... 14 2.2.2 Les solveurs concurrentiels......................... 15 2.2.3 Le solveur PENELOPE........................... 16 2.2.4 Le modèle collaboratif........................... 16 2.2.5 Le chemin de guidage............................ 17 2.2.6 Le chemin de guidage : le rééquilibrage des charges............ 18 2.2.7 Les solveurs de type chemin de guidage.................. 21 2.3 Cube And Conquer................................. 21 2.3.1 Algorithme................................. 22 2.3.2 L heuristique de coupure.......................... 23 2.3.3 L heuristique de choix de variables..................... 24 2.3.4 La résolution des cubes........................... 24 2.4 Conclusion..................................... 25 LONGTEMPS étudié dans un contexte séquentiel pour ses nombreuses applications industrielles (planification, vérification formelle, bio-informatique, etc.), le problème SAT a fait éclore des algorithmes efficaces et puissants qui s expliquent à la fois par l envol des solveurs SAT modernes (apprentissage, VSIDS, watched literal) et l accroissement de la puissance de calcul. Ainsi, les solveurs SAT modernes permettent de résoudre des problèmes considérables contenant des millions de variables et de clauses. Cependant, de nombreuses instances restent encore inabordables dues à leur immense dimension et difficulté structurelle. Par ces complications, la parallélisation des algorithmes de résolution pour SAT semble nécessaire. Davantage par le fait qu actuellement la puissance d un ordinateur ne se traduit plus par une amplification des fréquences du microprocesseur mais par l augmentation du nombre de cœurs au sein de celui-ci. Néanmoins, la parallélisation d un problème NP-Complet est une tâche ardue, l efficacité qui en résulte reste atténuée sur de nombreux cœurs. 10

2.1. Modèles parallèles Au préalable, afin de comprendre cette accommodation, nous allons présenter les triviales notions de la parallélisation ainsi que ses propres modèles d exécution et de programmation. Cela nous servira à appréhender les deux aspects distincts de la parallélisation du problème SAT : à savoir les méthodes de types «diviser pour régner» dites collaboratives et, à l opposé des méthodes concurrentielles. Après avoir relaté un historique partiel des solveurs représentant ces deux approches, nous présenterons en détail deux techniques se basant sur l approche collaborative : le chemin de guidage (Guiding path) ainsi que la méthode originale Cube And Conquer. En conclusion, nous discuterons du sujet de ce manuscrit ainsi que la voie choisie pour élaborer notre tâche, à savoir, mettre en œuvre un modèle permettant la résolution du problème SAT à l aide des algorithmes de colonies d abeilles dans un but massivement parallèle. 2.1 Modèles parallèles PROCESSEUR MONO-CŒUR Cœur de calcul PROCESSEUR MULTI-CŒUR Cœur 1 Cœur 2 Cœur 3 Cœur 4 Mémoire cache L1 Mémoire cache L2 L1 dédiée L1 dédiée L1 dédiée L1 dédiée L2 partagée FIGURE 2.1 Schémas de processeurs Depuis l invention du premier microprocesseur (intel 4004) en 1971, Gordon Moore observe en 1975 que le nombre de transistors des microprocesseurs sur une puce de silicium se réplique tous les deux ans. Cette observation appelée loi de Moore n est pas une loi physique mais une extrapolation empirique qui s est révélée étonnamment fidèle pour le moment, elle s est traduite par une augmentation des fréquences de fonctionnement des microprocesseurs. Mais depuis environ 2005, à cause de l échauffement important des microprocesseurs à des fréquences avoisinant les 4 GHz, il n a plus été envisageable pour les entreprises de les accroître. En contrepartie, il est aujourd hui possible d ajouter plusieurs cœurs de calcul au sein du même microprocesseur (figure 2.1). De cette manière, les industriels annoncent toujours doubler la puissance de leur microprocesseur pour ainsi honorer la loi de Moore. Néanmoins, les développeurs ne voient pas ce gain directement, et doivent s apprivoiser à un modèle de programmation dit alors parallèle. Une contrainte embarrassante car tous les algorithmes voulant bénéficier du multi-cœur doivent être repensés. La loi de Moore ne sera probablement plus exacte dans le futur, et commence déjà à ne plus l être, certaines entreprises disent ne pas la respecter pour des raisons énergétiques et écologiques (informatique verte, netbook,...). De plus, l industrie approche de plus en plus des limites physiques de la micro-électronique où les transistors ne seront plus constitués que de quelques atomes et l isolant entre eux d un seul. Afin de mieux comprendre les rouages de cette programmation parallèle, nous allons présenter quelques notions élémentaires. 2.1.1 Préliminaires Définition (Parallélisme). Le parallélisme en informatique donne la possibilité d exécuter plusieurs instructions conjointement. 11

Chapitre 2. SAT en parallèle Définition (Exécution séquentielle, exécution parallèle). Une exécution séquentielle est une exécution faite sur une unité de calcul (cœur) tandis qu une exécution parallèle est une exécution faite sur plusieurs unités de calculs. Définition (Temps d exécution séquentiel, temps d exécution parallèle). Le temps d exécution d un programme séquentiel représentant un problème P est le temps écoulé entre le lancement du programme et l obtention du résultat, nous le notons Tsec. P Le temps d exécution d un programme représentant un problème P en parallèle sur n processus est l instant où le dernier processus a terminé son travail, nous le notons Tpar(n). P Définition (Accélération absolue, accélération relative). L accélération absolue représente le nombre de fois que le programme a été accéléré grâce à son exécution en parallèle par rapport au temps d exécution séquentielle du meilleur algorithme connu résolvant un problème P : Acc ab (n)= T P sec T P par(n) L accélération relative représente le nombre de fois que le programme a été accéléré grâce à son exécution en parallèle par rapport au temps d exécution du même programme lancé sur un seul cœur : Acc ab (n)= T P par(1) T P par(n) Définition (Efficacité). L efficacité représente la qualité de la parallélisation en fonction du nombre de processeurs : Eff(n)= Acc(n) n Définition (Extensibilité). L extensibilité d un algorithme parallèle est sa capacité à maintenir son efficacité quelque soit le nombre de processeurs utilisés. Exemple. Les solveurs SAT ont souvent une extensibilité réduite due à la difficulté du probléme NP- Complet. Définition (Accélération super linéaire, accélération linéaire, accélération sous linéaire). Quand une accélération dépasse le gain possible de la parallélisation, cela montre que le programme en question obtient donc aussi un gain algorithmique en plus de ce gain : cette accélération est dite super linéaire. Elle est obtenue lorsque Acc(n) > n pour n processeurs. Dans le cas contraire, si Acc(n) < n (respectivement Acc(n) = n) pour n processeurs, l accélération est dite sous linéaire (respectivement linéaire). Exemple. Pour un algorithme résolvant le problème SAT, des performances super linéaires sur une instance sont possibles si le parallélisme a permis de diminuer fortement la taille de l arbre de recherche en fonction du nombre de cœurs. Cela peut s avérer fréquent pour des problèmes satisfiables, moins pour des problèmes insatisfiables.néanmoins, ce cas n est pas abondant, il est difficile de trouver la bonne manière pour partager l arbre de recherche efficacement. 2.1.2 Modèles d exécution Il existe plusieurs manières d exécuter plusieurs tâches simultanément, une classification nommée taxinomie de Flynn [Fly72] a été élaborée afin de les distinguer. Elle contient donc l architecture de von 12

2.1. Modèles parallèles Neumann : modèle d exécution des machines séquentielles. Définition (SISD, SIMD, MISD, MIMD). La taxinomie de Flynn développe quatre modèles distincts : Single Instruction Single Data (SISD) : machine séquentielle d un seul processeur pouvant traiter un seul flot d instructions accompagné d un seul flot de données ; Single Instruction Multiple Data (SIMD) : machine constituée de plusieurs processeurs pouvant traiter un seul flot d instructions accompagné de plusieurs flots de données ; Multiple Instruction Single Data (MISD) : machine constituée de plusieurs processeurs pouvant traiter plusieurs flots d instructions accompagnés d un seul flot de données ; Multiple Instruction Multiple Data (MIMD) : machine constituée de plusieurs processeurs pouvant traiter plusieurs flots d instructions accompagnés de plusieurs flots de données. Le modèle connu du monde séquentiel SISD n exploite aucun parallélisme, tant au niveau des instructions qu à celui de la mémoire (architecture de von Neumann). SIMD est une machine qui utilise le parallélisme au niveau de la mémoire, comme le processeur vectoriel ou le processeur graphique (Graphics processing unit (GPU)). MISD est un modèle spécifique à certain traitement qui est généralement utilisé pour sa tolérance envers les pannes, ce modèle s exécute plus particulièrement sur des tableaux systoliques de processeur. Pour finir, MIMD est le plus répandu, le plus souple à utiliser, et appliquer par défaut dans le domaine SAT. Dans ce modèle, plusieurs processeurs traitent des données différentes, car chacun d eux possède une mémoire distincte. Les ordinateurs multi-cœurs sont basés sur ce modèle tandis que les supercalculateurs sont en général basés sur un MIMD hybride. Le modèle MIMD peut être exécuté sur différentes architectures selon la façon d accéder à la mémoire, cette classification a été introduite par [Joh88]. Définition (CC-UMA, CC-NUMA, NoRMA). Le modèle MIMD a trois architectures cibles sur lesquelles s exécuter : Cache Coherent - Uniform Memory Access (CC-UMA) : la mémoire est globale et partagée à la même vitesse par tous les processeurs d un ordinateur. Cache Coherent - Non Uniform Memory Access (CC-NUMA) : la mémoire est globale et partagée à des vitesses différentes par tous les processeurs d un ordinateur. No Remote Memory Access (NoRMA) : la mémoire est distribuée sur les processeurs, chaque processeur accède uniquement à sa mémoire locale. Les architectures CC-UMA et CC-NUMA sont Cache Coherent, cela veut dire que la cohérence des mémoires caches est garantie par l ordinateur. Dans l architecture CC-UMA, chaque processeur accède à la mémoire à la même vitesse grâce à un bus d interconnexion, ce qui limite la taille à quelques dizaines de cœurs. Typiquement, un ordinateur multi-cœurs est d architecture CC-UMA. Par contre, l architecture CC-NUMA ne possède pas de bus d interconnexion : chaque cœur possède une mémoire locale qui lui est directement adressable à très grande vitesse et une autre, adressable par tous les cœurs, mais à vitesse réduite. Ce qui permet à cette architecture d accueillir plus de cœurs que CC-UMA mais pour un coût de cohérence des mémoires caches plus important. L architecture NoRMA est très opposée aux deux autres : elle ne possède pas de mémoire globale. Le partage de l information s effectue d une manière différente : l échange de messages entre processeurs à travers le réseau d interconnexion. Néanmoins, cette architecture a l atout de pouvoir compter plusieurs milliers de cœurs grâce à des difficultés de conception moindre. Le sujet de ce manuscrit, étant basé sur une application massivement parallèle de 13

Chapitre 2. SAT en parallèle SAT, se doit donc par défaut de choisir cette architecture. Remarquons que les supercalculateurs actuels sont en général constitués d une hybridation des architectures présentées ci-dessus : quasiment tous basés sur une interconnexion NoRMA de nœuds CC-UMA ou CC-NUMA. 2.1.3 Modèles de programmation Nous venons de voir que la communication entre les processeurs ne se fait toujours pas de la même façon suivant l architecture utilisée, ainsi, cela a un impact sur les algorithmes et la manière de programmer. Nous allons présenter ici, deux modèles conceptuels de communication pour écrire des algorithmes parallèles. Définition (PRAM). Dans le modèle de programmation Parallel Random Access Machine (PRAM), la mémoire est directement accessible par l ensemble des processeurs. Or, les accès concurrents en écriture à la mémoire sont une complication pour le programmeur. Pour cela, il doit explicitement gérer des verrous d accès pour s assurer qu un seul processeur accède à une variable lors de l écriture. Les architectures cibles pour ce type de programmation sont les machines CC-UMA et CC-NUMA. Définition (DRAM). Dans le modèle de programmation Distributed Random Access Machine (DRAM), chaque unité de calcul a seulement accès en temps constant à sa propre mémoire locale. La seule manière de communiquer est de la faire explicitement par l échange de messages. L architecture cible est la machine NoRMA. Utile pour le modèle de programmation DRAM, la bibliothèque de fonctions Message Passing Interface (MPI), conçue en 1993, est une norme utilisable avec les langages C, C++ et Fortran. Elle permet d exploiter des ordinateurs distants ou multiprocesseurs par passage de messages. Le terme calcul parallèle (respectivement distribué) est associé au modèle de programmation PRAM (respectivement DRAM). A ne pas confondre avec la définition d un algorithme distribué (ou réparti) qui est généralement un algorithme parallèle (mais pas toujours, exemple, une communication téléphonique) réparti sur plusieurs sites. Nos approches dans ce manuscrit seront basées sur le modèle de programmation DRAM, qui possède avec les algorithmes de colonies d abeilles le point commun d utiliser un système d échange de messages. Nous allons maintenant étudier les approches pour résoudre SAT en parallèle. 2.2 Résoudre SAT en parallèle Nous présenterons dans cette section les deux modèles permettant de faire travailler les processus en parallèle pour le problème SAT ainsi que quelques solveurs respectifs. D une part, nous avons le modèle collaboratif (coopératif) basé sur le paradigme «diviser pour régner» puis, d un autre côté, le modèle concurrentiel, qui exécute en parallèle plusieurs solveurs séquentiels en concurrence sur le même problème. Nous acheminerons ainsi la notion de chemin de guidage, centrale dans le modèle collaboratif, qui nous permettra de circonscrire une méthode originale nommée Cube And Conquer [HKWB12] étudiée dans la prochaine section. 2.2.1 Le modèle concurrentiel Le modèle concurrentiel aussi nommé portfolio fait fonctionner les processeurs sur le même problème sans le partager, mais en l exécutant sur différentes stratégies de résolution avec des paramétrages divers et variés. Ainsi, le premier trouvant la solution (SAT ou UNSAT) arrête tous les autres (figure 2.2). 14

2.2. Résoudre SAT en parallèle Solveur 1 Solveur 2 Solveur 3 Solveur 4 Solution FIGURE 2.2 Parallélisme concurrentiel Bien sûr, cela n a de sens que pour les problèmes qui possèdent plusieurs algorithmes distincts à leur actif fourmillant de paramètres sensibles ou ayant un comportement aléatoire. Il se trouve que le problème SAT en regorge et qui plus est, les solveurs modernes sont extrêmement sensibles au moindre changement de paramètre : cela s explique par la structure interne des instances que connaît le problème SAT. Il est donc nécessaire que l ensemble des solveurs fasse leurs recherches le plus différemment possible afin de former un ensemble complémentaire. Les solveurs concurrentiels utilisent en général le modèle de programmation PRAM afin de pouvoir partager des informations utiles à tous les processeurs. 2.2.2 Les solveurs concurrentiels Il existe de nombreux solveurs concurrentiels, nous en mentionnons une liste non exhaustive ayant pour but de voir une certaine évolution. Dans le domaine des solveurs incomplets, citons le parallélisme du solveur GNOVELTY + T [PG09] qui est simplement l exécution concurrentielle et indépendante de plusieurs solveurs GNOVELTY + [PTGS08] utilisant une recherche locale stochastique afin de varier la recherche. Le solveur GNOVELTY + utilise un mécanisme de poids sur les clauses non satisfaites, incrémenté à chaque fois que la clause a été testée non satisfaite. Cela améliore le choix de la prochaine variable dont la valeur sera inversée. Les solveurs complets modernes de type CDCL (ZCHAFF [Her03], MINISAT [SE02], PICOSAT [Bie08],...) sont une extension de la procédure DPLL. La procédure CDCL, d abord introduite par [SS96], a apporté son lot d améliorations au fil du temps : le backjumping, l apprentissage de clauses, l heuristique VSIDS, les restarts et une structure de données efficace nommée Watched literals. Un atout de la procédure CDCL dans le monde parallèle est le partage des clauses apprises parmi les solveurs exécutés. Le solveur complet MANYSAT tente de tirer parti de cet avantage en jouant sur la sensibilisation des paramètres des solveurs CDCL [HS09]. Il procède à un échange des clauses apprises parmi les processeurs. Néanmoins, un coût de communication ralentit la recherche, il faut donc décongestionner un canal de communication trop encombré. Les auteurs mettent en place une limite basée sur la taille des clauses échangées : elles doivent être de taille inférieure ou égale à 8. De plus, afin de réaliser une recherche orthogonale et complémentaire, les auteurs proposent de différencier les solveurs sur leur stratégie de redémarrage, de choix de variables, de choix de polarité et d apprentissage. D un autre côté, le solveur PLINGELING propose d échanger uniquement les clauses unaires avec des solveurs dont la stratégie diffère [Bie10]. 15

Chapitre 2. SAT en parallèle Malgré cela, un simple outil de parallélisation statique PPFOLIO fait tourner les meilleurs solveurs en concurrence sans échange de clause, et obtient de meilleurs résultats [Rou12]. A présent, nous allons détailler le solveur PENELOPE, possédant l originalité de s attaquer au surplus de clauses apprises en proposant de «geler» certaines d entre elles [AHJ + 12]. 2.2.3 Le solveur PENELOPE PENELOPE [AHJ + 12] est un solveur concurrentiel de type portefolio reprenant pour socle le solveur MANYSAT. Intégrant les approches efficaces du cadre séquentiel (propagation unitaire, structure de données paresseuses, heuristique basée sur l activité des variables, apprentissage de clauses, etc.), son atout est d intégrer une technique récente permettant d aménager la base de clauses apprises pour les différencier suivant leur utilité à un instant donné du solveur. Voyons tout d abord la notion du progress saving qui consiste à préserver la dernière polarité de chaque variable dans une interprétation complète notée P. Ainsi quand une décision sera prise, le solveur choisit pour valeur de vérité d une variable de décision cette polarité sauvegardée. Le travail accompli par le solveur pour résoudre les sous-problèmes traversés avant d atteindre un conflit devient donc plus utile [PD07]. Néanmoins, cette technique a le désavantage de ne pas assez diversifier la recherche. Pour gérer la base de clauses apprises, les auteurs de [ALMS11] ont défini une mesure nommée progress saving based quality measure (PSM) définie comme suit : pour une clause C et une interprétation complète P représentant la dernière polarité de chaque variable (le progress saving) : PSM(C) = P C Quand PSM(C)est petit, la clause C a plus de chance de participer à la propagation unitaire, elle est donc pour nous importante et pertinente. A l inverse, si PSM(C)est grand, cela signifie que la clause a plus de chance d être satisfaite par un littéral, elle est donc moins utile à cet instant de la recherche. Cet effet est dû à l interprétationp qui nous donne une image de l état courant de la recherche. L heuristique PSM est utilisée pour classer les clauses apprises des solveurs. On peut distinguer 3 types de clauses apprises : Les clauses actives A : clauses utilisées dans la recherche ; Les clauses gelées G : clauses inutilisées dans la recherche mais encore en mémoire (enlevées de la liste des watched-literals) ; Et les clauses suppriméess de la mémoire. Périodiquement, la mesure PSM est calculée sur toutes les clauses apprises. Suivant un seuil L, les clauses ayant un petit PSM<Lsont activées. A l opposé, les clauses avec un grand PSM>Lsont gelées. Grâce au calcul périodique de PSM, les clauses changent donc de camp, pour devenir gelées ou dégelées (actives), suivant la recherche en cours. De plus, les clauses restant gelées trop longtemps et les clauses actives mais sans participation à la recherche depuis un trop long laps de temps K sont supprimées, ce qui nous donne notre troisième type de clauses apprises (figure 2.3). 2.2.4 Le modèle collaboratif Le modèle collaboratif consiste à réduire récursivement l arbre de recherche en plusieurs sousproblèmes du même type (figure 2.4). Pour cela, plusieurs approches ont été proposées souvent bâties 16

2.2. Résoudre SAT en parallèle Non utilisée ( ) Non activée ( ) FIGURE 2.3 Diagramme des clauses apprises dans PENELOPE FIGURE 2.4 Parallélisme «diviser pour régner» sur une programmation ne demandant que des échanges minimes : le modèle DRAM. Nous exposerons la plus utilisée, qui découpe l arbre de recherche sous forme de trajet, intitulée chemin de guidage. Néanmoins, bien que cette division semble parfaite pour un solveur de type DPLL, elle pose souci au niveau des backtracks non chronologiques d un solveur CDCL : il se peut qu un processeur travaille pour rien. Un autre désavantage est la charge des processeurs qui est déséquilibrée, en effet, la division de l arbre de recherche nous donne deux sous-problèmes dont les difficultés diffèrent. Il faut donc amener une politique d équilibrage de charge qui peut s avérer coûteuse. De plus, contrairement à la méthode concurrentielle, cette technique doit attendre que tous les solveurs ont terminé leurs recherches pour prouver l intisfaisabilité d une instance. 2.2.5 Le chemin de guidage Dans cette section, nous présenterons l approche la plus populaire du modèle collaboratif : cette notion appelée chemin de guidage (Guiding path) a été proposée par [ZB94]. Cette approche consiste à conserver des chemins de recherche permettant d indiquer quels sont les sous-arbres à développer pour un processeur. Un tel chemin est représenté par un ensemble de couples(f i,c i ), ou F i est un littéral à propager et C i est une variable booléenne indiquant quelles branches sont en cours de calcul parmi les deux sous-arbres disponibles à partir de la variable provenant du littéralf i. Cette variable booléenne est définie comme suit : C i = les deux sous-arbres sont en cours de traitement ou traités. C i = un seul des deux sous-arbres est en cours de traitement ou traité. 17

Chapitre 2. SAT en parallèle Exemple. Le chemin de guidage de la figure 2.5 est ((x 1, ),(x 2, ),( x 3, )). A partir de celui-ci, il est possible d obtenir deux chemins de guidage différents qui permettront d orienter deux processeurs : (( x 1, )) et ((x 1, ),(x 2, ),( x 3, )). Par la suite, si un troisième processeur est inutilisé, nous pouvons appliquer ce même raisonnement sur la variable x 2 pour avoir trois chemins de guidage : (( x 1, )), ((x 1, ),( x 2, )) et ((x 1, ),(x 2, ),( x 3, )) FIGURE 2.5 Chemin de guidage Cette notion présente le défaut de donner au processeur des chemins dont le calcul est déséquilibré, en effet, il se peut qu un chemin soit très long à calculer tandis qu un autre se finisse instantanément. Afin de pallier à ce problème, un modèle d équilibrage de charge doit être installé. De plus, il est possible de diviser le travail en deux sous-chemins, l un contenant le littéral et l autre, son littéral complémentaire. 2.2.6 Le chemin de guidage : le rééquilibrage des charges Le rééquilibrage des charges est basé sur un modèle maître/esclave comme peut nous montrer la figure 2.6. Un processeur maître est chargé de distribuer les tâches aux esclaves tandis qu un processeur esclave est chargé de calculer une tâche. Le modèle mis en place pour équilibrer la charge par une distribution des chemins de guidage est généralement centralisé au sein du processeur maître. Le maître maintient à jour une liste de chemins de guidage. Un chemin permet de symboliser le futur travail sur un sous-arbre puisque le chemin permet de retrouver la racine d un sous-arbre. Un exemple du rééquilibrage des charges exposé est donné par les figures 2.7, 2.8, 2.9, 2.10, 2.11 et 2.12, partiellement tirés de [VS09]. 18