Fix namespaces?

arbor/backends/event.hpp

@@ -25,6 +25,15 @@ struct target_handle {
     ARB_SERDES_ENABLE(target_handle, mech_id, mech_index);
 };
 
+}
+
+template<typename K>
+void serialize(arb::serializer &ser, const K &k, const arb::target_handle&);
+template<typename K>
+void deserialize(arb::serializer &ser, const K &k, arb::target_handle&);
+
+namespace arb {
+
 struct deliverable_event {
     time_type time = 0;
     float weight = 0;

arbor/backends/multicore/shared_state.hpp

@@ -151,7 +151,7 @@ struct ARB_ARBOR_API shared_state:
     ARB_SERDES_ENABLE(shared_state,
                       cbprng_seed,
                       ion_data,
-                      storage,
+                      //storage,
                       voltage,
                       conductivity,
                       time_since_spike,

arbor/benchmark_cell_group.cpp

@@ -13,6 +13,11 @@
 
 #include "util/span.hpp"
 
+template<typename K>
+void serialize(arb::serializer& s, const K& k, const arb::benchmark_cell_group&);
+template<typename K>
+void deserialize(arb::serializer& s, const K& k, arb::benchmark_cell_group&);
+
 namespace arb {
 
 benchmark_cell_group::benchmark_cell_group(const std::vector<cell_gid_type>& gids,
@@ -50,6 +55,13 @@ void benchmark_cell_group::reset() {
     clear_spikes();
 }
 
+void benchmark_cell_group::t_serialize(serializer& ser, const std::string& k) const {
+    serialize(ser, k, *this);
+}
+void benchmark_cell_group::t_deserialize(serializer& ser, const std::string& k) {
+    deserialize(ser, k, *this);
+}
+
 cell_kind benchmark_cell_group::get_cell_kind() const {
     return cell_kind::benchmark;
 }

arbor/benchmark_cell_group.hpp

@@ -34,8 +34,8 @@ class benchmark_cell_group: public cell_group {
 
     ARB_SERDES_ENABLE(benchmark_cell_group, cells_, spikes_, gids_);
 
-    virtual void t_serialize(serializer& ser, const std::string& k) const override { serialize(ser, k, *this); }
-    virtual void t_deserialize(serializer& ser, const std::string& k) override { deserialize(ser, k, *this); }
+    void t_serialize(serializer& ser, const std::string& k) const override;
+    void t_deserialize(serializer& ser, const std::string& k) override;
 
 private:
     std::vector<benchmark_cell> cells_;

arbor/include/arbor/benchmark_cell.hpp

@@ -3,6 +3,11 @@
 #include <arbor/export.hpp>
 #include <arbor/schedule.hpp>
 
+template<typename K>
+void serialize(arb::serializer& s, const K& k, const arb::schedule&);
+template<typename K>
+void deserialize(arb::serializer& s, const K& k, arb::schedule&);
+
 namespace arb {
 
 // Cell description returned by recipe::cell_description(gid) for cells with

arbor/include/arbor/schedule.hpp

@@ -27,29 +27,12 @@ inline time_event_span as_time_event_span(const std::vector<time_type>& v) {
 
 // Default schedule is empty.
 
-class ARB_ARBOR_API empty_schedule {
-public:
+struct ARB_ARBOR_API empty_schedule {
     void reset() {}
     time_event_span events(time_type t0, time_type t1) {
         static time_type no_time;
         return {&no_time, &no_time};
     }
-
-    template<typename K>
-    friend ARB_ARBOR_API void serialize(::arb::serializer& ser,
-                                        const K& k,
-                                        const arb::empty_schedule& t) {
-        ser.begin_write_map(::arb::to_serdes_key(k));
-        ser.end_write_map();
-    }
-
-    template<typename K>
-    friend ARB_ARBOR_API void deserialize(::arb::serializer& ser,
-                                          const K& k,
-                                          arb::empty_schedule& t) {
-        ser.begin_read_map(::arb::to_serdes_key(k));
-        ser.end_read_map();
-    }
 };
 
 // Schedule at k·dt for integral k≥0 within the interval [t0, t1).
@@ -157,10 +140,48 @@ class poisson_schedule_impl {
 // then 0 ≤ _t0_ ≤ _t1_ ≤ _t2_ ≤ _t3_.
 
 template<typename K>
-void serialize(serializer& s, const K& k, const explicit_schedule_impl&);
+void serialize(arb::serializer& s, const K& k, const arb::explicit_schedule_impl&);
+template<typename K>
+void deserialize(arb::serializer& s, const K& k, arb::explicit_schedule_impl&);
+
+template<typename K>
+void serialize(arb::serializer& s, const K& k, const arb::regular_schedule_impl&);
 template<typename K>
-void deserialize(serializer& s, const K& k, explicit_schedule_impl&);
+void deserialize(arb::serializer& s, const K& k, arb::regular_schedule_impl&);
 
+template <typename K>
+ARB_ARBOR_API void serialize(::arb::serializer& ser,
+                  const K& k,
+                  const arb::empty_schedule& t) {
+    ser.begin_write_map(::arb::to_serdes_key(k));
+    ser.end_write_map();
+}
+
+template <typename K>
+ARB_ARBOR_API void deserialize(::arb::serializer& ser,
+                        const K& k,
+                        arb::empty_schedule& t) {
+    ser.begin_read_map(::arb::to_serdes_key(k));
+    ser.end_read_map();
+}
+
+// These are custom to get the reset in.
+template<typename K, typename R>
+void serialize(::arb::serializer& ser, const K& k, const ::arb::poisson_schedule_impl<R>& t) {
+    ser.begin_write_map(arb::to_serdes_key(k));
+    ARB_SERDES_WRITE(tstart_);
+    ARB_SERDES_WRITE(tstop_);
+    ser.end_write_map();
+}
+
+template<typename K, typename R>
+void deserialize(::arb::serializer& ser, const K& k, ::arb::poisson_schedule_impl<R>& t) {
+    ser.begin_read_map(arb::to_serdes_key(k));
+    ARB_SERDES_READ(tstart_);
+    ARB_SERDES_READ(tstop_);
+    ser.end_read_map();
+    t.reset();
+}
 
 class schedule {
 public:
@@ -192,9 +213,9 @@ class schedule {
     void reset() { impl_->reset(); }
 
     template<typename K>
-    friend ARB_ARBOR_API void serialize(serializer& s, const K& k, const schedule& v) { v.impl_->serialize(s, to_serdes_key(k)); }
+    friend ARB_ARBOR_API void serialize(serializer& s, const K& k, const schedule& v) { v.impl_->t_serialize(s, to_serdes_key(k)); }
     template<typename K>
-    friend ARB_ARBOR_API void deserialize(serializer& s, const K& k, schedule& v) { v.impl_->deserialize(s, to_serdes_key(k
+    friend ARB_ARBOR_API void deserialize(serializer& s, const K& k, schedule& v) { v.impl_->t_deserialize(s, to_serdes_key(k
 )); }
 
 private:
@@ -204,8 +225,8 @@ class schedule {
         virtual void reset() = 0;
         virtual std::unique_ptr<interface> clone() = 0;
         virtual ~interface() {}
-        virtual void serialize(serializer&, const std::string&k) const = 0;
-        virtual void deserialize(serializer&, const std::string&k) = 0;
+        virtual void t_serialize(serializer&, const std::string&k) const = 0;
+        virtual void t_deserialize(serializer&, const std::string&k) = 0;
     };
 
     using iface_ptr = std::unique_ptr<interface> ;
@@ -219,8 +240,8 @@ class schedule {
         virtual time_event_span events(time_type t0, time_type t1) override { return wrapped.events(t0, t1); }
         virtual void reset() override { wrapped.reset(); }
         virtual iface_ptr clone() override { return std::make_unique<wrap<Impl>>(wrapped); }
-        virtual void serialize(serializer& s, const std::string& k) const override { serialize(s, k, wrapped); }
-        virtual void deserialize(serializer& s, const std::string& k) override { deserialize(s, k, wrapped); }
+        virtual void t_serialize(serializer& s, const std::string& k) const override { serialize(s, k, wrapped); }
+        virtual void t_deserialize(serializer& s, const std::string& k) override { deserialize(s, k, wrapped); }
 
         Impl wrapped;
     };
@@ -259,38 +280,3 @@ inline schedule poisson_schedule(time_type tstart, time_type rate_kHz, const Ran
 }
 
 } // namespace arb
-
-template <typename K>
-ARB_ARBOR_API void serialize(::arb::serializer& ser,
-                  const K& k,
-                  const arb::empty_schedule& t) {
-    ser.begin_write_map(::arb::to_serdes_key(k));
-    ser.end_write_map();
-}
-
-template <typename K>
-ARB_ARBOR_API void deserialize(::arb::serializer& ser,
-                        const K& k,
-                        arb::empty_schedule& t) {
-    ser.begin_read_map(::arb::to_serdes_key(k));
-    ser.end_read_map();
-}
-
-// These are custom to get the reset in.
-template<typename K, typename R>
-void serialize(::arb::serializer& ser, const K& k, const ::arb::poisson_schedule_impl<R>& t) {
-    ser.begin_write_map(to_serdes_key(k));
-    ARB_SERDES_WRITE(tstart_);
-    ARB_SERDES_WRITE(tstop_);
-    ser.end_write_map();
-    t.reset();
-}
-
-template<typename K, typename R>
-void deserialize(::arb::serializer& ser, const K& k, ::arb::poisson_schedule_impl<R>& t) {
-    ser.begin_read_map(to_serdes_key(k));
-    ARB_SERDES_READ(tstart_);
-    ARB_SERDES_READ(tstop_);
-    ser.end_read_map();
-    t.reset();
-}

arbor/include/arbor/serdes.hpp

@@ -112,6 +112,8 @@ struct serializer {
         virtual void end_read_map() = 0;
         virtual void begin_read_array(const serdes_key_type&) = 0;
         virtual void end_read_array() = 0;
+
+        virtual ~interface(){}
     };
 
     template <typename I>
@@ -146,7 +148,6 @@ struct serializer {
 
     std::unique_ptr<interface> wrapped = nullptr;
 };
-} // arb
 
 // The actual interface. This needs to go to the global namespace as
 // A) friend in a class is just weird that way (it puts the defined function into the global namespace)
@@ -254,6 +255,14 @@ ARB_ARBOR_API void serialize(::arb::serializer& ser, const K& k, const std::vect
     ser.end_write_array();
 }
 
+template <typename K,
+          typename V>
+ARB_ARBOR_API void serialize(::arb::serializer& ser, const K& k, const std::vector<V>& vs) {
+    ser.begin_write_array(arb::to_serdes_key(k));
+    for (std::size_t ix = 0; ix < vs.size(); ++ix) serialize(ser, ix, vs[ix]);
+    ser.end_write_array();
+}
+
 template <typename K,
           typename V,
           size_t N>
@@ -349,7 +358,7 @@ ARB_ARBOR_API void deserialize(::arb::serializer& ser, const K& k, std::unordere
         auto q = ser.next_key();
         if (!q) break;
         typename std::remove_cv_t<Q> key;
-        from_serdes_key(key, *q);
+        arb::from_serdes_key(key, *q);
         if (!vs.count(key)) vs[key] = {}; // NOTE Must be default constructible anyhow
         deserialize(ser, *q, vs[key]);
     }
@@ -365,7 +374,7 @@ ARB_ARBOR_API void deserialize(::arb::serializer& ser, const K& k, std::map<Q, V
         auto q = ser.next_key();
         if (!q) break;
         typename std::remove_cv_t<Q> key;
-        from_serdes_key(key, *q);
+        arb::from_serdes_key(key, *q);
         if (!vs.count(key)) vs[key] = {}; // NOTE Must be default constructible anyhow
         deserialize(ser, *q, vs[key]);
     }
@@ -496,10 +505,16 @@ ARB_ARBOR_API void deserialize(::arb::serializer& ser, const K& k, std::array<V,
        t = static_cast<T>(tmp);                                          \
     }
 
+
+// #define ARB_SERDES_ENABLE(T, ...)
+// #define ARB_SERDES_ENABLE_EXT(T, ...)
+// #define ARB_SERDES_ENABLE_ENUM(T)
+
 // from common_types
 ARB_SERDES_ENABLE_EXT(arb::cell_member_type, gid, index);
 ARB_SERDES_ENABLE_ENUM(arb::lid_selection_policy);
 ARB_SERDES_ENABLE_EXT(arb::cell_local_label_type, tag, policy);
 ARB_SERDES_ENABLE_EXT(arb::cell_global_label_type, gid, label);
 ARB_SERDES_ENABLE_ENUM(arb::backend_kind);
 ARB_SERDES_ENABLE_ENUM(arb::cell_kind);
+} // arb

arbor/include/arbor/spike.hpp

@@ -21,7 +21,8 @@ struct basic_spike {
     basic_spike(id_type s, time_type t):
         source(std::move(s)), time(t)
     {}
-    ARB_SERDES_ENABLE(basic_spike, source, time);
+
+    ARB_SERDES_ENABLE(basic_spike<I>, source, time);
 };
 
 /// Standard specialization:

arbor/lif_cell_group.cpp

@@ -241,6 +241,14 @@ void lif_cell_group::advance_cell(time_type tfinal,
     }
 }
 
+void lif_cell_group::t_serialize(serializer& ser, const std::string& k) const {
+    serialize(ser, k, *this);
+}
+
+void lif_cell_group::t_deserialize(serializer& ser, const std::string& k) {
+    deserialize(ser, k, *this);
+}
+
 std::vector<probe_metadata> lif_cell_group::get_probe_metadata(cell_member_type key) const {
     if (probes_.count(key)) {
         return {probe_metadata{key, {}, 0, {&probes_.at(key).metadata}}};

arbor/lif_cell_group.hpp

@@ -42,8 +42,8 @@ class ARB_ARBOR_API lif_cell_group: public cell_group {
 
     ARB_SERDES_ENABLE(lif_cell_group, gids_, cells_, spikes_, last_time_updated_, next_time_updatable_);
 
-    virtual void t_serialize(serializer& ser, const std::string& k) const override { serialize(ser, k, *this); }
-    virtual void t_deserialize(serializer& ser, const std::string& k) override { deserialize(ser, k, *this); }
+    virtual void t_serialize(serializer& ser, const std::string& k) const override;
+    virtual void t_deserialize(serializer& ser, const std::string& k) override;
 
 private:
     enum class lif_probe_kind { voltage };

arbor/memory/wrappers.hpp

@@ -152,18 +152,19 @@ auto on_gpu(const C& c) -> device_vector<typename C::value_type> {
     using T = typename C::value_type;
     return device_vector<T>(make_const_view(c));
 }
-
+} // namespace memory
+  //
 template<typename K,
          typename T>
-void serialize(::arb::serializer ser, const K& k, const host_vector<T>& hvs) {
+void serialize(::arb::serializer ser, const K& k, const memory::host_vector<T>& hvs) {
     ser.begin_write_array(to_serdes_key(k));
     for (int ix = 0; ix < hvs.size(); ++ix) serialize(ser, ix, hvs[ix]);
     ser.end_write_array();
 }
 
 template<typename K,
          typename T>
-void serialize(::arb::serializer ser, const K& k, const device_vector<T>& vs) {
+void serialize(::arb::serializer ser, const K& k, const memory::device_vector<T>& vs) {
     auto hvs = on_host(vs);
     ser.begin_write_array(to_serdes_key(k));
     for (size_t ix = 0; ix < hvs.size(); ++ix) serialize(ser, ix, hvs[ix]);
@@ -172,7 +173,7 @@ void serialize(::arb::serializer ser, const K& k, const device_vector<T>& vs) {
 
 template<typename K,
          typename V>
-void deserialize(::arb::serializer ser, const K& k, host_vector<V>& hvs) {
+void deserialize(::arb::serializer ser, const K& k, memory::host_vector<V>& hvs) {
     ser.begin_read_array(to_serdes_key(k));
     for (size_t ix = 0;; ++ix) {
         auto q = ser.next_key();
@@ -189,7 +190,7 @@ void deserialize(::arb::serializer ser, const K& k, host_vector<V>& hvs) {
 
 template<typename K,
          typename V>
-void deserialize(::arb::serializer ser, const K& k, device_vector<V>& vs) {
+void deserialize(::arb::serializer ser, const K& k, memory::device_vector<V>& vs) {
     auto hvs = on_host(vs);
     ser.begin_read_array(to_serdes_key(k));
     for (size_t ix = 0;; ++ix) {
@@ -206,6 +207,4 @@ void deserialize(::arb::serializer ser, const K& k, device_vector<V>& vs) {
     vs = on_gpu(hvs);
 }
 
-
-} // namespace memory
 } // namespace arb

arbor/simulation.cpp

@@ -11,6 +11,7 @@
 #include <arbor/schedule.hpp>
 #include <arbor/simulation.hpp>
 
+#include "epoch.hpp"
 #include "cell_group.hpp"
 #include "cell_group_factory.hpp"
 #include "communication/communicator.hpp"
@@ -159,7 +160,7 @@ class simulation_state {
 
     friend void deserialize(serializer& ser, const std::string& k, simulation_state& t) {
         ARB_SERDES_READ(t_interval_);
-        ARB_SERDES_READ(epoch_);
+        // ARB_SERDES_READ(epoch_);
         ARB_SERDES_READ(pending_events_);
         ARB_SERDES_READ(event_lanes_);
         ARB_SERDES_READ(cell_groups_);