Hierarchical Constraint Parallel Solver: P-CHAL

OVERVIEW:
A parallel solver for constraint hierarchy
which introduces hierarchy in terms of strength of constraints.

EXPLANATION:
Hierarchical constraint parallel solver P-CHAL
is based on new programming paradigm ``constraint programming''
which allows user a high-level description in problem solving.
P-CHAL is a parallel constraint solver which manipulates
various strength of constraints in various domains.

(1) Parallel Solving of Constraint Hierarchy:
P-CHAL reduces computational costs by a bottom-up calculation of
maximal consistent sets and parallel processing of GDCC.

(2) Constraints Solvers for Various Domains:
P-CHAL provides constraint solvers for non-linear algebraic equations
and Boolean equations for various domains of users.  User can specify
various strength for these constraints.

EXAMPLE
The following is an example session of P-CHAL.

*** KL1 LISTENER (V 3.400 29-Apr-92) ***
DEFAULT PACKAGE   : bool
CURRENT DIRECTORY : >sys>user>ksatoh>gdcc_bool

[1] change_macro(gdcc:: gdcc_expander) .
 [pimos] => [gdcc:: gdcc_expander]

[2]  # set_mode(go) .

[3] default_package gdcc .

[4] display_variables(no) .

[5] remember .

[6]  # register(alg,alg) .

[7]  # register(bool,bool) .

[8] statistics .
 663 reductions
 932 msec

[9] compile("pchal.gdcc") .
** KL1 Compiler **
Parameter File : "icpsi556::>sys>user>ksatoh>gdcc_bool>compile.param.3"

Compile File : icpsi556::>sys>user>ksatoh>gdcc_bool>pchal.gdcc.9
*** Translating module pchal ***
*** Analyzing ***
*** Normalizing ***
*** Transforming ***
*** Optimize ***
*** Output ***
[pchal.gdcc] Compile Module : pchal
Compile Succeeded : pchal

"gdcc:: pchal" Updated
Compilation(s) Succeeded
Compilation Time = 241413 [MSEC]
 1752444 reductions
 243199 msec

[10] compile("gear.gdcc") .
** KL1 Compiler **
Parameter File : "icpsi556::>sys>user>ksatoh>gdcc_bool>compile.param.3"

Compile File : icpsi556::>sys>user>ksatoh>gdcc_bool>gear.gdcc.1
*** Translating module gear ***
*** Analyzing ***
*** Normalizing ***
*** Transforming ***
*** Optimize ***
*** Output ***
[gear.gdcc] Compile Module : gear
Compile Succeeded : gear

"gdcc:: gear" Updated
Compilation(s) Succeeded
Compilation Time = 43674 [MSEC]
 377651 reductions
 45450 msec

[11]  # use(alg) .
 4 reductions
 7 msec

[12] alg# alloc(100,R1,R2,R3,R4,R5,R6,R7,R8,X1,X2) .
 1360 reductions
 933 msec

[13] gear: gear(16,R1,R2,R3,R4,R5,R6,R7,R8,X1,X2) .
R1 = 3
R2 = 4
R3 = 3
R4 = 2
R5 = 2
R6 = (16/5)
R7 = 2
R8 = (4/5)
X1 = 6
X2 = 4

 18958136 reductions
 69577 msec

[14] compile("meeting.gdcc") .
** KL1 Compiler **
Parameter File : "icpsi556::>sys>user>ksatoh>gdcc_bool>compile.param.3"

Compile File : icpsi556::>sys>user>ksatoh>gdcc_bool>meeting.gdcc.23
*** Translating module meeting ***
*** Analyzing ***
*** Normalizing ***
*** Transforming ***
*** Optimize ***
*** Output ***
[meeting.gdcc] Compile Module : meeting
Compile Succeeded : meeting

"gdcc:: meeting" Updated
Compilation(s) Succeeded
Compilation Time = 51686 [MSEC]
 379950 reductions
 53868 msec

[15]  # use(bool) .
 4 reductions
 7 msec

[16] bool# alloc(100,Cmon,Pmon,Vmon,Mmon,Ctue,Ptue,Vtue,Mtue,Cwed,Pwed,Vwed,Mwed) .
 2830 reductions
 834 msec

[17] meeting: meeting1(Cmon,Pmon,Vmon,Mmon,Ctue,Ptue,Vtue,Mtue,Cwed,Pwed,Vwed,Mwed) .
Mwed = 1
Vwed = 1
Pwed = 1
Cwed = 1
Mtue = 0
Vtue = 0
Ptue = 0
Ctue = 0
Mmon = 0
Vmon = 0
Pmon = 0
Cmon = 0

 33594 reductions
 3342 msec

[18] meeting: meeting2(Cmon,Pmon,Vmon,Mmon,Ctue,Ptue,Vtue,Mtue,Cwed,Pwed,Vwed,Mwed) .
Mwed = 0
Vwed = 0
Pwed = 0
Cwed = 0
Mtue = 0
Vtue = 1
Ptue = 1
Ctue = 1
Mmon = 0
Vmon = 0
Pmon = 0
Cmon = 0

 28154 reductions
 2919 msec

 % End of take ( icpsi556::>sys>user>ksatoh>gdcc_bool>gdcc.com.10 ) %

[19] exit.
 Do you really exit?(y/n <cr>)y
------------------------------------------------------------------------
Notes:
You must compile "pchal.gdcc" beforehand.
If you use algebraic solver in your program, then you must specify it
by the command "#use(alg)".
If you use boolean solver in your program, then you must specify it
by the command "#use(bool)".
You can register soft constraints into constraint hierarchy by calling
"pchal:soft(Constraint,Strength,CHin,CHout)"
where initial data of CHin is [].
You can invoke a hierarchical constraint solver by calling
"pchal:solve_hierarchy(DomainName,
                       Number_of_PE,
                       HardConstraint,
                       ConstraintHierarchy)"
where DomainName is alg or bool.

LIST OF FILES
chal.dvi: DVI file for a paper which explains the background of CHAL.
copy.kl1: copying facility for memory management
gdcc.com: gdcc command file for pchal
gear.gdcc: example for gear design problem using algebraic solver.
meeting.gdcc: example for meeting scheduling problem using boolean solver.
pchal.gdcc: hierarchical constraint solver in parallel
shell.com: shell command file
compile.param: Parameter list for compiler

NOTES ON INSTALLATION
You need environment of GDCC/PIMOS/KL1.
Invoke GDCC and compile pchal.gdcc.

REFERENCE
Please refer a user's manual for GDCC.
