The operational performance of an underground mine depends critically on how the production is scheduled. Increasingly advanced methods are used to create optimized long-term plans, and simultaneously the actual excavation is getting more and more automated. Therefore, the mapping of long-term goals into tasks by manual short-term scheduling is becoming a limiting segment in the optimization chain. In this thesis we study automating the short-term mine scheduling process, and thus contribute to an important missing piece in the pursuit of autonomous mining. First, we clarify the fleet scheduling problem and the surrounding context. Based on this knowledge, we propose a flow shop that models the mine scheduling problem. A flow shop is a general abstract process formulation that captures the key properties of a scheduling problem without going into specific details. We argue that several popular mining methods can be modeled as a rich variant of a k-stage hybrid flow shop, where the flow shop includes a mix of interruptible and uninterruptible tasks, after-lags, machine unavailabilities, and sharing of machines between stages. Then, we propose a Constraint Programming approach to schedule the underground production fleet. We formalize the problem and present a model that can be used to solve it. The model is implemented and evaluated on instances representative of medium-sized underground mines. After that, we introduce travel times of the mobile machines to the scheduling problem. This acknowledges that underground road networks can span several hundreds of kilometers. With this addition, the initially proposed Constraint Programming model struggles with scaling to larger instances. Therefore, we introduce a second model. The second model does not solve the interruptible scheduling problem directly; instead, it solves a related uninterruptible problem and transforms the solution back to the original time domain. This model is significantly faster, and can solve instances representative of large-sized mines even when including travel times. Lastly, we focus on finding high-quality schedules by introducing Large Neighborhood Search. To do this, we present a domain-specific neighborhood definition based on relaxing variables corresponding to certain work areas. Variants of this neighborhood are evaluated in Large Neighborhood Search and compared to using only restarts. All methods and models in this thesis are evaluated on instances generated from an operational underground mine. / Underjordsgruvans operativa prestanda är till stor del beroende av schemaläggningen av de mobila maskinerna. Allt mer avancerade metoder används för att skapa optimerade långtidsplaner samtidigt som produktionsaktiviteterna blir allt mer automatiserade. Att överföra långtidsmål till aktiviteter genom manuell schemaläggning blir därför ett begränsande segment i optimeringskedjan. I denna avhandling studerar vi automatisering av schemaläggning för underjordsgruvor och bidrar således med en viktig komponent i utvecklandet av autonom gruvdrift. Vi börjar med att klargöra schemaläggningsproblemet och dess omgivande kontext. Baserat på detta klargörande föreslår vi en abstraktion där problemet kan ses som en flow shop. En flow shop är en processmodell som fångar de viktigaste delarna av ett schemaläggningsproblem utan att hänsyn tas till allt för många detaljer. Vi visar att flera populära gruvbrytningsmetoder kan modelleras som en utökad variant av en k-stage hybrid flow shop. Denna utökade flow shop innehåller en mix av avbrytbara och icke avbrytbara aktiviteter, eftergångstid, indisponibla maskiner samt gemensamma maskinpooler för vissa steg. Sedan föreslår vi ett koncept för att lösa schemaläggningsproblemet med hjälp av villkorsprogrammering. Vi formaliserar problemet och presenterar en modell som kan användas för att lösa det. Modellen implementeras och utvärderas på probleminstanser representativa för mellanstora underjordsgruvor. Efter det introducerar vi restider för de mobila maskinerna i schemaläggningsproblemet. Detta grundar sig i att vägnätet i underjordsgruvor kan sträcka sig upp till flera hundra kilometer. Med det tillägget får den initiala villkorsprogrammeringsmodellen svårt att lösa större instanser. För att möta det problemet så introducerar vi en ny modell. Den nya modellen löser inte det avbrytbara problemet direkt utan börjar med att lösa ett relaterat, icke avbrytbart, problem för att sedan transformera lösningen tillbaka till den ursprungliga tidsdomänen. Denna modell är betydligt snabbare och kan lösa probleminstanser representativa för stora underjordsgruvor även när restider inkluderas. Avslutningsvis fokuserar vi på att hitta scheman av hög kvalitet genom att optimera med Large Neighborhood Search. För att åstadkomma detta presenterar vi ett domänspecifikt grannskap baserat på att relaxera variabler som rör aktiviteter inom vissa produktionsområden. Flera varianter av detta grannskap utvärderas och jämförs med att enbart använda omstarter. Alla metoder och modeller i den här avhandlingen är utvärderade på genererade instanser från en operativ underjordsgruva. / <p>QC 20181026</p>

Design Space Exploration (DSE) is the exploration of a space of possible designs with the goal of finding some optimal design according to some constraints and criteria. Within embedded systems design, automated DSE in particular can allow the system designer to efficiently find good solutions in highly complex design spaces. One particular tool for performing automated DSE is IDeSyDe which uses Constraint Programming (CP) and constraint optimization for modelling and optimization. The constraint models of DSE often include some real-valued parameters, but optimized CP-solvers typically require integer arguments. This makes it necessary to discretize the problem in order to make the approach useful in practice, effectively limiting the size of the search space significantly. The effects of this discretization procedure on the quality of the solutions have not previously been well studied. An investigation into how this kind of discretization affects the approximate solutions could make the approach more rigorous, and possibly also uncover exploitable details that could facilitate the development of even more efficient algorithms. This project presents a convergence proof based in CP and Multiresolutional analysis (MRA), including a practically useful error bound for solutions obtained with different discretizations. In particular, the mapping and scheduling of Syncronous Data Flow (SDF) models for streaming applications onto tile-based multiple processor system-on-chip platforms with a common time-division multiplexing bus interconnect is studied. The theoretical results are also verified using IDeSyDe for a few different configurations of applications and platforms. It can be seen that the experiments behave as predicted, with first order convergence in total error and adherence to the bound. / Designrymdsutforskning är benämningen för en systematisk utforskning av en rymd av möjliga designer i syfte att hitta bra eller optimala lösningar som optimerar något mål och som uppfyller krav och begränsningar. Automatiserad designrymdsutforskning har i synnerhet sett utveckling för tillämpningar inom design av inbyggda system, där den ständigt ökande komplexiteten hos moderna plattformar motiverat utvecklingen av nya metoder. Två stora delar är nödvändiga för att kunna tillämpa designrymdsutforskning för design av inbyggda system: en modell av systemet och en optimiseringsprocess. Beroende på situation kan systemmodeller variera från detaljerade simuleringar på transistornivå till övergripande analytiska modeller på applikationsnivå eller högre. Detaljerade simuleringar gör det möjligt att utvärdera en viss lösning mycket noggrant, men till en hög beräkningskostnad. Med analytiska modeller är det istället billigt att utvärdera enskilda lösningar, men på bekostnad av noggrannhet. På samma sätt kan olika optimeringsprocesser också användas: snabbare approximativa algoritmer kan användas för att hitta lösningar relativt snabbt men utan garantier för optimalitet, medans mer uttömmande algoritmer typiskt kräver mycket beräkningskraft. Ett verktyg för automatiserad designrymdsutforskning är IDeSyDe. IDeSyDe använder villkorsbaserade modeller och uttömmande sökning genom Branch and Bound. Optimerade algoritmiska lösare för villkorsprogrammeringsproblem kräver ofta heltalsparametrar. Modeller för designrymdsutforskning innehåller å andra sidan ofta kontinuerliga parametrar. På grund av detta är det ofta nödvändigt att disktretisera problemet för att effektivt kunna hitta lösningar. Eftersom en diskretisering begränsar mängden lösningar i sökrymden riskerar en sådan omformulering att ta bort även optimala lösningar. En designrymdsutforskningsalgoritm som utnyttjar diskretisering av designrymden måste på grund av detta generellt ses som en approximativ algoritm. Hur en sådan diskretisering påverkar lösningarna -- dvs. hur nära de approximativa lösningarna kan förväntas komma den optimala lösningen utan diskretisering -- har dock inte studerats i närmare detalj. En bättre förståelse för hur diskreta, approximativa problem och lösningar relaterar till sina exakta motsvarigheter kan ge metoden mer rigör. En undersökning av den underliggande matematiken har också potential att belysa andra samband och strukturer som potentiellt skulle kunna användas för att utveckla bättre eller mer effektiva algoritmer. I den här rapporten presenteras ett konvergensbevis baserat på villkorsprogrammering och multiupplösningsanalys med ett begränsat felintervall i termer av probleminstansspecifika parametrar och en diskretiseringsparameter. Beviset är framtaget för tillämpning med IDeSyDe och är därför begränsat till en kombination av modeller som verktyget för närvarande stödjer, nämligen strömmande-dataflödesapplikationer beskrivna som synkrona dataflödesmodeller (Synchronous Data Flow, SDF) samt en ''tile''-baserad modell för system med flera processorer på ett chip (MPSoC) med en gemensam tidspartitionerad multiplexor-bus för kommunikation mellan processor-''tiles''. De teoretiska resultaten är verifierade och tillämpade på ett flertal exempelfall beräknade med IDeSyDe, där konvergensen studerats experimentellt.

The aim of this thesis was to study co-authorship in the constraint programming research community. This was done by conducting social network analysis (SNA) based on published scientific papers from the proceedings of the International Conference on Principles and Practice of Constraint Programming. Bibliographic data of the scientific literature was collected for the years 2018–2022 of the annual conference. For quantitative analysis, graph metrics were computed to study the properties and structure of the overall network, and also to study the attributes and characteristics of individual authors to be able to identify central actors of the community. Furthermore, graph layout algorithms were used for visualisation of the network. The computed metrics and the graphical visualisations enabled identifying collaboration patterns and behaviours within the studied field. The results of this study show that the most central actors of the community are mainly male and dominated by white organisations and countries. The results of the study also show that the vast majority of authors of the community collaborate with others in writing papers. However, due to the low density of the network there is opportunity and room for new collaboration patterns to take place within the research community.

No description available.

Cloud applications and services are frequently built using multiple tiers and current trends such as micro-services further increase componentization, allowing us to place each component in a different physical machine in a distributed cloud. Ericsson owns and manages very large networks, which offer diverse infrastructure in terms of computational power, storage but most importantly position in the network. Typically, a machine which is closer to the edge of the network (closer to the end user) will have limited resources but it will offer less latency, for a higher price. At the same time, several enterprise/industrial areas expect to benefit from the cloud business model in a large-scale distributed environment. These types of applications have very diverse end-2-end Service-Level Agreements (SLA) to be fulfilled, while at the same time the cloud environment needs to optimize processing, storage, and networking costs. Moreover, customers might want to change and adjust SLAs/requirements themselves using selfmanagement portals. The objective of this project is to model the network and services offered by Ericsson. Then, given the SLA, finding a valid solution of the problem, using a constraint solver. A solution is a set of physical machines that host the components the required service is composed from. This approach has many challenges since the same service can be composed from different sets of components. The connected components form a connectivity graph, where nodes in the graph are connected by physical links. But, since the connection is described by higher level components (composed by simpler components), this graph can also be expressed as a tree. Leaves in the tree are the nodes that compose the higher-level services and the ones that must be hosted in the infrastructure. The characteristics of each leaf-node depend on its parent and/or siblings in the component tree. Finally, since the components are normally connected, the physical connection between nodes in the network must be taken into consideration. The proposed model is evaluated in several cases, in order to identify how the number of the software components and the infrastructure topology affect the solution finding. The results are promising, showing fast resolution of the problem instances, varying for each test case, from a few seconds to a couple of minutes. / Molnapplikationer och tjänster är ofta byggda med flera nivåer och nuvarande trender såsom mikro-tjänster ökar ytterligare komponentiseringen, vilket tillåter oss att placera varje komponent i en annan fysisk maskin på ett distribuerat moln. Ericsson äger och förvaltar väldigt stora nätverk som erbjuder varierande infrastruktur när det gäller beräkningskraft , lagring och framför allt position i nätverket. Typiskt kommer en maskin som är närmare kanten av nätet (närmare slutanvändaren) att ha begränsade resurser, men det kommer att erbjuda mindre latens till ett högre pris. Samtidigt räknar flera företag / industriområden med att dra nytta av moln affärsmodelltjänster i en storskalig och distribuerad miljö. Den här typen av applikationer har väldigt olika end-to-end varierande servicenivåavtal (SLA) som skall uppfyllas, medan moln miljön behöver optimera bearbetnings, lagrings och nätverks kostnader. Dessutom, kan kunden komma att vilja ändra och justera SLA / krav själva med hjälp av självhantering portaler. Målet för detta projekt är att modellera nät och tjänster som erbjuds av Ericsson. Sedan, givet ett SLA, att hitta en giltig lösning på problemet, med hjälp av en villkorslösare. En lösning är en uppsättning av fysiska maskiner som är värdar för komponenterna från vilka den efterfrågade tjänsten är sammansatt. Detta tillvägagångssätt är förenat med många utmaningar eftersom samma tjänst kan bestå av olika uppsättningar av komponenter. De anslutna komponenterna bildar ett förbindelseschema, där noder i grafen är anslutna med fysiska länkar. Men eftersom anslutningen beskrivs av komponenter högre nivå (bestående av enklare komponenter), denna graf kan också uttryckas som ett träd. Löv i trädet är noderna som utgör de högre nivå tjänster och de som måste finnas i infrastrukturen. Egenskaperna hos varje löv-nod att bero på dess förälder och / eller syskon i komponentträdet. Slutligen, eftersom komponenterna i normal fall är anslutna, måste den fysiska anslutningen mellan noder i nätet tas i beaktande. Den föreslagna modellen utvärderas i flera fall, för att identifiera hur antalet programvarukomponenter och infrastrukturens topologi påverkar resultatet av lösningen. Resultaten är lovande och visar snabb lösning av problemets instanser, varierande för varje testfall, från några sekunder till ett par minuter.

As High-Performance Computing (HPC) becomes increasingly prevalent and resource-intensive, there is a growing need for the development of more efficient job schedulers, which play a crucial role in the performance of HPC clusters. This dissertation manifests a comprehensive approach to this complex issue, contributing to three major components of the problem: (1) metrics of job packing efficiency and fairness, (2) advanced scheduling algorithms, and (3) job resource utilization prediction techniques. To ensure high relevance of the results, this study emphasizes scheduling objectives. Therefore, scheduling quality metrics are investigated first, yielding a set of metrics that allow comparing alternative schedules and evaluating scheduling goals trade-offs. The set of metrics enables the first comprehensive analysis of effects of different scheduling improvement approaches on several aspects of scheduling quality, covering a variety of list scheduling algorithms as well as constraint programming optimization schedulers. The contribution to the third research area covers techniques to measure and estimate resource usage data. It reports a first-of-a-kind evaluation of various job runtime prediction techniques in improving scheduling quality, demonstrates an approach capable of estimating job parameters beyond the runtime, and explores measuring resources consumed by a job in an HPC cluster. The dissertation concludes with a practical demonstration of these concepts through an I/O-aware scheduling prototype that measures real-time resource utilization, autonomously determines job resource requirements the scheduler needs, and implements full-featured multi-resource backfill scheduling that accounts for the specific properties of the parallel file system bandwidth resource. The study exhibits the advantages of further reducing I/O congestion—beyond the capability of generic I/O-aware scheduling—and presents the Workload-adaptive scheduling strategy that attains such improvement. This approach features a “two-group” approximation technique to maintain efficient performance regardless of zero-throughput job availability. An evaluation conducted on a real HPC cluster demonstrates the effectiveness of the novel strategy.

Constraints allow developers to specify desired properties of systems in a number of domains, and have those properties be maintained automatically. This results in compact, declarative code, avoiding scattered code to check and imperatively re-satisfy invariants. Despite these advantages, constraint programming is not yet widespread, with standard imperative programming still the norm. There is a long history of research on integrating constraint programming with the imperative paradigm. However, this integration typically does not unify the constructs for encapsulation and abstraction from both paradigms. This impedes re-use of modules, as client code written in one paradigm can only use modules written to support that paradigm. Modules require redundant definitions if they are to be used in both paradigms. We present a language – Babelsberg – that unifies the constructs for en- capsulation and abstraction by using only object-oriented method definitions for both declarative and imperative code. Our prototype – Babelsberg/R – is an extension to Ruby, and continues to support Ruby’s object-oriented se- mantics. It allows programmers to add constraints to existing Ruby programs in incremental steps by placing them on the results of normal object-oriented message sends. It is implemented by modifying a state-of-the-art Ruby virtual machine. The performance of standard object-oriented code without con- straints is only modestly impacted, with typically less than 10% overhead compared with the unmodified virtual machine. Furthermore, our architec- ture for adding multiple constraint solvers allows Babelsberg to deal with constraints in a variety of domains. We argue that our approach provides a useful step toward making con- straint solving a generic tool for object-oriented programmers. We also provide example applications, written in our Ruby-based implementation, which use constraints in a variety of application domains, including interactive graphics, circuit simulations, data streaming with both hard and soft constraints on performance, and configuration file Management. / Constraints – Beschränkungen und Abhängigkeiten zwischen Systemteilen – erlauben es Entwicklern, erwünschte Eigenschaften von Systemen zu spezifizieren, sodass diese automatisch sichergestellt werden. Das führt zu kompaktem, deklarativem Quelltext, und vermeidet verstreute Anweisungen, die wiederholt Invarianten prüfen und wiederherstellen müssen. Trotz dieser Vorteile ist Programmieren mit Constraints nicht verbreitet, sondern imperatives Programmieren die Norm. Es gibt eine lange Forschungsgeschichte zur Integration von Constraints mit imperativem Programmieren. Jedoch vereinheitlicht diese Integration nicht die Programmierkonstrukte zur Abstraktion und Kapselung beider Paradigmen. Das verhindert die Wiederverwendung von Modulen, da Quelltext, der in einem Paradigma geschrieben wurde, nur Module verwenden kann, die so geschrieben sind, dass sie dieses Paradigma unterstützen. Module benötigen daher redundante Definitionen, wenn sie in beiden Paradigmen zur Verfügung stehen sollen. Wir präsentieren hier eine Sprache – Babelsberg – welche die Konstrukte zur Abstraktion und Kapselung vereinheitlicht, indem sie bekannte objektorientierte Methodendefinitionen sowohl für deklarativen, als auch für imperativen Code verwendet. Unser Prototyp –Babelsberg/R – ist eine Erweiterung von Ruby, und unterstützt Rubys objektorientierte Semantik. Dieser erlaubt es Programmieren, Constraints schrittweise zu existierenden Ruby Programmen hinzuzufügen, indem diese auf den Ergebnissen von Methodenaufrufen deklariert werden. Der Prototyp ist auf Basis einer virtuellen Maschine für Ruby implementiert, wobei die Ausführungsgeschwindigkeit von objektorienterten Programmteilen ohne Constraints nur minimal – typischerweise weniger als 10% – beeinträchtigt wird. Weiterhin erlaubt es unsere Architektur, je nach Anwendungsfall, mehrere Lösungsalgorithmen für Constraints zu verwenden. Wir argumentieren, dass unser Ansatz einen nützlichen Schritt darstellt, um Programmieren mit Constraints zu einem allgemeinen Werkzeug für objektorientierte Programmierer zu machen. Wir zeigen Beispielanwendungen, die unserer Ruby-basierten Implementierung geschrieben sind, welche Constraints in einer Reihe von Anwendungen verwenden: Für interaktive Grafik, Schaltkreissimulation, Datenströme mit sowohl harten, als auch weichen Constraints bezüglich ihrer Geschwindigkeit, und Konfigurationsverwaltung.

A wide range of problems can be modelled as constraint satisfaction problems (CSPs), that is, a set of constraints that must be satisfied simultaneously. Constraints can either be represented extensionally, by explicitly listing allowed combinations of values, or intensionally, whether by an equation, propositional logic formula, or other means. Intensionally represented constraints, known as global constraints, are a powerful modelling technique, and many modern CSP solvers provide them. We give examples to show how problems that deal with product configuration can be modelled with such constraints, and how this approach relates to other modelling formalisms. The complexity of CSPs with extensionally represented constraints is well understood, and there are several known techniques that can be used to identify tractable classes of such problems. For CSPs with global constraints, however, many of these techniques fail, and far fewer tractable classes are known. In order to remedy this state of affairs, we undertake a systematic review of research into the tractability of CSPs. In particular, we look at CSPs with extensionally represented constraints in order to understand why many of the techniques that give tractable classes for this case fail for CSPs with global constraints. The above investigation leads to two discoveries. First, many restrictions on how the constraints of a CSP interact implicitly rely on a property of extensionally represented constraints to guarantee tractability. We identify this property as being a bound on the number of solutions in key parts of the instance, and find classes of global constraints that also possess this property. For such classes, we show that many known tractability results apply. Furthermore, global constraints allow us to treat entire CSP instances as constraints. We combine this observation with the above result, and obtain new tractable classes of CSPs by dividing a CSP into smaller CSPs drawn from known tractable classes. Second, for CSPs that simply do not possess the above property, we look at how the constraints of an instance overlap, and how assignments to the overlapping parts extend to the rest of the problem. We show that assignments that extend in the same way can be identified. Combined with a new structural restriction, this observation leads to a second set of tractable classes. We conclude with a summary, as well as some observations about potential for future work in this area.

La plupart des scénarios multimédia interactifs sont basés sur des spécifications informelles, il n'est donc pas possible de vérifier formellement des propriétés de ces systèmes. Nous préconisons la nécessité d'un modèle général et formel. Partitions interactives est un formalisme pour décrire des scénarios multimédia interactifs. Nous proposons une nouvelle sémantique pour les partitions interactives basée sur les structures d'événements temporisés. Avec une telle sémantique, nous pouvons spécifier des propriétés pour le système, en particulier, des propriétés sur les traces, qui sont difficiles à préciser avec la programmation par contraintes. Nous présentons également une sémantique opérationnelle des partitions interactives basée sur le calcul non-déterministe, temporisé, concurrent, par contraintes (ntcc) et nous rapportons la sémantique operationelle à la semantique en structures d'événements temporisés. Avec la sémantique opérationnelle, nous pouvons décrire formellement le comportement d'un scenario dont les durées des objets temporels peuvent être des intervalles d'entiers arbitraires. La sémantique opérationnelle est obtenue à partir de la sémantique en structures d'événements temporisés de la partition interactive. Pour fournir une telle traduction, nous avons d'abord défini la forme normale d'une structure d'événements temporisés, dans laquel les événements liés avec une durée zéro sont regroupés en un seul. Nous avons également défini la notion de structures d'événements temporisés répartissables, de telle sorte que son graphe de contraintes peut être expédié en se fondant uniquementsur la propagation locale. Nous croyons que la sémantique opérationnelle basée sur ntcc offre certains avantages par rapport à la sémantique des partitions interactives basée sur des réseaux de Petri; par exemple, les durées des objets temporels peuvent être des intervalles d'entiers arbitraires, tandis que dans la plupart des modèles de partitions interactives, les intervalles ne peut être utilisés que pour représenterles relations telles que l'égalité et les inégalités. Nos modèles ntcc de partitions interactives sont exécutés en utilisant Ntccrt, un interprète temps réel pour ntcc. Nos modèles peuvent également être vérifiés automatiquement en utilisant ntccMC, un vérificateur pour ntcc, de temps borné, basée sur les automates finis, que nous introduisons dans cette thèse. En utilisant ntccMC, nous pouvons vérifier des propriétés de logique de temps linéaire avec des contrantes (CLTL). Dans cette thèse, nous introduisons deux extensions du formalisme de partitions interactives:(1) l'une pour gérer le traitement audio en utilisant le langage de programmation français Faustet (2) l'autre pour traiter des condition et des branchements, permettant de spécifier des choix et des boucles. Pour la première extension, nous présentons une sémantique basée sur les structures d'événements temporisés et des idées sur la façon de définir une sémantique opérationnelle. Pour la deuxième extension, nous présentons une mise en oeuvre et la comparaison des résultats du jitter relative moyenne d'une implémentation d'un arpège base sur l'algorithme de Karplus-Strong par rapport aux implémentations existants écrits dans Pure Data. Nous définissons aussi un format de sauvegarde XML pour les partitions interactives et pour la extension avec branchement conditionnel. Un format de sauvegarde est crucial pour assurer la persistance des partitions. / Technology has shaped the way on which we compose and produce music. Notably, the invention of microphones and computers pushed the development of new music styles in the 20th century. In fact, several artistic domains have been benefiting from such technology developments ; for instance, Experimental music, non-linear multimedia, Electroacoustic music, and interactive multimedia. In this dissertation, we focus on interactive multimedia.Interactive multimedia deals with the design of scenarios where multimedia content and interactive events are handled by computer programs. Examples of such scenarios are multimedia art installations, interactive museum exhibitions, some Electroacoustic music pieces, and some Experimental music pieces. Unfortunately, most interactive multimedia scenarios are based on informal specifications, thus it is not possible to formally verify properties of such systems. We advocate the need of a general and formal model. Interactive scores is a formalism to describe interactive multimedia scenarios. We propose new semantics for interactive scores based on timed eventstructures. With such a semantics, we can specify properties for the system, in particular, properties about traces, which are difficult to specify as constraints. In fact, constraints are an important part of the semantic model of interactive scores because the formalism is based on temporal constraints among the objects of the scenario. We also present an operational semantics of interactive scores based on the non-deterministic timed concurrent constraint (ntcc) calculus and we relate such a semantics to the timed event structures semantics. With the operational semantics, we formally describe the behavior of a score whose temporal object durations can be arbitrary integer intervals. The operational semantics is obtained from the timed event structures semantics of the score. To provide such a translation, we first define the normal form of a timed event structure in which events related with zero-duration delays are collapsed into a single one. We also define the notion of dispatchable timed event structures. Event structures such that its constraint graph can be dispatched by relying only on local propagation.We believe that operational semantics in ntcc offers some advantages over existing Petri nets semantics for interactive scores; for instance, the duration of the temporal objects can be arbitrary integer intervals, whereas inprevious models of interactive scores, such durations can only be intervals to represent equalities and inequalities. In this dissertation, we also introduce two extensions of the formalism of interactive scores : (1) one to handle audio processing using the Fast AUdio Stream (Faust) languageand (2) another one to handle conditional branching, allowing designers to specify choices and loops. For the first extension, we present a timed event structures semantics and ideas on how to define operational semantics. For the second extension, we present an implementation and results comparing the average relative jitter of an implementation ofan arpeggio based on Karplus-Strong with respect to existing implementations of Karplus written in Pure Data. We also define a XML file format for interactive scores and for the conditional branching extension. A file format is crucial to assure the persistence of the scores. Ntcc models of interactive scores are executed using Ntccrt, a real-time capable interpreter for ntcc. They can also be verified automatically using ntccMC, a bounded-time automata based model checker for ntcc which we introduce in this dissertation. Using ntccMC, we can verify properties expressed on constraint linear-time logic. Ntcc has been used in the past, not only for multimedia interaction models, but alsofor system biology, security protocols and robots.

La programmation par contraintes est une approche intéressante pour traiter des problèmes d’ordonnancement. En ordonnancement cumulatif, les activités sont définies par leur date de début, leur durée et la quantité de ressource nécessaire à leur exécution. La ressource totale disponible (la capacité) en chaque instant est fixe. La contrainte globale Cumulative modélise ce problème en programmation par contraintes. Dans de nombreux cas pratiques, la date limite de fin d’un projet est fixée et ne peut être retardée. Dans ce cas, il n’est pas toujours possible de trouver un ordonnancement des activités qui n’engendre aucun dépassement de la capacité en ressource. On peut alors tolérer de relâcher la contrainte de capacité, dans une limite raisonnable, pour obtenir une solution. Nous proposons une nouvelle contrainte globale : la contrainte SoftCumulative qui étend la contrainte Cumulative pour prendre en compte ces dépassements de capacité. Nous illustrons son pouvoir de modélisation sur plusieurs problèmes pratiques, et présentons différents algorithmes de filtrage. Nous adaptons notamment les algorithmes de balayage et d’Edge-Finding à la contrainte SoftCumulative. Nous montrons également que certains problèmes pratiques nécessitent d’imposer des violations de capacité pour satisfaire des règles métiers, modélisées par des contraintes additionnelles. Nous présentons une procédure de filtrage originale pour traiter ces dépassements imposés. Nous complétons notre étude par une approche par décomposition. Enfin, nous testons et validons nos différentes techniques de résolution par une série d’expériences. / Constraint programming is an interesting approach to solve scheduling problems. In cumulative scheduling, activities are defined by their starting date, their duration and the amount of resource necessary for their execution. The total available resource at each point in time (the capacity) is fixed. In constraint programming, the Cumulative global constraint models this problem. In several practical cases, the deadline of theproject is fixed and can not be delayed. In this case, it is not always possible to find a schedule that does not lead to an overload of the resource capacity. It can be tolerated to relax the capacity constraint, in a reasonable limit, to obtain a solution. We propose a new global constraint : the SoftCumulative constraint that extends the Cumulative constraint to handle these overloads. We illustrate its modeling power on several practical problems, and we present various filtering algorithms. In particular, we adapt the sweep and Edge-Finding algorithms to the SoftCumulative constraint. We also show that some practical problems require to impose overloads to satisfy business rules, modelled by additional constraints. We present an original filtering procedure to deal with these imposed overloads. We complete our study by an approach by decomposition. At last, we test and validate our different resolution techniques through a series of experiments.