Update of /cvsroot/monetdb/MonetDB5/src/scheduler/Tests
In directory sc8-pr-cvs16.sourceforge.net:/tmp/cvs-serv31571/src/scheduler/Tests
Modified Files:
memo01.stable.out memo02.stable.out sched00.stable.out
Log Message:
The output of the instructions is cleaned up.
Amongst others, the properties of instructions are also displayed.
U = types not yet resolved
P = polymorphic instruction
G = subject to garbage control
R = subject to recycler control
J = jump towards other statement
A few tests are not handled yet.
Index: sched00.stable.out
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/scheduler/Tests/sched00.stable.out,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- sched00.stable.out 9 Dec 2007 16:21:19 -0000 1.2
+++ sched00.stable.out 15 Mar 2008 19:37:21 -0000 1.3
@@ -20,22 +20,22 @@
# io.print("done\n");
# mdb.list();
#end f;
-function user.f():void; # 0 (f:void)
- i{runonce,rows>4} := 1; # 1 (i:int)<-(_3:int)
-# just properties # 2 (_4:str)
- mdb.list(); # 3 MDBlist (_5:void)
- io.print("start running\n"); # 4 IOprint_val (_6:void)<-(_7:str)
- scheduler.isolation(); # 5 RUNisolation (_8:void)
- io.print("done\n"); # 6 IOprint_val (_9:void)<-(_10:str)
- mdb.list(); # 7 MDBlist (_11:void)
+function user.f():void; # 0 f:void
+ i{runonce,rows>4} := 1; # 1 i:int := _3:int
+# just properties
+ mdb.list(); # 3 _5:void
+ io.print("start running\n"); # 4 _6:void := IOprint_val(_7:str)
+ scheduler.isolation(); # 5 _8:void
+ io.print("done\n"); # 6 _9:void := IOprint_val(_10:str)
+ mdb.list(); # 7 _11:void
end f; # 8
#
#f(); #shows self-modification in action
#
#
-function user.main():void; # 0 (main:void)
- user.f(); # 1 (_1:void)
-#shows self-modification in action # 2 (_2:str)
+function user.main():void; # 0 main:void
+ user.f(); # 1 _1:void
+#shows self-modification in action
end main; # 3
function user.f():void;
i{runonce,rows>4} := 1;
Index: memo01.stable.out
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/scheduler/Tests/memo01.stable.out,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- memo01.stable.out 2 Jan 2008 08:23:32 -0000 1.2
+++ memo01.stable.out 15 Mar 2008 19:37:21 -0000 1.3
@@ -80,69 +80,69 @@
# answer:= scheduler.pick(T9,T10,T11,T12,T13);
# io.print(answer);
#
-function user.main():void; # 0 (main:void)
-# The first memo driven execution # 1 (_1:str)
-# use local cost functions, which leads to a hill-climber # 2 (_2:str)
-# Use the backward scheduling. # 3 (_3:str)
- A := bat.new(:int,:int); # 4 CMDBATnew
(A:bat[:int,:int])<-(_5:int)(_5:int)
- bat.insert(A,1,1); # 5 BKCinsert_bun
(_6:void)<-(A:bat[:int,:int])(_7:int)(_7:int)
- B := algebra.copy(A); # 6 ALGcopy
(B:bat[:int,:int])<-(A:bat[:int,:int])
- bat.setWriteMode(B); # 7 BKCsetWriteMode
(_9:bat[:int,:int])<-(B:bat[:int,:int])
- bat.insert(B,2,2); # 8 BKCinsert_bun
(_10:void)<-(B:bat[:int,:int])(_11:int)(_11:int)
- C := algebra.copy(B); # 9 ALGcopy
(C:bat[:int,:int])<-(B:bat[:int,:int])
- bat.setWriteMode(C); # 10 BKCsetWriteMode
(_13:bat[:int,:int])<-(C:bat[:int,:int])
- bat.insert(C,3,3); # 11 BKCinsert_bun
(_14:void)<-(C:bat[:int,:int])(_15:int)(_15:int)
- D := algebra.copy(C); # 12 ALGcopy
(D:bat[:int,:int])<-(C:bat[:int,:int])
- bat.setWriteMode(D); # 13 BKCsetWriteMode
(_17:bat[:int,:int])<-(D:bat[:int,:int])
- bat.insert(D,3,3); # 14 BKCinsert_bun
(_18:void)<-(D:bat[:int,:int])(_15:int)(_15:int)
- Acost := aggr.count(A); # 15 ALGcount_bat
(Acost:int)<-(A:bat[:int,:int])
- Bcost := aggr.count(B); # 16 ALGcount_bat
(Bcost:int)<-(B:bat[:int,:int])
- Ccost := aggr.count(C); # 17 ALGcount_bat
(Ccost:int)<-(C:bat[:int,:int])
- Dcost := aggr.count(D); # 18 ALGcount_bat
(Dcost:int)<-(D:bat[:int,:int])
- T1cost := calc.+(Acost,Bcost); # 19 CALCbinaryADDintint
(T1cost:int)<-(Acost:int)(Bcost:int)
- T2cost := calc.+(Bcost,Ccost); # 20 CALCbinaryADDintint
(T2cost:int)<-(Bcost:int)(Ccost:int)
- T3cost := calc.+(Ccost,Dcost); # 21 CALCbinaryADDintint
(T3cost:int)<-(Ccost:int)(Dcost:int)
- io.printf("choicepoint 1\n"); # 22 IOprint_str (_26:void)<-(_27:str)
- scheduler.choice(); # 23 RUNchoice (_28:void)
- T1 := algebra.join(A,B); # 24 ALGjoin
(T1:bat[:int,:int])<-(A:bat[:int,:int])(B:bat[:int,:int])
- T1cost := aggr.count(T1); # 25 ALGcount_bat
(T1cost:int)<-(T1:bat[:int,:int])
- T2 := algebra.join(B,C); # 26 ALGjoin
(T2:bat[:int,:int])<-(B:bat[:int,:int])(C:bat[:int,:int])
- T2cost := aggr.count(T2); # 27 ALGcount_bat
(T2cost:int)<-(T2:bat[:int,:int])
- T3 := algebra.join(C,D); # 28 ALGjoin
(T3:bat[:int,:int])<-(C:bat[:int,:int])(D:bat[:int,:int])
- T3cost := aggr.count(T3); # 29 ALGcount_bat
(T3cost:int)<-(T3:bat[:int,:int])
- io.printf("choicepoint 2\n"); # 30 IOprint_str (_32:void)<-(_33:str)
- scheduler.choice(T1cost,T1,T2cost,T2,T3cost,T3); # 31 RUNchoice
(_34:void)<-(T1cost:int)(T1:bat[:int,:int])(T2cost:int)(T2:bat[:int,:int])(T3cost:int)(T3:bat[:int,:int])
- T4cost := calc.+(T1cost,Ccost); # 32 CALCbinaryADDintint
(T4cost:int)<-(T1cost:int)(Ccost:int)
- T5cost := calc.+(Acost,T2cost); # 33 CALCbinaryADDintint
(T5cost:int)<-(Acost:int)(T2cost:int)
- T6cost := calc.+(T2cost,Dcost); # 34 CALCbinaryADDintint
(T6cost:int)<-(T2cost:int)(Dcost:int)
- T7cost := calc.+(Bcost,T3cost); # 35 CALCbinaryADDintint
(T7cost:int)<-(Bcost:int)(T3cost:int)
- T8cost := calc.+(Ccost,Dcost); # 36 CALCbinaryADDintint
(T8cost:int)<-(Ccost:int)(Dcost:int)
- T4 := algebra.join(T1,C); # 37 ALGjoin
(T4:bat[:int,:int])<-(T1:bat[:int,:int])(C:bat[:int,:int])
- T4cost := aggr.count(T4); # 38 ALGcount_bat
(T4cost:int)<-(T4:bat[:int,:int])
- T5 := algebra.join(A,T2); # 39 ALGjoin
(T5:bat[:int,:int])<-(A:bat[:int,:int])(T2:bat[:int,:int])
- T5cost := aggr.count(T5); # 40 ALGcount_bat
(T5cost:int)<-(T5:bat[:int,:int])
- T6 := algebra.join(T2,D); # 41 ALGjoin
(T6:bat[:int,:int])<-(T2:bat[:int,:int])(D:bat[:int,:int])
- T6cost := aggr.count(T6); # 42 ALGcount_bat
(T6cost:int)<-(T6:bat[:int,:int])
- T7 := algebra.join(B,T3); # 43 ALGjoin
(T7:bat[:int,:int])<-(B:bat[:int,:int])(T3:bat[:int,:int])
- T7cost := aggr.count(T7); # 44 ALGcount_bat
(T7cost:int)<-(T7:bat[:int,:int])
- T8 := algebra.join(C,D); # 45 ALGjoin
(T8:bat[:int,:int])<-(C:bat[:int,:int])(D:bat[:int,:int])
- T8cost := aggr.count(T8); # 46 ALGcount_bat
(T8cost:int)<-(T8:bat[:int,:int])
- io.printf("choicepoint 3\n"); # 47 IOprint_str (_45:void)<-(_46:str)
- scheduler.choice(T4cost,T4,T5cost,T5,T6cost,T6,T7cost,T7,T8cost,T8);
# 48 RUNchoice
(_47:void)<-(T4cost:int)(T4:bat[:int,:int])(T5cost:int)(T5:bat[:int,:int])(T6cost:int)(T6:bat[:int,:int])(T7cost:int)(T7:bat[:int,:int])(T8cost:int)(T8:bat[:int,:int])
- T9cost := calc.+(T2cost,Dcost); # 49 CALCbinaryADDintint
(T9cost:int)<-(T2cost:int)(Dcost:int)
- T10cost := calc.+(T5cost,Dcost); # 50 CALCbinaryADDintint
(T10cost:int)<-(T5cost:int)(Dcost:int)
- T11cost := calc.+(Acost,T6cost); # 51 CALCbinaryADDintint
(T11cost:int)<-(Acost:int)(T6cost:int)
- T12cost := calc.+(Acost,T7cost); # 52 CALCbinaryADDintint
(T12cost:int)<-(Acost:int)(T7cost:int)
- T13cost := calc.+(T1cost,T8cost); # 53 CALCbinaryADDintint
(T13cost:int)<-(T1cost:int)(T8cost:int)
- T9 := algebra.join(T4,D); # 54 ALGjoin
(T9:bat[:int,:int])<-(T4:bat[:int,:int])(D:bat[:int,:int])
- T10 := algebra.join(T5,D); # 55 ALGjoin
(T10:bat[:int,:int])<-(T5:bat[:int,:int])(D:bat[:int,:int])
- T11 := algebra.join(A,T6); # 56 ALGjoin
(T11:bat[:int,:int])<-(A:bat[:int,:int])(T6:bat[:int,:int])
- T12 := algebra.join(A,T7); # 57 ALGjoin
(T12:bat[:int,:int])<-(A:bat[:int,:int])(T7:bat[:int,:int])
- T13 := algebra.join(T1,T8); # 58 ALGjoin
(T13:bat[:int,:int])<-(T1:bat[:int,:int])(T8:bat[:int,:int])
- io.printf("choicepoint 4\n"); # 59 IOprint_str (_58:void)<-(_59:str)
-
scheduler.choice(T9cost,T9,T10cost,T10,T11cost,T11,T12cost,T12,T13cost,T13);
# 60 RUNchoice
(_60:void)<-(T9cost:int)(T9:bat[:int,:int])(T10cost:int)(T10:bat[:int,:int])(T11cost:int)(T11:bat[:int,:int])(T12cost:int)(T12:bat[:int,:int])(T13cost:int)(T13:bat[:int,:int])
- answer := scheduler.pick(T9,T10,T11,T12,T13); # 61 RUNpickResult
(answer:bat[:int,:int])<-(T9:bat[:int,:int])(T10:bat[:int,:int])(T11:bat[:int,:int])(T12:bat[:int,:int])(T13:bat[:int,:int])
- io.print(answer); # 62 IOprint_val (_62:void)<-(answer:bat[:int,:int])
+function user.main():void; # 0 main:void {G}
+# The first memo driven execution
+# use local cost functions, which leads to a hill-climber
+# Use the backward scheduling.
+ A := bat.new(:int,:int); # 4 A:bat[:int,:int] :=
CMDBATnew(_5:int, _5:int) {G}
+ bat.insert(A,1,1); # 5 _6:void :=
BKCinsert_bun(A:bat[:int,:int], _7:int, _7:int)
+ B := algebra.copy(A); # 6 B:bat[:int,:int] :=
ALGcopy(A:bat[:int,:int]) {G}
+ bat.setWriteMode(B); # 7 _9:bat[:int,:int] :=
BKCsetWriteMode(B:bat[:int,:int]) {G}
+ bat.insert(B,2,2); # 8 _10:void :=
BKCinsert_bun(B:bat[:int,:int], _11:int, _11:int)
+ C := algebra.copy(B); # 9 C:bat[:int,:int] :=
ALGcopy(B:bat[:int,:int]) {G}
+ bat.setWriteMode(C); # 10 _13:bat[:int,:int] :=
BKCsetWriteMode(C:bat[:int,:int]) {G}
+ bat.insert(C,3,3); # 11 _14:void :=
BKCinsert_bun(C:bat[:int,:int], _15:int, _15:int)
+ D := algebra.copy(C); # 12 D:bat[:int,:int] :=
ALGcopy(C:bat[:int,:int]) {G}
+ bat.setWriteMode(D); # 13 _17:bat[:int,:int] :=
BKCsetWriteMode(D:bat[:int,:int]) {G}
+ bat.insert(D,3,3); # 14 _18:void :=
BKCinsert_bun(D:bat[:int,:int], _15:int, _15:int)
+ Acost := aggr.count(A); # 15 Acost:int :=
ALGcount_bat(A:bat[:int,:int])
+ Bcost := aggr.count(B); # 16 Bcost:int :=
ALGcount_bat(B:bat[:int,:int])
+ Ccost := aggr.count(C); # 17 Ccost:int :=
ALGcount_bat(C:bat[:int,:int])
+ Dcost := aggr.count(D); # 18 Dcost:int :=
ALGcount_bat(D:bat[:int,:int])
+ T1cost := calc.+(Acost,Bcost); # 19 T1cost:int :=
CALCbinaryADDintint(Acost:int, Bcost:int)
+ T2cost := calc.+(Bcost,Ccost); # 20 T2cost:int :=
CALCbinaryADDintint(Bcost:int, Ccost:int)
+ T3cost := calc.+(Ccost,Dcost); # 21 T3cost:int :=
CALCbinaryADDintint(Ccost:int, Dcost:int)
+ io.printf("choicepoint 1\n"); # 22 _26:void := IOprint_str(_27:str)
+ scheduler.choice(); # 23 _28:void
+ T1 := algebra.join(A,B); # 24 T1:bat[:int,:int] :=
ALGjoin(A:bat[:int,:int], B:bat[:int,:int]) {G}
+ T1cost := aggr.count(T1); # 25 T1cost:int :=
ALGcount_bat(T1:bat[:int,:int])
+ T2 := algebra.join(B,C); # 26 T2:bat[:int,:int] :=
ALGjoin(B:bat[:int,:int], C:bat[:int,:int]) {G}
+ T2cost := aggr.count(T2); # 27 T2cost:int :=
ALGcount_bat(T2:bat[:int,:int])
+ T3 := algebra.join(C,D); # 28 T3:bat[:int,:int] :=
ALGjoin(C:bat[:int,:int], D:bat[:int,:int]) {G}
+ T3cost := aggr.count(T3); # 29 T3cost:int :=
ALGcount_bat(T3:bat[:int,:int])
+ io.printf("choicepoint 2\n"); # 30 _32:void := IOprint_str(_33:str)
+ scheduler.choice(T1cost,T1,T2cost,T2,T3cost,T3);# 31 _34:void :=
RUNchoice(T1cost:int, T1:bat[:int,:int], T2cost:int, T2:bat[:int,:int],
T3cost:int, T3:bat[:int,:int])
+ T4cost := calc.+(T1cost,Ccost); # 32 T4cost:int :=
CALCbinaryADDintint(T1cost:int, Ccost:int)
+ T5cost := calc.+(Acost,T2cost); # 33 T5cost:int :=
CALCbinaryADDintint(Acost:int, T2cost:int)
+ T6cost := calc.+(T2cost,Dcost); # 34 T6cost:int :=
CALCbinaryADDintint(T2cost:int, Dcost:int)
+ T7cost := calc.+(Bcost,T3cost); # 35 T7cost:int :=
CALCbinaryADDintint(Bcost:int, T3cost:int)
+ T8cost := calc.+(Ccost,Dcost); # 36 T8cost:int :=
CALCbinaryADDintint(Ccost:int, Dcost:int)
+ T4 := algebra.join(T1,C); # 37 T4:bat[:int,:int] :=
ALGjoin(T1:bat[:int,:int], C:bat[:int,:int]) {G}
+ T4cost := aggr.count(T4); # 38 T4cost:int :=
ALGcount_bat(T4:bat[:int,:int])
+ T5 := algebra.join(A,T2); # 39 T5:bat[:int,:int] :=
ALGjoin(A:bat[:int,:int], T2:bat[:int,:int]) {G}
+ T5cost := aggr.count(T5); # 40 T5cost:int :=
ALGcount_bat(T5:bat[:int,:int])
+ T6 := algebra.join(T2,D); # 41 T6:bat[:int,:int] :=
ALGjoin(T2:bat[:int,:int], D:bat[:int,:int]) {G}
+ T6cost := aggr.count(T6); # 42 T6cost:int :=
ALGcount_bat(T6:bat[:int,:int])
+ T7 := algebra.join(B,T3); # 43 T7:bat[:int,:int] :=
ALGjoin(B:bat[:int,:int], T3:bat[:int,:int]) {G}
+ T7cost := aggr.count(T7); # 44 T7cost:int :=
ALGcount_bat(T7:bat[:int,:int])
+ T8 := algebra.join(C,D); # 45 T8:bat[:int,:int] :=
ALGjoin(C:bat[:int,:int], D:bat[:int,:int]) {G}
+ T8cost := aggr.count(T8); # 46 T8cost:int :=
ALGcount_bat(T8:bat[:int,:int])
+ io.printf("choicepoint 3\n"); # 47 _45:void := IOprint_str(_46:str)
+ scheduler.choice(T4cost,T4,T5cost,T5,T6cost,T6,T7cost,T7,T8cost,T8);# 48
_47:void := RUNchoice(T4cost:int, T4:bat[:int,:int], T5cost:int,
T5:bat[:int,:int], T6cost:int, T6:bat[:int,:int], T7cost:int,
T7:bat[:int,:int], T8cost:int, T8:bat[:int,:int])
+ T9cost := calc.+(T2cost,Dcost); # 49 T9cost:int :=
CALCbinaryADDintint(T2cost:int, Dcost:int)
+ T10cost := calc.+(T5cost,Dcost); # 50 T10cost:int :=
CALCbinaryADDintint(T5cost:int, Dcost:int)
+ T11cost := calc.+(Acost,T6cost); # 51 T11cost:int :=
CALCbinaryADDintint(Acost:int, T6cost:int)
+ T12cost := calc.+(Acost,T7cost); # 52 T12cost:int :=
CALCbinaryADDintint(Acost:int, T7cost:int)
+ T13cost := calc.+(T1cost,T8cost); # 53 T13cost:int :=
CALCbinaryADDintint(T1cost:int, T8cost:int)
+ T9 := algebra.join(T4,D); # 54 T9:bat[:int,:int] :=
ALGjoin(T4:bat[:int,:int], D:bat[:int,:int]) {G}
+ T10 := algebra.join(T5,D); # 55 T10:bat[:int,:int] :=
ALGjoin(T5:bat[:int,:int], D:bat[:int,:int]) {G}
+ T11 := algebra.join(A,T6); # 56 T11:bat[:int,:int] :=
ALGjoin(A:bat[:int,:int], T6:bat[:int,:int]) {G}
+ T12 := algebra.join(A,T7); # 57 T12:bat[:int,:int] :=
ALGjoin(A:bat[:int,:int], T7:bat[:int,:int]) {G}
+ T13 := algebra.join(T1,T8); # 58 T13:bat[:int,:int] :=
ALGjoin(T1:bat[:int,:int], T8:bat[:int,:int]) {G}
+ io.printf("choicepoint 4\n"); # 59 _58:void := IOprint_str(_59:str)
+
scheduler.choice(T9cost,T9,T10cost,T10,T11cost,T11,T12cost,T12,T13cost,T13);#
60 _60:void := RUNchoice(T9cost:int, T9:bat[:int,:int], T10cost:int,
T10:bat[:int,:int], T11cost:int, T11:bat[:int,:int], T12cost:int,
T12:bat[:int,:int], T13cost:int, T13:bat[:int,:int])
+ answer := scheduler.pick(T9,T10,T11,T12,T13);# 61 answer:bat[:int,:int] :=
RUNpickResult(T9:bat[:int,:int], T10:bat[:int,:int], T11:bat[:int,:int],
T12:bat[:int,:int], T13:bat[:int,:int]) {G}
+ io.print(answer); # 62 _62:void :=
IOprint_val(answer:bat[:int,:int])
end main; # 63
choicepoint 1
choicepoint 2
Index: memo02.stable.out
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/scheduler/Tests/memo02.stable.out,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- memo02.stable.out 13 Mar 2007 22:27:51 -0000 1.2
+++ memo02.stable.out 15 Mar 2008 19:37:21 -0000 1.3
@@ -42,39 +42,39 @@
# answer:= scheduler.pick(T9,T10,T11,T12,T13);
# io.print(answer);
#
-function user.main():void; # 0 (main:void)
-# The first memo driven execution # 1 (_1:str)
-# use a generic cost function # 2 (_2:str)
- A := bat.new(:int,:int); # 3 CMDBATnew
(A:bat[:int,:int])<-(_4:int)(_4:int)
- bat.insert(A,1,1); # 4 BKCinsert_bun
(_5:void)<-(A:bat[:int,:int])(_6:int)(_6:int)
- B := algebra.copy(A); # 5 ALGcopy
(B:bat[:int,:int])<-(A:bat[:int,:int])
- bat.setWriteMode(B); # 6 BKCsetWriteMode
(_8:bat[:int,:int])<-(B:bat[:int,:int])
- bat.insert(B,2,2); # 7 BKCinsert_bun
(_9:void)<-(B:bat[:int,:int])(_10:int)(_10:int)
- C := algebra.copy(B); # 8 ALGcopy
(C:bat[:int,:int])<-(B:bat[:int,:int])
- bat.setWriteMode(C); # 9 BKCsetWriteMode
(_12:bat[:int,:int])<-(C:bat[:int,:int])
- bat.insert(C,3,3); # 10 BKCinsert_bun
(_13:void)<-(C:bat[:int,:int])(_14:int)(_14:int)
- D := algebra.copy(C); # 11 ALGcopy
(D:bat[:int,:int])<-(C:bat[:int,:int])
- bat.setWriteMode(D); # 12 BKCsetWriteMode
(_16:bat[:int,:int])<-(D:bat[:int,:int])
- bat.insert(D,3,3); # 13 BKCinsert_bun
(_17:void)<-(D:bat[:int,:int])(_14:int)(_14:int)
- scheduler.choice(); # 14 RUNchoice (_18:void)
- T1 := algebra.join(A,B); # 15 ALGjoin
(T1:bat[:int,:int])<-(A:bat[:int,:int])(B:bat[:int,:int])
- T2 := algebra.join(B,C); # 16 ALGjoin
(T2:bat[:int,:int])<-(B:bat[:int,:int])(C:bat[:int,:int])
- T3 := algebra.join(C,D); # 17 ALGjoin
(T3:bat[:int,:int])<-(C:bat[:int,:int])(D:bat[:int,:int])
- scheduler.choice("getVolume",T1,T2,T3); # 18 RUNchoice
(_22:void)<-(_23:str)(T1:bat[:int,:int])(T2:bat[:int,:int])(T3:bat[:int,:int])
- T4 := algebra.join(T1,C); # 19 ALGjoin
(T4:bat[:int,:int])<-(T1:bat[:int,:int])(C:bat[:int,:int])
- T5 := algebra.join(A,T2); # 20 ALGjoin
(T5:bat[:int,:int])<-(A:bat[:int,:int])(T2:bat[:int,:int])
- T6 := algebra.join(T2,D); # 21 ALGjoin
(T6:bat[:int,:int])<-(T2:bat[:int,:int])(D:bat[:int,:int])
- T7 := algebra.join(B,T3); # 22 ALGjoin
(T7:bat[:int,:int])<-(B:bat[:int,:int])(T3:bat[:int,:int])
- T8 := algebra.join(C,D); # 23 ALGjoin
(T8:bat[:int,:int])<-(C:bat[:int,:int])(D:bat[:int,:int])
- scheduler.choice("getVolume",T4,T5,T6,T7,T8); # 24 RUNchoice
(_29:void)<-(_23:str)(T4:bat[:int,:int])(T5:bat[:int,:int])(T6:bat[:int,:int])(T7:bat[:int,:int])(T8:bat[:int,:int])
- T9 := algebra.join(T4,D); # 25 ALGjoin
(T9:bat[:int,:int])<-(T4:bat[:int,:int])(D:bat[:int,:int])
- T10 := algebra.join(T5,D); # 26 ALGjoin
(T10:bat[:int,:int])<-(T5:bat[:int,:int])(D:bat[:int,:int])
- T11 := algebra.join(A,T6); # 27 ALGjoin
(T11:bat[:int,:int])<-(A:bat[:int,:int])(T6:bat[:int,:int])
- T12 := algebra.join(A,T7); # 28 ALGjoin
(T12:bat[:int,:int])<-(A:bat[:int,:int])(T7:bat[:int,:int])
- T13 := algebra.join(T1,T8); # 29 ALGjoin
(T13:bat[:int,:int])<-(T1:bat[:int,:int])(T8:bat[:int,:int])
- scheduler.choice("getVolume",T9,T10,T11,T12,T13); # 30 RUNchoice
(_35:void)<-(_23:str)(T9:bat[:int,:int])(T10:bat[:int,:int])(T11:bat[:int,:int])(T12:bat[:int,:int])(T13:bat[:int,:int])
- answer := scheduler.pick(T9,T10,T11,T12,T13); # 31 RUNpickResult
(answer:bat[:int,:int])<-(T9:bat[:int,:int])(T10:bat[:int,:int])(T11:bat[:int,:int])(T12:bat[:int,:int])(T13:bat[:int,:int])
- io.print(answer); # 32 IOprint_val (_37:void)<-(answer:bat[:int,:int])
+function user.main():void; # 0 main:void {G}
+# The first memo driven execution
+# use a generic cost function
+ A := bat.new(:int,:int); # 3 A:bat[:int,:int] :=
CMDBATnew(_4:int, _4:int) {G}
+ bat.insert(A,1,1); # 4 _5:void :=
BKCinsert_bun(A:bat[:int,:int], _6:int, _6:int)
+ B := algebra.copy(A); # 5 B:bat[:int,:int] :=
ALGcopy(A:bat[:int,:int]) {G}
+ bat.setWriteMode(B); # 6 _8:bat[:int,:int] :=
BKCsetWriteMode(B:bat[:int,:int]) {G}
+ bat.insert(B,2,2); # 7 _9:void :=
BKCinsert_bun(B:bat[:int,:int], _10:int, _10:int)
+ C := algebra.copy(B); # 8 C:bat[:int,:int] :=
ALGcopy(B:bat[:int,:int]) {G}
+ bat.setWriteMode(C); # 9 _12:bat[:int,:int] :=
BKCsetWriteMode(C:bat[:int,:int]) {G}
+ bat.insert(C,3,3); # 10 _13:void :=
BKCinsert_bun(C:bat[:int,:int], _14:int, _14:int)
+ D := algebra.copy(C); # 11 D:bat[:int,:int] :=
ALGcopy(C:bat[:int,:int]) {G}
+ bat.setWriteMode(D); # 12 _16:bat[:int,:int] :=
BKCsetWriteMode(D:bat[:int,:int]) {G}
+ bat.insert(D,3,3); # 13 _17:void :=
BKCinsert_bun(D:bat[:int,:int], _14:int, _14:int)
+ scheduler.choice(); # 14 _18:void
+ T1 := algebra.join(A,B); # 15 T1:bat[:int,:int] :=
ALGjoin(A:bat[:int,:int], B:bat[:int,:int]) {G}
+ T2 := algebra.join(B,C); # 16 T2:bat[:int,:int] :=
ALGjoin(B:bat[:int,:int], C:bat[:int,:int]) {G}
+ T3 := algebra.join(C,D); # 17 T3:bat[:int,:int] :=
ALGjoin(C:bat[:int,:int], D:bat[:int,:int]) {G}
+ scheduler.choice("getVolume",T1,T2,T3);# 18 _22:void := RUNchoice(_23:str,
T1:bat[:int,:int], T2:bat[:int,:int], T3:bat[:int,:int])
+ T4 := algebra.join(T1,C); # 19 T4:bat[:int,:int] :=
ALGjoin(T1:bat[:int,:int], C:bat[:int,:int]) {G}
+ T5 := algebra.join(A,T2); # 20 T5:bat[:int,:int] :=
ALGjoin(A:bat[:int,:int], T2:bat[:int,:int]) {G}
+ T6 := algebra.join(T2,D); # 21 T6:bat[:int,:int] :=
ALGjoin(T2:bat[:int,:int], D:bat[:int,:int]) {G}
+ T7 := algebra.join(B,T3); # 22 T7:bat[:int,:int] :=
ALGjoin(B:bat[:int,:int], T3:bat[:int,:int]) {G}
+ T8 := algebra.join(C,D); # 23 T8:bat[:int,:int] :=
ALGjoin(C:bat[:int,:int], D:bat[:int,:int]) {G}
+ scheduler.choice("getVolume",T4,T5,T6,T7,T8);# 24 _29:void :=
RUNchoice(_23:str, T4:bat[:int,:int], T5:bat[:int,:int], T6:bat[:int,:int],
T7:bat[:int,:int], T8:bat[:int,:int])
+ T9 := algebra.join(T4,D); # 25 T9:bat[:int,:int] :=
ALGjoin(T4:bat[:int,:int], D:bat[:int,:int]) {G}
+ T10 := algebra.join(T5,D); # 26 T10:bat[:int,:int] :=
ALGjoin(T5:bat[:int,:int], D:bat[:int,:int]) {G}
+ T11 := algebra.join(A,T6); # 27 T11:bat[:int,:int] :=
ALGjoin(A:bat[:int,:int], T6:bat[:int,:int]) {G}
+ T12 := algebra.join(A,T7); # 28 T12:bat[:int,:int] :=
ALGjoin(A:bat[:int,:int], T7:bat[:int,:int]) {G}
+ T13 := algebra.join(T1,T8); # 29 T13:bat[:int,:int] :=
ALGjoin(T1:bat[:int,:int], T8:bat[:int,:int]) {G}
+ scheduler.choice("getVolume",T9,T10,T11,T12,T13);# 30 _35:void :=
RUNchoice(_23:str, T9:bat[:int,:int], T10:bat[:int,:int], T11:bat[:int,:int],
T12:bat[:int,:int], T13:bat[:int,:int])
+ answer := scheduler.pick(T9,T10,T11,T12,T13);# 31 answer:bat[:int,:int] :=
RUNpickResult(T9:bat[:int,:int], T10:bat[:int,:int], T11:bat[:int,:int],
T12:bat[:int,:int], T13:bat[:int,:int]) {G}
+ io.print(answer); # 32 _37:void :=
IOprint_val(answer:bat[:int,:int])
end main; # 33
#-----------------#
# h t # name
-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Monetdb-checkins mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/monetdb-checkins
