access_type.h

Go to the documentation of this file.

#ifndef FREE_TENSOR_ACCESS_TYPE_H
#define FREE_TENSOR_ACCESS_TYPE_H
 
#include <array>
#include <iostream>
#include <string>
 
#include <container_utils.h>
#include <except.h>
#include <serialize/to_string.h>
 
namespace freetensor {
 
enum class AccessType : size_t {
    Input = 0,
    Bypass,
    Cache,
    Output,
    InputMutable,
    InOut,
    // ------
    NumTypes,
};
 
// First deduce array length, then assert, to ensure the length
constexpr std::array accessTypeNames = {
    "input", "bypass", "cache", "output", "input-mutable", "inout",
};
static_assert(accessTypeNames.size() == (size_t)AccessType::NumTypes);
 
namespace detail {
 
template <typename T, T... i>
constexpr auto createAllAccessTypes(std::integer_sequence<T, i...>) {
    return std::array{(AccessType)i...};
}
 
} // namespace detail
 
constexpr auto allAccessTypes = detail::createAllAccessTypes(
    std::make_index_sequence<(size_t)AccessType::NumTypes>{});
 
inline std::ostream &operator<<(std::ostream &os, AccessType atype) {
    return os << accessTypeNames.at((size_t)atype);
}
 
inline AccessType parseAType(const std::string &_str) {
    auto &&str = tolower(_str);
    for (auto &&[i, s] : views::enumerate(accessTypeNames)) {
        if (s == str) {
            return (AccessType)i;
        }
    }
    ERROR(FT_MSG << "Unrecognized access type \"" << _str
                 << "\". Candidates are (case-insensitive): "
                 << (accessTypeNames | join(", ")));
}
 
inline bool isWritable(AccessType atype) {
    switch (atype) {
    case AccessType::Cache:
    case AccessType::Output:
    case AccessType::InputMutable:
    case AccessType::InOut:
        return true;
    default:
        return false;
    }
}
 
inline bool isInputting(AccessType atype) {
    switch (atype) {
    case AccessType::Input:
    case AccessType::Bypass:
    case AccessType::InputMutable:
    case AccessType::InOut:
        return true;
    default:
        return false;
    }
}
 
inline bool isOutputting(AccessType atype) {
    switch (atype) {
    case AccessType::Bypass:
    case AccessType::Output:
    case AccessType::InOut:
        return true;
    default:
        return false;
    }
}
 
inline AccessType addOutputting(AccessType atype) {
    switch (atype) {
    case AccessType::Input:
        return AccessType::Bypass;
    case AccessType::Cache:
        return AccessType::Output;
    case AccessType::InputMutable:
        return AccessType::InOut;
    default:
        return atype;
    }
}
 
inline AccessType removeOutputting(AccessType atype) {
    switch (atype) {
    case AccessType::Bypass:
        return AccessType::Input;
    case AccessType::Output:
        return AccessType::Cache;
    case AccessType::InOut:
        return AccessType::InputMutable;
    default:
        return atype;
    }
}
 
} // namespace freetensor
 
#endif // FREE_TENSOR_ACCESS_TYPE_H