The advances in agricultural robotics bring autonomous robots to work in farms. Farm Management Information Systems (FMIS) are sophisticated and complex systems to support production management in farms. They need to integrate software for the scheduling of a fleet of such robots. As agricultural systems are by nature subject to unpredictable events, it seems necessary to provide a solution for online scheduling. After the description of the problem, which is to schedule tasks for the robots in order to fulfill demands for agricultural activities, we propose an online approach based on solving a Mixed Integer Linear Programming (MILP) problem at each step, meaning each time the FMIS is requested to adjust or complete the schedule.

We present Hedgehog, a general-purpose library for taking advantage of powerful compute nodes, multicore CPUs, and multiple GPUs. The novel aspects of Hedgehog are: (1) its explicit representation of a program as a dataflow graph, (2) its pure dataflow-driven scheduling, (3) its maintenance of a computation's localized state via state managers, and (4) its fine control of memory via memory managers. This dataflow approach results in extremely low overhead for task executions (< 1 microsecond) and no-cost profiling at the task level. This allows us to prototype operations that compare favorably with leading libraries such as cuBLAS-XT.

When developing software in Operational Research (OR), one usually aims at getting the shortest execution time. There are multiple means to achieve this, including improving the algorithmic time complexity (finding better suited algorithms and data structures), optimizing the code (e.g. to avoid cache misses), parallelizing the execution... These improvements can be written by the end developer, requiring some coding effort and knowledge, whereas some of them could be achieved automatically. In previous work, we proposed a library to ease the building of parallel implementations of OR algorithms from the knowledge of their structure with no runtime overhead. We chose to use algorithmic skeletons in order to describe metaheuristics and make them ready for parallelization. For this purpose, Template Metaprogramming (TMP) techniques are used first to provide facilities to describe a metaheuristic as a composition of algorithmic skeletons, and secondly to analyze and transform the skeleton, at compile-time, into an efficient code to be executed at runtime. C++ TMP allows writing full algorithms to be executed at compile-time, but it is rare for an end developer to use TMP directly, as its syntax greatly differs from the usual language. Hence, we present here some insights of an intermediary library designed to ease the writing of code to process the algorithmic skeletons at compile-time as trees and vectors.

Getting performance on high-end heterogeneous nodes is challenging. This is due to the large semantic gap between a computation's specification-possibly mathematical formulas or an abstract sequential algorithm-and its parallel implementation; this gap obscures the program's parallel structures and how it gains or loses performance. We present Hedgehog, a library aimed at coarse-grain parallelism. It explicitly embeds a dataflow graph in a program and uses this graph at runtime to drive the program's execution so it takes advantage of hardware parallelism (multicore CPUs and multiple accelerators). Hedgehog has asynchronicity built in. It statically binds individual threads to graph nodes, which are ready to fire when any of their inputs are available. This allows Hedgehog to avoid using a global scheduler and the loss of performance associated with global synchronizations and managing of thread pools. Hedgehog provides a separation of concerns and distinguishes between compute and state maintenance tasks. Its API reflects this separation and allows a developer to gain a better understanding of performance when executing the graph. Hedgehog is implemented as a C++ 17 headers-only library. One feature of the framework is its low overhead; it transfers control of data between two nodes in ≈ 1 μs. This low overhead combines with Hedgehog's API to provide essentially cost-free profiling of the graph, thereby enabling experimentation for performance, which enhances a developer's insight into a program's performance. Hedgehog's asynchronous data-flow graph supports a data streaming programming model both within and between graphs. We demonstrate the effectiveness of this approach by highlighting the performance of streaming implementations of two numerical linear algebra routines, which are comparable to existing libraries: matrix multiplication achieves >95 % of the theoretical peak of 4 GPUs; LU decomposition with partial pivoting starts streaming partial final result blocks 40× earlier than waiting for the full result. The relative ease and understandability of obtaining performance with Hedgehog promises to enable non-specialists to target performance on high-end single nodes.

SummaryConcepts are likely to be introduced in a future C++ standard. They can be used for constraining template parameters, which enables checking requirements on template parameters sooner in the compilation process, and thus providing more intelligible error messages to the user. They can also be used in the specialization of templates, thus leading to a better control over the selection of the most appropriate version of a template for a given instantiation. This latter aspect offers new possibilities in the design of template libraries, as it enhances the specialization mechanism of templates, and set it up as a solid alternative to inheritance when static binding can replace dynamic binding. This article addresses the design of expression templates (i.e., templates that represent expressions and are usually built through operator overloading) that are useful to develop an embedded domain specific language (EDSL), and can speed up the evaluation of an expression by delaying the evaluation of intermediate operations to avoid unnecessary temporary objects. We propose to use concept‐based template specialization to parse expression templates in order to ease the design of an EDSL. This approach is a static variant of the well‐known visitor design pattern that replaces the overridden methods in the double dispatch of the original design pattern by template specializations based on concepts. An example of EDSL for linear programming developed with our solution demonstrates that a concept‐based design helps producing concise and reliable code. Copyright © 2017 John Wiley & Sons, Ltd.

In generic programming, software components are parameterized on types. When available, a static specialization mechanism allows selecting, for a given set of parameters, a more suitable version of a generic component than its primary version. The normal C++ template specialization mechanism is based on the type pattern of the parameters, which is not always the best way to guide the specialization process: type patterns are missing some information on types that could be relevant to define specializations.The notion of a concept, which represents a set of requirements including syntactic and semantic aspects for a type, is known to be an interesting approach to control template specialization. For many reasons, concepts were dropped from C++11 standard, this article therefore describes template metaprogramming techniques for declaring concepts, modeling relationships meaning that a type fulfills the requirements of a concept, and refinement relationships meaning that a concept refines the requirements of another concept.From a taxonomy of concepts and template specializations based on concepts, an automatic mechanism selects the most appropriate version of a generic component for a given instantiation. Our purely library-based solution is also open for retroactive extension: new concepts, relationships, and template specializations can be defined at any time; such additions will then be picked up by the specialization mechanism.

Generic programming is a powerful technique for its possibility to design software components parameterized on types (and static values for some languages), and not only on dynamic values. Like in object-oriented programming, the mechanism of specialization, defined here as "static" for generic programming and "dynamic" for object-oriented programming, makes the technique particularly interesting. In C++, the way of selecting the best static specialization for a generic component is based on the type signature (or sometimes the static value) of parameters, which is not rigorous enough and can lead to ambiguities or false specializations. Another option to control static specialization might be through "concepts". A concept represents a set of requirements for a component that can refer to its interface (e.g. existence of a method), its behavior (e.g. complexity of a method) or anything else relevant to its use in a software. This paper justifies using concepts to control static specialization, and proposes an implementation for the C++ language to define concepts and refinements of concepts, and to use them to specify unambiguous specializations of generic components.

In generic programming, software components are parameter iz d on types (and sometimes static values, as in C++) rather than dynamic values. When available, a static specialization mechanism allows building, for a given set of parameters, a more suitable version of a generi c component than its primary version. The normal C++ template specialization mechanism is based on th e type pattern (or sometimes the static value) of parameters, which may not be accurate enough and may lead t o ambiguities or false specializations. This is mainly due to the fact that some relationships between typ es, which can be considered as similar in some ways, are missing. Thus, it is not always possible to determi ne an order of the specializations of a generic component. Concepts can be used to introduce relationships between "si milar" types: a concept represents a set of requirements for a component that among others refer to its i nterface and its behavior. This paper describes generic programming techniques in C++ for declaring concep ts, "modeling" relationships (between a type and a concept) and "refinement" relationships (between two c oncepts), and for controlling template specializations based on a taxonomy of concepts. This control relie s on a metaprogram that determines, in a given static specialization context, the most specialized conce pt of any type instantiating a template parameter. The solution presented here is open for retroactive extensi on: at any time, a new concept or a new modeling/refinement relationship can be declared, or a new t emplate specialization can be defined; and this new statement will be picked up by the specialization mechan ism. The control is also improved by avoiding false specializations and many ambiguities during the spec ialization process.

The C4TS++ library, that stands for Concepts for Template Specialization in C++, provides an implementation for the C++ language to define concepts and refinements of concepts, and to use them to specify unambiguous specializations of generic components. In generic programming, software components are parameterized on types. When available, a static specialization mechanism allows selecting, for a given set of parameters, a more suitable version of a generic component than its primary version. The normal C++ template specialization mechanism is based on the type pattern of the parameters, which is not always the best way to guide the specialization process: type patterns are missing some information on types that could be relevant to define specializations. The notion of a concept, which represents a set of requirements (including syntactic and semantic aspects) for a type, is known to be an interesting approach to control template specialization. For many reasons, concepts were dropped from C++11 standard, this library is therefore based on template metaprogramming techniques for declaring concepts, modeling relationships (meaning that a type fulfills the requirements of a concept), and refinement relationships (meaning that a concept refines the requirements of another concept). From a taxonomy of concepts and template specializations based on concepts, an automatic mechanism selects the most appropriate version of a generic component for a given instantiation. Our purely library-based solution is also open for retroactive extension: new concepts, relationships, and template specializations can be defined at any time; such additions will then be picked up by the specialization mechanism.

We present here a Demand Maximizing Circuit Problem, which involves time elastic demands, and which is related to applications of Network Synthesis to the design of urban public transportation systems. This problem consists in the optimization, on some irregular domain, of some quantity whose computation involves heavy computational costs. We propose a specific metaheuristic Pursuit scheme, based upon the application to the original problem of a multiform rewriting process. We present and discuss various interpretations of this scheme together with practical experimentations. The whole paper is an extension of a work which was presented during the LT '2007 conference in Sousse.

L'interet de l'utilisation des biopuces cdna pour la genetique n'est plus a demontrer [EISE-99]. Cette technologie complexe arrive maintenant a une certaine maturite et son utilisation s'etend notamment dans la modelisation des relations gene expression individu. De ce fait, le defi actuel est l'amelioration de la precision des mesures realisees de fac¸on a augmenter la qualite des expressions estimees et donc les resultats fonctionnels. En effet, le plus souvent les reponses cherchees jusqu'a present etaient binaires, alors que maintenant la recherche s'oriente vers des mesures moins tranchees ou l'on veut mesurer un quantum d'expression.

Many optimization techniques are based on mathematical representations. In this case, important modeling simplifications need to be made. The solution thus provided, even if proven to be theoretically one of the best, might not be so good in practice. Simulation can be used to evaluate the actual performance of the solution. We propose here a coupling between optimization and simulation that tries to improve the solution provided by a mathematical model. This approach, named “model enhancement” here, still focuses on optimizing the theoretical objective function, contrary to the common optimization–simulation coupling that focuses on improving the objective function evaluated from simulation. We propose to illustrate this approach on a routing problem, and present numerical results on the quality of the solution and the efficiency of both coupling approaches.

We present here a Demand Maximizing Circuit Problem, which involves time elastic demands, and which is related to applications of Network Synthesis to the design of urban public transportation systems. This problem consists in the optimization, on some irregular domain, of some quantity whose computation involves heavy computational costs. We propose a specific metaheuristic Pursuit scheme, based upon the application to the original problem of a multiform rewriting process. We present and discuss various interpretations of this scheme together with practical experimentations.

Design solutions have been proposed to implement generic data structures, however such techniques dedicated to algorithms are not well known. This article discusses various recurrent problems encountered when designing reusable, extensible algorithms for operations research. It explains how to use object-oriented concepts and the notion of genericity to design algorithms that are independent of the data structures and the algorithms they use, but that can still interact deeply with them. An object-oriented design is sometimes considered to be less efficient than a classical one, and operations research is one of these scientific fields where efficiency really matters. Hence, the main goal of this article is to explain how to design algorithms that are both generic and efficient. It also discusses specific recurring design issues for operations research software and proposes solutions that improve the genericity of the algorithms. Copyright © 2005 John Wiley & Sons, Ltd.

When using optimization techniques based on mathematical models, we often need to make important simplifications. The solution thus provided, even if proven to be theoretically one of the best, might not be so good in practice. Simulation can be used to evaluate the actual performance of the solution. We propose here a coupling between optimization and simulation that tries to improve the solution provided by a mathematical model. This approach still focuses on optimizing the theoretical objective function, contrary to the common optimization-simulation coupling that focuses on improving the objective function evaluated from simulation. We propose to illustrate this approach on a routing problem, and present numerical results on the quality of the solution and the efficiency of both coupling approaches.

Nous proposons des methodes et des outils pour l'aide a la conception strategique de reseaux de transports publics en milieu urbain. Un etat de l'art des problemes de synthese de reseaux est suivi par la definition du probleme de synthese de reseaux de mobilite avec demande elastique (dependante de la qualite de service) . Nous declinons differentes modelisations et des extensions etudiees de maniere exacte sur de modestes instances. Les metaheuristiques GRASP et Tabou permettent d'obtenir de bonnes solutions sur des instances plus grandes. Nous utilisons pour cela la geodesique, une description particuliere de circuit. La resolution est acceleree en introduisant une fonction objectif auxiliaire. Enfin, nous utilisons une methode inspiree du schema de Benders. En annexe, nous formalisons des schemas de conception de composants logiciels flexibles et performants avec la programmation generique. Nous presentons aussi le couplage par enrichissement, entre optimisation et simulation.