Changeset 2901


Ignore:
Timestamp:
Sep 19, 2013 8:07:15 AM (7 years ago)
Author:
bradbell
Message:

Detect and report atomic function name when user
attempts to use an atomic function that has been deleted.

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/cppad/local/atomic_base.hpp

    r2900 r2901  
    3535        // ------------------------------------------------------
    3636        // constants
    37         /// name for this atomic funciton (used for error reporting)
    38         const std::string afun_name_;
    39 
     37        //
    4038        /// index of this object in class_object
    4139        const size_t index_;
     
    4341        // -----------------------------------------------------
    4442        // variables
     43        //
    4544        /// sparsity pattern this object is currently using
    4645        /// (set by constructor and option member functions)
     
    5655        // -----------------------------------------------------
    5756        // static member functions
    58         // 2DO: seems like this function needs to be public to be used by
    59         //      *_sweep.hpp, but it seems to work this way. Why ?
     57        //
    6058        /// List of all the object in this class
    61         /// (null pointer used for objects that have been deleted)
    6259        static std::vector<atomic_base *>& class_object(void)
    6360        {       CPPAD_ASSERT_FIRST_CALL_NOT_PARALLEL;
    6461                static std::vector<atomic_base *> list_;
     62                return list_;
     63        }
     64        /// List of names for each object in this class
     65        static std::vector<std::string>& class_name(void)
     66        {       CPPAD_ASSERT_FIRST_CALL_NOT_PARALLEL;
     67                static std::vector<std::string> list_;
    6568                return list_;
    6669        }
     
    6972        // -----------------------------------------------------
    7073        // member functions not in user API
     74        //
    7175        /// current sparsity setting
    7276        option_enum sparsity(void) const
     
    7579        /// Name corresponding to a base_atomic object
    7680        const std::string& afun_name(void) const
    77         {       return afun_name_; }
     81        {       return class_name()[index_]; }
    7882/*
    7983$begin atomic_ctor$$
     
    171175*/
    172176atomic_base( const std::string&  name) :
    173 afun_name_( name )                  ,
    174177index_( class_object().size() )     ,
    175178sparsity_( set_sparsity_enum )
     
    179182        );
    180183        class_object().push_back(this);
     184        class_name().push_back(name);
     185        CPPAD_ASSERT_UNKNOWN( class_object().size() == class_name().size() );
    181186}
    182187/// destructor informs CppAD that this atomic function with this index
     
    184189virtual ~atomic_base(void)
    185190{       CPPAD_ASSERT_UNKNOWN( class_object().size() > index_ );
     191        // change object pointer to null, but leave name for error reporting
    186192        class_object()[index_] = CPPAD_NULL;
    187193}
     
    190196{       CPPAD_ASSERT_UNKNOWN( class_object().size() > index );
    191197        return class_object()[index];
     198}
     199/// atomic_base function name corresponding to a certain index
     200static const std::string& class_name(size_t index)
     201{       CPPAD_ASSERT_UNKNOWN( class_name().size() > index );
     202        return class_name()[index];
    192203}
    193204/*
     
    355366# ifndef NDEBUG
    356367        bool ok;
    357         std::string msg = "atomic_base: " + afun_name_ + ".eval: ";
     368        std::string msg = "atomic_base: " + afun_name() + ".eval: ";
    358369        if( (n == 0) | (m == 0) )
    359370        {       msg += "ax.size() or ay.size() is zero";
     
    391402# ifndef NDEBUG
    392403                        if( tape_id != ax[j].tape_id_ )
    393                         {       msg += afun_name_ +
     404                        {       msg += afun_name() +
    394405                                ": ax contains variables from different threads.";
    395406                                CPPAD_ASSERT_KNOWN(false, msg.c_str());
     
    406417        ok = forward(q, p, vx, vy, tx, ty); 
    407418        if( ! ok )
    408         {       msg += afun_name_ + ": ok is false for "
     419        {       msg += afun_name() + ": ok is false for "
    409420                        "zero order forward mode calculation.";
    410421                CPPAD_ASSERT_KNOWN(false, msg.c_str());
  • trunk/cppad/local/for_jac_sweep.hpp

    r2900 r2901  
    548548                                user_m     = arg[3];
    549549                                user_atom  = atomic_base<Base>::class_object(user_index);
     550# ifndef NDEBUG
     551                                if( user_atom == CPPAD_NULL )
     552                                {       std::string msg =
     553                                                atomic_base<Base>::class_name(user_index)
     554                                                + ": atomic_base function has been deleted";
     555                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
     556                                }
     557# endif
    550558                                user_bool  = user_atom->sparsity() ==
    551559                                                        atomic_base<Base>::bool_sparsity_enum;
     
    579587# ifndef NDEBUG
    580588                                if( ! user_ok )
    581                                 {       std::string msg = user_atom->afun_name()
    582                                         + ": atomic_base.for_sparse_jac: returned false";
     589                                {       std::string msg =
     590                                                atomic_base<Base>::class_name(user_index)
     591                                                + ": atomic_base.for_sparse_jac: returned false";
    583592                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
    584593                                }
  • trunk/cppad/local/forward0sweep.hpp

    r2900 r2901  
    540540                                user_m     = arg[3];
    541541                                user_atom  = atomic_base<Base>::class_object(user_index);
     542# ifndef NDEBUG
     543                                if( user_atom == CPPAD_NULL )
     544                                {       std::string msg =
     545                                                atomic_base<Base>::class_name(user_index)
     546                                                + ": atomic_base function has been deleted";
     547                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
     548                                }
     549# endif
    542550                                if(user_tx.size() != user_n)
    543551                                        user_tx.resize(user_n);
     
    556564# ifndef NDEBUG
    557565                                if( ! user_ok )
    558                                 {       std::string msg = user_atom->afun_name()
    559                                         + ": atomic_base.forward: returned false";
     566                                {       std::string msg =
     567                                                atomic_base<Base>::class_name(user_index)
     568                                                + ": atomic_base.forward: returned false";
    560569                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
    561570                                }
  • trunk/cppad/local/forward_sweep.hpp

    r2900 r2901  
    589589                                user_m     = arg[3];
    590590                                user_atom  = atomic_base<Base>::class_object(user_index);
     591# ifndef NDEBUG
     592                                if( user_atom == CPPAD_NULL )
     593                                {       std::string msg =
     594                                                atomic_base<Base>::class_name(user_index)
     595                                                + ": atomic_base function has been deleted";
     596                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
     597                                }
     598# endif
    591599                                if(user_tx.size() != user_n * user_p1)
    592600                                        user_tx.resize(user_n * user_p1);
     
    613621# ifndef NDEBUG
    614622                                if( ! user_ok )
    615                                 {       std::string msg = user_atom->afun_name()
    616                                         + ": atomic_base.forward: returned false";
     623                                {       std::string msg =
     624                                                atomic_base<Base>::class_name(user_index)
     625                                                + ": atomic_base.forward: returned false";
    617626                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
    618627                                }
  • trunk/cppad/local/rev_hes_sweep.hpp

    r2900 r2901  
    577577                                user_m     = arg[3];
    578578                                user_atom  = atomic_base<Base>::class_object(user_index);
     579# ifndef NDEBUG
     580                                if( user_atom == CPPAD_NULL )
     581                                {       std::string msg =
     582                                                atomic_base<Base>::class_name(user_index)
     583                                                + ": atomic_base function has been deleted";
     584                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
     585                                }
     586# endif
    579587                                user_bool  = user_atom->sparsity() ==
    580588                                                        atomic_base<Base>::bool_sparsity_enum;
     
    651659                                );
    652660                                if( ! user_ok )
    653                                 {       std::string msg = user_atom->afun_name()
    654                                         + ": atomic_base.rev_sparse_hes: returned false";
     661                                {       std::string msg =
     662                                                atomic_base<Base>::class_name(user_index)
     663                                                + ": atomic_base.rev_sparse_hes: returned false";
    655664                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
    656665                                }
  • trunk/cppad/local/rev_jac_sweep.hpp

    r2900 r2901  
    546546                                user_m     = arg[3];
    547547                                user_atom  = atomic_base<Base>::class_object(user_index);
     548# ifndef NDEBUG
     549                                if( user_atom == CPPAD_NULL )
     550                                {       std::string msg =
     551                                                atomic_base<Base>::class_name(user_index)
     552                                                + ": atomic_base function has been deleted";
     553                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
     554                                }
     555# endif
    548556                                user_bool  = user_atom->sparsity() ==
    549557                                                        atomic_base<Base>::bool_sparsity_enum;
     
    577585# ifndef NDEBUG
    578586                                if( ! user_ok )
    579                                 {       std::string msg = user_atom->afun_name()
    580                                         + ": atomic_base.rev_sparse_jac: returned false";
     587                                {       std::string msg =
     588                                                atomic_base<Base>::class_name(user_index)
     589                                                + ": atomic_base.rev_sparse_jac: returned false";
    581590                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
    582591                                }
  • trunk/cppad/local/reverse_sweep.hpp

    r2900 r2901  
    548548                                user_m     = arg[3];
    549549                                user_atom  = atomic_base<Base>::class_object(user_index);
     550# ifndef NDEBUG
     551                                if( user_atom == CPPAD_NULL )
     552                                {       std::string msg =
     553                                                atomic_base<Base>::class_name(user_index)
     554                                                + ": atomic_base function has been deleted";
     555                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
     556                                }
     557# endif
    550558                                if(user_ix.size() != user_n)
    551559                                        user_ix.resize(user_n);
     
    576584# ifndef NDEBUG
    577585                                if( ! user_ok )
    578                                 {       std::string msg = user_atom->afun_name()
    579                                         + ": atomic_base.reverse: returned false";
     586                                {       std::string msg =
     587                                                atomic_base<Base>::class_name(user_index)
     588                                                + ": atomic_base.reverse: returned false";
    580589                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
    581590                                }
  • trunk/omh/whats_new/whats_new_13.omh

    r2900 r2901  
    5555$head 09-18$$
    5656$list number$$
     57A segmentation fault would occur if
     58an $cref ADFun$$ object used an $cref atomic$$
     59function that had been deleted.
     60This has been fixed so that when $code NDEBUG$$ is not defined,
     61an error message is generated.
     62$lnext
    5763A mistake in the documentation for
    5864$cref/Memory and Parallel Mode/CppAD_vector/Memory and Parallel Mode/$$
Note: See TracChangeset for help on using the changeset viewer.