libpcp/pcp_poly_spi_c.cc

   1 // Copyright (C) 2009 Free Software Foundation, Inc.
   2 // Contributed by Jan Sjodin <jan.sjodin@amd.com>.
   3
   4 // This file is part of the Polyhedral Compilation Package Library (libpcp).
   5
   6 // Libpcp is free software; you can redistribute it and/or modify it
   7 // under the terms of the GNU Lesser General Public License as published by
   8 // the Free Software Foundation; either version 2.1 of the License, or
   9 // (at your option) any later version.
  10
  11 // Libpcp is distributed in the hope that it will be useful, but WITHOUT ANY
  12 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13 // FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
  14 // more details.
  15
  16 // You should have received a copy of the GNU Lesser General Public License
  17 // along with libpcp; see the file COPYING.LIB.  If not, write to the
  18 // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19 // MA 02110-1301, USA.
  20
  21 // As a special exception, if you link this library with other files, some
  22 // of which are compiled with GCC, to produce an executable, this library
  23 // does not by itself cause the resulting executable to be covered by the
  24 // GNU General Public License.  This exception does not however invalidate
  25 // any other reasons why the executable file might be covered by the GNU
  26 // General Public License.
  27
  28 #include "config.h"
  29 #include "pcp_poly_spi.h"
  30 #include "pcp_dynamic_array.h"
  31 #include "pcp_string_buffer.h"
  32 #include "pcp_poly_spi_c.h"
  33
  34 class PcpPolySpiC : public PcpPolySpi
  35 {
  36 private:
  37   struct pcp_poly_spi* interface;
  38
  39 public:
  40
  41     // Coefficient primitives
  42 int
  43 coefficientGetValue(Coefficient* coeff)
  44 {
  45   return this->interface->coefficientGetValue(coeff);
  46 }
  47
  48 PcpPolySpi::Coefficient*
  49 coefficientCreate(int value)
  50 {
  51   return (PcpPolySpi::Coefficient*)this->interface->coefficientCreate(value);
  52 }
  53
  54 const char*
  55 coefficientToString(Coefficient* coeff)
  56 {
  57   return this->interface->coefficientToString(coeff);
  58 }
  59
  60 void coefficientDestroy(Coefficient* coeff)
  61 {
  62   this->interface->coefficientDestroy(coeff);
  63 }
  64
  65
  66 // Linear Expr Primitives
  67 PcpPolySpi::LinearExpr* linearExprCopy(LinearExpr* linearExpr)
  68 {
  69   return (PcpPolySpi::LinearExpr*)this->interface->linearExprCopy(linearExpr);
  70 }
  71
  72 void linearExprAddToCoefficient(LinearExpr* linearExpr, int dimension, Coefficient* value)
  73 {
  74   this->interface->linearExprAddToCoefficient(linearExpr, dimension, value);
  75 }
  76
  77 void linearExprAddToInhomogenous(LinearExpr* linearExpr, Coefficient* value)
  78 {
  79   this->interface->linearExprAddToInhomogenous(linearExpr, value);
  80 }
  81
  82 void linearExprSetCoefficient(LinearExpr* linearExpr, int dimension, Coefficient* value)
  83 {
  84   this->interface->linearExprSetCoefficient(linearExpr, dimension, value);
  85 }
  86
  87
  88 int linearExprGetNumDimensions(LinearExpr* linearExpr)
  89 {
  90   return this->interface->linearExprGetNumDimensions(linearExpr);
  91 }
  92
  93 void linearExprSubtract(LinearExpr* linearExpr, LinearExpr* subtract)
  94 {
  95   this->interface->linearExprSubtract(linearExpr, subtract);
  96 }
  97
  98 const char*
  99 linearExprToString(LinearExpr* linearExpr)
 100 {
 101   return this->interface->linearExprToString(linearExpr);
 102 }
 103
 104 PcpPolySpi::LinearExpr* linearExprCreate()
 105 {
 106   return (PcpPolySpi::LinearExpr*)this->interface->linearExprCreate();
 107 }
 108
 109 PcpPolySpi::LinearExpr* linearExprCreate(int numDimensions)
 110 {
 111   return (PcpPolySpi::LinearExpr*) this->interface->linearExprCreateDim(numDimensions);
 112 }
 113
 114 void linearExprDestroy(LinearExpr* linearExpr)
 115 {
 116   this->interface->linearExprDestroy(linearExpr);
 117 }
 118
 119   // Constraint primitives
 120 PcpPolySpi::Constraint* constraintCreateEqualZero(LinearExpr* linearExpr)
 121 {
 122   return (PcpPolySpi::Constraint*) this->interface->constraintCreateEqualZero(linearExpr);
 123 }
 124
 125 PcpPolySpi::Constraint* constraintCreateGreaterEqualZero(LinearExpr* linearExpr)
 126 {
 127   return (PcpPolySpi::Constraint*) this->interface->constraintCreateGreaterEqualZero(linearExpr);
 128 }
 129
 130 void constraintDestroy(Constraint* constraint)
 131 {
 132   this->interface->constraintDestroy(constraint);
 133 }
 134
 135 const char*
 136 constraintToString(Constraint* constraint)
 137 {
 138   return this->interface->constraintToString(constraint);
 139 }
 140
 141 // Polyhedron primitives
 142 PcpPolySpi::ConstraintSystem* polyhedronGetConstraintSystem(Polyhedron* polyhedron)
 143 {
 144   return (PcpPolySpi::ConstraintSystem*) this->interface->polyhedronGetConstraintSystem(polyhedron);
 145 }
 146
 147
 148 void polyhedronAddConstraint(Polyhedron* polyhedron, Constraint* constraint)
 149 {
 150   this->interface->polyhedronAddConstraint(polyhedron, constraint);
 151 }
 152
 153 void polyhedronAddConstraints(Polyhedron* polyhedron, ConstraintSystem* constraintSystem)
 154 {
 155   this->interface->polyhedronAddConstraints(polyhedron, constraintSystem);
 156 }
 157
 158 void polyhedronRemap(Polyhedron* polyhedron, PcpArray<int>* map)
 159 {
 160   // FIXME: implement conversion from array to int*
 161   int size = map->getSize();
 162   int* array = (int*)malloc(sizeof(int)*size);
 163   for(int i = 0; i < size; i++)
 164     array[i] = map->get(i);
 165   this->interface->polyhedronRemap(polyhedron, array, size);
 166 }
 167
 168 PcpPolySpi::Polyhedron* polyhedronCopy(Polyhedron* polyhedron)
 169 {
 170   return (PcpPolySpi::Polyhedron*) this->interface->polyhedronCopy(polyhedron);
 171 }
 172
 173 PcpPolySpi::Polyhedron* polyhedronCreate(int numDimensions)
 174 {
 175   return (PcpPolySpi::Polyhedron*) this->interface->polyhedronCreate(numDimensions);
 176 }
 177
 178 void polyhedronDestroy(Polyhedron* polyhedron)
 179 {
 180   this->interface->polyhedronDestroy(polyhedron);
 181 }
 182
 183 void pointsetPowersetDestroy(PointsetPowerset* poinsetPowerset)
 184 {
 185   this->interface->pointsetPowersetDestroy(poinsetPowerset);
 186 }
 187
 188
 189 PcpPolySpi::PointsetPowerset* pointsetPowersetCreate(Polyhedron* polyhedron)
 190 {
 191   return (PcpPolySpi::PointsetPowerset*) this->interface->pointsetPowersetCreate(polyhedron);
 192 }
 193
 194 PcpPolySpiC()
 195 {
 196   this->interface = NULL;
 197 }
 198
 199 PcpPolySpiC(struct pcp_poly_spi* spi)
 200 {
 201   this->interface = spi;
 202 }
 203
 204 };
 205
 206 #include "cloog/cloog.h"
 207 #include "ppl_c.h"
 208 #include "pcp_poly_spi_c.h"
 209 #include <string.h>
 210 #include "pcp_string_buffer.h"
 211
 212 static void ppl_coefficient_print(ppl_Coefficient_t* coeff)
 213 {
 214   printf("Coefficient: ");
 215   ppl_io_print_Coefficient(*coeff);
 216   printf("\n");
 217 }
 218
 219 static int ppl_coefficient_to_int(void* coeff)
 220 {
 221   Value v;
 222   value_init(v);
 223   ppl_Coefficient_to_mpz_t(*((ppl_Coefficient_t*) coeff), v);
 224   return value_get_si(v);
 225 }
 226
 227 static const char* ppl_coefficient_to_string(void* coeff)
 228 {
 229   PcpStringBuffer stringBuffer;
 230   stringBuffer.appendInt(ppl_coefficient_to_int(coeff));
 231   return stringBuffer.toString();
 232 }
 233
 234 static void* ppl_coefficient_create(int value)
 235 {
 236   Value v;
 237   value_init(v);
 238   value_set_si(v, value);
 239
 240   ppl_Coefficient_t* coeff = (ppl_Coefficient_t*) malloc(sizeof(ppl_Coefficient_t));
 241   ppl_new_Coefficient(coeff);
 242   ppl_assign_Coefficient_from_mpz_t(*coeff, v);
 243   return coeff;
 244 }
 245
 246 static void ppl_coefficient_destroy(void* coeff)
 247 {
 248   ppl_delete_Coefficient(*((ppl_Coefficient_t*)coeff));
 249   free((ppl_Coefficient_t*)coeff);
 250 }
 251
 252
 253 static void ppl_linear_expr_print(ppl_Linear_Expression_t* linearExpr)
 254 {
 255   printf("Linear Expression: ");
 256   ppl_io_print_Linear_Expression(*linearExpr);
 257   printf("\n");
 258 }
 259
 260 static void ppl_linear_expr_add_to_coefficient(void* linearExpr, int dimension, void* value)
 261 {
 262   ppl_Linear_Expression_add_to_coefficient(*((ppl_Linear_Expression_t*)linearExpr),
 263                                            dimension,
 264                                            *((ppl_Coefficient_t*)value));
 265 }
 266
 267 static void ppl_linear_expr_add_to_inhomogenous(void* linearExpr, void* value)
 268 {
 269   ppl_Linear_Expression_add_to_inhomogeneous(*((ppl_Linear_Expression_t*)linearExpr),
 270                                              *((ppl_Coefficient_t*)value));
 271 }
 272
 273 static void
 274 set_coef (ppl_Linear_Expression_t e, ppl_dimension_type i, int x)
 275 {
 276   Value v0, v1;
 277   ppl_Coefficient_t c;
 278
 279   value_init (v0);
 280   value_init (v1);
 281   ppl_new_Coefficient (&c);
 282
 283   ppl_Linear_Expression_coefficient (e, i, c);
 284   ppl_Coefficient_to_mpz_t (c, v1);
 285   value_oppose (v1, v1);
 286   value_set_si (v0, x);
 287   value_addto (v0, v0, v1);
 288   ppl_assign_Coefficient_from_mpz_t (c, v0);
 289   ppl_Linear_Expression_add_to_coefficient (e, i, c);
 290
 291   value_clear (v0);
 292   value_clear (v1);
 293   ppl_delete_Coefficient (c);
 294 }
 295
 296 static void ppl_linear_expr_set_coefficient(void* linearExpr, int dimension, void* value)
 297 {
 298   ppl_Coefficient_t coeff;
 299   ppl_new_Coefficient(&coeff);
 300   ppl_Linear_Expression_coefficient(*((ppl_Linear_Expression_t*)linearExpr), dimension, coeff);
 301   set_coef(*((ppl_Linear_Expression_t*)linearExpr),
 302            dimension,
 303            ppl_coefficient_to_int(value));
 304
 305   ppl_Linear_Expression_coefficient(*((ppl_Linear_Expression_t*)linearExpr), dimension, coeff);
 306 }
 307
 308 static int ppl_linear_expr_get_num_dimensions(void* linearExpr)
 309 {
 310   ppl_dimension_type numDimensions;
 311   ppl_Linear_Expression_space_dimension (*((ppl_Linear_Expression_t*)linearExpr), &numDimensions);
 312   return (int)numDimensions;
 313 }
 314
 315 static void ppl_linear_expr_subtract(void* linearExpr0, void* linearExpr1)
 316 {
 317   ppl_subtract_Linear_Expression_from_Linear_Expression(*((ppl_Linear_Expression_t*)linearExpr0),
 318                                                         *((ppl_Linear_Expression_t*)linearExpr1));
 319 }
 320
 321 static const char* ppl_linear_expr_to_string(void* linearExpr)
 322 {
 323   int numDimensions = ppl_linear_expr_get_num_dimensions(linearExpr);
 324   int i;
 325   PcpStringBuffer buffer;
 326   ppl_Coefficient_t coeff;
 327
 328   ppl_new_Coefficient(&coeff);
 329   buffer.append("(");
 330   for(i = 0; i < numDimensions; i++)
 331     {
 332
 333       ppl_Linear_Expression_coefficient(*((ppl_Linear_Expression_t*)linearExpr),
 334                                         i,
 335                                         coeff);
 336       buffer.appendInt(ppl_coefficient_to_int(coeff));
 337       buffer.append(" ");
 338     }
 339
 340   ppl_Linear_Expression_inhomogeneous_term(*((ppl_Linear_Expression_t*)linearExpr),
 341                                           coeff);
 342   buffer.appendInt(ppl_coefficient_to_int(&coeff));
 343   ppl_delete_Coefficient(coeff);
 344   return buffer.toString();
 345 }
 346
 347 static void* ppl_linear_expr_create_dim(int numDimensions)
 348 {
 349   ppl_Linear_Expression_t* linearExpr = (ppl_Linear_Expression_t*) malloc(sizeof(ppl_Linear_Expression_t));
 350   ppl_new_Linear_Expression_with_dimension(linearExpr, numDimensions);
 351   return linearExpr;
 352 }
 353
 354 static void ppl_linear_expr_destroy(void* linearExpr)
 355 {
 356   ppl_delete_Linear_Expression(*((ppl_Linear_Expression_t*)linearExpr));
 357   free(linearExpr);
 358 }
 359
 360 static void* ppl_constraint_create_equal_zero(void* linearExpr)
 361 {
 362   ppl_Constraint_t* constraint = (ppl_Constraint_t*) malloc(sizeof(ppl_Constraint_t));
 363   ppl_new_Constraint(constraint, *((ppl_Linear_Expression_t*)linearExpr), PPL_CONSTRAINT_TYPE_EQUAL);
 364   return constraint;
 365 }
 366
 367 static void* ppl_constraint_create_greater_equal_zero(void* linearExpr)
 368 {
 369   ppl_Constraint_t* constraint = (ppl_Constraint_t*) malloc(sizeof(ppl_Constraint_t));
 370   ppl_new_Constraint(constraint, *((ppl_Linear_Expression_t*)linearExpr), PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
 371   return constraint;
 372 }
 373
 374 static void ppl_constraint_destory(void* constraint)
 375 {
 376   ppl_delete_Constraint(*((ppl_Constraint_t*)constraint));
 377   free(constraint);
 378 }
 379
 380 static const char* ppl_constraint_to_string(void* constr)
 381 {
 382   ppl_Constraint_t* constraint = (ppl_Constraint_t*) constr;
 383   bool isEqual = ppl_Constraint_type(*constraint) == PPL_CONSTRAINT_TYPE_EQUAL;
 384   ppl_dimension_type numDimensions;
 385   PcpStringBuffer buffer;
 386   ppl_Coefficient_t coeff;
 387   int i;
 388
 389   ppl_new_Coefficient(&coeff);
 390   ppl_Constraint_space_dimension(*constraint, &numDimensions);
 391   for(i = 0; i < numDimensions; i++)
 392     {
 393       ppl_Constraint_coefficient(*constraint, i, coeff);
 394       buffer.append(ppl_coefficient_to_string(&coeff));
 395       buffer.append(" ");
 396     }
 397   ppl_Constraint_inhomogeneous_term(*constraint, coeff);
 398   buffer.appendInt(ppl_coefficient_to_int(&coeff));
 399
 400   buffer.append( isEqual ? " == 0" : " >= 0" );
 401   ppl_delete_Coefficient(coeff);
 402   return buffer.toString();
 403 }
 404
 405 static void* ppl_polyhedron_get_constraint_system(void* polyhedron)
 406 {
 407   ppl_const_Constraint_System_t* constraintSystem =
 408     (ppl_const_Constraint_System_t*) malloc(sizeof(ppl_const_Constraint_System_t));
 409   ppl_Polyhedron_get_constraints(*((ppl_Polyhedron_t*)polyhedron), constraintSystem);
 410   return constraintSystem;
 411 }
 412
 413 static void ppl_polyhedron_add_constraint(void* polyhedron, void* constraint)
 414 {
 415   ppl_Polyhedron_add_constraint(*((ppl_Polyhedron_t*)polyhedron), *((ppl_Constraint_t*)constraint));
 416 }
 417
 418 static void ppl_polyhedron_add_constraints(void* polyhedron, void* constraintsystem)
 419 {
 420   ppl_Polyhedron_add_constraints(*((ppl_Polyhedron_t*)polyhedron), *((ppl_Constraint_System_t*)constraintsystem));
 421 }
 422
 423 static void ppl_polyhedron_remap(void* polyhedron, int* map, int numElements)
 424 {
 425   ppl_Polyhedron_map_space_dimensions(*((ppl_Polyhedron_t*)polyhedron), (ppl_dimension_type*)map, numElements);
 426 }
 427
 428 static void* ppl_polyhedron_copy(void* polyhedron)
 429 {
 430   ppl_Polyhedron_t* copy = (ppl_Polyhedron_t*)malloc(sizeof(ppl_Polyhedron_t*));
 431   ppl_new_NNC_Polyhedron_from_NNC_Polyhedron(copy, *((ppl_Polyhedron_t*)polyhedron));
 432   return copy;
 433 }
 434
 435 static void* ppl_polyhedron_create(int numDimensions)
 436 {
 437   ppl_Polyhedron_t* polyhedron = (ppl_Polyhedron_t*)malloc(sizeof(ppl_Polyhedron_t*));
 438   ppl_new_NNC_Polyhedron_from_space_dimension(polyhedron, numDimensions, 0);
 439   return polyhedron;
 440 }
 441
 442 static void ppl_polyhedron_destroy(void* polyhedron)
 443 {
 444   ppl_delete_Polyhedron(*((ppl_Polyhedron_t*)polyhedron));
 445 }
 446
 447 void* ppl_pointset_powerset_create(void* polyhedron)
 448 {
 449   ppl_Pointset_Powerset_NNC_Polyhedron_t* pointsetPowerset = (ppl_Pointset_Powerset_NNC_Polyhedron_t*)
 450     malloc(sizeof(ppl_Pointset_Powerset_NNC_Polyhedron_t));
 451   ppl_new_Pointset_Powerset_NNC_Polyhedron_from_NNC_Polyhedron(pointsetPowerset, *((ppl_Polyhedron_t*)polyhedron));
 452   return pointsetPowerset;
 453 }
 454
 455 void ppl_pointset_powerset_destroy(void* pointsetPowerset)
 456 {
 457   ppl_delete_Pointset_Powerset_NNC_Polyhedron(*((ppl_Pointset_Powerset_NNC_Polyhedron_t*)pointsetPowerset));
 458 }
 459
 460 static pcp_poly_spi* create_ppl_c_interface()
 461 {
 462   struct pcp_poly_spi* pcp_poly_spi_impl = (struct pcp_poly_spi*)malloc(sizeof(pcp_poly_spi));
 463
 464   pcp_poly_spi_impl->coefficientGetValue = &ppl_coefficient_to_int;
 465   pcp_poly_spi_impl->coefficientToString = &ppl_coefficient_to_string;
 466   pcp_poly_spi_impl->coefficientCreate = &ppl_coefficient_create;
 467   pcp_poly_spi_impl->coefficientDestroy = &ppl_coefficient_destroy;
 468   pcp_poly_spi_impl->linearExprCopy = NULL; // Probably not needed
 469   pcp_poly_spi_impl->linearExprAddToCoefficient = ppl_linear_expr_add_to_coefficient;
 470   pcp_poly_spi_impl->linearExprAddToInhomogenous = ppl_linear_expr_add_to_inhomogenous;
 471   pcp_poly_spi_impl->linearExprSetCoefficient = ppl_linear_expr_set_coefficient;
 472   pcp_poly_spi_impl->linearExprGetNumDimensions = ppl_linear_expr_get_num_dimensions;
 473   pcp_poly_spi_impl->linearExprSubtract = ppl_linear_expr_subtract;
 474   pcp_poly_spi_impl->linearExprToString = ppl_linear_expr_to_string;
 475   pcp_poly_spi_impl->linearExprCreate = NULL; // Not needed
 476   pcp_poly_spi_impl->linearExprCreateDim = ppl_linear_expr_create_dim;
 477   pcp_poly_spi_impl->linearExprDestroy = ppl_linear_expr_destroy;
 478   pcp_poly_spi_impl->constraintCreateGreaterEqualZero = ppl_constraint_create_greater_equal_zero;
 479   pcp_poly_spi_impl->constraintCreateEqualZero = ppl_constraint_create_equal_zero;
 480   pcp_poly_spi_impl->constraintDestroy = ppl_constraint_destory;
 481   pcp_poly_spi_impl->constraintToString = ppl_constraint_to_string;
 482   pcp_poly_spi_impl->polyhedronGetConstraintSystem = ppl_polyhedron_get_constraint_system;
 483   pcp_poly_spi_impl->polyhedronAddConstraint = ppl_polyhedron_add_constraint;
 484   pcp_poly_spi_impl->polyhedronAddConstraints = ppl_polyhedron_add_constraints;
 485   pcp_poly_spi_impl->polyhedronRemap = ppl_polyhedron_remap;
 486   pcp_poly_spi_impl->polyhedronCopy = ppl_polyhedron_copy;
 487   pcp_poly_spi_impl->polyhedronCreate = ppl_polyhedron_create;
 488   pcp_poly_spi_impl->polyhedronDestroy = ppl_polyhedron_destroy;
 489   pcp_poly_spi_impl->pointsetPowersetCreate = ppl_pointset_powerset_create;
 490   pcp_poly_spi_impl->pointsetPowersetDestroy = ppl_pointset_powerset_destroy;
 491 }
 492
 493 PcpPolySpi* createPPLPolySpi()
 494 {
 495   return new PcpPolySpiC(create_ppl_c_interface());
 496 }
 497
 498
 499
 500