2017-01-28 06:51:36 +08:00
|
|
|
//===------ ISLTools.cpp ----------------------------------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Tools, utilities, helpers and extensions useful in conjunction with the
|
|
|
|
// Integer Set Library (isl).
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "polly/Support/ISLTools.h"
|
2017-09-29 23:45:40 +08:00
|
|
|
#include "llvm/ADT/StringRef.h"
|
2017-01-28 06:51:36 +08:00
|
|
|
|
|
|
|
using namespace polly;
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
/// Create a map that shifts one dimension by an offset.
|
|
|
|
///
|
|
|
|
/// Example:
|
|
|
|
/// makeShiftDimAff({ [i0, i1] -> [o0, o1] }, 1, -2)
|
|
|
|
/// = { [i0, i1] -> [i0, i1 - 1] }
|
|
|
|
///
|
|
|
|
/// @param Space The map space of the result. Must have equal number of in- and
|
|
|
|
/// out-dimensions.
|
|
|
|
/// @param Pos Position to shift.
|
|
|
|
/// @param Amount Value added to the shifted dimension.
|
|
|
|
///
|
|
|
|
/// @return An isl_multi_aff for the map with this shifted dimension.
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::multi_aff makeShiftDimAff(isl::space Space, int Pos, int Amount) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto Identity = give(isl_multi_aff_identity(Space.take()));
|
|
|
|
if (Amount == 0)
|
|
|
|
return Identity;
|
|
|
|
auto ShiftAff = give(isl_multi_aff_get_aff(Identity.keep(), Pos));
|
|
|
|
ShiftAff = give(isl_aff_set_constant_si(ShiftAff.take(), Amount));
|
|
|
|
return give(isl_multi_aff_set_aff(Identity.take(), Pos, ShiftAff.take()));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Construct a map that swaps two nested tuples.
|
|
|
|
///
|
|
|
|
/// @param FromSpace1 { Space1[] }
|
|
|
|
/// @param FromSpace2 { Space2[] }
|
|
|
|
///
|
|
|
|
/// @return { [Space1[] -> Space2[]] -> [Space2[] -> Space1[]] }
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::basic_map makeTupleSwapBasicMap(isl::space FromSpace1,
|
|
|
|
isl::space FromSpace2) {
|
2017-01-28 06:51:36 +08:00
|
|
|
assert(isl_space_is_set(FromSpace1.keep()) != isl_bool_false);
|
|
|
|
assert(isl_space_is_set(FromSpace2.keep()) != isl_bool_false);
|
|
|
|
|
|
|
|
auto Dims1 = isl_space_dim(FromSpace1.keep(), isl_dim_set);
|
|
|
|
auto Dims2 = isl_space_dim(FromSpace2.keep(), isl_dim_set);
|
|
|
|
auto FromSpace = give(isl_space_wrap(isl_space_map_from_domain_and_range(
|
|
|
|
FromSpace1.copy(), FromSpace2.copy())));
|
|
|
|
auto ToSpace = give(isl_space_wrap(isl_space_map_from_domain_and_range(
|
|
|
|
FromSpace2.take(), FromSpace1.take())));
|
|
|
|
auto MapSpace = give(
|
|
|
|
isl_space_map_from_domain_and_range(FromSpace.take(), ToSpace.take()));
|
|
|
|
|
|
|
|
auto Result = give(isl_basic_map_universe(MapSpace.take()));
|
|
|
|
for (auto i = Dims1 - Dims1; i < Dims1; i += 1) {
|
|
|
|
Result = give(isl_basic_map_equate(Result.take(), isl_dim_in, i,
|
|
|
|
isl_dim_out, Dims2 + i));
|
|
|
|
}
|
|
|
|
for (auto i = Dims2 - Dims2; i < Dims2; i += 1) {
|
|
|
|
Result = give(isl_basic_map_equate(Result.take(), isl_dim_in, Dims1 + i,
|
|
|
|
isl_dim_out, i));
|
|
|
|
}
|
|
|
|
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
/// Like makeTupleSwapBasicMap(isl::space,isl::space), but returns
|
2017-01-28 06:51:36 +08:00
|
|
|
/// an isl_map.
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::map makeTupleSwapMap(isl::space FromSpace1, isl::space FromSpace2) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto BMapResult =
|
|
|
|
makeTupleSwapBasicMap(std::move(FromSpace1), std::move(FromSpace2));
|
|
|
|
return give(isl_map_from_basic_map(BMapResult.take()));
|
|
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::map polly::beforeScatter(isl::map Map, bool Strict) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto RangeSpace = give(isl_space_range(isl_map_get_space(Map.keep())));
|
|
|
|
auto ScatterRel = give(Strict ? isl_map_lex_gt(RangeSpace.take())
|
|
|
|
: isl_map_lex_ge(RangeSpace.take()));
|
|
|
|
return give(isl_map_apply_range(Map.take(), ScatterRel.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_map polly::beforeScatter(isl::union_map UMap, bool Strict) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
|
2017-04-14 21:39:40 +08:00
|
|
|
UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto After = beforeScatter(Map, Strict);
|
|
|
|
Result = give(isl_union_map_add_map(Result.take(), After.take()));
|
2017-04-14 21:39:40 +08:00
|
|
|
return isl::stat::ok;
|
2017-01-28 06:51:36 +08:00
|
|
|
});
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::map polly::afterScatter(isl::map Map, bool Strict) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto RangeSpace = give(isl_space_range(isl_map_get_space(Map.keep())));
|
|
|
|
auto ScatterRel = give(Strict ? isl_map_lex_lt(RangeSpace.take())
|
|
|
|
: isl_map_lex_le(RangeSpace.take()));
|
|
|
|
return give(isl_map_apply_range(Map.take(), ScatterRel.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_map polly::afterScatter(const isl::union_map &UMap, bool Strict) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
|
2017-04-14 21:39:40 +08:00
|
|
|
UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto After = afterScatter(Map, Strict);
|
|
|
|
Result = give(isl_union_map_add_map(Result.take(), After.take()));
|
2017-04-14 21:39:40 +08:00
|
|
|
return isl::stat::ok;
|
2017-01-28 06:51:36 +08:00
|
|
|
});
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::map polly::betweenScatter(isl::map From, isl::map To, bool InclFrom,
|
|
|
|
bool InclTo) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto AfterFrom = afterScatter(From, !InclFrom);
|
|
|
|
auto BeforeTo = beforeScatter(To, !InclTo);
|
|
|
|
|
|
|
|
return give(isl_map_intersect(AfterFrom.take(), BeforeTo.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_map polly::betweenScatter(isl::union_map From, isl::union_map To,
|
|
|
|
bool InclFrom, bool InclTo) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto AfterFrom = afterScatter(From, !InclFrom);
|
|
|
|
auto BeforeTo = beforeScatter(To, !InclTo);
|
|
|
|
|
|
|
|
return give(isl_union_map_intersect(AfterFrom.take(), BeforeTo.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::map polly::singleton(isl::union_map UMap, isl::space ExpectedSpace) {
|
2017-01-28 06:51:36 +08:00
|
|
|
if (!UMap)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (isl_union_map_n_map(UMap.keep()) == 0)
|
2017-09-04 18:05:29 +08:00
|
|
|
return isl::map::empty(ExpectedSpace);
|
|
|
|
|
|
|
|
isl::map Result = isl::map::from_union_map(UMap);
|
|
|
|
assert(!Result || Result.get_space().has_equal_tuples(ExpectedSpace));
|
2017-01-28 06:51:36 +08:00
|
|
|
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::set polly::singleton(isl::union_set USet, isl::space ExpectedSpace) {
|
2017-01-28 06:51:36 +08:00
|
|
|
if (!USet)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (isl_union_set_n_set(USet.keep()) == 0)
|
2017-09-04 18:05:29 +08:00
|
|
|
return isl::set::empty(ExpectedSpace);
|
|
|
|
|
|
|
|
isl::set Result(USet);
|
|
|
|
assert(!Result || Result.get_space().has_equal_tuples(ExpectedSpace));
|
2017-01-28 06:51:36 +08:00
|
|
|
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
unsigned polly::getNumScatterDims(const isl::union_map &Schedule) {
|
2017-01-28 06:51:36 +08:00
|
|
|
unsigned Dims = 0;
|
2017-04-14 21:39:40 +08:00
|
|
|
Schedule.foreach_map([&Dims](isl::map Map) -> isl::stat {
|
2017-01-28 06:51:36 +08:00
|
|
|
Dims = std::max(Dims, isl_map_dim(Map.keep(), isl_dim_out));
|
2017-04-14 21:39:40 +08:00
|
|
|
return isl::stat::ok;
|
2017-01-28 06:51:36 +08:00
|
|
|
});
|
|
|
|
return Dims;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
|
2017-01-28 06:51:36 +08:00
|
|
|
if (!Schedule)
|
|
|
|
return nullptr;
|
|
|
|
auto Dims = getNumScatterDims(Schedule);
|
|
|
|
auto ScatterSpace =
|
|
|
|
give(isl_space_set_from_params(isl_union_map_get_space(Schedule.keep())));
|
|
|
|
return give(isl_space_add_dims(ScatterSpace.take(), isl_dim_set, Dims));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_map polly::makeIdentityMap(const isl::union_set &USet,
|
|
|
|
bool RestrictDomain) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto Result = give(isl_union_map_empty(isl_union_set_get_space(USet.keep())));
|
2017-04-14 21:39:40 +08:00
|
|
|
USet.foreach_set([=, &Result](isl::set Set) -> isl::stat {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto IdentityMap = give(isl_map_identity(
|
|
|
|
isl_space_map_from_set(isl_set_get_space(Set.keep()))));
|
|
|
|
if (RestrictDomain)
|
|
|
|
IdentityMap =
|
|
|
|
give(isl_map_intersect_domain(IdentityMap.take(), Set.take()));
|
|
|
|
Result = give(isl_union_map_add_map(Result.take(), IdentityMap.take()));
|
2017-04-14 21:39:40 +08:00
|
|
|
return isl::stat::ok;
|
2017-01-28 06:51:36 +08:00
|
|
|
});
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::map polly::reverseDomain(isl::map Map) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto DomSpace =
|
|
|
|
give(isl_space_unwrap(isl_space_domain(isl_map_get_space(Map.keep()))));
|
|
|
|
auto Space1 = give(isl_space_domain(DomSpace.copy()));
|
|
|
|
auto Space2 = give(isl_space_range(DomSpace.take()));
|
|
|
|
auto Swap = makeTupleSwapMap(std::move(Space1), std::move(Space2));
|
|
|
|
return give(isl_map_apply_domain(Map.take(), Swap.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_map polly::reverseDomain(const isl::union_map &UMap) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
|
2017-04-14 21:39:40 +08:00
|
|
|
UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto Reversed = reverseDomain(std::move(Map));
|
|
|
|
Result = give(isl_union_map_add_map(Result.take(), Reversed.take()));
|
2017-04-14 21:39:40 +08:00
|
|
|
return isl::stat::ok;
|
2017-01-28 06:51:36 +08:00
|
|
|
});
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::set polly::shiftDim(isl::set Set, int Pos, int Amount) {
|
2017-01-28 06:51:36 +08:00
|
|
|
int NumDims = isl_set_dim(Set.keep(), isl_dim_set);
|
|
|
|
if (Pos < 0)
|
|
|
|
Pos = NumDims + Pos;
|
|
|
|
assert(Pos < NumDims && "Dimension index must be in range");
|
|
|
|
auto Space = give(isl_set_get_space(Set.keep()));
|
|
|
|
Space = give(isl_space_map_from_domain_and_range(Space.copy(), Space.copy()));
|
|
|
|
auto Translator = makeShiftDimAff(std::move(Space), Pos, Amount);
|
|
|
|
auto TranslatorMap = give(isl_map_from_multi_aff(Translator.take()));
|
|
|
|
return give(isl_set_apply(Set.take(), TranslatorMap.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_set polly::shiftDim(isl::union_set USet, int Pos, int Amount) {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto Result = give(isl_union_set_empty(isl_union_set_get_space(USet.keep())));
|
2017-04-14 21:39:40 +08:00
|
|
|
USet.foreach_set([=, &Result](isl::set Set) -> isl::stat {
|
2017-01-28 06:51:36 +08:00
|
|
|
auto Shifted = shiftDim(Set, Pos, Amount);
|
|
|
|
Result = give(isl_union_set_add_set(Result.take(), Shifted.take()));
|
2017-04-14 21:39:40 +08:00
|
|
|
return isl::stat::ok;
|
2017-01-28 06:51:36 +08:00
|
|
|
});
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2017-03-23 03:31:06 +08:00
|
|
|
isl::map polly::shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount) {
|
|
|
|
int NumDims = Map.dim(Dim);
|
|
|
|
if (Pos < 0)
|
|
|
|
Pos = NumDims + Pos;
|
|
|
|
assert(Pos < NumDims && "Dimension index must be in range");
|
|
|
|
auto Space = give(isl_map_get_space(Map.keep()));
|
|
|
|
switch (Dim) {
|
|
|
|
case isl::dim::in:
|
|
|
|
Space = std::move(Space).domain();
|
|
|
|
break;
|
|
|
|
case isl::dim::out:
|
|
|
|
Space = give(isl_space_range(Space.take()));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Unsupported value for 'dim'");
|
|
|
|
}
|
|
|
|
Space = give(isl_space_map_from_domain_and_range(Space.copy(), Space.copy()));
|
|
|
|
auto Translator = makeShiftDimAff(std::move(Space), Pos, Amount);
|
|
|
|
auto TranslatorMap = give(isl_map_from_multi_aff(Translator.take()));
|
|
|
|
switch (Dim) {
|
|
|
|
case isl::dim::in:
|
|
|
|
return Map.apply_domain(TranslatorMap);
|
|
|
|
case isl::dim::out:
|
|
|
|
return Map.apply_range(TranslatorMap);
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Unsupported value for 'dim'");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
isl::union_map polly::shiftDim(isl::union_map UMap, isl::dim Dim, int Pos,
|
|
|
|
int Amount) {
|
|
|
|
auto Result = isl::union_map::empty(UMap.get_space());
|
|
|
|
|
2017-04-14 21:39:40 +08:00
|
|
|
UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
|
2017-03-23 03:31:06 +08:00
|
|
|
auto Shifted = shiftDim(Map, Dim, Pos, Amount);
|
|
|
|
Result = std::move(Result).add_map(Shifted);
|
2017-04-14 21:39:40 +08:00
|
|
|
return isl::stat::ok;
|
2017-03-23 03:31:06 +08:00
|
|
|
});
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
void polly::simplify(isl::set &Set) {
|
2017-01-28 06:51:36 +08:00
|
|
|
Set = give(isl_set_compute_divs(Set.take()));
|
|
|
|
Set = give(isl_set_detect_equalities(Set.take()));
|
|
|
|
Set = give(isl_set_coalesce(Set.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
void polly::simplify(isl::union_set &USet) {
|
2017-01-28 06:51:36 +08:00
|
|
|
USet = give(isl_union_set_compute_divs(USet.take()));
|
|
|
|
USet = give(isl_union_set_detect_equalities(USet.take()));
|
|
|
|
USet = give(isl_union_set_coalesce(USet.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
void polly::simplify(isl::map &Map) {
|
2017-01-28 06:51:36 +08:00
|
|
|
Map = give(isl_map_compute_divs(Map.take()));
|
|
|
|
Map = give(isl_map_detect_equalities(Map.take()));
|
|
|
|
Map = give(isl_map_coalesce(Map.take()));
|
|
|
|
}
|
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
void polly::simplify(isl::union_map &UMap) {
|
2017-01-28 06:51:36 +08:00
|
|
|
UMap = give(isl_union_map_compute_divs(UMap.take()));
|
|
|
|
UMap = give(isl_union_map_detect_equalities(UMap.take()));
|
|
|
|
UMap = give(isl_union_map_coalesce(UMap.take()));
|
|
|
|
}
|
2017-02-04 23:42:01 +08:00
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_map polly::computeReachingWrite(isl::union_map Schedule,
|
|
|
|
isl::union_map Writes, bool Reverse,
|
|
|
|
bool InclPrevDef, bool InclNextDef) {
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
// { Scatter[] }
|
2017-10-24 23:19:46 +08:00
|
|
|
isl::space ScatterSpace = getScatterSpace(Schedule);
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
// { ScatterRead[] -> ScatterWrite[] }
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::map Relation;
|
2017-02-04 23:42:01 +08:00
|
|
|
if (Reverse)
|
2017-10-24 23:19:46 +08:00
|
|
|
Relation = InclPrevDef ? isl::map::lex_lt(ScatterSpace)
|
|
|
|
: isl::map::lex_le(ScatterSpace);
|
2017-02-04 23:42:01 +08:00
|
|
|
else
|
2017-10-24 23:19:46 +08:00
|
|
|
Relation = InclNextDef ? isl::map::lex_gt(ScatterSpace)
|
|
|
|
: isl::map::lex_ge(ScatterSpace);
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
// { ScatterWrite[] -> [ScatterRead[] -> ScatterWrite[]] }
|
2017-10-24 23:19:46 +08:00
|
|
|
isl::map RelationMap = Relation.range_map().reverse();
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
// { Element[] -> ScatterWrite[] }
|
2017-10-24 23:19:46 +08:00
|
|
|
isl::union_map WriteAction = Schedule.apply_domain(Writes);
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
// { ScatterWrite[] -> Element[] }
|
2017-10-24 23:19:46 +08:00
|
|
|
isl::union_map WriteActionRev = WriteAction.reverse();
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
// { Element[] -> [ScatterUse[] -> ScatterWrite[]] }
|
2017-10-24 23:19:46 +08:00
|
|
|
isl::union_map DefSchedRelation =
|
|
|
|
isl::union_map(RelationMap).apply_domain(WriteActionRev);
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
// For each element, at every point in time, map to the times of previous
|
|
|
|
// definitions. { [Element[] -> ScatterRead[]] -> ScatterWrite[] }
|
2017-10-24 23:19:46 +08:00
|
|
|
isl::union_map ReachableWrites = DefSchedRelation.uncurry();
|
2017-02-04 23:42:01 +08:00
|
|
|
if (Reverse)
|
2017-10-24 23:19:46 +08:00
|
|
|
ReachableWrites = ReachableWrites.lexmin();
|
2017-02-04 23:42:01 +08:00
|
|
|
else
|
2017-10-24 23:19:46 +08:00
|
|
|
ReachableWrites = ReachableWrites.lexmax();
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
// { [Element[] -> ScatterWrite[]] -> ScatterWrite[] }
|
2017-10-24 23:19:46 +08:00
|
|
|
isl::union_map SelfUse = WriteAction.range_map();
|
2017-02-04 23:42:01 +08:00
|
|
|
|
|
|
|
if (InclPrevDef && InclNextDef) {
|
|
|
|
// Add the Def itself to the solution.
|
2017-10-24 23:19:46 +08:00
|
|
|
ReachableWrites = ReachableWrites.unite(SelfUse).coalesce();
|
2017-02-04 23:42:01 +08:00
|
|
|
} else if (!InclPrevDef && !InclNextDef) {
|
|
|
|
// Remove Def itself from the solution.
|
2017-10-24 23:19:46 +08:00
|
|
|
ReachableWrites = ReachableWrites.subtract(SelfUse);
|
2017-02-04 23:42:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// { [Element[] -> ScatterRead[]] -> Domain[] }
|
2017-10-24 23:19:46 +08:00
|
|
|
return ReachableWrites.apply_range(Schedule.reverse());
|
2017-02-04 23:42:01 +08:00
|
|
|
}
|
2017-02-04 23:42:10 +08:00
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_map
|
|
|
|
polly::computeArrayUnused(isl::union_map Schedule, isl::union_map Writes,
|
|
|
|
isl::union_map Reads, bool ReadEltInSameInst,
|
|
|
|
bool IncludeLastRead, bool IncludeWrite) {
|
2017-02-04 23:42:10 +08:00
|
|
|
// { Element[] -> Scatter[] }
|
|
|
|
auto ReadActions =
|
|
|
|
give(isl_union_map_apply_domain(Schedule.copy(), Reads.take()));
|
|
|
|
auto WriteActions =
|
|
|
|
give(isl_union_map_apply_domain(Schedule.copy(), Writes.copy()));
|
|
|
|
|
|
|
|
// { [Element[] -> DomainWrite[]] -> Scatter[] }
|
|
|
|
auto EltDomWrites = give(isl_union_map_apply_range(
|
|
|
|
isl_union_map_range_map(isl_union_map_reverse(Writes.copy())),
|
|
|
|
Schedule.copy()));
|
|
|
|
|
|
|
|
// { [Element[] -> Scatter[]] -> DomainWrite[] }
|
|
|
|
auto ReachingOverwrite = computeReachingWrite(
|
|
|
|
Schedule, Writes, true, ReadEltInSameInst, !ReadEltInSameInst);
|
|
|
|
|
|
|
|
// { [Element[] -> Scatter[]] -> DomainWrite[] }
|
|
|
|
auto ReadsOverwritten = give(isl_union_map_intersect_domain(
|
|
|
|
ReachingOverwrite.take(), isl_union_map_wrap(ReadActions.take())));
|
|
|
|
|
|
|
|
// { [Element[] -> DomainWrite[]] -> Scatter[] }
|
|
|
|
auto ReadsOverwrittenRotated = give(isl_union_map_reverse(
|
|
|
|
isl_union_map_curry(reverseDomain(ReadsOverwritten).take())));
|
|
|
|
auto LastOverwrittenRead =
|
2017-08-22 07:04:45 +08:00
|
|
|
give(isl_union_map_lexmax(ReadsOverwrittenRotated.copy()));
|
2017-02-04 23:42:10 +08:00
|
|
|
|
|
|
|
// { [Element[] -> DomainWrite[]] -> Scatter[] }
|
|
|
|
auto BetweenLastReadOverwrite = betweenScatter(
|
|
|
|
LastOverwrittenRead, EltDomWrites, IncludeLastRead, IncludeWrite);
|
|
|
|
|
2017-08-22 07:04:45 +08:00
|
|
|
// { [Element[] -> Scatter[]] -> DomainWrite[] }
|
|
|
|
isl::union_map ReachingOverwriteZone = computeReachingWrite(
|
|
|
|
Schedule, Writes, true, IncludeLastRead, IncludeWrite);
|
|
|
|
|
|
|
|
// { [Element[] -> DomainWrite[]] -> Scatter[] }
|
|
|
|
isl::union_map ReachingOverwriteRotated =
|
|
|
|
reverseDomain(ReachingOverwriteZone).curry().reverse();
|
|
|
|
|
|
|
|
// { [Element[] -> DomainWrite[]] -> Scatter[] }
|
|
|
|
isl::union_map WritesWithoutReads = ReachingOverwriteRotated.subtract_domain(
|
|
|
|
ReadsOverwrittenRotated.domain());
|
|
|
|
|
|
|
|
return BetweenLastReadOverwrite.unite(WritesWithoutReads)
|
|
|
|
.domain_factor_domain();
|
2017-02-04 23:42:10 +08:00
|
|
|
}
|
2017-02-04 23:42:17 +08:00
|
|
|
|
Introduce isl C++ bindings, Part 1: value_ptr style interface
Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.
This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.
An isl object has the following smart pointer interface:
inline set manage(__isl_take isl_set *ptr);
class set {
friend inline set manage(__isl_take isl_set *ptr);
isl_set *ptr = nullptr;
inline explicit set(__isl_take isl_set *ptr);
public:
inline set();
inline set(const set &obj);
inline set &operator=(set obj);
inline ~set();
inline __isl_give isl_set *copy() const &;
inline __isl_give isl_set *copy() && = delete;
inline __isl_keep isl_set *get() const;
inline __isl_give isl_set *release();
inline bool is_null() const;
}
The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.
We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.
The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:
S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.
We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.
S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.
This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:
- operator bool() : Conversion from objects to bool
- construction from nullptr_t
- get_ctx() method
- take/keep/give methods, which match the currently used naming
convention of IslPtr<T> in Polly. They just forward to
(release/get/manage).
- raw_ostream printers
We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.
We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)
As part of the code review, the following two questions were asked:
- Why do we not use a standard smart pointer?
std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.
- Why do we not use templates or macros to avoid code duplication?
It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.
These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.
Tags: #polly
Reviewed By: Meinersbur
Differential Revision: https://reviews.llvm.org/D30325
llvm-svn: 297452
2017-03-10 19:41:03 +08:00
|
|
|
isl::union_set polly::convertZoneToTimepoints(isl::union_set Zone,
|
|
|
|
bool InclStart, bool InclEnd) {
|
2017-02-04 23:42:17 +08:00
|
|
|
if (!InclStart && InclEnd)
|
|
|
|
return Zone;
|
|
|
|
|
|
|
|
auto ShiftedZone = shiftDim(Zone, -1, -1);
|
|
|
|
if (InclStart && !InclEnd)
|
|
|
|
return ShiftedZone;
|
|
|
|
else if (!InclStart && !InclEnd)
|
|
|
|
return give(isl_union_set_intersect(Zone.take(), ShiftedZone.take()));
|
|
|
|
|
|
|
|
assert(InclStart && InclEnd);
|
|
|
|
return give(isl_union_set_union(Zone.take(), ShiftedZone.take()));
|
|
|
|
}
|
2017-03-23 03:31:06 +08:00
|
|
|
|
|
|
|
isl::union_map polly::convertZoneToTimepoints(isl::union_map Zone, isl::dim Dim,
|
|
|
|
bool InclStart, bool InclEnd) {
|
|
|
|
if (!InclStart && InclEnd)
|
|
|
|
return Zone;
|
|
|
|
|
|
|
|
auto ShiftedZone = shiftDim(Zone, Dim, -1, -1);
|
|
|
|
if (InclStart && !InclEnd)
|
|
|
|
return ShiftedZone;
|
|
|
|
else if (!InclStart && !InclEnd)
|
|
|
|
return give(isl_union_map_intersect(Zone.take(), ShiftedZone.take()));
|
|
|
|
|
|
|
|
assert(InclStart && InclEnd);
|
|
|
|
return give(isl_union_map_union(Zone.take(), ShiftedZone.take()));
|
|
|
|
}
|
|
|
|
|
2017-08-08 02:40:29 +08:00
|
|
|
isl::map polly::convertZoneToTimepoints(isl::map Zone, isl::dim Dim,
|
|
|
|
bool InclStart, bool InclEnd) {
|
|
|
|
if (!InclStart && InclEnd)
|
|
|
|
return Zone;
|
|
|
|
|
|
|
|
auto ShiftedZone = shiftDim(Zone, Dim, -1, -1);
|
|
|
|
if (InclStart && !InclEnd)
|
|
|
|
return ShiftedZone;
|
|
|
|
else if (!InclStart && !InclEnd)
|
|
|
|
return give(isl_map_intersect(Zone.take(), ShiftedZone.take()));
|
|
|
|
|
|
|
|
assert(InclStart && InclEnd);
|
|
|
|
return give(isl_map_union(Zone.take(), ShiftedZone.take()));
|
|
|
|
}
|
|
|
|
|
2017-03-23 03:31:06 +08:00
|
|
|
isl::map polly::distributeDomain(isl::map Map) {
|
|
|
|
// Note that we cannot take Map apart into { Domain[] -> Range1[] } and {
|
|
|
|
// Domain[] -> Range2[] } and combine again. We would loose any relation
|
|
|
|
// between Range1[] and Range2[] that is not also a constraint to Domain[].
|
|
|
|
|
|
|
|
auto Space = give(isl_map_get_space(Map.keep()));
|
|
|
|
auto DomainSpace = give(isl_space_domain(Space.copy()));
|
|
|
|
auto DomainDims = isl_space_dim(DomainSpace.keep(), isl_dim_set);
|
|
|
|
auto RangeSpace = give(isl_space_unwrap(isl_space_range(Space.copy())));
|
|
|
|
auto Range1Space = give(isl_space_domain(RangeSpace.copy()));
|
|
|
|
auto Range1Dims = isl_space_dim(Range1Space.keep(), isl_dim_set);
|
|
|
|
auto Range2Space = give(isl_space_range(RangeSpace.copy()));
|
|
|
|
auto Range2Dims = isl_space_dim(Range2Space.keep(), isl_dim_set);
|
|
|
|
|
|
|
|
auto OutputSpace = give(isl_space_map_from_domain_and_range(
|
|
|
|
isl_space_wrap(isl_space_map_from_domain_and_range(DomainSpace.copy(),
|
|
|
|
Range1Space.copy())),
|
|
|
|
isl_space_wrap(isl_space_map_from_domain_and_range(DomainSpace.copy(),
|
|
|
|
Range2Space.copy()))));
|
|
|
|
|
|
|
|
auto Translator =
|
|
|
|
give(isl_basic_map_universe(isl_space_map_from_domain_and_range(
|
|
|
|
isl_space_wrap(Space.copy()), isl_space_wrap(OutputSpace.copy()))));
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < DomainDims; i += 1) {
|
|
|
|
Translator = give(
|
|
|
|
isl_basic_map_equate(Translator.take(), isl_dim_in, i, isl_dim_out, i));
|
|
|
|
Translator =
|
|
|
|
give(isl_basic_map_equate(Translator.take(), isl_dim_in, i, isl_dim_out,
|
|
|
|
DomainDims + Range1Dims + i));
|
|
|
|
}
|
|
|
|
for (unsigned i = 0; i < Range1Dims; i += 1) {
|
|
|
|
Translator =
|
|
|
|
give(isl_basic_map_equate(Translator.take(), isl_dim_in, DomainDims + i,
|
|
|
|
isl_dim_out, DomainDims + i));
|
|
|
|
}
|
|
|
|
for (unsigned i = 0; i < Range2Dims; i += 1) {
|
|
|
|
Translator = give(isl_basic_map_equate(
|
|
|
|
Translator.take(), isl_dim_in, DomainDims + Range1Dims + i, isl_dim_out,
|
|
|
|
DomainDims + Range1Dims + DomainDims + i));
|
|
|
|
}
|
|
|
|
|
|
|
|
return give(isl_set_unwrap(isl_set_apply(
|
|
|
|
isl_map_wrap(Map.copy()), isl_map_from_basic_map(Translator.copy()))));
|
|
|
|
}
|
|
|
|
|
|
|
|
isl::union_map polly::distributeDomain(isl::union_map UMap) {
|
|
|
|
auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
|
2017-08-09 19:21:40 +08:00
|
|
|
isl::stat Success = UMap.foreach_map([=, &Result](isl::map Map) {
|
2017-03-23 03:31:06 +08:00
|
|
|
auto Distributed = distributeDomain(Map);
|
|
|
|
Result = give(isl_union_map_add_map(Result.take(), Distributed.copy()));
|
2017-04-14 21:39:40 +08:00
|
|
|
return isl::stat::ok;
|
2017-03-23 03:31:06 +08:00
|
|
|
});
|
2017-08-09 19:21:40 +08:00
|
|
|
if (Success != isl::stat::ok)
|
|
|
|
return {};
|
2017-03-23 03:31:06 +08:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
isl::union_map polly::liftDomains(isl::union_map UMap, isl::union_set Factor) {
|
|
|
|
|
|
|
|
// { Factor[] -> Factor[] }
|
|
|
|
auto Factors = makeIdentityMap(std::move(Factor), true);
|
|
|
|
|
|
|
|
return std::move(Factors).product(std::move(UMap));
|
|
|
|
}
|
|
|
|
|
|
|
|
isl::union_map polly::applyDomainRange(isl::union_map UMap,
|
|
|
|
isl::union_map Func) {
|
|
|
|
// This implementation creates unnecessary cross products of the
|
|
|
|
// DomainDomain[] and Func. An alternative implementation could reverse
|
|
|
|
// domain+uncurry,apply Func to what now is the domain, then undo the
|
|
|
|
// preparing transformation. Another alternative implementation could create a
|
|
|
|
// translator map for each piece.
|
|
|
|
|
|
|
|
// { DomainDomain[] }
|
|
|
|
auto DomainDomain = UMap.domain().unwrap().domain();
|
|
|
|
|
|
|
|
// { [DomainDomain[] -> DomainRange[]] -> [DomainDomain[] -> NewDomainRange[]]
|
|
|
|
// }
|
|
|
|
auto LifetedFunc = liftDomains(std::move(Func), DomainDomain);
|
|
|
|
|
|
|
|
return std::move(UMap).apply_domain(std::move(LifetedFunc));
|
|
|
|
}
|
2017-08-29 04:39:07 +08:00
|
|
|
|
|
|
|
isl::map polly::intersectRange(isl::map Map, isl::union_set Range) {
|
|
|
|
isl::set RangeSet = Range.extract_set(Map.get_space().range());
|
|
|
|
return Map.intersect_range(RangeSet);
|
2017-09-04 18:05:29 +08:00
|
|
|
}
|
2017-09-29 23:45:40 +08:00
|
|
|
|
|
|
|
isl::val polly::getConstant(isl::pw_aff PwAff, bool Max, bool Min) {
|
|
|
|
assert(!Max || !Min); // Cannot return min and max at the same time.
|
|
|
|
isl::val Result;
|
|
|
|
PwAff.foreach_piece([=, &Result](isl::set Set, isl::aff Aff) -> isl::stat {
|
|
|
|
if (Result && Result.is_nan())
|
|
|
|
return isl::stat::ok;
|
|
|
|
|
|
|
|
// TODO: If Min/Max, we can also determine a minimum/maximum value if
|
|
|
|
// Set is constant-bounded.
|
|
|
|
if (!Aff.is_cst()) {
|
|
|
|
Result = isl::val::nan(Aff.get_ctx());
|
|
|
|
return isl::stat::error;
|
|
|
|
}
|
|
|
|
|
|
|
|
isl::val ThisVal = Aff.get_constant_val();
|
|
|
|
if (!Result) {
|
|
|
|
Result = ThisVal;
|
|
|
|
return isl::stat::ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Result.eq(ThisVal))
|
|
|
|
return isl::stat::ok;
|
|
|
|
|
|
|
|
if (Max && ThisVal.gt(Result)) {
|
|
|
|
Result = ThisVal;
|
|
|
|
return isl::stat::ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Min && ThisVal.lt(Result)) {
|
|
|
|
Result = ThisVal;
|
|
|
|
return isl::stat::ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Not compatible
|
|
|
|
Result = isl::val::nan(Aff.get_ctx());
|
|
|
|
return isl::stat::error;
|
|
|
|
});
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
|
|
|
static void foreachPoint(const isl::set &Set,
|
|
|
|
const std::function<void(isl::point P)> &F) {
|
|
|
|
isl_set_foreach_point(
|
|
|
|
Set.keep(),
|
|
|
|
[](__isl_take isl_point *p, void *User) -> isl_stat {
|
|
|
|
auto &F = *static_cast<const std::function<void(isl::point)> *>(User);
|
|
|
|
F(give(p));
|
|
|
|
return isl_stat_ok;
|
|
|
|
},
|
|
|
|
const_cast<void *>(static_cast<const void *>(&F)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void foreachPoint(isl::basic_set BSet,
|
|
|
|
const std::function<void(isl::point P)> &F) {
|
|
|
|
foreachPoint(give(isl_set_from_basic_set(BSet.take())), F);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Determine the sorting order of the sets @p A and @p B without considering
|
|
|
|
/// the space structure.
|
|
|
|
///
|
|
|
|
/// Ordering is based on the lower bounds of the set's dimensions. First
|
|
|
|
/// dimensions are considered first.
|
|
|
|
static int flatCompare(const isl::basic_set &A, const isl::basic_set &B) {
|
|
|
|
int ALen = A.dim(isl::dim::set);
|
|
|
|
int BLen = B.dim(isl::dim::set);
|
|
|
|
int Len = std::min(ALen, BLen);
|
|
|
|
|
|
|
|
for (int i = 0; i < Len; i += 1) {
|
|
|
|
isl::basic_set ADim =
|
|
|
|
A.project_out(isl::dim::param, 0, A.dim(isl::dim::param))
|
|
|
|
.project_out(isl::dim::set, i + 1, ALen - i - 1)
|
|
|
|
.project_out(isl::dim::set, 0, i);
|
|
|
|
isl::basic_set BDim =
|
|
|
|
B.project_out(isl::dim::param, 0, B.dim(isl::dim::param))
|
|
|
|
.project_out(isl::dim::set, i + 1, BLen - i - 1)
|
|
|
|
.project_out(isl::dim::set, 0, i);
|
|
|
|
|
|
|
|
isl::basic_set AHull = isl::set(ADim).convex_hull();
|
|
|
|
isl::basic_set BHull = isl::set(BDim).convex_hull();
|
|
|
|
|
|
|
|
bool ALowerBounded =
|
|
|
|
bool(isl::set(AHull).dim_has_any_lower_bound(isl::dim::set, 0));
|
|
|
|
bool BLowerBounded =
|
|
|
|
bool(isl::set(BHull).dim_has_any_lower_bound(isl::dim::set, 0));
|
|
|
|
|
|
|
|
int BoundedCompare = BLowerBounded - ALowerBounded;
|
|
|
|
if (BoundedCompare != 0)
|
|
|
|
return BoundedCompare;
|
|
|
|
|
|
|
|
if (!ALowerBounded || !BLowerBounded)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
isl::pw_aff AMin = isl::set(ADim).dim_min(0);
|
|
|
|
isl::pw_aff BMin = isl::set(BDim).dim_min(0);
|
|
|
|
|
|
|
|
isl::val AMinVal = polly::getConstant(AMin, false, true);
|
|
|
|
isl::val BMinVal = polly::getConstant(BMin, false, true);
|
|
|
|
|
|
|
|
int MinCompare = AMinVal.sub(BMinVal).sgn();
|
|
|
|
if (MinCompare != 0)
|
|
|
|
return MinCompare;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If all the dimensions' lower bounds are equal or incomparable, sort based
|
|
|
|
// on the number of dimensions.
|
|
|
|
return ALen - BLen;
|
|
|
|
}
|
|
|
|
|
2018-01-17 02:39:42 +08:00
|
|
|
/// Compare the sets @p A and @p B according to their nested space structure.
|
|
|
|
/// Returns 0 if the structure is considered equal.
|
|
|
|
/// If @p ConsiderTupleLen is false, the number of dimensions in a tuple are
|
|
|
|
/// ignored, i.e. a tuple with the same name but different number of dimensions
|
|
|
|
/// are considered equal.
|
|
|
|
static int structureCompare(const isl::space &ASpace, const isl::space &BSpace,
|
|
|
|
bool ConsiderTupleLen) {
|
2017-09-29 23:45:40 +08:00
|
|
|
int WrappingCompare = bool(ASpace.is_wrapping()) - bool(BSpace.is_wrapping());
|
|
|
|
if (WrappingCompare != 0)
|
|
|
|
return WrappingCompare;
|
|
|
|
|
2018-01-17 02:39:42 +08:00
|
|
|
if (ASpace.is_wrapping() && BSpace.is_wrapping()) {
|
|
|
|
isl::space AMap = ASpace.unwrap();
|
|
|
|
isl::space BMap = BSpace.unwrap();
|
2017-09-29 23:45:40 +08:00
|
|
|
|
2018-01-17 02:39:42 +08:00
|
|
|
int FirstResult =
|
|
|
|
structureCompare(AMap.domain(), BMap.domain(), ConsiderTupleLen);
|
2017-09-29 23:45:40 +08:00
|
|
|
if (FirstResult != 0)
|
|
|
|
return FirstResult;
|
|
|
|
|
2018-01-17 02:39:42 +08:00
|
|
|
return structureCompare(AMap.range(), BMap.range(), ConsiderTupleLen);
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
2018-01-17 02:39:42 +08:00
|
|
|
std::string AName;
|
|
|
|
if (ASpace.has_tuple_name(isl::dim::set))
|
|
|
|
AName = ASpace.get_tuple_name(isl::dim::set);
|
|
|
|
|
|
|
|
std::string BName;
|
|
|
|
if (BSpace.has_tuple_name(isl::dim::set))
|
|
|
|
BName = BSpace.get_tuple_name(isl::dim::set);
|
2017-09-29 23:45:40 +08:00
|
|
|
|
|
|
|
int NameCompare = AName.compare(BName);
|
|
|
|
if (NameCompare != 0)
|
|
|
|
return NameCompare;
|
|
|
|
|
2018-01-17 02:39:42 +08:00
|
|
|
if (ConsiderTupleLen) {
|
|
|
|
int LenCompare = BSpace.dim(isl::dim::set) - ASpace.dim(isl::dim::set);
|
|
|
|
if (LenCompare != 0)
|
|
|
|
return LenCompare;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
2018-01-17 02:39:42 +08:00
|
|
|
/// Compare the sets @p A and @p B according to their nested space structure. If
|
|
|
|
/// the structure is the same, sort using the dimension lower bounds.
|
|
|
|
/// Returns an std::sort compatible bool.
|
2017-09-29 23:45:40 +08:00
|
|
|
static bool orderComparer(const isl::basic_set &A, const isl::basic_set &B) {
|
2018-01-17 02:39:42 +08:00
|
|
|
isl::space ASpace = A.get_space();
|
|
|
|
isl::space BSpace = B.get_space();
|
|
|
|
|
|
|
|
// Ignoring number of dimensions first ensures that structures with same tuple
|
|
|
|
// names, but different number of dimensions are still sorted close together.
|
|
|
|
int TupleNestingCompare = structureCompare(ASpace, BSpace, false);
|
|
|
|
if (TupleNestingCompare != 0)
|
|
|
|
return TupleNestingCompare < 0;
|
|
|
|
|
|
|
|
int TupleCompare = structureCompare(ASpace, BSpace, true);
|
|
|
|
if (TupleCompare != 0)
|
|
|
|
return TupleCompare < 0;
|
|
|
|
|
|
|
|
return flatCompare(A, B) < 0;
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Print a string representation of @p USet to @p OS.
|
|
|
|
///
|
|
|
|
/// The pieces of @p USet are printed in a sorted order. Spaces with equal or
|
|
|
|
/// similar nesting structure are printed together. Compared to isl's own
|
|
|
|
/// printing function the uses the structure itself as base of the sorting, not
|
|
|
|
/// a hash of it. It ensures that e.g. maps spaces with same domain structure
|
|
|
|
/// are printed together. Set pieces with same structure are printed in order of
|
|
|
|
/// their lower bounds.
|
|
|
|
///
|
|
|
|
/// @param USet Polyhedra to print.
|
|
|
|
/// @param OS Target stream.
|
|
|
|
/// @param Simplify Whether to simplify the polyhedron before printing.
|
|
|
|
/// @param IsMap Whether @p USet is a wrapped map. If true, sets are
|
|
|
|
/// unwrapped before printing to again appear as a map.
|
|
|
|
static void printSortedPolyhedra(isl::union_set USet, llvm::raw_ostream &OS,
|
|
|
|
bool Simplify, bool IsMap) {
|
|
|
|
if (!USet) {
|
|
|
|
OS << "<null>\n";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Simplify)
|
|
|
|
simplify(USet);
|
|
|
|
|
|
|
|
// Get all the polyhedra.
|
|
|
|
std::vector<isl::basic_set> BSets;
|
|
|
|
USet.foreach_set([&BSets](isl::set Set) -> isl::stat {
|
|
|
|
Set.foreach_basic_set([&BSets](isl::basic_set BSet) -> isl::stat {
|
|
|
|
BSets.push_back(BSet);
|
|
|
|
return isl::stat::ok;
|
|
|
|
});
|
|
|
|
return isl::stat::ok;
|
|
|
|
});
|
|
|
|
|
|
|
|
if (BSets.empty()) {
|
|
|
|
OS << "{\n}\n";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sort the polyhedra.
|
|
|
|
std::sort(BSets.begin(), BSets.end(), orderComparer);
|
|
|
|
|
|
|
|
// Print the polyhedra.
|
|
|
|
bool First = true;
|
|
|
|
for (const isl::basic_set &BSet : BSets) {
|
|
|
|
std::string Str;
|
|
|
|
if (IsMap)
|
|
|
|
Str = isl::map(BSet.unwrap()).to_str();
|
|
|
|
else
|
|
|
|
Str = isl::set(BSet).to_str();
|
|
|
|
size_t OpenPos = Str.find_first_of('{');
|
|
|
|
assert(OpenPos != std::string::npos);
|
|
|
|
size_t ClosePos = Str.find_last_of('}');
|
|
|
|
assert(ClosePos != std::string::npos);
|
|
|
|
|
|
|
|
if (First)
|
|
|
|
OS << llvm::StringRef(Str).substr(0, OpenPos + 1) << "\n ";
|
|
|
|
else
|
|
|
|
OS << ";\n ";
|
|
|
|
|
|
|
|
OS << llvm::StringRef(Str).substr(OpenPos + 1, ClosePos - OpenPos - 2);
|
|
|
|
First = false;
|
|
|
|
}
|
|
|
|
assert(!First);
|
|
|
|
OS << "\n}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
static void recursiveExpand(isl::basic_set BSet, int Dim, isl::set &Expanded) {
|
|
|
|
int Dims = BSet.dim(isl::dim::set);
|
|
|
|
if (Dim >= Dims) {
|
|
|
|
Expanded = Expanded.unite(BSet);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
isl::basic_set DimOnly =
|
|
|
|
BSet.project_out(isl::dim::param, 0, BSet.dim(isl::dim::param))
|
|
|
|
.project_out(isl::dim::set, Dim + 1, Dims - Dim - 1)
|
|
|
|
.project_out(isl::dim::set, 0, Dim);
|
|
|
|
if (!DimOnly.is_bounded()) {
|
|
|
|
recursiveExpand(BSet, Dim + 1, Expanded);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreachPoint(DimOnly, [&, Dim](isl::point P) {
|
|
|
|
isl::val Val = P.get_coordinate_val(isl::dim::set, 0);
|
|
|
|
isl::basic_set FixBSet = BSet.fix_val(isl::dim::set, Dim, Val);
|
|
|
|
recursiveExpand(FixBSet, Dim + 1, Expanded);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Make each point of a set explicit.
|
|
|
|
///
|
|
|
|
/// "Expanding" makes each point a set contains explicit. That is, the result is
|
|
|
|
/// a set of singleton polyhedra. Unbounded dimensions are not expanded.
|
|
|
|
///
|
|
|
|
/// Example:
|
|
|
|
/// { [i] : 0 <= i < 2 }
|
|
|
|
/// is expanded to:
|
|
|
|
/// { [0]; [1] }
|
|
|
|
static isl::set expand(const isl::set &Set) {
|
|
|
|
isl::set Expanded = isl::set::empty(Set.get_space());
|
|
|
|
Set.foreach_basic_set([&](isl::basic_set BSet) -> isl::stat {
|
|
|
|
recursiveExpand(BSet, 0, Expanded);
|
|
|
|
return isl::stat::ok;
|
|
|
|
});
|
|
|
|
return Expanded;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Expand all points of a union set explicit.
|
|
|
|
///
|
|
|
|
/// @see expand(const isl::set)
|
|
|
|
static isl::union_set expand(const isl::union_set &USet) {
|
|
|
|
isl::union_set Expanded =
|
|
|
|
give(isl_union_set_empty(isl_union_set_get_space(USet.keep())));
|
|
|
|
USet.foreach_set([&](isl::set Set) -> isl::stat {
|
|
|
|
isl::set SetExpanded = expand(Set);
|
|
|
|
Expanded = Expanded.add_set(SetExpanded);
|
|
|
|
return isl::stat::ok;
|
|
|
|
});
|
|
|
|
return Expanded;
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpPw(const isl::set &Set) {
|
|
|
|
printSortedPolyhedra(Set, llvm::errs(), true, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpPw(const isl::map &Map) {
|
|
|
|
printSortedPolyhedra(Map.wrap(), llvm::errs(), true, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpPw(const isl::union_set &USet) {
|
|
|
|
printSortedPolyhedra(USet, llvm::errs(), true, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpPw(const isl::union_map &UMap) {
|
|
|
|
printSortedPolyhedra(UMap.wrap(), llvm::errs(), true, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpPw(__isl_keep isl_set *Set) {
|
2018-02-20 15:26:58 +08:00
|
|
|
dumpPw(isl::manage_copy(Set));
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpPw(__isl_keep isl_map *Map) {
|
2018-02-20 15:26:58 +08:00
|
|
|
dumpPw(isl::manage_copy(Map));
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpPw(__isl_keep isl_union_set *USet) {
|
2018-02-20 15:26:58 +08:00
|
|
|
dumpPw(isl::manage_copy(USet));
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpPw(__isl_keep isl_union_map *UMap) {
|
2018-02-20 15:26:58 +08:00
|
|
|
dumpPw(isl::manage_copy(UMap));
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpExpanded(const isl::set &Set) {
|
|
|
|
printSortedPolyhedra(expand(Set), llvm::errs(), false, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpExpanded(const isl::map &Map) {
|
|
|
|
printSortedPolyhedra(expand(Map.wrap()), llvm::errs(), false, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpExpanded(const isl::union_set &USet) {
|
|
|
|
printSortedPolyhedra(expand(USet), llvm::errs(), false, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpExpanded(const isl::union_map &UMap) {
|
|
|
|
printSortedPolyhedra(expand(UMap.wrap()), llvm::errs(), false, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpExpanded(__isl_keep isl_set *Set) {
|
2018-02-20 15:26:58 +08:00
|
|
|
dumpExpanded(isl::manage_copy(Set));
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpExpanded(__isl_keep isl_map *Map) {
|
2018-02-20 15:26:58 +08:00
|
|
|
dumpExpanded(isl::manage_copy(Map));
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpExpanded(__isl_keep isl_union_set *USet) {
|
2018-02-20 15:26:58 +08:00
|
|
|
dumpExpanded(isl::manage_copy(USet));
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
LLVM_DUMP_METHOD void polly::dumpExpanded(__isl_keep isl_union_map *UMap) {
|
2018-02-20 15:26:58 +08:00
|
|
|
dumpExpanded(isl::manage_copy(UMap));
|
2017-09-29 23:45:40 +08:00
|
|
|
}
|
|
|
|
#endif
|