disconnect() does not work reliably without compressed spikes

[heplesser]

This code creates four connections and deletes the second of them:

import nest
nest.use_compressed_spikes = False
n = nest.Create("parrot_neuron", 2)
nest.Connect(n, n)
c = nest.GetConnections()
c[1].disconnect()

If run as is, it will raise

NESTErrors.The connection does not exist: The connection does not exist in SLI function Disconnect_a: Deletion of connection is not possible.

even though the connection obviously is there.

When run with nest.use_compressed_spikes = True (default), the test completes successfully.

This raises the overall question whether there are other tests that will fail if they were run without compressed spikes?

[med-ayssar]

Hey @heplesser,

TL;DR

1. The cause of the problem is an undefined behavior when calling std::lower_bound without sorting the array first, and this happens when compressedSpike=False
2. Plz check my changes and give me your feedback.

Observation

Given the above script with two nodes: p1 and p2 -> connection list is as SourceTable:[(source, target)] -> [(1, 1), (2 ,1), (1, 2), (2, 2)], and TableConnection:[lcid->target] - > [0->1, 1->1, 2->2, 3->2]

• [Info]: when calling getConnection -> we call SimulationManager::update_connection_infrastructure, which will sort the SourceTable and apply the permutation to the TableConnection.

• Using CompressedSpike=True

  • AfterSort:getConnections -> [(1,1), (1, 2), (2, 1), (2, 2)]
  • AfterSort:TableConnection -> [0->1, 1->2, 2->1, 3->2]

• Using CompressedSpike=False

  • Same Original Input (SourceTable & TableConnection) without SORT!!

Now let's check the following Code, and we want to delete the Connection (edge) with id=1

size_t
nest::ConnectionManager::find_connection( const size_t tid,
  const synindex syn_id,
  const size_t snode_id,
  const size_t tnode_id )
{
  // lcid will hold the position of the /first/ connection from node
  // snode_id to any local node, or be invalid
  size_t lcid = source_table_.find_first_source( tid, syn_id, snode_id );
  if ( lcid == invalid_index )
  {
    return invalid_index;
  }

  // lcid will hold the position of the /first/ connection from node
  // snode_id to node tnode_id, or be invalid
  lcid = connections_[ tid ][ syn_id ]->find_first_target( tid, lcid, tnode_id );
  if ( lcid != invalid_index )
  {
    return lcid;
  }

  return lcid;
}

inline size_t
SourceTable::find_first_source( const size_t tid, const synindex syn_id, const size_t snode_id ) const
{
  // binary search in sorted sources
  const BlockVector< Source >::const_iterator begin = sources_[ tid ][ syn_id ].begin();
  const BlockVector< Source >::const_iterator end = sources_[ tid ][ syn_id ].end();
  BlockVector< Source >::const_iterator it = std::lower_bound( begin, end, Source( snode_id, true ) );

  // source found by binary search could be disabled, iterate through
  // sources until a valid one is found
  while ( it != end )
  {
    if ( it->get_node_id() == snode_id and not it->is_disabled() )
    {
      const size_t lcid = it - begin;
      return lcid;
    }
    ++it;
  }

  // no enabled entry with this snode ID found
  return invalid_index;
}

 // File:nestkernel/connector_base.h
  size_t
  find_first_target( const size_t tid, const size_t start_lcid, const size_t target_node_id ) const override
  {
    size_t lcid = start_lcid;
    while ( true )
    {
      if ( C_[ lcid ].get_target( tid )->get_node_id() == target_node_id and not C_[ lcid ].is_disabled() )
      {
        return lcid;
      }

      if ( not C_[ lcid ].source_has_more_targets() )
      {
        return invalid_index;
      }

      ++lcid;
    }
  }

Setup:

[Info]: I was mainly debugging and going through the documentation, so my explanation of the function logic might not be entirely accurate.

CompressedSpike=On, Delete Connection with id=1=> Edge:source=1, and Edge:target=2

To my understanding, find_first_source tries to find the first edge x with node:source =1 from SourceTable, then use that edge position in find_first_target as starting position in the TableConnection, and then iterate under a condition to find the appropriate edge.

PS: I am not sure about the logic behind find_first_target
For our case with compressedSpike=True, given our SourceTable as [1,1,2,2], using std::lowe_bound with value=1 => iter{val=1, pos=0}, because 1 is the first item in the list that is larger or equal to value=1.

using pos=0, we iterate the Connection table, trying to find a target with Id=2, in our example, AfterSort: TableConnection -> [0->1, 1->2, 2->1, 3->2], it is the second item in the list, and thus we return 1 and it is valid.

CompressedSpike=Off, Delete Connection with id=1=> Edge:source=2, and Edge:target=1**

The interesting part with CompressedSpike=False, calling std:lower_bound with vec:[1,2,1,2] and value=2 (hier value=2 because the second (id=1) created edge is from 2 to 1), will result in getting an iterator pointing to the second 2 (pos=3).

Since our target is 1, and we start iterating the TableConnection at pos=3, and there is no edge starting from pos=3 that has target=1, thus we get the error.

Have a nice Monday.

[github-actions]

Issue automatically marked stale!