ppu.h

Go to the documentation of this file.

#pragma once
#include "halco/common/typed_heap_array.h"
#include "halco/hicann-dls/vx/coordinates.h"
#include "haldls/cerealization.h"
#include "hate/visibility.h"
#include "lola/vx/cerealization.h"
#include "lola/vx/genpybind.h"
#include <boost/hana/adapt_struct.hpp>
 
#include "haldls/vx/fpga.h"
#include "haldls/vx/ppu.h"
 
class Elf;
 
namespace lola {
namespace vx GENPYBIND_TAG_LOLA_VX {
 
class GENPYBIND(visible) ExternalPPUMemoryBlock
{
public:
    typedef halco::hicann_dls::vx::ExternalPPUMemoryBlockOnFPGA coordinate_type;
    typedef std::false_type has_local_data;
 
    typedef std::vector<haldls::vx::ExternalPPUMemoryByte> bytes_type;
 
    typedef halco::hicann_dls::vx::ExternalPPUMemoryBlockSize size_type;
 
    explicit ExternalPPUMemoryBlock(
        size_type size = size_type(halco::hicann_dls::vx::ExternalPPUMemoryByteOnFPGA::size))
        SYMBOL_VISIBLE;
 
    haldls::vx::ExternalPPUMemoryByte& at(size_t index) SYMBOL_VISIBLE;
    haldls::vx::ExternalPPUMemoryByte const& at(size_t index) const SYMBOL_VISIBLE;
    haldls::vx::ExternalPPUMemoryByte& operator[](size_t index) SYMBOL_VISIBLE;
    haldls::vx::ExternalPPUMemoryByte const& operator[](size_t index) const SYMBOL_VISIBLE;
 
    ExternalPPUMemoryBlock get_subblock(size_t begin, size_type length) const SYMBOL_VISIBLE;
    void set_subblock(size_t begin, ExternalPPUMemoryBlock const& subblock) SYMBOL_VISIBLE;
 
    size_type size() const SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(bytes))
    bytes_type const& get_bytes() const SYMBOL_VISIBLE;
    GENPYBIND(setter_for(bytes))
    void set_bytes(bytes_type const& bytes) SYMBOL_VISIBLE;
 
    bool operator==(ExternalPPUMemoryBlock const& other) const SYMBOL_VISIBLE;
    bool operator!=(ExternalPPUMemoryBlock const& other) const SYMBOL_VISIBLE;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, ExternalPPUMemoryBlock const& config)
        SYMBOL_VISIBLE;
 
    std::string to_string() const SYMBOL_VISIBLE;
 
    friend haldls::vx::detail::VisitPreorderImpl<ExternalPPUMemoryBlock>;
 
private:
    friend class cereal::access;
    template <typename Archive>
    void serialize(Archive& ar, std::uint32_t const version);
 
    bytes_type m_bytes;
};
 
 
class GENPYBIND(visible) ExternalPPUMemory
{
public:
    typedef halco::hicann_dls::vx::ExternalPPUMemoryOnFPGA coordinate_type;
    typedef std::false_type has_local_data;
 
    typedef halco::common::typed_heap_array<
        haldls::vx::ExternalPPUMemoryByte,
        halco::hicann_dls::vx::ExternalPPUMemoryByteOnFPGA>
        Bytes GENPYBIND(opaque);
 
    typedef halco::hicann_dls::vx::ExternalPPUMemoryBlockSize size_type;
 
    ExternalPPUMemory() SYMBOL_VISIBLE;
 
    Bytes bytes;
 
    ExternalPPUMemoryBlock get_subblock(size_t begin, size_type length) const SYMBOL_VISIBLE;
    void set_subblock(size_t begin, ExternalPPUMemoryBlock const& subblock) SYMBOL_VISIBLE;
 
    bool operator==(ExternalPPUMemory const& other) const SYMBOL_VISIBLE;
    bool operator!=(ExternalPPUMemory const& other) const SYMBOL_VISIBLE;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, ExternalPPUMemory const& config)
        SYMBOL_VISIBLE;
 
    std::string to_string() const SYMBOL_VISIBLE;
 
    friend haldls::vx::detail::VisitPreorderImpl<ExternalPPUMemory>;
 
private:
    friend class cereal::access;
    template <typename Archive>
    void serialize(Archive& ar, std::uint32_t const version);
};
 
 
class GENPYBIND(visible) PPUProgram
{
public:
    class GENPYBIND(visible) Symbol
    {
    public:
        enum class Type
        {
            object,
            function,
            other
        };
 
        Symbol() SYMBOL_VISIBLE;
 
        Symbol(Type const& type, halco::hicann_dls::vx::PPUMemoryBlockOnPPU const& coord)
            SYMBOL_VISIBLE;
 
        Type type;
 
        halco::hicann_dls::vx::PPUMemoryBlockOnPPU coordinate;
 
        bool operator==(Symbol const& other) const SYMBOL_VISIBLE;
 
        bool operator!=(Symbol const& other) const SYMBOL_VISIBLE;
 
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, Symbol const& symbol) SYMBOL_VISIBLE;
    };
};
 
 
class GENPYBIND(visible) PPUElfFile
{
public:
    typedef std::map<std::string, PPUProgram::Symbol> symbols_type;
 
    PPUElfFile(std::string const& filename) SYMBOL_VISIBLE;
 
    symbols_type read_symbols() SYMBOL_VISIBLE;
 
    haldls::vx::PPUMemoryBlock read_program() SYMBOL_VISIBLE;
 
    ~PPUElfFile() SYMBOL_VISIBLE;
 
private:
    int m_fd;
    Elf* m_elf_ptr;
};
 
} // namespace vx
} // namespace lola
 
#include "lola/vx/ppu.tcc"