polyhedral.h

Go to the documentation of this file.

 
#pragma once
 
#include <isl/ctx.h>
#include <isl/map.h>
#include <isl/set.h>
#include <isl/space.h>
 
#include "sdfg/symbolic/assumptions.h"
#include "sdfg/symbolic/symbolic.h"
 
namespace sdfg {
namespace symbolic {
namespace polyhedral {

class IslCtx {
public:
    IslCtx();
    ~IslCtx();
 
    IslCtx(const IslCtx&) = delete;
    IslCtx& operator=(const IslCtx&) = delete;
    IslCtx(IslCtx&& other) noexcept;
    IslCtx& operator=(IslCtx&& other) noexcept;
 
    isl_ctx* get() const {
        return ctx_;
    }
    explicit operator bool() const {
        return ctx_ != nullptr;
    }
 
private:
    isl_ctx* ctx_;
};

template<typename T, T* (*FreeFn)(T*)>
class IslHandle {
public:
    IslHandle() : ptr_(nullptr) {
    }
    explicit IslHandle(T* ptr) : ptr_(ptr) {
    }
    ~IslHandle() {
        reset();
    }
 
    IslHandle(const IslHandle&) = delete;
    IslHandle& operator=(const IslHandle&) = delete;
 
    IslHandle(IslHandle&& other) noexcept : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }
    IslHandle& operator=(IslHandle&& other) noexcept {
        if (this != &other) {
            reset();
            ptr_ = other.ptr_;
            other.ptr_ = nullptr;
        }
        return *this;
    }

    T* get() const {
        return ptr_;
    }

    T* release() {
        T* p = ptr_;
        ptr_ = nullptr;
        return p;
    }

    void reset(T* p = nullptr) {
        if (ptr_ != nullptr) {
            FreeFn(ptr_);
        }
        ptr_ = p;
    }
 
    explicit operator bool() const {
        return ptr_ != nullptr;
    }
 
private:
    T* ptr_;
};
 
using IslMap = IslHandle<isl_map, isl_map_free>;
using IslSet = IslHandle<isl_set, isl_set_free>;
using IslSpace = IslHandle<isl_space, isl_space_free>;

bool equal_on_domain(const MultiExpression& f, const MultiExpression& g, const Symbol indvar, const Assumptions& assums);
 
} // namespace polyhedral
} // namespace symbolic
} // namespace sdfg