HALDLS
fpga.h
Go to the documentation of this file.
1 #pragma once
2 #include <array>
3 #include <iosfwd>
4 
5 #include "halco/common/geometry.h"
6 #include "halco/common/typed_array.h"
7 #include "halco/hicann-dls/vx/fpga.h"
8 #include "halco/hicann-dls/vx/quad.h"
9 #include "haldls/cerealization.h"
10 #include "haldls/vx/common.h"
11 #include "haldls/vx/genpybind.h"
12 #include "haldls/vx/timer.h"
13 #include "haldls/vx/traits.h"
14 #include "hate/visibility.h"
15 
16 namespace halco::hicann_dls::vx {
17 class OmnibusAddress;
18 } // namespace halco::hicann_dls::vx
19 
20 namespace lola::vx {
21 struct ExternalPPUMemoryBlock;
22 struct ExternalPPUMemory;
23 } // namespace lola::vx
24 
25 namespace haldls {
26 namespace vx GENPYBIND_TAG_HALDLS_VX {
27 
31 class GENPYBIND(visible) FPGADeviceDNA
32 {
33 public:
34  typedef halco::hicann_dls::vx::FPGADeviceDNAOnFPGA coordinate_type;
35  typedef std::true_type is_leaf_node;
36 
38  struct GENPYBIND(inline_base("*")) Value
39  : public halco::common::detail::RantWrapper<Value, uint64_t, 0x1ff'ffff'ffff'ffffull, 0>
40  {
41  constexpr explicit Value(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
42  rant_t(val)
43  {}
44  };
45 
50  explicit FPGADeviceDNA(Value value = Value()) SYMBOL_VISIBLE;
51 
56  GENPYBIND(getter_for(value))
57  Value get_value() const SYMBOL_VISIBLE;
58 
63  GENPYBIND(setter_for(value))
64  void set_value(Value value) SYMBOL_VISIBLE;
65 
66  bool operator==(FPGADeviceDNA const& other) const SYMBOL_VISIBLE;
67  bool operator!=(FPGADeviceDNA const& other) const SYMBOL_VISIBLE;
68 
69  GENPYBIND(stringstream)
70  friend std::ostream& operator<<(std::ostream& os, FPGADeviceDNA const& config) SYMBOL_VISIBLE;
71 
72  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 2;
73  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 0;
74  static std::array<halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words>
75  read_addresses(coordinate_type const& word) SYMBOL_VISIBLE GENPYBIND(hidden);
76  static std::array<halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words>
77  write_addresses(coordinate_type const& word) SYMBOL_VISIBLE GENPYBIND(hidden);
78  std::array<fisch::vx::word_access_type::Omnibus, write_config_size_in_words> encode() const
79  SYMBOL_VISIBLE GENPYBIND(hidden);
80  void decode(std::array<fisch::vx::word_access_type::Omnibus, read_config_size_in_words> const&
81  data) SYMBOL_VISIBLE GENPYBIND(hidden);
82 
83 private:
84  friend class cereal::access;
85  template <class Archive>
86  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
87 
88  Value m_value;
89 };
90 
91 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(FPGADeviceDNA)
92 
96 class GENPYBIND(visible) EventRecordingConfig
97 {
98 public:
99  typedef halco::hicann_dls::vx::EventRecordingConfigOnFPGA coordinate_type;
100  typedef std::true_type is_leaf_node;
101 
102  explicit EventRecordingConfig() SYMBOL_VISIBLE;
103 
108  GENPYBIND(getter_for(enable_event_recording))
109  bool get_enable_event_recording() const SYMBOL_VISIBLE;
110 
115  GENPYBIND(setter_for(enable_event_recording))
116  void set_enable_event_recording(bool value) SYMBOL_VISIBLE;
117 
118  bool operator==(EventRecordingConfig const& other) const SYMBOL_VISIBLE;
119  bool operator!=(EventRecordingConfig const& other) const SYMBOL_VISIBLE;
120 
121  GENPYBIND(stringstream)
122  friend std::ostream& operator<<(std::ostream& os, EventRecordingConfig const& config) SYMBOL_VISIBLE;
123 
124  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 1;
125  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 1;
126  std::array<halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words> read_addresses(
127  coordinate_type const& word) const SYMBOL_VISIBLE GENPYBIND(hidden);
128  std::array<halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words> write_addresses(
129  coordinate_type const& word) const SYMBOL_VISIBLE GENPYBIND(hidden);
130  std::array<fisch::vx::word_access_type::Omnibus, write_config_size_in_words> encode() const
131  SYMBOL_VISIBLE GENPYBIND(hidden);
132  void decode(std::array<fisch::vx::word_access_type::Omnibus, read_config_size_in_words> const&
133  data) SYMBOL_VISIBLE GENPYBIND(hidden);
134 
135 private:
136  friend class cereal::access;
137  template <class Archive>
138  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
139 
140  bool m_enable_event_recording;
141 };
142 
143 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(EventRecordingConfig)
144 
148 class GENPYBIND(visible) InstructionTimeoutConfig
149 {
150 public:
151  typedef halco::hicann_dls::vx::InstructionTimeoutConfigOnFPGA coordinate_type;
152  typedef std::true_type is_leaf_node;
153 
154  typedef Timer::Value Value GENPYBIND(visible);
155 
156  explicit InstructionTimeoutConfig() SYMBOL_VISIBLE;
157 
162  GENPYBIND(getter_for(value))
163  Value get_value() const SYMBOL_VISIBLE;
164 
169  GENPYBIND(setter_for(value))
170  void set_value(Value value) SYMBOL_VISIBLE;
171 
172  bool operator==(InstructionTimeoutConfig const& other) const SYMBOL_VISIBLE;
173  bool operator!=(InstructionTimeoutConfig const& other) const SYMBOL_VISIBLE;
174 
175  GENPYBIND(stringstream)
176  friend std::ostream& operator<<(std::ostream& os, InstructionTimeoutConfig const& config)
177  SYMBOL_VISIBLE;
178 
179  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 1;
180  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 1;
181  std::array<halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words> read_addresses(
182  coordinate_type const& word) const SYMBOL_VISIBLE GENPYBIND(hidden);
183  std::array<halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words> write_addresses(
184  coordinate_type const& word) const SYMBOL_VISIBLE GENPYBIND(hidden);
185  std::array<fisch::vx::word_access_type::Omnibus, write_config_size_in_words> encode() const
186  SYMBOL_VISIBLE GENPYBIND(hidden);
187  void decode(std::array<fisch::vx::word_access_type::Omnibus, read_config_size_in_words> const&
188  data) SYMBOL_VISIBLE GENPYBIND(hidden);
189 
190 private:
191  friend class cereal::access;
192  template <class Archive>
193  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
194 
195  Value m_value;
196 };
197 
198 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(InstructionTimeoutConfig)
199 
200 class GENPYBIND(visible) ExternalPPUMemoryByte
201 {
202 public:
203  typedef halco::hicann_dls::vx::ExternalPPUMemoryByteOnFPGA coordinate_type;
204  typedef std::true_type is_leaf_node;
205 
206  struct GENPYBIND(inline_base("*")) Value
207  : public halco::common::detail::BaseType<Value, uint8_t>
208  {
209  constexpr explicit Value(uintmax_t const val = 0) : base_t(val) {}
210  };
211 
212  typedef uint8_t raw_type;
213  // verify that the underlying word size matches the value type size
214  static_assert(
215  static_cast<raw_type>(-1) == Value::max, "raw_type size does not match Value type.");
216 
217  explicit ExternalPPUMemoryByte(Value value = Value()) : m_value(value) {}
218 
219  GENPYBIND(getter_for(value))
220  Value get_value() const SYMBOL_VISIBLE;
221  GENPYBIND(setter_for(value))
222  void set_value(Value const& value) SYMBOL_VISIBLE;
223 
224  bool operator==(ExternalPPUMemoryByte const& other) const SYMBOL_VISIBLE;
225  bool operator!=(ExternalPPUMemoryByte const& other) const SYMBOL_VISIBLE;
226 
227  GENPYBIND(stringstream)
228  friend std::ostream& operator<<(std::ostream& os, ExternalPPUMemoryByte const& config)
229  SYMBOL_VISIBLE;
230 
231  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
232  static std::array<halco::hicann_dls::vx::OmnibusAddress, config_size_in_words> addresses(
233  coordinate_type const& word) SYMBOL_VISIBLE GENPYBIND(hidden);
234  std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> encode(
235  coordinate_type const& coord) const SYMBOL_VISIBLE GENPYBIND(hidden);
236  void decode(
237  coordinate_type const& coord,
238  std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> const& data)
239  SYMBOL_VISIBLE GENPYBIND(hidden);
240 
241 private:
242  friend class cereal::access;
243  template <typename Archive>
244  void serialize(Archive& ar, std::uint32_t);
245 
246  friend haldls::vx::detail::VisitPreorderImpl<lola::vx::ExternalPPUMemoryBlock>;
247  friend haldls::vx::detail::VisitPreorderImpl<lola::vx::ExternalPPUMemory>;
248  Value m_value;
249 };
250 
251 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(ExternalPPUMemoryByte)
252 
253 class GENPYBIND(visible) ExternalPPUMemoryQuad
254 {
255 public:
256  typedef halco::hicann_dls::vx::ExternalPPUMemoryQuadOnFPGA coordinate_type;
257  typedef std::true_type is_leaf_node;
258 
259  typedef ExternalPPUMemoryByte::Value Value GENPYBIND(visible);
260 
261  typedef halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> Quad
262  GENPYBIND(opaque(false));
263  typedef halco::common::typed_array<bool, halco::hicann_dls::vx::EntryOnQuad> Enables
264  GENPYBIND(opaque(false));
265 
266  ExternalPPUMemoryQuad() SYMBOL_VISIBLE;
267 
268  GENPYBIND(getter_for(quad))
269  Quad const& get_quad() const SYMBOL_VISIBLE;
270  GENPYBIND(setter_for(quad))
271  void set_quad(Quad const& quad) SYMBOL_VISIBLE;
272 
273  GENPYBIND(getter_for(enables))
274  Enables const& get_enables() const SYMBOL_VISIBLE;
275  GENPYBIND(setter_for(enables))
276  void set_enables(Enables const& enables) SYMBOL_VISIBLE;
277 
278  bool operator==(ExternalPPUMemoryQuad const& other) const SYMBOL_VISIBLE;
279  bool operator!=(ExternalPPUMemoryQuad const& other) const SYMBOL_VISIBLE;
280 
281  GENPYBIND(stringstream)
282  friend std::ostream& operator<<(std::ostream& os, ExternalPPUMemoryQuad const& config)
283  SYMBOL_VISIBLE;
284 
285  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
286  static std::array<halco::hicann_dls::vx::OmnibusAddress, config_size_in_words> addresses(
287  coordinate_type const& word) SYMBOL_VISIBLE GENPYBIND(hidden);
288  std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> encode() const
289  SYMBOL_VISIBLE GENPYBIND(hidden);
290  void decode(std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> const& data)
291  SYMBOL_VISIBLE GENPYBIND(hidden);
292 
293 private:
294  friend class cereal::access;
295  template <typename Archive>
296  void serialize(Archive& ar, std::uint32_t);
297 
298  friend haldls::vx::detail::VisitPreorderImpl<lola::vx::ExternalPPUMemoryBlock>;
299  friend haldls::vx::detail::VisitPreorderImpl<lola::vx::ExternalPPUMemory>;
300  Quad m_quad;
301  Enables m_enables;
302 };
303 
304 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(ExternalPPUMemoryQuad)
305 
306 namespace detail {
307 
308 template <>
309 struct BackendContainerTrait<FPGADeviceDNA>
310  : public BackendContainerBase<FPGADeviceDNA, fisch::vx::word_access_type::Omnibus>
311 {};
312 
313 template <>
314 struct BackendContainerTrait<EventRecordingConfig>
315  : public BackendContainerBase<EventRecordingConfig, fisch::vx::word_access_type::Omnibus>
316 {};
317 
318 template <>
319 struct BackendContainerTrait<InstructionTimeoutConfig>
320  : public BackendContainerBase<InstructionTimeoutConfig, fisch::vx::word_access_type::Omnibus>
321 {};
322 
323 template <>
324 struct BackendContainerTrait<ExternalPPUMemoryByte>
325  : public BackendContainerBase<ExternalPPUMemoryByte, fisch::vx::word_access_type::Omnibus>
326 {};
327 
328 template <>
329 struct BackendContainerTrait<ExternalPPUMemoryQuad>
330  : public BackendContainerBase<ExternalPPUMemoryQuad, fisch::vx::word_access_type::Omnibus>
331 {};
332 
333 } // namespace detail
334 
335 } // namespace vx
336 } // namespace haldls
337 
338 namespace std {
339 
340 HALCO_GEOMETRY_HASH_CLASS(haldls::vx::FPGADeviceDNA::Value)
341 HALCO_GEOMETRY_HASH_CLASS(haldls::vx::ExternalPPUMemoryByte::Value)
342 
343 } // namespace std
haldls::vx::FPGADeviceDNA
Container for reading out the unique identifier of the FPGA.
Definition: fpga.h:32
haldls::vx::FPGADeviceDNA::is_leaf_node
std::true_type is_leaf_node
Definition: fpga.h:35
haldls::vx::FPGADeviceDNA::coordinate_type
halco::hicann_dls::vx::FPGADeviceDNAOnFPGA coordinate_type
Definition: fpga.h:34
GENPYBIND_TAG_HALDLS_VX
#define GENPYBIND_TAG_HALDLS_VX
Definition: genpybind.h:4
halco::hicann_dls::vx
Definition: arq.h:13
lola::vx::v2::ExternalPPUMemoryBlock
lola::vx::ExternalPPUMemoryBlock ExternalPPUMemoryBlock
Definition: is_readable.h:50
lola::vx
Definition: fpga.h:20