VirtualMemorySpace.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_VIRTUALMEMORYSPACE_HXX
#define _OPENLCB_VIRTUALMEMORYSPACE_HXX
 
#include "openlcb/ConfigEntry.hxx"
#include "openlcb/ConfigRepresentation.hxx"
#include "openlcb/MemoryConfig.hxx"
#include "utils/SortedListMap.hxx"
 
namespace openlcb
{
 
class VirtualMemorySpace : public MemorySpace
{
public:
    VirtualMemorySpace()
        : isReadOnly_(false)
    {
    }
 
    bool read_only() override
    {
        return isReadOnly_;
    }
    address_t min_address() override
    {
        return minAddress_;
    }
    address_t max_address() override
    {
        return maxAddress_;
    }
 
    size_t write(address_t destination, const uint8_t *data, size_t len,
        errorcode_t *error, Notifiable *again) override
    {
        if ((destination > maxAddress_) || ((destination + len) <= minAddress_))
        {
            *error = MemoryConfigDefs::ERROR_OUT_OF_BOUNDS;
            return 0;
        }
        if (destination + len > maxAddress_ + 1)
        {
            len = maxAddress_ + 1 - destination;
        }
        *error = 0;
        unsigned repeat;
        const DataElement *element = nullptr;
        ssize_t skip = find_data_element(destination, len, &element, &repeat);
        string payload;
        size_t written_len;
        if (skip > 0)
        {
            // Will cause a new call be delivered with adjusted data and len.
            return skip;
        }
        else if (skip < 0)
        {
            HASSERT(element);
            // We have some missing bytes that we need to read out first, then
            // can perform the write.
            address_t field_start = destination + skip;
            if (!(cacheOffset_ == field_start &&
                    (cachedData_.size() >= (size_t)-skip)))
            {
                cacheOffset_ = field_start;
                cachedData_.clear();
                bn_.reset(again);
                element->readImpl_(repeat, &cachedData_, bn_.new_child());
                if (!bn_.abort_if_almost_done())
                {
                    // did not succeed synchronously.
                    bn_.notify(); // our slice
                    *error = MemorySpace::ERROR_AGAIN;
                    return 0;
                }
                cachedData_.resize(element->size_); // pads with zeroes
            }
            // Now: cachedData_ contains the payload in the current storage.
            payload = cachedData_;
            written_len =
                std::min((size_t)len, (size_t)(element->size_ + skip));
            memcpy(&payload[-skip], (const char *)data, written_len);
        }
        else // exact address write.
        {
            HASSERT(element);
            payload.assign((const char *)data,
                std::min((size_t)len, (size_t)element->size_));
            written_len = payload.size();
        }
        bn_.reset(again);
        element->writeImpl_(repeat, std::move(payload), bn_.new_child());
        if (bn_.abort_if_almost_done())
        {
            cachedData_.clear();
            return written_len;
        }
        else
        {
            // did not succeed synchronously.
            bn_.notify(); // our slice
            *error = MemorySpace::ERROR_AGAIN;
            return 0;
        }
    }
 
    size_t read(address_t source, uint8_t *dst, size_t len, errorcode_t *error,
        Notifiable *again) override
    {
        if ((source > maxAddress_) || ((source + len) <= minAddress_))
        {
            *error = MemoryConfigDefs::ERROR_OUT_OF_BOUNDS;
            return 0;
        }
        if (source + len > maxAddress_ + 1)
        {
            len = maxAddress_ + 1 - source;
        }
        *error = 0;
        unsigned repeat;
        const DataElement *element = nullptr;
        ssize_t skip = find_data_element(source, len, &element, &repeat);
        if (skip > 0)
        {
            memset(dst, 0, skip);
            return skip;
        }
        // Now: skip <= 0
        HASSERT(element);
        string payload;
        bn_.reset(again);
        element->readImpl_(repeat, &payload, bn_.new_child());
        if (!bn_.abort_if_almost_done())
        {
            // did not succeed synchronously.
            bn_.notify(); // our slice
            *error = MemorySpace::ERROR_AGAIN;
            return 0;
        }
        payload.resize(element->size_); // pads with zeroes
        size_t data_len = std::min(payload.size() + skip, len);
        memcpy(dst, payload.data() - skip, data_len);
        return data_len;
    }
 
protected:
    using WriteFunction = std::function<void(
        unsigned repeat, string contents, BarrierNotifiable *done)>;
    using ReadFunction = std::function<void(
        unsigned repeat, string *contents, BarrierNotifiable *done)>;
 
    template <typename T>
    using TypedWriteFunction = typename std::function<void(
        unsigned repeat, T contents, BarrierNotifiable *done)>;
 
    template <typename T>
    using TypedReadFunction = typename std::function<T (
        unsigned repeat, BarrierNotifiable *done)>;
 
    template <class G> void set_bounds_from_group(const G &group)
    {
        minAddress_ = group.offset();
        maxAddress_ = group.offset() + group.size() - 1;
    }
 
    template <class G> void expand_bounds_from_group(const G &group)
    {
        minAddress_ = std::min(minAddress_, (address_t)group.offset());
        maxAddress_ = std::max(
            maxAddress_, (address_t)(group.offset() + group.size() - 1));
    }
 
    void register_element(address_t address, address_t size,
        ReadFunction read_f, WriteFunction write_f)
    {
        elements_.insert(DataElement(address, size, read_f, write_f));
    }
 
    template <unsigned SIZE>
    void register_string(const StringConfigEntry<SIZE> &entry,
        ReadFunction read_f, WriteFunction write_f)
    {
        expand_bounds_from_group(entry);
        register_element(entry.offset(), SIZE, read_f, write_f);
    }
 
    template <typename T>
    void register_numeric(const NumericConfigEntry<T> &entry,
        TypedReadFunction<T> read_f, TypedWriteFunction<T> write_f)
    {
        expand_bounds_from_group(entry);
        auto trf = [read_f](unsigned repeat, string *contents,
                       BarrierNotifiable *done) {
            T result = read_f(repeat, done);
            contents->clear();
            contents->resize(sizeof(T));
            *((T *)&((*contents)[0])) =
                NumericConfigEntry<T>::endian_convert(result);
        };
        auto twf = [write_f](unsigned repeat, string contents,
                       BarrierNotifiable *done) {
            contents.resize(sizeof(T));
            T result = NumericConfigEntry<T>::endian_convert(
                *(const T *)contents.data());
            write_f(repeat, result, done);
        };
        register_element(
            entry.offset(), entry.size(), std::move(trf), std::move(twf));
    }
 
    template <class Group, unsigned N>
    void register_repeat(const RepeatedGroup<Group, N> &group)
    {
        RepeatElement re;
        re.start_ = group.offset();
        re.end_ = group.end_offset();
        re.repeatSize_ = Group::size();
        HASSERT(re.repeatSize_ * N == re.end_ - re.start_);
        repeats_.insert(std::move(re));
        expand_bounds_from_group(group);
    }
 
    address_t minAddress_ = 0xFFFFFFFFu;
    address_t maxAddress_ = 0;
    unsigned isReadOnly_ : 1;
 
private:
    struct DataElement
    {
        DataElement(address_t address, address_t size, ReadFunction read_f,
            WriteFunction write_f)
            : address_(address)
            , size_(size)
            , writeImpl_(write_f)
            , readImpl_(read_f)
        {
        }
        address_t address_;
        address_t size_;
        WriteFunction writeImpl_;
        ReadFunction readImpl_;
    };
 
    struct DataComparator
    {
        bool operator()(const DataElement &a, const DataElement &b) const
        {
            return a.address_ < b.address_;
        }
        bool operator()(unsigned a, const DataElement &b) const
        {
            return a < b.address_;
        }
        bool operator()(const DataElement &a, unsigned b) const
        {
            return a.address_ < b;
        }
    };
 
    struct RepeatElement
    {
        uint32_t start_;
        uint32_t repeatSize_;
        uint32_t end_;
    };
 
    struct RepeatComparator
    {
        bool operator()(const RepeatElement &a, const RepeatElement &b) const
        {
            return a.end_ < b.end_;
        }
        bool operator()(uint32_t a, const RepeatElement &b) const
        {
            return a < b.end_;
        }
    };
 
    ssize_t find_data_element(address_t address, address_t len,
        const DataElement **ptr, unsigned *repeat)
    {
        *repeat = 0;
        *ptr = nullptr;
        bool in_repeat = false;
        address_t original_address = address;
        ElementsType::iterator b = elements_.begin();
        ElementsType::iterator e = elements_.end();
        // Align in the known repetitions first.
        auto rit = repeats_.upper_bound(address);
        int max_repeat = 0;
        if (rit == repeats_.end())
        {
            // not a repeat.
        }
        else
        {
            if (rit->start_ <= address && address < rit->end_)
            {
                // we are in the repeat.
                unsigned cnt = (address - rit->start_) / rit->repeatSize_;
                *repeat = cnt;
                if (address + rit->repeatSize_ < rit->end_)
                {
                    // Try one repetition later too.
                    max_repeat = 1;
                }
                // re-aligns address to the first repetition.
                address -= cnt * rit->repeatSize_;
                in_repeat = true;
                b = elements_.lower_bound(rit->start_);
                e = elements_.lower_bound(rit->start_ + rit->repeatSize_);
            }
        }
        LOG(VERBOSE,
            "searching for element at address %u in_repeat=%d address=%u "
            "len=%u",
            (unsigned)original_address, in_repeat, (unsigned)address,
            (unsigned)len);
 
        for (int is_repeat = 0; is_repeat <= max_repeat; ++is_repeat)
        {
            auto it = std::upper_bound(b, e, address, DataComparator());
            if (it != elements_.begin())
            {
                auto pit = it - 1;
                // now: pit->address_ <= address
                if (pit->address_ + pit->size_ > address)
                {
                    // found overlap
                    *ptr = &*pit;
                    return (ssize_t)pit->address_ -
                        (ssize_t)address; // may be negative!
                }
                // else: no overlap, look at the next item
            }
            // now: it->address_ > address
            if ((it != elements_.end()) && (address + len > it->address_))
            {
                // found overlap, but some data needs to be discarded.
                *ptr = &*it;
                return it->address_ - address;
            }
 
            if (in_repeat)
            {
                // We might be too close to the end of a repetition, we will
                // try with the next repeat instead.
                address -= rit->repeatSize_;
                *repeat += 1;
                if (original_address + rit->repeatSize_ >= rit->end_)
                {
                    // We ran out of repeats. Look at the range beyond the
                    // group instead.
                    b = elements_.lower_bound(rit->end_);
                    e = elements_.end();
                    *repeat = 0;
                }
            }
            else
            {
                break;
            }
        }
 
        // now: no overlap either before or after.
        LOG(VERBOSE, "element not found for address %u",
            (unsigned)original_address);
        return len;
    }
 
    static constexpr unsigned NO_CACHE = static_cast<address_t>(-1);
    address_t cacheOffset_ = NO_CACHE;
    string cachedData_;
    typedef SortedListSet<DataElement, DataComparator> ElementsType;
    ElementsType elements_;
    SortedListSet<RepeatElement, RepeatComparator> repeats_;
    BarrierNotifiable bn_;
}; // class VirtualMemorySpace
 
} // namespace openlcb
 
#endif // _OPENLCB_VIRTUALMEMORYSPACE_HXX