~ubuntu-branches/ubuntu/vivid/cloog/vivid-proposed : revision 4

1

2

Index: b/source/isl/domain.c

3

===================================================================

4

--- a/source/isl/domain.c

5

+++ b/source/isl/domain.c

6

@@ -7,7 +7,11 @@

7

#include <isl/list.h>

8

#include <isl/constraint.h>

9

#include <isl/ilp.h>

10

+#include <isl/lp.h>

11

#include <isl/aff.h>

12

+#include <isl/map.h>

13

+#include <isl/val.h>

14

+#include <isl/val_gmp.h>

15

16

#ifdef OSL_SUPPORT

17

#include <osl/macros.h>

18

@@ -510,15 +514,18 @@ static struct isl_constraint *isl_constr

19

else

20

constraint = isl_inequality_alloc(ls);

21

22

- for (j = 0; j < nvariables; ++j)

23

- isl_constraint_set_coefficient(constraint, isl_dim_out, j,

24

- row[1 + j]);

25

-

26

- for (j = 0; j < nparam; ++j)

27

- isl_constraint_set_coefficient(constraint, isl_dim_param, j,

28

- row[1 + nvariables + j]);

29

+ for (j = 0; j < nvariables; ++j) {

30

+ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + j]);

31

+ isl_constraint_set_coefficient_val(constraint, isl_dim_out, j, val);

32

+ }

33

+

34

+ for (j = 0; j < nparam; ++j) {

35

+ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + nvariables + j]);

36

+ isl_constraint_set_coefficient_val(constraint, isl_dim_param, j, val);

37

+ }

38

39

- isl_constraint_set_constant(constraint, row[1 + nvariables + nparam]);

40

+ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + nvariables + nparam]);

41

+ isl_constraint_set_constant_val(constraint, val);

42

43

return constraint;

44

}

45

@@ -631,7 +638,6 @@ CloogDomain *cloog_domain_from_osl_relat

46

return domain;

47

}

48

49

-

50

/**

51

* Converts an openscop scattering relation to a CLooG scattering.

52

* \param[in,out] state CLooG state.

53

@@ -779,10 +785,22 @@ int cloog_domain_is_otl(CloogDomain *dom

54

void cloog_domain_stride(CloogDomain *domain, int strided_level,

55

cloog_int_t *stride, cloog_int_t *offset)

56

{

57

+ int ret = -1;

58

isl_set *set = isl_set_from_cloog_domain(domain);

59

- isl_set_dim_residue_class(set, strided_level - 1, stride, offset);

60

- if (!isl_int_is_zero(*offset))

61

- isl_int_sub(*offset, *stride, *offset);

62

+ isl_val *stride_val = NULL;

63

+ isl_val *offset_val = NULL;

64

+ ret = isl_set_dim_residue_class_val(set, strided_level - 1, &stride_val, &offset_val);

65

+ if (ret != 0)

66

+ cloog_die("failure to compute stride.\n");

67

+ isl_val_to_cloog_int(stride_val, stride);

68

+ isl_val_to_cloog_int(offset_val, offset);

69

+

70

+ if (!cloog_int_is_zero(*offset))

71

+ cloog_int_sub(*offset, *stride, *offset);

72

+

73

+ isl_val_free(stride_val);

74

+ isl_val_free(offset_val);

75

+

76

return;

77

}

78

79

@@ -796,7 +814,7 @@ static int constraint_can_stride(__isl_t

80

{

81

struct cloog_can_stride *ccs = (struct cloog_can_stride *)user;

82

int i;

83

- isl_int v;

84

+ isl_val *v;

85

unsigned n_div;

86

87

if (isl_constraint_is_equality(c)) {

88

@@ -804,21 +822,22 @@ static int constraint_can_stride(__isl_t

89

return 0;

90

}

91

92

- isl_int_init(v);

93

- isl_constraint_get_coefficient(c, isl_dim_set, ccs->level - 1, &v);

94

- if (isl_int_is_pos(v)) {

95

+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, ccs->level - 1);

96

+ if (isl_val_is_pos(v)) {

97

n_div = isl_constraint_dim(c, isl_dim_div);

98

+

99

for (i = 0; i < n_div; ++i) {

100

- isl_constraint_get_coefficient(c, isl_dim_div, i, &v);

101

- if (!isl_int_is_zero(v))

102

+ isl_val_free(v);

103

+ v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);

104

+ if (!isl_val_is_zero(v))

105

break;

106

}

107

if (i < n_div)

108

ccs->can_stride = 0;

109

}

110

- isl_int_clear(v);

111

- isl_constraint_free(c);

112

+ isl_val_free(v);

113

114

+ isl_constraint_free(c);

115

return 0;

116

}

117

118

@@ -903,7 +922,7 @@ struct cloog_stride_lower {

119

static int constraint_stride_lower(__isl_take isl_constraint *c, void *user)

120

{

121

struct cloog_stride_lower *csl = (struct cloog_stride_lower *)user;

122

- isl_int v;

123

+ isl_val *v;

124

isl_constraint *bound;

125

isl_aff *b;

126

127

@@ -912,31 +931,31 @@ static int constraint_stride_lower(__isl

128

return 0;

129

}

130

131

- isl_int_init(v);

132

- isl_constraint_get_coefficient(c, isl_dim_set, csl->level - 1, &v);

133

- if (!isl_int_is_pos(v)) {

134

- isl_int_clear(v);

135

+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, csl->level - 1);

136

+ if (!isl_val_is_pos(v)) {

137

+ isl_val_free(v);

138

isl_constraint_free(c);

139

140

return 0;

141

}

142

+ isl_val_free(v);

143

144

b = isl_constraint_get_bound(c, isl_dim_set, csl->level - 1);

145

146

b = isl_aff_neg(b);

147

- b = isl_aff_add_constant(b, csl->stride->offset);

148

- b = isl_aff_scale_down(b, csl->stride->stride);

149

+ b = isl_aff_add_constant_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->offset));

150

+ b = isl_aff_scale_down_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->stride));

151

b = isl_aff_floor(b);

152

- b = isl_aff_scale(b, csl->stride->stride);

153

- isl_int_neg(v, csl->stride->offset);

154

- b = isl_aff_add_constant(b, v);

155

+ b = isl_aff_scale_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->stride));

156

+ v = cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->offset);

157

+ v = isl_val_neg(v);

158

+ b = isl_aff_add_constant_val(b, v);

159

b = isl_aff_add_coefficient_si(b, isl_dim_in, csl->level - 1, 1);

160

161

bound = isl_inequality_from_aff(b);

162

163

csl->bounds = isl_basic_set_add_constraint(csl->bounds, bound);

164

165

- isl_int_clear(v);

166

isl_constraint_free(c);

167

168

return 0;

169

@@ -960,7 +979,7 @@ static int constraint_stride_lower(__isl

170

static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)

171

{

172

struct cloog_stride_lower *csl = (struct cloog_stride_lower *)user;

173

- isl_int v;

174

+ isl_val *v;

175

isl_constraint *bound;

176

isl_constraint *csl_c;

177

isl_aff *d, *b;

178

@@ -970,10 +989,9 @@ static int constraint_stride_lower_c(__i

179

return 0;

180

}

181

182

- isl_int_init(v);

183

- isl_constraint_get_coefficient(c, isl_dim_set, csl->level - 1, &v);

184

- if (!isl_int_is_pos(v)) {

185

- isl_int_clear(v);

186

+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, csl->level - 1);

187

+ if (!isl_val_is_pos(v)) {

188

+ isl_val_free(v);

189

isl_constraint_free(c);

190

191

return 0;

192

@@ -984,15 +1002,15 @@ static int constraint_stride_lower_c(__i

193

d = isl_constraint_get_aff(csl_c);

194

d = isl_aff_drop_dims(d, isl_dim_div, 0, isl_aff_dim(d, isl_dim_div));

195

d = isl_aff_set_coefficient_si(d, isl_dim_in, csl->level - 1, 0);

196

- d = isl_aff_scale(d, csl->stride->factor);

197

+ d = isl_aff_scale_val(d, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->factor));

198

199

b = isl_constraint_get_bound(c, isl_dim_set, csl->level - 1);

200

201

b = isl_aff_neg(b);

202

b = isl_aff_add(b, isl_aff_copy(d));

203

- b = isl_aff_scale_down(b, csl->stride->stride);

204

+ b = isl_aff_scale_down_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->stride));

205

b = isl_aff_floor(b);

206

- b = isl_aff_scale(b, csl->stride->stride);

207

+ b = isl_aff_scale_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->stride));

208

b = isl_aff_sub(b, d);

209

b = isl_aff_add_coefficient_si(b, isl_dim_in, csl->level - 1, 1);

210

211

@@ -1000,7 +1018,7 @@ static int constraint_stride_lower_c(__i

212

213

csl->bounds = isl_basic_set_add_constraint(csl->bounds, bound);

214

215

- isl_int_clear(v);

216

+ isl_val_free(v);

217

isl_constraint_free(c);

218

219

return 0;

220

@@ -1090,28 +1108,30 @@ struct cloog_bound_split {

221

static int constraint_bound_split(__isl_take isl_constraint *c, void *user)

222

{

223

struct cloog_bound_split *cbs = (struct cloog_bound_split *)user;

224

- isl_int v;

225

+ isl_val *v;

226

int i;

227

int handle = 0;

228

229

- isl_int_init(v);

230

- isl_constraint_get_coefficient(c, isl_dim_set, cbs->level - 1, &v);

231

- if (!cbs->lower && isl_int_is_pos(v))

232

+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, cbs->level - 1);

233

+ if (!cbs->lower && isl_val_is_pos(v))

234

cbs->lower = handle = 1;

235

- else if (!cbs->upper && isl_int_is_neg(v))

236

+ else if (!cbs->upper && isl_val_is_neg(v))

237

cbs->upper = handle = 1;

238

+

239

if (handle) {

240

for (i = 0; i < isl_set_dim(cbs->set, isl_dim_param); ++i) {

241

- isl_constraint_get_coefficient(c, isl_dim_param, i, &v);

242

- if (isl_int_is_zero(v))

243

+ isl_val_free(v);

244

+ v = isl_constraint_get_coefficient_val(c, isl_dim_param, i);

245

+ if (isl_val_is_zero(v))

246

continue;

247

+

248

cbs->set = isl_set_split_dims(cbs->set,

249

isl_dim_param, i, 1);

250

}

251

}

252

- isl_int_clear(v);

253

- isl_constraint_free(c);

254

+ isl_val_free(v);

255

256

+ isl_constraint_free(c);

257

return (cbs->lower && cbs->upper) ? -1 : 0;

258

}

259

260

@@ -1203,7 +1223,7 @@ static int injective_scattering(CloogSca

261

* - scattdims is the total number of scattering dimentions.

262

*/

263

int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2,

264

- CloogScatteringList *scattering, int scattdims)

265

+ CloogScatteringList *scattering, int scattdims)

266

{

267

int i;

268

struct isl_space *dim;

269

@@ -1211,8 +1231,8 @@ int cloog_scattering_lazy_block(CloogSca

270

struct isl_set *delta;

271

isl_map *map1 = isl_map_from_cloog_scattering(s1);

272

isl_map *map2 = isl_map_from_cloog_scattering(s2);

273

- int fixed, block;

274

- isl_int cst;

275

+ int block;

276

+ isl_val *cst;

277

unsigned n_scat;

278

279

n_scat = isl_map_dim(map1, isl_dim_out);

280

@@ -1225,22 +1245,33 @@ int cloog_scattering_lazy_block(CloogSca

281

rel = isl_map_apply_domain(rel, isl_map_copy(map1));

282

rel = isl_map_apply_range(rel, isl_map_copy(map2));

283

delta = isl_map_deltas(rel);

284

- isl_int_init(cst);

285

+ cst = NULL;

286

for (i = 0; i < n_scat; ++i) {

287

- fixed = isl_set_fast_dim_is_fixed(delta, i, &cst);

288

- if (fixed != 1)

289

+ cst = isl_set_plain_get_val_if_fixed(delta, isl_dim_set, i);

290

+ if (!cst){

291

+ isl_val_free(cst);

292

break;

293

- if (isl_int_is_zero(cst))

294

+ }

295

+ if (isl_val_is_zero(cst)){

296

+ isl_val_free(cst);

297

continue;

298

- if (i + 1 < n_scat)

299

+ }

300

+ if (i + 1 < n_scat){

301

+ isl_val_free(cst);

302

break;

303

- if (!isl_int_is_one(cst))

304

+ }

305

+ if (!isl_val_is_one(cst)){

306

+ isl_val_free(cst);

307

break;

308

- if (!injective_scattering(scattering))

309

+ }

310

+ if (!injective_scattering(scattering)){

311

+ isl_val_free(cst);

312

break;

313

+ }

314

+

315

+ isl_val_free(cst);

316

}

317

block = i >= n_scat;

318

- isl_int_clear(cst);

319

isl_set_free(delta);

320

return block;

321

}

322

@@ -1345,10 +1376,25 @@ CloogDomain *cloog_domain_simplify_union

323

* If value is not NULL, then it is set to the constant value of dimension.

324

*/

325

int cloog_scattering_lazy_isscalar(CloogScattering *scatt, int dimension,

326

- cloog_int_t *value)

327

+ cloog_int_t *value)

328

{

329

isl_map *map = isl_map_from_cloog_scattering(scatt);

330

- return isl_map_fast_is_fixed(map, isl_dim_out, dimension, value);

331

+ isl_val *v = isl_map_plain_get_val_if_fixed(map, isl_dim_out, dimension);

332

+ if (v != NULL) {

333

+ if (!isl_val_is_nan(v)){

334

+ if (value != NULL)

335

+ isl_val_to_cloog_int(v, value);

336

+

337

+ isl_val_free(v);

338

+ return 1;

339

+ }

340

+ else {

341

+ isl_val_free(v);

342

+ return 0;

343

+ }

344

+ }

345

+

346

+ return 0;

347

}

348

349

350

@@ -1362,7 +1408,22 @@ int cloog_domain_lazy_isconstant(CloogDo

351

cloog_int_t *value)

352

{

353

isl_set *set = isl_set_from_cloog_domain(domain);

354

- return isl_set_fast_dim_is_fixed(set, dimension, value);

355

+ isl_val *cst = isl_set_plain_get_val_if_fixed(set, isl_dim_set, dimension);

356

+ if (cst != NULL) {

357

+ if (!isl_val_is_nan(cst)){

358

+ if (value != NULL)

359

+ isl_val_to_cloog_int(cst, value);

360

+

361

+ isl_val_free(cst);

362

+ return 1;

363

+ }

364

+ else {

365

+ isl_val_free(cst);

366

+ return 0;

367

+ }

368

+ }

369

+

370

+ return 0;

371

}

372

373

374

@@ -1389,20 +1450,24 @@ CloogDomain *cloog_domain_cube(CloogStat

375

int dim, cloog_int_t min, cloog_int_t max)

376

{

377

int i;

378

- struct isl_basic_set *cube;

379

- struct isl_basic_set *interval;

380

- struct isl_basic_set_list *list;

381

+ isl_space *space;

382

+ isl_set *cube;

383

+ isl_val *min_v;

384

+ isl_val *max_v;

385

386

if (dim == 0)

387

return cloog_domain_universe(state, dim);

388

389

- interval = isl_basic_set_interval(state->backend->ctx, min, max);

390

- list = isl_basic_set_list_alloc(state->backend->ctx, dim);

391

- for (i = 0; i < dim; ++i)

392

- list = isl_basic_set_list_add(list, isl_basic_set_copy(interval));

393

- isl_basic_set_free(interval);

394

- cube = isl_basic_set_list_product(list);

395

- return cloog_domain_from_isl_set(isl_set_from_basic_set(cube));

396

+ space = isl_space_set_alloc(state->backend->ctx, 0, dim);

397

+ cube = isl_set_universe(space);

398

+ for (i = 0; i < dim; ++i) {

399

+ min_v = cloog_int_to_isl_val(isl_set_get_ctx(cube), min);

400

+ max_v = cloog_int_to_isl_val(isl_set_get_ctx(cube), max);

401

+ cube = isl_set_lower_bound_val(cube, isl_dim_set, i, min_v);

402

+ cube = isl_set_upper_bound_val(cube, isl_dim_set, i, max_v);

403

+ }

404

+

405

+ return cloog_domain_from_isl_set(cube);

406

}

407

408

409

@@ -1595,7 +1660,7 @@ static void Euclid(cloog_int_t a, cloog_

410

cloog_int_mul(tmp, tmp, d);

411

cloog_int_sub(c, c, tmp);

412

cloog_int_swap(c, d);

413

- cloog_int_swap(e, f);

414

+ cloog_int_swap(e, f);

415

}

416

cloog_int_set(*g, c);

417

if (cloog_int_is_zero(a))

418

@@ -1631,49 +1696,70 @@ static void Euclid(cloog_int_t a, cloog_

419

static CloogStride *construct_stride(isl_constraint *c, int level)

420

{

421

int i, n, sign;

422

- isl_int v, m, gcd, stride, factor;

423

+ isl_val *v, *m, *gcd, *stride;

424

+ isl_val *v_copy, *m_copy, *gcd_copy;

425

+ cloog_int_t c_v, c_m, c_gcd, c_stride, c_factor;

426

CloogStride *s;

427

+ isl_ctx *ctx = isl_constraint_get_ctx(c);;

428

429

if (!c)

430

return NULL;

431

432

- isl_int_init(v);

433

- isl_int_init(m);

434

- isl_int_init(gcd);

435

- isl_int_init(factor);

436

- isl_int_init(stride);

437

-

438

- isl_constraint_get_coefficient(c, isl_dim_set, level - 1, &v);

439

- sign = isl_int_sgn(v);

440

- isl_int_abs(m, v);

441

+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, level - 1);

442

443

- isl_int_set_si(gcd, 0);

444

+ sign = isl_val_sgn(v);

445

+ m = isl_val_abs(v); /* *takes* v. */

446

+

447

+ gcd = isl_val_int_from_si(ctx, 0);

448

n = isl_constraint_dim(c, isl_dim_div);

449

for (i = 0; i < n; ++i) {

450

- isl_constraint_get_coefficient(c, isl_dim_div, i, &v);

451

- isl_int_gcd(gcd, gcd, v);

452

+ v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);

453

+ gcd = isl_val_gcd(gcd, v);

454

}

455

456

- isl_int_gcd(v, m, gcd);

457

- isl_int_divexact(stride, gcd, v);

458

+ m_copy = isl_val_copy(m);

459

+ gcd_copy = isl_val_copy(gcd);

460

+

461

+ v = isl_val_gcd(m, gcd);

462

+

463

+ v_copy = isl_val_copy(v);

464

+ gcd = isl_val_copy(gcd_copy);

465

+ stride = isl_val_div(gcd, v);

466

467

- if (isl_int_is_zero(stride) || isl_int_is_one(stride))

468

+ if (isl_val_is_zero(stride) || isl_val_is_one(stride))

469

s = NULL;

470

else {

471

- Euclid(m, stride, &factor, &v, &gcd);

472

+ cloog_int_init(c_m);

473

+ cloog_int_init(c_stride);

474

+ cloog_int_init(c_v);

475

+ cloog_int_init(c_gcd);

476

+ cloog_int_init(c_factor);

477

+

478

+ isl_val_to_cloog_int(m_copy, &c_m);

479

+ isl_val_to_cloog_int(stride, &c_stride);

480

+ isl_val_to_cloog_int(v_copy, &c_v);

481

+ isl_val_to_cloog_int(gcd_copy, &c_gcd);

482

+

483

+ Euclid(c_m, c_stride, &c_factor, &c_v, &c_gcd);

484

if (sign > 0)

485

- isl_int_neg(factor, factor);

486

+ cloog_int_neg(c_factor, c_factor);

487

488

c = isl_constraint_copy(c);

489

- s = cloog_stride_alloc_from_constraint(stride,

490

- cloog_constraint_from_isl_constraint(c), factor);

491

+ s = cloog_stride_alloc_from_constraint(c_stride,

492

+ cloog_constraint_from_isl_constraint(c), c_factor);

493

+

494

+

495

+ cloog_int_clear(c_m);

496

+ cloog_int_clear(c_stride);

497

+ cloog_int_clear(c_v);

498

+ cloog_int_clear(c_gcd);

499

+ cloog_int_clear(c_factor);

500

}

501

502

- isl_int_clear(stride);

503

- isl_int_clear(factor);

504

- isl_int_clear(gcd);

505

- isl_int_clear(m);

506

- isl_int_clear(v);

507

+ isl_val_free(stride);

508

+ isl_val_free(gcd_copy);

509

+ isl_val_free(m_copy);

510

+ isl_val_free(v_copy);

511

512

return s;

513

}

514

@@ -1694,7 +1780,7 @@ static int find_stride(__isl_take isl_co

515

{

516

struct cloog_isl_find_stride_data *data;

517

int n;

518

- isl_int v;

519

+ isl_val *v;

520

521

if (!isl_constraint_is_equality(c)) {

522

isl_constraint_free(c);

523

@@ -1714,13 +1800,11 @@ static int find_stride(__isl_take isl_co

524

return 0;

525

}

526

527

- isl_int_init(v);

528

-

529

- isl_constraint_get_coefficient(c, isl_dim_set, data->level - 1, &v);

530

- if (!isl_int_is_zero(v))

531

+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, data->level - 1);

532

+ if (!isl_val_is_zero(v))

533

data->stride = construct_stride(c, data->level);

534

535

- isl_int_clear(v);

536

+ isl_val_free(v);

537

538

isl_constraint_free(c);

539

540

@@ -1769,7 +1853,7 @@ struct cloog_can_unroll {

541

int level;

542

isl_constraint *c;

543

isl_set *set;

544

- isl_int *n;

545

+ isl_val *n;

546

};

547

548

549

@@ -1782,11 +1866,11 @@ struct cloog_can_unroll {

550

* with l the given lower bound and i the iterator identified by level.

551

*/

552

static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu,

553

- __isl_keep isl_constraint *c, isl_int *v)

554

+ __isl_keep isl_constraint *c, isl_val **v)

555

{

556

unsigned n_div;

557

isl_aff *aff;

558

- enum isl_lp_result res;

559

+ enum isl_lp_result;

560

561

n_div = isl_constraint_dim(c, isl_dim_div);

562

if (isl_constraint_involves_dims(c, isl_dim_div, 0, n_div))

563

@@ -1796,15 +1880,19 @@ static int is_valid_unrolling_lower_boun

564

aff = isl_aff_ceil(aff);

565

aff = isl_aff_neg(aff);

566

aff = isl_aff_add_coefficient_si(aff, isl_dim_in, ccu->level - 1, 1);

567

- res = isl_set_max(ccu->set, aff, v);

568

+ *v = isl_set_max_val(ccu->set, aff);

569

isl_aff_free(aff);

570

571

- if (res == isl_lp_unbounded)

572

- return 0;

573

+ if (!*v || isl_val_is_nan(*v))

574

+ cloog_die("Fail to decide about unrolling (cannot find max)");

575

576

- assert(res == isl_lp_ok);

577

+ if (isl_val_is_infty(*v) || isl_val_is_neginfty(*v)){

578

+ isl_val_free(*v);

579

+ *v = NULL;

580

+ return 0;

581

+ }

582

583

- cloog_int_add_ui(*v, *v, 1);

584

+ *v = isl_val_add_ui(*v, 1);

585

586

return 1;

587

}

588

@@ -1818,21 +1906,21 @@ static int is_valid_unrolling_lower_boun

589

static int constraint_can_unroll(__isl_take isl_constraint *c, void *user)

590

{

591

struct cloog_can_unroll *ccu = (struct cloog_can_unroll *)user;

592

- isl_int v;

593

- isl_int count;

594

+ isl_val *v;

595

+ isl_val *count = NULL;

596

597

- isl_int_init(v);

598

- isl_int_init(count);

599

- isl_constraint_get_coefficient(c, isl_dim_set, ccu->level - 1, &v);

600

- if (isl_int_is_pos(v) &&

601

- is_valid_unrolling_lower_bound(ccu, c, &count) &&

602

- (!ccu->c || isl_int_lt(count, *ccu->n))) {

603

+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, ccu->level - 1);

604

+ if (isl_val_is_pos(v) &&

605

+ is_valid_unrolling_lower_bound(ccu, c, &count) &&

606

+ (!ccu->c || (isl_val_lt(count, ccu->n))) ) {

607

isl_constraint_free(ccu->c);

608

ccu->c = isl_constraint_copy(c);

609

- isl_int_set(*ccu->n, count);

610

+ if (ccu->n)

611

+ isl_val_free(ccu->n);

612

+ ccu->n = isl_val_copy(count);

613

}

614

- isl_int_clear(count);

615

- isl_int_clear(v);

616

+ isl_val_free(count);

617

+ isl_val_free(v);

618

isl_constraint_free(c);

619

620

return 0;

621

@@ -1872,7 +1960,8 @@ int cloog_domain_can_unroll(CloogDomain

622

CloogConstraint **lb)

623

{

624

isl_set *set = isl_set_from_cloog_domain(domain);

625

- struct cloog_can_unroll ccu = { 1, level, NULL, set, n };

626

+ isl_val *v = cloog_int_to_isl_val(isl_set_get_ctx(set), *n);

627

+ struct cloog_can_unroll ccu = { 1, level, NULL, set, v };

628

int r;

629

630

*lb = NULL;

631

@@ -1887,6 +1976,11 @@ int cloog_domain_can_unroll(CloogDomain

632

633

*lb = cloog_constraint_from_isl_constraint(ccu.c);

634

635

+ isl_val_to_cloog_int(ccu.n, n);

636

+ /* Note: we have to free ccu.n and not v because v has been

637

+ * freed and replaced in ccu during isl_set_foreach_basic_set

638

+ */

639

+ isl_val_free(ccu.n);

640

return ccu.can_unroll;

641

}

642

643

@@ -1904,6 +1998,7 @@ CloogDomain *cloog_domain_fixed_offset(C

644

{

645

isl_aff *aff;

646

isl_set *set = isl_set_from_cloog_domain(domain);

647

+ isl_ctx *ctx = isl_set_get_ctx(set);

648

isl_constraint *c;

649

isl_constraint *eq;

650

651

@@ -1911,7 +2006,7 @@ CloogDomain *cloog_domain_fixed_offset(C

652

aff = isl_constraint_get_bound(c, isl_dim_set, level - 1);

653

aff = isl_aff_ceil(aff);

654

aff = isl_aff_add_coefficient_si(aff, isl_dim_in, level - 1, -1);

655

- aff = isl_aff_add_constant(aff, offset);

656

+ aff = isl_aff_add_constant_val(aff, cloog_int_to_isl_val(ctx, offset));

657

eq = isl_equality_from_aff(aff);

658

set = isl_set_add_constraint(set, eq);

659

660

Index: b/include/cloog/isl/constraintset.h

661

===================================================================

662

--- a/include/cloog/isl/constraintset.h

663

+++ b/include/cloog/isl/constraintset.h

664

@@ -27,6 +27,12 @@ CloogConstraintSet *cloog_constraint_set

665

CloogConstraint *cloog_constraint_from_isl_constraint(struct isl_constraint *constraint);

666

isl_constraint *cloog_constraint_to_isl(CloogConstraint *constraint);

667

668

+__isl_give isl_val *cloog_int_to_isl_val(isl_ctx* ctx, cloog_int_t c);

669

+void isl_val_to_cloog_int(__isl_keep isl_val *val, cloog_int_t *cint);

670

+

671

+__isl_give isl_val *cloog_constraint_coefficient_get_val(CloogConstraint *constraint,

672

+ int var);

673

+

674

#if defined(__cplusplus)

675

}

676

#endif

677

Index: b/source/isl/constraints.c

678

===================================================================

679

--- a/source/isl/constraints.c

680

+++ b/source/isl/constraints.c

681

@@ -5,11 +5,51 @@

682

#include <cloog/isl/backend.h>

683

#include <isl/aff.h>

684

#include <isl/set.h>

685

+#include <isl/val.h>

686

+#include <isl/val_gmp.h>

687

688

689

#define ALLOC(type) (type*)malloc(sizeof(type))

690

#define ALLOCN(type,n) (type*)malloc((n)*sizeof(type))

691

692

+__isl_give isl_val *cloog_int_to_isl_val(isl_ctx* ctx, cloog_int_t c)

693

+{

694

+ isl_val *v;

695

+#if defined(CLOOG_INT_INT)

696

+ v = isl_val_int_from_si(ctx, c);

697

+#elif defined(CLOOG_INT_LONG)

698

+ v = isl_val_int_from_si(ctx, c);

699

+#elif defined(CLOOG_INT_LONG_LONG)

700

+ v = isl_val_int_from_si(ctx, c);

701

+#elif defined(CLOOG_INT_GMP)

702

+ v = isl_val_int_from_gmp(ctx, c);

703

+#else

704

+#error "No integer type defined"

705

+#endif

706

+ return v;

707

+}

708

+

709

+/*

710

+ * CLooG'll be dealing in integers so we expect numerator/1 form

711

+ * from isl_val. Thus get numerator to assign to cloog_int

712

+ */

713

+void isl_val_to_cloog_int(__isl_keep isl_val *val, cloog_int_t *cint)

714

+{

715

+ assert(isl_val_is_int(val));

716

+#if defined(CLOOG_INT_INT)

717

+ *cint = isl_val_get_num_si(val);

718

+#elif defined(CLOOG_INT_LONG)

719

+ *cint = isl_val_get_num_si(val);

720

+#elif defined(CLOOG_INT_LONG_LONG)

721

+ *cint = isl_val_get_num_si(val);

722

+#elif defined(CLOOG_INT_GMP)

723

+ isl_val_get_num_gmp(val, *cint);

724

+#else

725

+#error "No integer type defined"

726

+#endif

727

+}

728

+

729

+

730

CloogConstraintSet *cloog_constraint_set_from_isl_basic_set(struct isl_basic_set *bset)

731

{

732

return (CloogConstraintSet *)bset;

733

@@ -266,53 +306,65 @@ int cloog_equal_count(CloogEqualities *e

734

static int cloog_constraint_equal_type(CloogConstraint *cc, int level)

735

{

736

int i;

737

- isl_int c;

738

+ isl_val *c;

739

int type = EQTYPE_NONE;

740

struct isl_constraint *constraint = cloog_constraint_to_isl(cc);

741

742

- isl_int_init(c);

743

- isl_constraint_get_constant(constraint, &c);

744

- if (!isl_int_is_zero(c))

745

+ c = isl_constraint_get_constant_val(constraint);

746

+ if (!isl_val_is_zero(c))

747

type = EQTYPE_CONSTANT;

748

- isl_constraint_get_coefficient(constraint, isl_dim_set, level - 1, &c);

749

- if (!isl_int_is_one(c) && !isl_int_is_negone(c))

750

+ isl_val_free(c);

751

+ c = isl_constraint_get_coefficient_val(constraint, isl_dim_set, level - 1);

752

+ if (!isl_val_is_one(c) && !isl_val_is_negone(c))

753

type = EQTYPE_EXAFFINE;

754

+ isl_val_free(c);

755

for (i = 0; i < isl_constraint_dim(constraint, isl_dim_param); ++i) {

756

- isl_constraint_get_coefficient(constraint, isl_dim_param, i, &c);

757

- if (isl_int_is_zero(c))

758

+ c = isl_constraint_get_coefficient_val(constraint, isl_dim_param, i);

759

+ if (isl_val_is_zero(c)){

760

+ isl_val_free(c);

761

continue;

762

- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||

763

+ }

764

+ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||

765

type != EQTYPE_NONE) {

766

type = EQTYPE_EXAFFINE;

767

+ isl_val_free(c);

768

break;

769

}

770

type = EQTYPE_PUREITEM;

771

+ isl_val_free(c);

772

}

773

for (i = 0; i < isl_constraint_dim(constraint, isl_dim_set); ++i) {

774

if (i == level - 1)

775

continue;

776

- isl_constraint_get_coefficient(constraint, isl_dim_set, i, &c);

777

- if (isl_int_is_zero(c))

778

+ c = isl_constraint_get_coefficient_val(constraint, isl_dim_set, i);

779

+ if (isl_val_is_zero(c)){

780

+ isl_val_free(c);

781

continue;

782

- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||

783

+ }

784

+ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||

785

type != EQTYPE_NONE) {

786

type = EQTYPE_EXAFFINE;

787

+ isl_val_free(c);

788

break;

789

}

790

type = EQTYPE_PUREITEM;

791

+ isl_val_free(c);

792

}

793

for (i = 0; i < isl_constraint_dim(constraint, isl_dim_div); ++i) {

794

- isl_constraint_get_coefficient(constraint, isl_dim_div, i, &c);

795

- if (isl_int_is_zero(c))

796

+ c = isl_constraint_get_coefficient_val(constraint, isl_dim_div, i);

797

+ if (isl_val_is_zero(c)){

798

+ isl_val_free(c);

799

continue;

800

- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||

801

+ }

802

+ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||

803

type != EQTYPE_NONE) {

804

type = EQTYPE_EXAFFINE;

805

+ isl_val_free(c);

806

break;

807

}

808

type = EQTYPE_PUREITEM;

809

+ isl_val_free(c);

810

}

811

- isl_int_clear(c);

812

813

if (type == EQTYPE_NONE)

814

type = EQTYPE_CONSTANT;

815

@@ -447,27 +499,31 @@ static struct clast_expr *div_expr(Cloog

816

{

817

int i, nb_elts;

818

unsigned dim = cloog_constraint_total_dimension(constraint);

819

- cloog_int_t c;

820

+ isl_val *c;

821

struct clast_reduction *r;

822

struct clast_expr *e = NULL;

823

isl_aff *div;

824

+ cloog_int_t cint;

825

826

+ cloog_int_init(cint);

827

div = isl_constraint_get_div(cloog_constraint_to_isl(constraint), pos);

828

829

- cloog_int_init(c);

830

for (i = 0, nb_elts = 0; i < dim; ++i) {

831

struct cloog_isl_dim dim;

832

833

dim = constraint_cloog_dim_to_isl_dim(constraint, i);

834

if (dim.type == isl_dim_set)

835

dim.type = isl_dim_in;

836

- isl_aff_get_coefficient(div, dim.type, dim.pos, &c);

837

- if (!cloog_int_is_zero(c))

838

+ c = isl_aff_get_coefficient_val(div, dim.type, dim.pos);

839

+ if (!isl_val_is_zero(c))

840

++nb_elts;

841

+

842

+ isl_val_free(c);

843

}

844

- isl_aff_get_constant(div, &c);

845

- if (!cloog_int_is_zero(c))

846

+ c = isl_aff_get_constant_val(div);

847

+ if (!isl_val_is_zero(c))

848

++nb_elts;

849

+ isl_val_free(c);

850

851

r = new_clast_reduction(clast_red_sum, nb_elts);

852

for (i = 0, nb_elts = 0; i < dim; ++i) {

853

@@ -477,22 +533,35 @@ static struct clast_expr *div_expr(Cloog

854

dim = constraint_cloog_dim_to_isl_dim(constraint, i);

855

if (dim.type == isl_dim_set)

856

dim.type = isl_dim_in;

857

- isl_aff_get_coefficient(div, dim.type, dim.pos, &c);

858

- if (cloog_int_is_zero(c))

859

+ c = isl_aff_get_coefficient_val(div, dim.type, dim.pos);

860

+ if (isl_val_is_zero(c)){

861

+ isl_val_free(c);

862

continue;

863

+ }

864

865

v = cloog_constraint_variable_expr(constraint, 1 + i, names);

866

867

- r->elts[nb_elts++] = &new_clast_term(c, v)->expr;

868

+ /* We are interested only in the numerator */

869

+ cloog_int_set_si(cint, isl_val_get_num_si(c));

870

+ r->elts[nb_elts++] = &new_clast_term(cint, v)->expr;

871

+

872

+ isl_val_free(c);

873

}

874

- isl_aff_get_constant(div, &c);

875

- if (!cloog_int_is_zero(c))

876

- r->elts[nb_elts++] = &new_clast_term(c, NULL)->expr;

877

878

- isl_aff_get_denominator(div, &c);

879

- e = &new_clast_binary(clast_bin_fdiv, &r->expr, c)->expr;

880

+ c = isl_aff_get_constant_val(div);

881

+ if (!isl_val_is_zero(c)) {

882

+ /* We are interested only in the numerator */

883

+ cloog_int_set_si(cint, isl_val_get_num_si(c));

884

+ r->elts[nb_elts++] = &new_clast_term(cint, NULL)->expr;

885

+ }

886

+ isl_val_free(c);

887

888

- cloog_int_clear(c);

889

+ c = isl_aff_get_denominator_val(div);

890

+ isl_val_to_cloog_int(c, &cint);

891

+ isl_val_free(c);

892

+ e = &new_clast_binary(clast_bin_fdiv, &r->expr, cint)->expr;

893

+

894

+ cloog_int_clear(cint);

895

896

isl_aff_free(div);

897

898

@@ -529,37 +598,34 @@ struct clast_expr *cloog_constraint_vari

899

*/

900

int cloog_constraint_involves(CloogConstraint *constraint, int v)

901

{

902

- isl_int c;

903

+ isl_val *c;

904

int res;

905

906

- isl_int_init(c);

907

- cloog_constraint_coefficient_get(constraint, v, &c);

908

- res = !isl_int_is_zero(c);

909

- isl_int_clear(c);

910

+ c = cloog_constraint_coefficient_get_val(constraint, v);

911

+ res = !isl_val_is_zero(c);

912

+ isl_val_free(c);

913

return res;

914

}

915

916

int cloog_constraint_is_lower_bound(CloogConstraint *constraint, int v)

917

{

918

- isl_int c;

919

+ isl_val *c;

920

int res;

921

922

- isl_int_init(c);

923

- cloog_constraint_coefficient_get(constraint, v, &c);

924

- res = isl_int_is_pos(c);

925

- isl_int_clear(c);

926

+ c = cloog_constraint_coefficient_get_val(constraint, v);

927

+ res = isl_val_is_pos(c);

928

+ isl_val_free(c);

929

return res;

930

}

931

932

int cloog_constraint_is_upper_bound(CloogConstraint *constraint, int v)

933

{

934

- isl_int c;

935

+ isl_val *c;

936

int res;

937

938

- isl_int_init(c);

939

- cloog_constraint_coefficient_get(constraint, v, &c);

940

- res = isl_int_is_neg(c);

941

- isl_int_clear(c);

942

+ c = cloog_constraint_coefficient_get_val(constraint, v);

943

+ res = isl_val_is_neg(c);

944

+ isl_val_free(c);

945

return res;

946

}

947

948

@@ -585,15 +651,37 @@ void cloog_constraint_coefficient_get(Cl

949

{

950

struct cloog_isl_dim dim;

951

isl_constraint *c;

952

+ isl_val *ival;

953

954

if (!constraint)

955

- return;

956

+ val = NULL;

957

958

dim = constraint_cloog_dim_to_isl_dim(constraint, var);

959

c = cloog_constraint_to_isl(constraint);

960

- isl_constraint_get_coefficient(c, dim.type, dim.pos, val);

961

+ ival = isl_constraint_get_coefficient_val(c, dim.type, dim.pos);

962

+

963

+ isl_val_to_cloog_int(ival, val);

964

+ isl_val_free(ival);

965

}

966

967

+isl_val *cloog_constraint_coefficient_get_val(CloogConstraint *constraint,

968

+ int var)

969

+{

970

+ struct cloog_isl_dim dim;

971

+ isl_constraint *c;

972

+ isl_val *val;

973

+

974

+ if (!constraint)

975

+ return NULL;

976

+

977

+ dim = constraint_cloog_dim_to_isl_dim(constraint, var);

978

+ c = cloog_constraint_to_isl(constraint);

979

+ val = isl_constraint_get_coefficient_val(c, dim.type, dim.pos);

980

+ return val;

981

+}

982

+

983

+

984

+

985

void cloog_constraint_coefficient_set(CloogConstraint *constraint,

986

int var, cloog_int_t val)

987

{

988

@@ -604,14 +692,26 @@ void cloog_constraint_coefficient_set(Cl

989

990

dim = constraint_cloog_dim_to_isl_dim(constraint, var);

991

c = cloog_constraint_to_isl(constraint);

992

- isl_constraint_set_coefficient(c, dim.type, dim.pos, val);

993

+ isl_constraint_set_coefficient_val(c, dim.type, dim.pos,

994

+ cloog_int_to_isl_val(isl_constraint_get_ctx(c), val));

995

}

996

997

void cloog_constraint_constant_get(CloogConstraint *constraint, cloog_int_t *val)

998

{

999

- isl_constraint_get_constant(cloog_constraint_to_isl(constraint), val);

1000

+ isl_val *ival;

1001

+ ival = isl_constraint_get_constant_val(cloog_constraint_to_isl(constraint));

1002

+ isl_val_to_cloog_int(ival, val);

1003

+ isl_val_free(ival);

1004

}

1005

1006

+

1007

+__isl_give isl_val *cloog_constraint_constant_get_val(CloogConstraint *constraint)

1008

+{

1009

+ return isl_constraint_get_constant_val(cloog_constraint_to_isl(constraint));

1010

+}

1011

+

1012

+

1013

+

1014

/**

1015

* Copy the coefficient of constraint c into dst in PolyLib order,

1016

* i.e., first the coefficients of the variables, then the coefficients

1017

@@ -700,15 +800,11 @@ CloogConstraintSet *cloog_constraint_set

1018

1019

static int add_constant_term(CloogConstraint *c, void *user)

1020

{

1021

- isl_int *bound = (isl_int *)user;

1022

- isl_int v;

1023

-

1024

- isl_int_init(v);

1025

+ isl_val **bound = (isl_val **)user;

1026

+ isl_val *v;

1027

1028

- cloog_constraint_constant_get(c, &v);

1029

- isl_int_add(*bound, *bound, v);

1030

-

1031

- isl_int_clear(v);

1032

+ v = cloog_constraint_constant_get_val(c);

1033

+ *bound = isl_val_add(*bound, v);

1034

1035

return 0;

1036

}

1037

@@ -822,11 +918,14 @@ CloogConstraintSet *cloog_constraint_set

1038

c = isl_constraint_set_coefficient_si(c, isl_dim_set, dim.pos, -1);

1039

bset = isl_basic_set_add_constraint(bset, c);

1040

1041

- isl_int_set_si(*bound, 0);

1042

+ cloog_int_set_si(*bound, 0);

1043

+ isl_val *v = cloog_int_to_isl_val(isl_basic_set_get_ctx(bset), *bound);

1044

constraints = cloog_constraint_set_from_isl_basic_set(bset);

1045

cloog_constraint_set_foreach_constraint(constraints,

1046

- add_constant_term, bound);

1047

+ add_constant_term, &v);

1048

+ isl_val_to_cloog_int(v, bound); //return the value to bound

1049

1050

+ isl_val_free(v);

1051

isl_basic_set_free(orig);

1052

return cloog_constraint_set_from_isl_basic_set(bset);

1053

}

1054

@@ -896,31 +995,27 @@ static isl_aff *extract_stride_offset(__

1055

isl_space *dim = isl_constraint_get_space(c);

1056

isl_local_space *ls = isl_local_space_from_space(dim);

1057

isl_aff *offset = isl_aff_zero_on_domain(ls);

1058

- isl_int u;

1059

+ isl_val *u;

1060

unsigned nparam, nvar;

1061

1062

- isl_int_init(u);

1063

-

1064

nparam = isl_constraint_dim(c, isl_dim_param);

1065

nvar = isl_constraint_dim(c, isl_dim_set);

1066

1067

for (i = 0; i < nparam; ++i) {

1068

- isl_constraint_get_coefficient(c, isl_dim_param, i, &u);

1069

- isl_int_mul(u, u, stride->factor);

1070

- offset = isl_aff_set_coefficient(offset, isl_dim_param, i, u);

1071

+ u = isl_constraint_get_coefficient_val(c, isl_dim_param, i);

1072

+ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));

1073

+ offset = isl_aff_set_coefficient_val(offset, isl_dim_param, i, u);

1074

}

1075

for (i = 0; i < nvar; ++i) {

1076

if (i == level - 1)

1077

continue;

1078

- isl_constraint_get_coefficient(c, isl_dim_set, i, &u);

1079

- isl_int_mul(u, u, stride->factor);

1080

- offset = isl_aff_set_coefficient(offset, isl_dim_in, i, u);

1081

- }

1082

- isl_constraint_get_constant(c, &u);

1083

- isl_int_mul(u, u, stride->factor);

1084

- offset = isl_aff_set_constant(offset, u);

1085

-

1086

- isl_int_clear(u);

1087

+ u = isl_constraint_get_coefficient_val(c, isl_dim_set, i);

1088

+ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));

1089

+ offset = isl_aff_set_coefficient_val(offset, isl_dim_in, i, u);

1090

+ }

1091

+ u = isl_constraint_get_constant_val(c);

1092

+ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));

1093

+ offset = isl_aff_set_constant_val(offset, u);

1094

1095

return offset;

1096

}

1097

@@ -953,9 +1048,9 @@ CloogConstraint *cloog_constraint_stride

1098

offset = extract_stride_offset(stride_c, level, stride);

1099

1100

lower = isl_aff_sub(lower, isl_aff_copy(offset));

1101

- lower = isl_aff_scale_down(lower, stride->stride);

1102

+ lower = isl_aff_scale_down_val(lower, cloog_int_to_isl_val(isl_constraint_get_ctx(stride_c), stride->stride));

1103

lower = isl_aff_ceil(lower);

1104

- lower = isl_aff_scale(lower, stride->stride);

1105

+ lower = isl_aff_scale_val(lower, cloog_int_to_isl_val(isl_constraint_get_ctx(stride_c), stride->stride));

1106

lower = isl_aff_add(lower, offset);

1107

lower = isl_aff_neg(lower);

1108

lower = isl_aff_add_coefficient_si(lower, isl_dim_in, level - 1, 1);

1109

Index: b/test/reservoir/QR.c

1110

===================================================================

1111

--- a/test/reservoir/QR.c

1112

+++ b/test/reservoir/QR.c

1113

@@ -1,6 +1,12 @@

1114

/* Generated from ../../../git/cloog/test/./reservoir/QR.cloog by CLooG 0.14.0-136-gb91ef26 gmp bits in 0.21s. */

1115

if (N >= 1) {

1116

S1(0) ;

1117

+ if ((M <= 0) && (N >= 2)) {

1118

+ S3(0);

1119

+ S10(0);

1120

+ S1(1);

1121

+ S5(0);

1122

+ }

1123

if ((M >= 1) && (N == 1)) {

1124

for (c4=0;c4<=M-1;c4++) {

1125

S2(0,c4) ;

1126

@@ -28,12 +34,6 @@ if (N >= 1) {

1127

S10(0) ;

1128

S1(1) ;

1129

S5(0) ;

1130

- }

1131

- if ((M <= 0) && (N >= 2)) {

1132

- S3(0) ;

1133

- S10(0) ;

1134

- S1(1) ;

1135

- S5(0) ;

1136

}

1137

for (c2=2;c2<=min(M,N-1);c2++) {

1138

for (c4=c2-1;c4<=N-1;c4++) {