Calcom/calcom2.result

   1         Objective Caml version 3.00
   2
   3         Symbolic Parameterized Polyhedral Calculator version 1.00b
   4           (type: 'help ();;' for help)
   5
   6 # type distribute = STAR | CYCLIC | N_CYCLIC of int | BLOCK | N_BLOCK of int
   7 type problem = {
   8   parameters : string list;
   9   processors : string list * string list;
  10   template : string list * string list;
  11   distribution : distribute list;
  12   write : string * string list * string list;
  13   read : string * string list * string list;
  14   align_write : string list;
  15   align_read : string list;
  16   iteration : string * string list * string list;
  17   subscripts_write : string list;
  18   subscripts_read : string list;
  19 }
  20 type solution = {
  21   vector_parameters : SPPoC.Expr.t list ref;
  22   vector_processors : SPPoC.Expr.t list ref;
  23   vector_write : SPPoC.Expr.t list ref;
  24   vector_read : SPPoC.Expr.t list ref;
  25   vector_template : SPPoC.Expr.t list ref;
  26   vector_template_param_write : SPPoC.Expr.t list ref;
  27   vector_template_param_read : SPPoC.Expr.t list ref;
  28   vector_iteration : SPPoC.Expr.t list ref;
  29   vector_iteration_param : SPPoC.Expr.t list ref;
  30   domain_processors : SPPoC.Polyhedron.t ref;
  31   domain_write : SPPoC.Polyhedron.t ref;
  32   domain_read : SPPoC.Polyhedron.t ref;
  33   domain_iteration : SPPoC.Polyhedron.t ref;
  34   domain_template : SPPoC.Polyhedron.t ref;
  35   domain_write_param : SPPoC.Polyhedron.t ref;
  36   domain_read_param : SPPoC.Polyhedron.t ref;
  37   domain_communications : SPPoC.Polyhedron.t ref;
  38   system_distribution : SPPoC.System.t ref;
  39   system_problem : SPPoC.System.t ref;
  40   system_problem_simplified : SPPoC.System.t ref;
  41   write_delta : SPPoC.Function.t ref;
  42   write_gamma : SPPoC.Function.t ref;
  43   write_phi : SPPoC.Function.t ref;
  44   read_delta : SPPoC.Function.t ref;
  45   read_gamma : SPPoC.Function.t ref;
  46   read_phi : SPPoC.Function.t ref;
  47   solution : SPPoC.Polyhedron.expr_quast ref;
  48 }
  49 val char_processors : string = p
  50 val char_template : string = t
  51 val char_param_prefix : string = p
  52 val char_template_param_write : string = ptw
  53 val char_template_param_read : string = ptr
  54 val build_vector : string -> int -> SPPoC.Expr.t list = <fun>
  55 val constant_vector : string -> int -> SPPoC.Expr.t list = <fun>
  56 val make_vector : string list -> SPPoC.Expr.t list = <fun>
  57 val vector_to_list : SPPoC.Expr.t list -> string list = <fun>
  58 val ( |+ ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Expr.t list =
  59   <fun>
  60 val ( |- ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Expr.t list =
  61   <fun>
  62 val ( |* ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Expr.t list =
  63   <fun>
  64 val ( |: ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Expr.t list =
  65   <fun>
  66 val ( |/ ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Expr.t list =
  67   <fun>
  68 val ( |% ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Expr.t list =
  69   <fun>
  70 val ( |>= ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Ineq.t list =
  71   <fun>
  72 val ( |<= ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Ineq.t list =
  73   <fun>
  74 val ( |> ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Ineq.t list =
  75   <fun>
  76 val ( |< ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Ineq.t list =
  77   <fun>
  78 val ( |= ) : SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Ineq.t list =
  79   <fun>
  80 val function_of_vectors :
  81   SPPoC.Expr.t list -> SPPoC.Expr.t list -> SPPoC.Function.t = <fun>
  82 val void_function : SPPoC.Function.t = [ not_defined ] <- [ not_defined ]
  83 val void_polyhedron : SPPoC.Polyhedron.t = {({0 = 1}, {})}
  84 val void_system : SPPoC.System.t = {}
  85 val void_solution : solution =
  86   {vector_parameters={contents=[]}; vector_processors={contents=[]};
  87    vector_write={contents=[]}; vector_read={contents=[]};
  88    vector_template={contents=[]}; vector_template_param_write={contents=[]};
  89    vector_template_param_read={contents=[]}; vector_iteration={contents=[]};
  90    vector_iteration_param={contents=[]};
  91    domain_processors={contents={({0 = 1}, {})}};
  92    domain_write={contents={({0 = 1}, {})}};
  93    domain_read={contents={({0 = 1}, {})}};
  94    domain_iteration={contents={({0 = 1}, {})}};
  95    domain_template={contents={({0 = 1}, {})}};
  96    domain_write_param={contents={({0 = 1}, {})}};
  97    domain_read_param={contents={({0 = 1}, {})}};
  98    domain_communications={contents={({0 = 1}, {})}};
  99    system_distribution={contents={}}; system_problem={contents={}};
 100    system_problem_simplified={contents={}};
 101    write_delta={contents=[ not_defined ] <- [ not_defined ]};
 102    write_gamma={contents=[ not_defined ] <- [ not_defined ]};
 103    write_phi={contents=[ not_defined ] <- [ not_defined ]};
 104    read_delta={contents=[ not_defined ] <- [ not_defined ]};
 105    read_gamma={contents=[ not_defined ] <- [ not_defined ]};
 106    read_phi={contents=[ not_defined ] <- [ not_defined ]};
 107    solution={contents=[]}}
 108 val build_bounds :
 109   string ->
 110   string list * string list ->
 111   string -> SPPoC.Expr.t list * SPPoC.Polyhedron.t = <fun>
 112 val build_align :
 113   SPPoC.Expr.t list ->
 114   SPPoC.Expr.t list -> string list -> SPPoC.Function.t * SPPoC.Function.t =
 115   <fun>
 116 val build_distrib :
 117   SPPoC.Expr.t list ->
 118   SPPoC.Expr.t list * SPPoC.Expr.t list ->
 119   SPPoC.Expr.t list * SPPoC.Expr.t list ->
 120   distribute list -> SPPoC.Expr.t list * SPPoC.Expr.t list = <fun>
 121 val build_processors_and_template : problem -> solution -> solution = <fun>
 122 val build_iteration_and_write_and_read : problem -> solution -> solution =
 123   <fun>
 124 val build_write_and_read_aligns : problem -> solution -> solution = <fun>
 125 val build_write_and_read_subscripts : problem -> solution -> solution = <fun>
 126 val build_distribution : problem -> solution -> solution = <fun>
 127 val build_basics : problem -> solution -> solution = <fun>
 128 val build_write_and_read_parametric_domains : 'a -> solution -> solution =
 129   <fun>
 130 val build_main_system : 'a -> solution -> solution = <fun>
 131 val existence_test : 'a -> solution -> solution = <fun>
 132 val compute_volume : 'a -> solution -> solution = <fun>
 133 val calcom : problem -> solution = <fun>
 134 val p : problem =
 135   {parameters=[n; m]; processors=[1; 1], [8; 8]; template=[1; 1], [n; m];
 136    distribution=[CYCLIC; CYCLIC]; write=w, [1; 1], [n; m]; read=r, [1], [n];
 137    align_write=[w1; *]; align_read=[r1; 1]; iteration=i, [1; 1], [n; m];
 138    subscripts_write=[i1; i2]; subscripts_read=[i1]}
 139 val sol : solution =
 140   {vector_parameters={contents=[n; m]};
 141    vector_processors={contents=[p1; p2]}; vector_write={contents=[w1; w2]};
 142    vector_read={contents=[r1]}; vector_template={contents=[t1; t2]};
 143    vector_template_param_write={contents=[ptw1; ptw2]};
 144    vector_template_param_read={contents=[ptr1; ptr2]};
 145    vector_iteration={contents=[i1; i2]};
 146    vector_iteration_param={contents=[pi1; pi2]};
 147    domain_processors=
 148     {contents=
 149       {
 150        ({p2 <= 8, p1 <= 8, p2 >= 1, p1 >= 1},
 151         {vertex(8*p1+p2), vertex(p1+p2), vertex(p1+8*p2), vertex(8*p1+8*p2)})
 152        }};
 153    domain_write=
 154     {contents=
 155       {
 156        ({m >= w2, n >= w1, w2 >= 1, w1 >= 1},
 157         {ray(m), ray(n), ray(m+w2), ray(n+w1), vertex(m+n+w1+w2)})
 158        }};
 159    domain_read=
 160     {contents={({n >= r1, r1 >= 1}, {ray(n), ray(n+r1), vertex(n+r1)})}};
 161    domain_iteration=
 162     {contents=
 163       {
 164        ({i2 <= m, i1 <= n, i2 >= 1, i1 >= 1},
 165         {ray(m), ray(n), ray(i2+m), ray(i1+n), vertex(i1+i2+m+n)})
 166        }};
 167    domain_template=
 168     {contents=
 169       {
 170        ({m >= t2, n >= t1, t2 >= 1, t1 >= 1},
 171         {ray(m), ray(n), ray(m+t2), ray(n+t1), vertex(m+n+t1+t2)})
 172        }};
 173    domain_write_param=
 174     {contents=
 175       {
 176        (
 177         {pi1 = ptw1, ptw2 >= 1, ptw1 >= 1, m >= ptw2, n >= ptw1, m >= pi2,
 178          pi2 >= 1},
 179         {ray(n+pi1+ptw1), ray(m+ptw2), ray(m+pi2+ptw2), ray(m+pi2), ray(m),
 180           ray(n), vertex(m+n+pi1+pi2+ptw1+ptw2)})
 181        }};
 182    domain_read_param=
 183     {contents=
 184       {
 185        ({pi1 = ptr1, ptr2 = 1, pi2 >= 1, ptr1 >= 1, m >= pi2, n >= ptr1},
 186         {ray(n+pi1+ptr1), ray(m+pi2), ray(m), ray(n), vertex(
 187           m+n+pi1+pi2+ptr1+ptr2)})
 188        }};
 189    domain_communications=
 190     {contents=
 191       {
 192        (
 193         {pi1 = ptw1, _e0 = 0, ptw2 >= 1, ptw1 >= 1, pi2 >= 1, n >= ptw1,
 194          m >= ptw2, m >= pi2, 8*_div0-ptw2 = -1},
 195         {ray(n+pi1+ptw1), ray(n), vertex(m+n+pi1+pi2+ptw1+ptw2), ray(
 196           _div0+8*m+8*pi2+8*ptw2), ray(_div0+8*m+8*ptw2), ray(m), ray(
 197           m+pi2)})
 198        }};
 199    system_distribution=
 200     {contents=
 201       {(-1+p1)+(-((-1+t1) mod 8)) = 0, (-1+p2)+(-((-1+t2) mod 8)) = 0}};
 202    system_problem=
 203     {contents=
 204       {(-1+p1)+(-((-1+ptw1) mod 8)) = 0, (-1+p2)+(-((-1+ptw2) mod 8)) = 0,
 205        (-1+p1)+(-((-1+ptr1) mod 8)) = 0, (-1+p2)+(-((-1+ptr2) mod 8)) = 0,
 206        pi1 = ptw1, ptr1 = ptw1, ptr2 = 1, ptw1 >= 1, m >= pi2, n >= ptw1,
 207        pi2 >= 1, ptw2 >= 1, m >= ptw2}};
 208    system_problem_simplified=
 209     {contents=
 210       {pi1 = ptw1, (-1+ptw2) mod 8 = 0, ptw1 >= 1, m >= pi2, n >= ptw1,
 211        pi2 >= 1, ptw2 >= 1, m >= ptw2}};
 212    write_delta=
 213     {contents=[ m , n , ptw1 , ptw2 , t1 ] <- [ m , n , ptw1 , ptw2 , t1 ]};
 214    write_gamma=
 215     {contents=[ m , n , ptw1 , ptw2 , t1 ] <- [ m , n , ptw1 , ptw2 , w1 ]};
 216    write_phi=
 217     {contents=
 218       [ m , n , ptw1 , ptw2 , w1 , w2 ] <- [ m , n , ptw1 , ptw2 , i1 , i2 ]};
 219    read_delta=
 220     {contents=
 221       [ m , n , pi1 , pi2 , t1 , t2 ] <- [ m , n , pi1 , pi2 , t1 , t2 ]};
 222    read_gamma=
 223     {contents=
 224       [ m , n , pi1 , pi2 , t1 , t2 ] <- [ m , n , pi1 , pi2 , r1 , 1 ]};
 225    read_phi=
 226     {contents=[ m , n , pi1 , pi2 , r1 ] <- [ m , n , pi1 , pi2 , i1 ]};
 227    solution=
 228     {contents=
 229       [{({n >= 1, m >= 1}, {ray(n), ray(m), vertex(m+n)})},
 230        (7/8*n*(m**2))+(-m*n*(periodic m (0) 7/8 3/4 5/8 1/2 3/8 1/4 1/8))]}}
 231 #