A master slave architecture to integrate sets and finite domains in java
This presentation is the property of its rightful owner.
Sponsored Links
1 / 21

A Master-Slave Architecture to Integrate Sets and Finite Domains in Java PowerPoint PPT Presentation


  • 76 Views
  • Uploaded on
  • Presentation posted in: General

Convegno Italiano di Logica Computazionale. A Master-Slave Architecture to Integrate Sets and Finite Domains in Java. F. Bergenti E. Panegai G. Rossi Università degli Studi di Parma. Bari, 26-27 Giugno 2006. Outline of the talk. Aims:

Download Presentation

A Master-Slave Architecture to Integrate Sets and Finite Domains in Java

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


A master slave architecture to integrate sets and finite domains in java

Convegno Italiano di Logica Computazionale

A Master-Slave Architectureto Integrate Sets and Finite Domains in Java

F. Bergenti E. Panegai G. Rossi

Università degli Studi di Parma

Bari, 26-27 Giugno 2006


Outline of the talk

Outline of the talk

  • Aims:

    • Implement and validate the integration of JSetL (a set solver) and JFD (a finite domains solver);

    • Find out a generic architecture approach for a cooperation between constraint solvers;

  • The Master-Slave architecture;

  • Case study: JSetL+JFD;

  • Conclusions and future work.


Introduction

Introduction

  • Solvers are normally implemented on the basis of more or less explicit tradeoffs between:

    • Capabilities: the kinds of constraints they manage and under which assumptions; and

    • Performances: the adopted strategies, heuristics and optimizations.

  • Often single solvers cannot be used on hybrid problems. Idea: Combine several constraint solving techniques to solve problems that none of the single solvers can handle alone.

CILC 06 – Bari, 26/27 Giugno 2006


Introduction1

Meta-solver

Interface

Solver

1

Solver

2

Solver

n

Introduction

  • A common architectural outline can be found in many frameworks and architectures that explore the cooperative integration of constraint solvers:

    • A top level of meta-resolution (namely a meta-solver);

    • A set of constraint solvers; and

    • An interface between the meta-solver and the object-level solvers.

CILC 06 – Bari, 26/27 Giugno 2006


Introduction2

Meta-solver

Interface

Solver

1

Solver

2

Solver

n

Solver

1

Interface

Solver

2

Solver

n

Introduction

  • We always need a layer of meta-resolution? Often this layer implies implementation efforts to realize functionalities already present in the solvers.

  • The master-slave (M-S) approach:

    No meta-solver

    One of the solvers is opportunely selected and promoted to the role of master.


Introduction3

Introduction

  • The case study integrate two Java solvers, namely JSetL and JFD, into an added-value Java constraint solver capable of exploiting:

    • The full expressive power of JSetL, with its inherent flexibility and generality; and

    • The efficiency of JFD in treating finite integer domains variables.

  • Constraint solving algorithms are basically the same exploited in CLP(Set+FD). Moving from a logic programming framework, to an OO programming context (Java) causes some implementation decisions to become more evident.


M s constraint solving

M-S Constraint Solving

  • The general architecture:

    • Each solver is responsible for a predefined set of constraints and is equipped with a private constraint store (conjunction of atomic constraints).

    • The main task of each solver is to try to reduce any conjunction of atomic constraints to a simplified (irreducible) form.

    • One solver is selected as Master solver, all the others are Slaves (Slaves are black boxes).

    • The master is in charge of distributing tasks to, and gathering results from, the slaves.

    • The constraint distribution policy is based on a fixed a-priori mapping.


M s constraint solving selection of master

M-S Constraint Solving : Selection of Master

  • Good selection of the master:

    • The master should provide a constraint language that subsumes the union of the languages of all slaves;

    • The performances: slaves should perform better than the master in their reference domains;

    • The support for constraint programming abstractions, e.g., logical variables and nondeterminism;

    • The possibility of extending the selected solver to integrate master-specific procedures (e.g., constraint dispatching, result processing etc.); and

    • The public functionalities provided to programmers.


M s constraint solving communication

M-S Constraint Solving : Communication

  • At first stage the master needs to communicate constraints.

  • Allocation of an atomic constraint C=op(t1,...,tn):

    • (MASTER) If C is a constraint of the master and S=Ø, then the master solves it;

    • (SLAVE) If C is not a constraint of the master and SØ, then C is posted to all slaves in S;

    • (BOTH) If C is a constraint of the master and SØ, then the master posts C to all slaves in S and then solves it; or

    • (UNKNOWN) If C is not a constraint of the master and S=Ø, the allocation fails, i.e., the constraint is unknown.


M s constraint solving communication1

M-S Constraint Solving : Communication

  • Communication second stage: Interface that slave solvers provide:

    • add(C)where C is a slave constraint to be added to the constraint store of the slave;

    • get_constraints() that returns the conjunction of constraints that are present in the store of the slave;

    • solve(B) where B is a value from an enumerative type used to specify which solving process is requested.


M s constraint solving communication2

M-S Constraint Solving : Communication

  • Communication third stage: we need other glue functions for translate and filter constraints:

    • master_to_slave(Slave,C)translates a master constraint C to the corresponding slave constraint;

    • slave_to_master(Slave,D) translates a slave constraint D to the corresponding master constraint;

    • which_type(C) that allows C to be classified as belonging to one of the four types of constraints MASTER, SLAVE, BOTH and UNKNOWN; and

    • which_slave(C) that maps C to a possibly empty set of slaves that can handle it.


General constraint solving procedures

General Constraint Solving Procedures

  • The master's procedure for constraint solving:

    procedure master_solve(Constraint Store)

    repeat

    reset(Store);

    step(Store)

    until is_final_form(Store)

    end procedure;

  • Actions are repeated until the solving process terminates successfully or until it fails.

    • The process terminates successfully when no further constraint can be reduced or allocated to slaves and when all results are gathered from the constraint stores of slaves.

    • The process fails when the master, or any slave, detects an inconsistency and no further nondeterministic choices are left open.


General constraint solving procedures1

General Constraint Solving Procedures

procedure step (Constraint Store)

C = extract(Store);// Constraint C

Selected_Slaves = Ø;

while C  true do

T = which_type(C);

Slaves = which_slave(C);// Set Slaves

Selected_Slaves = Selected_Slaves υ Slaves;// Set Selected_Slaves

if T == SLAV E or T == BOTH then

for all Slave  Slaves do

Slave.add(master_to_slave(Slave, C))

end for

if T == BOTH or T == MASTER then handle_constraint(Store,C)

C = extract(Store);

end while;

for all Slave  Selected_Slaves do

Slave.solve(REDUCE);

slave_try_next(Slave, Store)

end for;

end procedure;


Nondeterminism management

Nondeterminism Management

  • The master and the slaves solvers can be sources of nondeterminism.

  • The slaves interface modules further provide the following methods:

    • next_solution() to explore the next nondeterministic alternative that a previous call to solve might have left open.

    • save() that returns a snapshot of the current state of computation of a slave; and

    • restore() that restores a previously saved state.


General constraint solving procedures2

General Constraint Solving Procedures

  • Procedure used to explore nondeterministic choices left open by slaves:

    procedure slave_try_next(Solver Slave, Constraint Store)

    Constraint D;

    either

    D = slave_to_master(Slave, Slave.get_constraints());

    if D == false then

    fail

    else

    insert(Store,D);

    end if;

    orelse// try next nondeterministic alternative

    Slave.next_solution();

    slave_try_next(Slave, Store)

    end either

    end procedure;


Case study jsetl jfd

Case Study: JSetL+JFD

  • JSetL is a library that endows Java to support general purpose declarative programming. In particular, JSetL provides:

    • logical variables,

    • unification,

    • list and set data structures,

    • constraint solving, and

    • nondeterminism.

  • JFD is a library that provides constraint solving techniques for variables with finite domains.


  • Case study jsetl jfd1

    Case Study: JSetL+JFD

    procedure step (Constraint Store)

    ... // initialization

    while C  true do

    T = which_type(C);

    Slaves = which_slave(C);// Set Slaves

    Selected_Slaves = Selected_Slaves υ Slaves;// Set Selected_Slaves

    if T == SLAV E or T == BOTH then

    for all Slave  Slaves do

    Slave.add(master_to_slave(Slave, C))

    end for

    if T == BOTH or T == MASTER then handle_constraint(Store,C)

    C = extract(Store);

    end while;

    for all Slave  Selected_Slaves do

    Slave.solve(LABEL_ALL);

    slave_try_next(Slave, Store)

    end for;

    end procedure;


    Case study jsetl jfd2

    Case Study: JSetL+JFD

    • The handle_constraint procedure of JSetL+JFD:

      procedure handle_constraint(Constraint Store, Constraint C)

      if C == op (o1,o2) then

      member(Store, C)

      else if C == op=(o1,o2) then

      equals(Store, C)

      else if ... then

      else if C == next then

      slave_try_next(Store, C) // Unroll nondeterministic choice

      end if

      end procedure


    Case study jsetl jfd3

    Case Study: JSetL+JFD

    • The procedure used to explore nondeterministic choices left open by slaves:

      procedure slave_try_next(Constraint Store, Constraint C)

      Constraint D;

      if C.get_alternative() = 0 then

      add_choice_point(next); // save computation state

      D = slave_to_master(jfd, jfd.get constraints());

      if D = false then

      fail

      else

      insert(Store,D)

      end if

      else

      jfd.next solution(); . try next nondeterministic alternative

      insert(Store, next)

      end if

      end procedure


    Case study jsetl jfd4

    Case Study: JSetL+JFD

    • Nondeterminism is confined to constraint solving:

      procedure member(Constraint Store, Constraint C)

      if C = op(o1,Ø) then

      fail

      else if C = op (o1,X) then

      insert(Store, op=(X, {o1 |N}))

      else if C = op (o1, {o2 | s}) then

      if C.get_alternative() = 0 then

      add_choice_point(C); // Save nondeterministic choice

      insert(Store, op=(o1, o2))

      else

      insert(Store, op2(o1, s))

      end if

      else if ... then

      end if

      end procedure


    Conclusions and future work

    Conclusions and Future Work

    • Extend constraints management and functionalities of JSetL+JFD.

    • Tests on solving processand labeling.

    • Tests with more slaves (i.e Solver for multisets).

    • Application on Configuration Problems.

    • Download at: http://www.math.unipr.it/~gianfr/JSetL/


  • Login