Changeset 3363


Ignore:
Timestamp:
Sep 26, 2014 8:41:00 AM (6 years ago)
Author:
bradbell
Message:

Move tracking of cache2var to cache_info object.

Location:
branches/cache/cppad/local
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branches/cache/cppad/local/cache_info.hpp

    r3362 r3363  
    1717class cache_info {
    1818private:
     19/// Number of varialbes in the tape
     20size_t num_var_;
    1921/// Number of cache values. If this is zero, there is no cache
    2022size_t num_cache_;
     
    4749*/
    4850pod_vector<addr_t> var2cache_;
     51/*!
     52This vector has size num_cache_ and maps the zero origin cache index
     53to the corresponding variable index for the current operator.
     54To be specific, if i_var is a result variable, or an argument variable
     55for the current operator
     56\code
     57        i_var = cache2var_ [ var2cache_ [ i_var ] - num_var ]
     58\endcode
     59Note that the current operator is controlled by calls to
     60forward_start, forward_next
     61*/
     62CppAD::vector<addr_t> cache2var_;
    4963//
    5064public:
    5165        // constructor (no cache)
    5266        cache_info(void) :
     67        num_var_(0),
    5368        num_cache_(0),
    5469        last_use_(  std::numeric_limits<addr_t>::max() ),
     
    5974        /// clear out any cache information
    6075        void clear(void)
    61         {       num_cache_ = 0;
     76        {       num_var_   = 0;
     77                num_cache_ = 0;
    6278                last_use_.free();
    6379                order_.free();
     
    6581        }
    6682       
    67         // assignment operator
     83        /// assignment operator
    6884        void operator=(const cache_info& info)
    69         {       num_cache_   = info.num_cache_;
     85        {       num_var_     = info.num_var_;
     86                num_cache_   = info.num_cache_;
    7087                last_use_    = info.last_use_;
    7188                order_       = info.order_;
     
    7390        }
    7491
    75         // get the number of cache values in the recording
     92        /// get the number of cache values in the recording
    7693        size_t num_cache(void) const
    7794        {       return num_cache_; }
    7895
    79         // get cache index corresponding to a variable index
     96        /// get cache index corresponding to a variable index
    8097        addr_t var2cache(addr_t i_var) const
    8198        {       return var2cache_[i_var]; }
    8299
     100        /// start a forward pass
     101        void forward_start(void)
     102        {       for(size_t i = 0; i < num_cache_; i++)
     103                        cache2var_[i] = 0;
     104        }
     105
     106        /// next variable for a forward pass
     107        void forward_next(size_t i_var)
     108        {       if( num_cache_ > 0 )
     109                {       size_t i_cache = var2cache_[i_var];
     110                        CPPAD_ASSERT_UNKNOWN( i_cache >= num_var_ );
     111                        cache2var_[i_cache - num_var_] = i_var;
     112                }
     113        }
     114
     115        /// the current mapping from zero reference cache indices to variable index
     116        const CppAD::vector<addr_t>* cache2var(void) const
     117        {       return &cache2var_; }
    83118
    84119        // create a cache version of a player
  • branches/cache/cppad/local/create_cache.hpp

    r3362 r3363  
    6767# ifndef NDEBUG
    6868        CPPAD_ASSERT_UNKNOWN( play.num_cache_rec() == 0 );
    69         CppAD::vector<addr_t> cache2var;
     69        // empty cache2variable vector
     70        CppAD::vector<addr_t> cache2variable;
    7071# endif
    7172
     
    7374        {       // next op
    7475                play.forward_next(op, arg, i_op, i_var);
    75                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
     76                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2variable, i_var);
    7677
    7778                user_i_var     = i_var;
     
    162163        {       // next op
    163164                play.forward_next(op, arg, i_op, i_var);
    164                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
     165                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2variable, i_var);
    165166
    166167                rec.PutOp(op);
     
    180181
    181182        // set the cache information for this recording
     183        num_var_   = num_var;
     184        num_cache_ = number_cache;
     185        //
    182186        last_use_.free();
    183         last_use_.extend( num_var );
     187        last_use_.extend( num_var_ );
     188        //
    184189        order_.free();
    185         order_.extend(num_var);
     190        order_.extend(num_var_);
     191        //
    186192        var2cache_.free();
    187         var2cache_.extend(num_var);
    188         //
    189         num_cache_ = number_cache;
    190         for(i_var = 0; i_var < num_var; i_var++)
     193        var2cache_.extend(num_var_);
     194        //
     195        cache2var_.clear();
     196        cache2var_.resize(num_cache_);
     197        //
     198        for(i_var = 0; i_var < num_var_; i_var++)
    191199        {       last_use_[i_var]  = addr_t( last_use[i_var] );
    192200                order_[i_var]     = addr_t( order[i_var] );
  • branches/cache/cppad/local/forward0sweep.hpp

    r3344 r3363  
    235235                text = play->GetTxt(0);
    236236
    237         // data structure for cache information
    238         size_t num_cache = play->num_cache_rec();
    239         CppAD::vector<addr_t> cache2var( num_cache );
    240 
    241         // initialize cache indices with invalid variable value
    242         for(size_t i = 0; i < num_cache; i++)
    243                 cache2var[i] = addr_t(0);
     237        // mapping from cache index to variable index
     238        const CppAD::vector<addr_t>* cache2var = play->cache2var();
    244239        /*
    245240        <!-- end forward0sweep_code_define -->
     
    277272                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    278273                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    279                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
     274                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, *cache2var, i_var);
    280275
    281276                // action to take depends on the case
     
    696691                        CPPAD_ASSERT_UNKNOWN(false);
    697692                }
    698                 if( num_cache != 0 )
     693                if( cache2var->size() != 0 )
    699694                {       size_t i_cache = size_t( play->GetVar2Cache(i_var) );
    700695                        CPPAD_ASSERT_UNKNOWN( i_cache >= num_var );
    701696                        taylor[ i_cache * J + 0 ]      = taylor[ i_var * J + 0 ];
    702                         // use zero orgin cache indiex for cache2var vector
    703                         cache2var[ i_cache - num_var ] = i_var;
    704697                }
    705698# if CPPAD_FORWARD0SWEEP_TRACE
     
    720713                                        CPPAD_NULL,
    721714                                        num_var,
    722                                         cache2var
     715                                        *cache2var
    723716                                );
    724717                                Base* Z_tmp = taylor + user_iy[i] * J;
     
    749742                                arg_tmp,
    750743                                num_var,
    751                                 cache2var
     744                                *cache2var
    752745                        );
    753746                        if( NumRes(op) > 0 ) printOpResult(
  • branches/cache/cppad/local/forward1sweep.hpp

    r3346 r3363  
    281281                text = play->GetTxt(0);
    282282
    283         // data structure for cache information
    284         size_t num_cache = play->num_cache_rec();
    285         CppAD::vector<addr_t> cache2var( num_cache );
    286 
    287         // initialize cache indices with invalid variable value
    288         for(size_t i = 0; i < num_cache; i++)
    289                 cache2var[i] = addr_t(0);
     283        // mapping from cache index to variable index
     284        const CppAD::vector<addr_t>* cache2var = play->cache2var();
    290285        /*
    291286        <!-- end forward0sweep_code_define -->
     
    327322                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    328323                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    329                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
     324                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, *cache2var, i_var);
    330325
    331326                // action depends on the operator
     
    818813                        CPPAD_ASSERT_UNKNOWN(0);
    819814                }
    820                 if( num_cache != 0 )
     815                if( cache2var->size() != 0 )
    821816                {       size_t i_cache = size_t( play->GetVar2Cache(i_var) );
    822817                        CPPAD_ASSERT_UNKNOWN( i_cache >= num_var );
    823818                        for(k = 0; k <= q; k++)
    824819                                taylor[ i_cache * J + k ] = taylor[ i_var * J + k ];
    825                         // use zero orgin cache indiex for cache2var vector
    826                         cache2var[ i_cache - num_var ] = i_var;
    827820                }
    828821# if CPPAD_FORWARD1SWEEP_TRACE
     
    842835                                        CPPAD_NULL,
    843836                                        num_var,
    844                                         cache2var
     837                                        *cache2var
    845838                                );
    846839                                Base* Z_tmp = taylor + user_iy[i] * J;
     
    871864                                arg_tmp,
    872865                                num_var,
    873                                 cache2var
     866                                *cache2var
    874867                        );
    875868                        if( NumRes(op) > 0 ) printOpResult(
  • branches/cache/cppad/local/forward2sweep.hpp

    r3347 r3363  
    234234# endif
    235235
    236         // data structure for cache information
    237         size_t num_cache = play->num_cache_rec();
    238         CppAD::vector<addr_t> cache2var( num_cache );
    239 
    240         // initialize cache indices with invalid variable value
    241         for(i = 0; i < num_cache; i++)
    242                 cache2var[i] = addr_t(0);
     236        // mapping from cache index to variable index
     237        const CppAD::vector<addr_t>* cache2var = play->cache2var();
    243238
    244239        bool more_operators = true;
     
    250245                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    251246                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    252                 CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
     247                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, *cache2var, i_var);
    253248
    254249                // check if we are skipping this operation
     
    663658                        CPPAD_ASSERT_UNKNOWN(0);
    664659                }
    665                 if( num_cache != 0 )
     660                if( cache2var->size() != 0 )
    666661                {       size_t i_cache = size_t( play->GetVar2Cache(i_var) );
    667662                        CPPAD_ASSERT_UNKNOWN( i_cache >= num_var );
     
    675670                                }
    676671                        }
    677                         // use zero orgin cache indiex for cache2var vector
    678                         cache2var[ i_cache - num_var ] = i_var;
    679672                }
    680673# if CPPAD_FORWARD2SWEEP_TRACE
     
    693686                                        CPPAD_NULL,
    694687                                        num_var,
    695                                         cache2var
     688                                        *cache2var
    696689                                );
    697690                                Base* Z_tmp = taylor + user_iy[i]*((J-1) * r + 1);
     
    727720                                arg_tmp,
    728721                                num_var,
    729                                 cache2var
     722                                *cache2var
    730723                        );
    731724                        Base* Z_tmp = CPPAD_NULL;
  • branches/cache/cppad/local/player.hpp

    r3355 r3363  
    311311public:
    312312        /*!
     313        Get mapping from zero origin cache index to variable index
     314        */
     315        const CppAD::vector<addr_t>* cache2var(void) const
     316        {       return cache_rec_.cache2var(); }
     317
     318        /*!
    313319        Start a play back of the recording during a forward sweep.
    314320
     
    343349                CPPAD_ASSERT_UNKNOWN( op_  == BeginOp );
    344350                CPPAD_ASSERT_NARG_NRES(op_, 1, 1);
     351
     352                cache_rec_.forward_start();
    345353
    346354                return;
     
    404412                // index for last result for next operator
    405413                var_index   = var_index_ += NumRes(op);
    406                
     414
     415                // inform cache
     416                cache_rec_.forward_next(var_index);
    407417
    408418                CPPAD_ASSERT_UNKNOWN( op_arg_rec_.data() <= op_arg_ );
Note: See TracChangeset for help on using the changeset viewer.