Final polish.

Author: thorstenhater

arbor/label_resolution.cpp

@@ -17,10 +17,9 @@ namespace arb {
 
 // cell_label_range methods
 cell_label_range::cell_label_range(std::vector<cell_size_type> size_vec,
-                                   std::vector<cell_tag_type> label_vec,
+                                   const std::vector<cell_tag_type>& label_vec,
                                    std::vector<lid_range> range_vec):
-    sizes(std::move(size_vec)), ranges(std::move(range_vec))
-{
+    sizes(std::move(size_vec)), ranges(std::move(range_vec)) {
     std::transform(label_vec.begin(), label_vec.end(),
                    std::back_inserter(labels),
                    hash_value<const std::string&>);
@@ -30,8 +29,7 @@ cell_label_range::cell_label_range(std::vector<cell_size_type> size_vec,
 cell_label_range::cell_label_range(std::vector<cell_size_type> size_vec,
                                    std::vector<hash_type> label_vec,
                                    std::vector<lid_range> range_vec):
-    sizes(std::move(size_vec)), labels(std::move(label_vec)), ranges(std::move(range_vec))
-{
+    sizes(std::move(size_vec)), labels(std::move(label_vec)), ranges(std::move(range_vec)) {
     arb_assert(check_invariant());
 };
 
@@ -75,10 +73,11 @@ bool cell_labels_and_gids::check_invariant() const {
 /* The n-th local item (by index) to its identifier (lid). The lids are organised
    in potentially discontiguous ranges.
 
-   idx --------
+   idx --------           len0 <= idx < len0 + len1
                 \
                  v
    | [s0, e0) [s1, e1), ... [sk, ek), ... |
+       len0     len1
 */
 cell_lid_type label_resolution_map::range_set::at(unsigned idx) const {
     if (0 == size) throw arbor_internal_error("no valid lids");
@@ -94,14 +93,6 @@ const label_resolution_map::range_set& label_resolution_map::at(cell_gid_type gi
     return map.at(std::make_pair(gid, hash));
 }
 
-const label_resolution_map::range_set& label_resolution_map::at(cell_gid_type gid, const cell_tag_type& tag) const {
-    return map.at(std::make_pair(gid, hash_value(tag)));
-}
-
-std::size_t label_resolution_map::count(cell_gid_type gid, const cell_tag_type& tag) const {
-    return map.count(std::make_pair(gid, hash_value(tag)));
-}
-
 std::size_t label_resolution_map::count(cell_gid_type gid, hash_type hash) const {
     return map.count(std::make_pair(gid, hash));
 }
@@ -139,7 +130,7 @@ cell_lid_type resolver::resolve(cell_gid_type gid, const cell_local_label_type&
     auto hash = hash_value(tag);
     if (!label_map_->count(gid, hash)) throw arb::bad_connection_label(gid, tag, "label does not exist");
     const auto& range_set = label_map_->at(gid, hash);
-    if (range_set.size < 1) throw arb::bad_connection_label(gid, tag, "no valid lids");
+    if (range_set.size <= 0) throw arb::bad_connection_label(gid, tag, "no valid lids");
     auto idx = 0ul;
     if (pol == lid_selection_policy::assert_univalent) {
         // must have single-entry range_set

arbor/label_resolution.hpp

@@ -23,8 +23,12 @@ struct ARB_ARBOR_API cell_label_range {
     cell_label_range& operator=(const cell_label_range&) = default;
     cell_label_range& operator=(cell_label_range&&) = default;
 
-    cell_label_range(std::vector<cell_size_type> size_vec, std::vector<cell_tag_type> label_vec, std::vector<lid_range> rapfnge_vec);
-    cell_label_range(std::vector<cell_size_type> size_vec, std::vector<hash_type> label_vec, std::vector<lid_range> range_vec);
+    cell_label_range(std::vector<cell_size_type> size_vec,
+                     const std::vector<cell_tag_type>& label_vec,
+                     std::vector<lid_range> range_vec);
+    cell_label_range(std::vector<cell_size_type> size_vec,
+                     std::vector<hash_type> label_vec,
+                     std::vector<lid_range> range_vec);
 
     void add_cell();
 
@@ -36,10 +40,8 @@ struct ARB_ARBOR_API cell_label_range {
 
     // The number of labels associated with each cell.
     std::vector<cell_size_type> sizes;
-
     // The labels corresponding to each cell, partitioned according to sizes_.
     std::vector<hash_type> labels;
-
     // The lid_range corresponding to each label.
     std::vector<lid_range> ranges;
 };
@@ -60,20 +62,17 @@ struct ARB_ARBOR_API cell_labels_and_gids {
 // Class constructed from `cell_labels_and_ranges`:
 // Represents the information in the object in a more
 // structured manner for lid resolution in `resolver`
-class ARB_ARBOR_API label_resolution_map {
-public:
+struct ARB_ARBOR_API label_resolution_map {
     struct range_set {
-        std::vector<lid_range> ranges;
         std::size_t size = 0;
+        std::vector<lid_range> ranges;
         cell_lid_type at(unsigned idx) const;
     };
 
     label_resolution_map() = default;
     explicit label_resolution_map(const cell_labels_and_gids&);
 
-    const range_set& at(cell_gid_type gid, const cell_tag_type& tag) const;
     const range_set& at(cell_gid_type gid, hash_type hash) const;
-    std::size_t count(cell_gid_type gid, const cell_tag_type& tag) const;
     std::size_t count(cell_gid_type gid, hash_type hash) const;
 
 private:

example/brunel/brunel.cpp

@@ -213,7 +213,7 @@ int main(int argc, char** argv) {
         unsigned num_threads = arbenv::default_concurrency();
         int gpu_id = arbenv::find_private_gpu(MPI_COMM_WORLD);
         auto context = arb::make_context(arb::proc_allocation{num_threads, gpu_id}, MPI_COMM_WORLD);
-        root = arb::rank(context)==0;
+        root = arb::rank(context) == 0;
 #else
         auto context = arb::make_context(arbenv::default_allocation());
 #endif
@@ -230,7 +230,10 @@ int main(int argc, char** argv) {
 
         // read parameters
         auto o = read_options(argc, argv);
-        if (!o) {return 0; }
+        if (!o) {
+            std::cerr << "Couldm't read options.\n";
+            return -1;
+        }
         cl_options options = o.value();
 
         std::fstream spike_out;
@@ -279,9 +282,7 @@ int main(int argc, char** argv) {
         hints[cell_kind::cable].gpu_group_size = group_size;
         auto dec = partition_load_balance(recipe, context, hints);
 
-        simulation sim(recipe,
-                       context,
-                       dec);
+        simulation sim(recipe, context, dec);
 
         // Set up spike recording.
         std::vector<arb::spike> recorded_spikes;
@@ -356,10 +357,12 @@ void add_subset(cell_gid_type gid,
     std::vector<bool> seen(end - start, false);
     if (gid >= start && gid < end) seen[gid - start] = true;
     std::mt19937 gen(gid + 42);
+    auto conn = arb::cell_connection{{0, src}, {tgt}, weight, delay*U::ms};
     while(m > 0) {
         cell_gid_type val = rand_range(gen, start, end);
         if (seen[val - start]) continue;
-        conns.push_back({{val, src}, {tgt}, weight, delay*U::ms});
+        conn.source.gid = val;
+        conns.push_back(conn);
         seen[val - start] = true;
         m--;
     }