hierarchical-object-name.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "virtutech-c++" -*-
 
/*
  © 2023 Intel Corporation
 
  This software and the related documents are Intel copyrighted materials, and
  your use of them is governed by the express license under which they were
  provided to you ("License"). Unless the License provides otherwise, you may
  not use, modify, copy, publish, distribute, disclose or transmit this software
  or the related documents without Intel's prior written permission.
 
  This software and the related documents are provided as is, with no express or
  implied warranties, other than those that are expressly stated in the License.
*/
 
#ifndef SIMICS_TYPE_HIERARCHICAL_OBJECT_NAME_H
#define SIMICS_TYPE_HIERARCHICAL_OBJECT_NAME_H
 
#include <string_view>
#include <string>
#ifdef __GNUC__
#include <cctype>  // isalpha
#endif
#include <utility>  // pair
#include <stdexcept>
#include <vector>
#include <map>
 
namespace simics {
namespace detail {
 
/*
 * Literal type that extends string_view type
 * Optimized to save the compile time on the large register data
 * Build with DEBUG enables the name validation
 */
class HierarchicalObjectName : public std::string_view {
  public:
    constexpr HierarchicalObjectName() noexcept
        : std::string_view() {}
    constexpr HierarchicalObjectName(
            const HierarchicalObjectName& other) noexcept = default;
    constexpr HierarchicalObjectName(const char* s, std::size_t count)
        : std::string_view(s, count) {
#ifndef NDEBUG
        validate_name();
#endif
    }
    constexpr HierarchicalObjectName(const char* s)  // NOLINT(runtime/explicit)
        : std::string_view(s) {
#ifndef NDEBUG
        validate_name();
#endif
    }
 
    // The base name without array information
    constexpr std::string_view base_name() const {
        return substr(0, find('['));
    }
 
    // The array information without base name
    constexpr std::string_view array_str() const {
        auto pos = find('[');
        if (pos != npos) {
            return substr(pos);
        }
        return {};
    }
 
    // @param width the distance between successive elements in the innermost
    //              array dimension if no stride information provided
    // @return a map from the name to its memory offset (from the first item)
    //         in an array by alphabetic order
    std::map<std::string, size_t> arrayNamesToOffsets(size_t width) const {
        if (width == 0) {
            throw std::invalid_argument("Invalid width 0");
        }
 
        if (array_str().empty()) {
            return {};
        }
 
        auto sizes_and_strides = arraySizesAndStrides();
        // Update strides for all dimensions
        for (auto it = sizes_and_strides.rbegin();
             it != sizes_and_strides.rend(); ++it) {
            if (it->second != 0) {
                continue;
            }
            if (it == sizes_and_strides.rbegin()) {
                // The innermost dimension, use width as the stride
                it->second = width;
            } else {
                // Use the sum of distances of inner dimension elements
                it->second = (it - 1)->first * (it - 1)->second;
            }
        }
 
        std::map<std::string, size_t> names_to_offsets;
        std::vector<size_t> indices(sizes_and_strides.size(), 0);
        generateNamesToOffsets(sizes_and_strides, 0, &indices,
                               &names_to_offsets);
        return names_to_offsets;
    }
 
    // @return the size and stride of all array dimensions
    // Returned value should be buffered for better performance
    std::vector<std::pair<size_t, size_t>> arraySizesAndStrides() const {
        auto s = array_str();
        if (s.empty()) {
            return {};
        }
 
        std::size_t content_pos = npos;
        std::vector<std::pair<size_t, size_t>> dims_;
        for (size_t i = 0; i < s.size(); ++i) {
            auto c = s[i];
            if (c == '[') {
                if (content_pos != npos) {
                    throw std::logic_error("Name has unbalanced brackets");
                }
                content_pos = i + 1;
            } else if (c == ']') {
                if (content_pos == npos) {
                    throw std::logic_error("Name has unbalanced brackets");
                }
                if (content_pos == i) {
                    throw std::logic_error("Name has nothing in brackets");
                }
                const auto &[size, stride] = sizeAndStride(
                        s.substr(content_pos, i - content_pos));
                if (size == 0) {
                    throw std::logic_error("Dimension size is 0");
                }
                dims_.push_back({size, stride});
                content_pos = npos;
            }
        }
 
        if (content_pos != npos) {
            throw std::logic_error("Name has unbalanced brackets");
        }
 
        return dims_;
    }
 
  private:
#ifndef __GNUC__
    // Microsoft Visual Studio 2022 treat these functions as non-constexpr and
    // generates C3615 error
    static constexpr bool isalpha(char c) {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }
 
    static constexpr bool isalnum(char c) {
        return isalpha(c) || (c >= '0' && c <= '9');
    }
#endif
 
    // Validation the name (array part is checked when information is requested)
    constexpr void validate_name() const {
#ifdef __GNUC__
        using std::isalpha;
        using std::isalnum;
#endif
        if (empty()) {
            throw std::invalid_argument("Empty name is not allowed");
        }
        if (!isalpha(front())) {
            throw std::invalid_argument(
                std::string("Name (") + data() \
                + ") does not begin with an alphabetic character");
        }
 
        // Validate base_name
        for (const auto &c : base_name()) {
            if (c != '_' && !isalnum(c)) {
                throw std::invalid_argument(
                        std::string("Character (") + c \
                        + ") is not allowed to use in a name");
            }
        }
    }
 
    std::pair<size_t, size_t> sizeAndStride(std::string_view s) const {
        auto stride_pos = s.find(" stride ");
        size_t size;
        size_t stride = 0;
 
        try {
            if (stride_pos != npos) {
                size = std::stoi(s.substr(0, stride_pos).data());
                stride = std::stoi(s.substr(stride_pos + 8).data());
            } else {
                if (s.find_first_not_of("0123456789") != npos) {
                    throw std::invalid_argument("non-digit character");
                }
                size = std::stoi(s.data());
            }
        } catch (const std::exception &e) {
            throw std::invalid_argument(
                    std::string("Array contents are malformed: ") + e.what());
        }
 
        return {size, stride};
    }
 
    void generateNamesToOffsets(const std::vector<std::pair<size_t, size_t>>
                                &dims_info,
                                size_t current_dim,
                                std::vector<size_t> *indices,
                                std::map<std::string, size_t>
                                *names_to_offsets) const {
        if (current_dim == dims_info.size()) {
            // We have reached the innermost dimension, so generate the name and
            // offset and add it to the vector
            std::string name {base_name()};
            size_t offset = 0;
            for (size_t i = 0; i < indices->size(); i++) {
                name += "[" + std::to_string((*indices)[i]) + "]";
                offset += (*indices)[i] * dims_info[i].second;
            }
            (*names_to_offsets)[name] = offset;
        } else {
            // Iterate over each index of the current dimension and recurse
            for (size_t i = 0; i < dims_info[current_dim].first; i++) {
                (*indices)[current_dim] = i;
                generateNamesToOffsets(dims_info, current_dim + 1,
                                       indices, names_to_offsets);
            }
        }
    }
};
 
}  // namespace detail
}  // namespace simics
 
#endif