target.h

Go to the documentation of this file.

/*
 *  target.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef TARGET_H
#define TARGET_H
 
// C++ includes:
#include <cassert>
 
// Includes from nestkernel:
#include "exceptions.h"
#include "nest_types.h"
#include "static_assert.h"
 
namespace nest
{
 
enum enum_status_target_id
{
  TARGET_ID_PROCESSED,
  TARGET_ID_UNPROCESSED
};
 
class Target
{
private:
  uint64_t remote_target_id_;
 
  static constexpr uint8_t BITPOS_LCID = 0U;
  static constexpr uint8_t BITPOS_RANK = NUM_BITS_LCID;
  static constexpr uint8_t BITPOS_TID = BITPOS_RANK + NUM_BITS_RANK;
  static constexpr uint8_t BITPOS_SYN_ID = BITPOS_TID + NUM_BITS_TID;
  static constexpr uint8_t BITPOS_PROCESSED_FLAG = BITPOS_SYN_ID + NUM_BITS_SYN_ID;
 
  using bits_for_processed_flag = StaticAssert< NUM_BITS_PROCESSED_FLAG == 1U >::success;
  using position_of_processed_flag = StaticAssert< BITPOS_PROCESSED_FLAG == 63U >::success;
 
  // generate bit-masks used in bit-operations
  static constexpr uint64_t MASK_LCID = generate_bit_mask( NUM_BITS_LCID, BITPOS_LCID );
  static constexpr uint64_t MASK_RANK = generate_bit_mask( NUM_BITS_RANK, BITPOS_RANK );
  static constexpr uint64_t MASK_TID = generate_bit_mask( NUM_BITS_TID, BITPOS_TID );
  static constexpr uint64_t MASK_SYN_ID = generate_bit_mask( NUM_BITS_SYN_ID, BITPOS_SYN_ID );
  static constexpr uint64_t MASK_PROCESSED_FLAG = generate_bit_mask( NUM_BITS_PROCESSED_FLAG, BITPOS_PROCESSED_FLAG );
 
public:
  Target();
  Target( const Target& target );
  Target( const size_t tid, const size_t rank, const synindex syn_id, const size_t lcid );
 
  Target& operator=( const Target& );
 
  void set_lcid( const size_t lcid );
 
  size_t get_lcid() const;
 
  void set_rank( const size_t rank );
 
  size_t get_rank() const;
 
  void set_tid( const size_t tid );
 
  size_t get_tid() const;
 
  void set_syn_id( const synindex syn_id );
 
  synindex get_syn_id() const;
 
  void set_status( enum_status_target_id status );
 
  enum_status_target_id get_status() const;
 
  bool is_processed() const;
 
  double get_offset() const;
 
  void mark_for_removal();
};
 
using success_target_size = StaticAssert< sizeof( Target ) == 8 >::success;
 
inline Target::Target()
  : remote_target_id_( 0 )
{
}
 
inline Target::Target( const Target& target )
  : remote_target_id_( target.remote_target_id_ )
{
  set_status( TARGET_ID_UNPROCESSED );  // initialize
}
 
inline Target&
Target::operator=( const Target& other )
{
  remote_target_id_ = other.remote_target_id_;
  set_status( TARGET_ID_UNPROCESSED );
  return *this;
}
 
inline Target::Target( const size_t tid, const size_t rank, const synindex syn_id, const size_t lcid )
  : remote_target_id_( 0 )
{
  // We need to call set_*() methods to properly encode values in bitfield.
  // Validity of arguments is asserted in set_*() methods.
  set_lcid( lcid );
  set_rank( rank );
  set_tid( tid );
  set_syn_id( syn_id );
  set_status( TARGET_ID_UNPROCESSED );  // initialize
}
 
inline void
Target::set_lcid( const size_t lcid )
{
  assert( lcid < MAX_LCID );
  remote_target_id_ = ( remote_target_id_ & ( ~MASK_LCID ) ) | ( static_cast< uint64_t >( lcid ) << BITPOS_LCID );
}
 
inline size_t
Target::get_lcid() const
{
  return ( ( remote_target_id_ & MASK_LCID ) >> BITPOS_LCID );
}
 
inline void
Target::set_rank( const size_t rank )
{
  assert( rank <= MAX_RANK );  // MAX_RANK is allowed since it is not used as invalid value
  remote_target_id_ = ( remote_target_id_ & ( ~MASK_RANK ) ) | ( static_cast< uint64_t >( rank ) << BITPOS_RANK );
}
 
inline size_t
Target::get_rank() const
{
  return ( ( remote_target_id_ & MASK_RANK ) >> BITPOS_RANK );
}
 
inline void
Target::set_tid( const size_t tid )
{
  assert( tid <= MAX_TID );  // MAX_TID is allowed since it is not used as invalid value
  remote_target_id_ = ( remote_target_id_ & ( ~MASK_TID ) ) | ( static_cast< uint64_t >( tid ) << BITPOS_TID );
}
 
inline size_t
Target::get_tid() const
{
  return ( ( remote_target_id_ & MASK_TID ) >> BITPOS_TID );
}
 
inline void
Target::set_syn_id( const synindex syn_id )
{
  assert( syn_id < MAX_SYN_ID );
  remote_target_id_ = ( remote_target_id_ & ( ~MASK_SYN_ID ) ) | ( static_cast< uint64_t >( syn_id ) << BITPOS_SYN_ID );
}
 
inline synindex
Target::get_syn_id() const
{
  return ( ( remote_target_id_ & MASK_SYN_ID ) >> BITPOS_SYN_ID );
}
 
inline void
Target::set_status( enum_status_target_id set_status_to )
{
  switch ( set_status_to )
  {
  case TARGET_ID_PROCESSED:
    remote_target_id_ = remote_target_id_ | MASK_PROCESSED_FLAG;  // set single bit
    break;
  case TARGET_ID_UNPROCESSED:
    remote_target_id_ = remote_target_id_ & ~MASK_PROCESSED_FLAG;  // clear single bit
    break;
  default:
    throw InternalError( "Invalid remote target id status." );
  }
}
 
inline enum_status_target_id
Target::get_status() const
{
  if ( ( remote_target_id_ & MASK_PROCESSED_FLAG ) >> BITPOS_PROCESSED_FLAG )  // test single bit
  {
    return ( TARGET_ID_PROCESSED );
  }
  return ( TARGET_ID_UNPROCESSED );
}
 
inline bool
Target::is_processed() const
{
  return ( get_status() == TARGET_ID_PROCESSED );
}
 
inline double
Target::get_offset() const
{
  return 0;
}
 
inline void
Target::mark_for_removal()
{
  set_status( TARGET_ID_PROCESSED );
}
 
 
class OffGridTarget : public Target
{
private:
  double offset_;
 
public:
  OffGridTarget();
  OffGridTarget( const Target& target, const double offset );
  double get_offset() const;
};
 
inline OffGridTarget::OffGridTarget()
  : Target()
  , offset_( 0 )
{
}
 
inline OffGridTarget::OffGridTarget( const Target& target, const double offset )
  : Target( target )
  , offset_( offset )
{
}
 
inline double
OffGridTarget::get_offset() const
{
  return offset_;
}
 
}  // namespace nest
 
#endif /* #ifndef TARGET_H */