SUNNY-CP and the MiniZinc Challenge

In Constraint Programming (CP) a portfolio solver combines a variety of different constraint solvers for solving a given problem. This fairly recent approach enables to significantly boost the performance of single solvers, especially when multicore architectures are exploited. In this work we give a brief overview of the portfolio solver sunny-cp, and we discuss its performance in the MiniZinc Challenge---the annual international competition for CP solvers---where it won two gold medals in 2015 and 2016. Under consideration in Theory and Practice of Logic Programming (TPLP)Comment: Under consideration in Theory and Practice of Logic Programming (TPLP

Propagators and Solvers for the Algebra of Modular Systems

To appear in the proceedings of LPAR 21. Solving complex problems can involve non-trivial combinations of distinct knowledge bases and problem solvers. The Algebra of Modular Systems is a knowledge representation framework that provides a method for formally specifying such systems in purely semantic terms. Formally, an expression of the algebra defines a class of structures. Many expressive formalism used in practice solve the model expansion task, where a structure is given on the input and an expansion of this structure in the defined class of structures is searched (this practice overcomes the common undecidability problem for expressive logics). In this paper, we construct a solver for the model expansion task for a complex modular systems from an expression in the algebra and black-box propagators or solvers for the primitive modules. To this end, we define a general notion of propagators equipped with an explanation mechanism, an extension of the alge- bra to propagators, and a lazy conflict-driven learning algorithm. The result is a framework for seamlessly combining solving technology from different domains to produce a solver for a combined system.Comment: To appear in the proceedings of LPAR 2

A review of literature on parallel constraint solving

As multicore computing is now standard, it seems irresponsible for constraints researchers to ignore the implications of it. Researchers need to address a number of issues to exploit parallelism, such as: investigating which constraint algorithms are amenable to parallelisation; whether to use shared memory or distributed computation; whether to use static or dynamic decomposition; and how to best exploit portfolios and cooperating search. We review the literature, and see that we can sometimes do quite well, some of the time, on some instances, but we are far from a general solution. Yet there seems to be little overall guidance that can be given on how best to exploit multicore computers to speed up constraint solving. We hope at least that this survey will provide useful pointers to future researchers wishing to correct this situation

Applications of matching theory in constraint programming

[no abstract

Power-Aware Job Dispatching in High Performance Computing Systems

This works deals with the power-aware job dispatching problem in supercomputers; broadly speaking the dispatching consists of assigning finite capacity resources to a set of activities, with a special concern toward power and energy efficient solutions. We introduce novel optimization approaches to address its multiple aspects. The proposed techniques have a broad application range but are aimed at applications in the field of High Performance Computing (HPC) systems. Devising a power-aware HPC job dispatcher is a complex, where contrasting goals must be satisfied. Furthermore, the online nature of the problem request that solutions must be computed in real time respecting stringent limits. This aspect historically discouraged the usage of exact methods and favouring instead the adoption of heuristic techniques. The application of optimization approaches to the dispatching task is still an unexplored area of research and can drastically improve the performance of HPC systems. In this work we tackle the job dispatching problem on a real HPC machine, the Eurora supercomputer hosted at the Cineca research center, Bologna. We propose a Constraint Programming (CP) model that outperforms the dispatching software currently in use. An essential element to take power-aware decisions during the job dispatching phase is the possibility to estimate jobs power consumptions before their execution. To this end, we applied Machine Learning techniques to create a prediction model that was trained and tested on the Euora supercomputer, showing a great prediction accuracy. Then we finally develop a power-aware solution, considering the same target machine, and we devise different approaches to solve the dispatching problem while curtailing the power consumption of the whole system under a given threshold. We proposed a heuristic technique and a CP/heuristic hybrid method, both able to solve practical size instances and outperform the current state-of-the-art techniques

Scheduling of the TTEthernet communication

TTEthernet je rozšířením Ethernetu o prostředky pro deterministickou komunikaci. V této práci TTEthernet stručně představíme a uvedeme stávající metody rozvrhování provozu v něm. Následně formulujeme tento rozvrhovací problém jako MRCPSP-GPR (také znám jako multimodální RCPSP/max) a zhodnotíme možnosti použití existujících řešičů MRCPSP-GPR pro rozvrhování provozu v síti TTEthernet. S využitím heuristiky, kterou jsme navrhli, se tento postup jeví jako realistický. Mimo to ještě uvádíme opravu nedávno publikované metody pro odhad maximálního zpoždění rate-constrained (RC) provozu v síti TTEthernet.TTEthernet is an extension of Ethernet for deterministic communication. We present an overview of TTEthernet and existing methods for scheduling TTEthernet traffic. Then we present a formulation of the scheduling problem as a MRCPSP-GPR (also known as multi-mode RCPSP/max) and evaluate the possibility of using existing MRCPSP-GPR solvers for scheduling TTEthernet traffic. With a heuristic we introduce, this approach appears practical. Apart from this, we present a correction of a state-of-the-art method for estimating worst-case delays of rate-constrained (RC) TTEthernet traffic

Constraint Programming-based Job Dispatching for Modern HPC Applications

A High-Performance Computing job dispatcher is a critical software that assigns the finite computing resources to submitted jobs. This resource assignment over time is known as the on-line job dispatching problem in HPC systems. The fact the problem is on-line means that solutions must be computed in real-time, and their required time cannot exceed some threshold to do not affect the normal system functioning. In addition, a job dispatcher must deal with a lot of uncertainty: submission times, the number of requested resources, and duration of jobs. Heuristic-based techniques have been broadly used in HPC systems, at the cost of achieving (sub-)optimal solutions in a short time. However, the scheduling and resource allocation components are separated, thus generates a decoupled decision that may cause a performance loss. Optimization-based techniques are less used for this problem, although they can significantly improve the performance of HPC systems at the expense of higher computation time. Nowadays, HPC systems are being used for modern applications, such as big data analytics and predictive model building, that employ, in general, many short jobs. However, this information is unknown at dispatching time, and job dispatchers need to process large numbers of them quickly while ensuring high Quality-of-Service (QoS) levels. Constraint Programming (CP) has been shown to be an effective approach to tackle job dispatching problems. However, state-of-the-art CP-based job dispatchers are unable to satisfy the challenges of on-line dispatching, such as generate dispatching decisions in a brief period and integrate current and past information of the housing system. Given the previous reasons, we propose CP-based dispatchers that are more suitable for HPC systems running modern applications, generating on-line dispatching decisions in a proper time and are able to make effective use of job duration predictions to improve QoS levels, especially for workloads dominated by short jobs

Partitioning into Isomorphic or Connected Subgraphs

This thesis deals mainly with the partitioning and connectedness of graphs. First, we show that the problem of partitioning the nodes of a graph into a specific number of subsets such that the induced subgraphs on these sets are isomorphic to one another is NP-complete. If the induced subgraphs have to be connected, the problem remains NP-complete. Then we inspect some special graph classes for which the problem is solvable in polynomial time. Afterwards, we deal with the problem of defining a polytope by incidence vectors of nodes, which induce a connected graph. We inspect some facet-defining inequalities and their general structure. For some graph classes we state the full description. We then proceed to the problem of partitioning the nodes of a graph into a given number of parts such that the induced graphs are connected. For the corresponding polytope we show the dimension and some facet defining inequalities. This theoretical inspection is advanced by the problem of partitioning a graph into different parts such that the parts induce a connected graph in order to maximize the induced cut. We introduce different ideas for solving this problem in SCIP and show the numerical results. This leads to interesting problems on MIPs in general. As the problem in literature generally deals with the feasible region, we focus on the objective function. To do that, we inspect the problem of finding MIPs for problems with nonlinear objective functions. We discuss properties and requirements showing the existence or non-existence of particular formulations. Lastly, we inspect the problem of partitioning the nodes of a graph such that all but one class are isomorphic. This problem becomes interesting if the part not inducing the isomorphism is minimized. For this purpose we also introduce a technique, which generates the parts by brute-force. Instead of partitioning the graph into isomorphic parts, we proceed to the problem of similar graphs. In this case we inspect different similarities and show algorithms which implement these