Changeset 2967


Ignore:
Timestamp:
Oct 18, 2013 1:03:40 PM (6 years ago)
Author:
bradbell
Message:

Delay setting CSkip arguments so can map old variable address to new addresses.

Location:
branches/opt_cond_exp/cppad/local
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • branches/opt_cond_exp/cppad/local/forward0sweep.hpp

    r2910 r2967  
    255255                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    256256                        forward_atan_op_0(i_var, arg[0], J, Taylor);
     257                        break;
     258                        // -------------------------------------------------
     259
     260                        case CSkipOp:
     261                        // CSumOp has a variable number of arguments and
     262                        // next_forward thinks it one has one argument.
     263                        // we must inform next_forward of this special case.
     264                        Rec->forward_cskip(op, arg, i_op, i_var);
     265                        // forward_cskip_op_0(
     266                        //      0, 0, i_var, arg, num_par, parameter, J, Taylor
     267                        // );
    257268                        break;
    258269                        // -------------------------------------------------
     
    626637
    627638                        default:
    628                         CPPAD_ASSERT_UNKNOWN(0);
     639                        CPPAD_ASSERT_UNKNOWN(false);
    629640                }
    630641# if CPPAD_FORWARD0SWEEP_TRACE
  • branches/opt_cond_exp/cppad/local/op_code.hpp

    r2964 r2967  
    507507                printOpField(os, "", CompareOpName[ ind[0] ], 3);
    508508        }
     509        else if( op == CSkipOp )
     510        {       printOpField(os, "op=", OpName[op], 5);
     511                printOpField(os, "", CompareOpName[ ind[0] ], 3);
     512        }
    509513        else if( op == ComOp )
    510514        {       printOpField(os, "op=", OpName[op], 3);
  • branches/opt_cond_exp/cppad/local/optimize.hpp

    r2966 r2967  
    251251        /// set of operations to skip on false
    252252        CppAD::vector<size_t> skip_on_false;
     253        /// pointer to space reserved for the arguments
     254        addr_t* arg;
    253255};
    254256
     
    18091811                        skip &= cskip_info[j].skip_on_true.size() > 0 ||
    18101812                                        cskip_info[j].skip_on_false.size() > 0;
    1811                 }
    1812                 if( skip )
    1813                 {       optimize_cskip_info info = cskip_info[j];
    1814                         CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
    1815                         CPPAD_ASSERT_UNKNOWN( info.left < i_var );
    1816                         CPPAD_ASSERT_UNKNOWN( info.right < i_var );
    1817                         rec->PutArg(
    1818                                 info.cop                  , // arg[0]
    1819                                 info.flag                 , // arg[1]
    1820                                 info.left                 , // arg[2]
    1821                                 info.right                , // arg[3]
    1822                                 info.skip_on_true.size()  , // arg[4]
    1823                                 info.skip_on_false.size()   // arg[5]
    1824                         );
    1825                         // These are old variable indices and need to be mapped
    1826                         // to new variable indices after forward pass is completed.
    1827                         for(i = 0; i < info.skip_on_true.size(); i++)
    1828                                 rec->PutArg( info.skip_on_true[i] );
    1829                         for(i = 0; i < info.skip_on_false.size(); i++)
    1830                                 rec->PutArg( info.skip_on_false[i] );
    1831                         //
    1832                         rec->PutOp(CSkipOp);
     1813                        if( skip )
     1814                        {       optimize_cskip_info info = cskip_info[j];
     1815                                CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
     1816                                CPPAD_ASSERT_UNKNOWN( info.left < i_var );
     1817                                CPPAD_ASSERT_UNKNOWN( info.right < i_var );
     1818                                size_t n_true  = info.skip_on_true.size();
     1819                                size_t n_false = info.skip_on_false.size();
     1820                                // reserve space for the arguments to this operator but
     1821                                // delay setting them until we have all the new addresses
     1822                                cskip_info[j].arg = rec->ReserveArg(7 + n_true + n_false);
     1823                                rec->PutOp(CSkipOp);
     1824                        }
     1825                        else    cskip_info[j].arg = CPPAD_NULL;
    18331826                }
    18341827
     
    22632256        // modify the dependent variable vector to new indices
    22642257        for(i = 0; i < dep_taddr.size(); i++ )
    2265         {       CPPAD_ASSERT_UNKNOWN( size_t(tape[ dep_taddr[i] ].new_var) < num_var );
     2258        {       CPPAD_ASSERT_UNKNOWN( size_t(tape[dep_taddr[i]].new_var) < num_var );
    22662259                dep_taddr[i] = tape[ dep_taddr[i] ].new_var;
     2260        }
     2261
     2262        // fill in the arguments for the CSkip operations
     2263        CPPAD_ASSERT_UNKNOWN( cskip_info_next == cskip_info.size() );
     2264        for(i = 0; i < cskip_info.size(); i++)
     2265        {       optimize_cskip_info info = cskip_info[i];
     2266                if( info.arg != CPPAD_NULL )
     2267                {       size_t n_true  = info.skip_on_true.size();
     2268                        size_t n_false = info.skip_on_false.size();
     2269                        info.arg[0] = static_cast<addr_t>( info.cop );
     2270                        info.arg[1] = static_cast<addr_t>( info.flag );
     2271                        info.arg[2] = static_cast<addr_t>( info.left );
     2272                        info.arg[3] = static_cast<addr_t>( info.right );
     2273                        info.arg[4] = static_cast<addr_t>( n_true );
     2274                        info.arg[5] = static_cast<addr_t>( n_false );
     2275                        for(j = 0; j < n_true; j++)
     2276                        {       i_var = info.skip_on_true[j];
     2277                                info.arg[6 + j] = tape[i_var].new_var;
     2278                        }
     2279                        for(j = 0; j < n_false; j++)
     2280                        {       i_var = info.skip_on_false[j];
     2281                                info.arg[6 + n_true + j] = tape[i_var].new_var;
     2282                        }
     2283                        info.arg[6 + n_true + n_false] =
     2284                                static_cast<addr_t>(n_true + n_false);
     2285                }
    22672286        }
    22682287}
  • branches/opt_cond_exp/cppad/local/player.hpp

    r2963 r2967  
    453453                CPPAD_ASSERT_UNKNOWN( NumArg(CSkipOp) == 0 );
    454454                CPPAD_ASSERT_UNKNOWN(
    455                 op_arg[1] + op_arg[2] == op_arg[ 3 + op_arg[1] + op_arg[2] ]
     455                op_arg[4] + op_arg[5] == op_arg[ 6 + op_arg[4] + op_arg[5] ]
    456456                );
    457457                /*
    458458                The only thing that really needs fixing is op_arg_.
    459459                Actual number of arugments for this operator is
    460                         op_arg[1] + op_arg[2] + 4.
     460                        7 + op_arg[4] + op_arg[5]
    461461                We must change op_arg_ so that when you add NumArg(CSkipOp)
    462462                you get first argument for next operator in sequence.
    463463                */
    464                 op_arg_    += op_arg[1] + op_arg[2] + 4;
     464                op_arg_    += 7 + op_arg[4] + op_arg[5];
    465465
    466466                CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
  • branches/opt_cond_exp/cppad/local/recorder.hpp

    r2910 r2967  
    33# define CPPAD_RECORDER_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    110110        inline void PutArg(addr_t arg0, addr_t arg1, addr_t arg2, addr_t arg3,
    111111                addr_t arg4, addr_t arg5);
     112        /// Reserve spacke for a specified number or arguments
     113        inline addr_t* ReserveArg(size_t n_arg);
    112114
    113115        /// Put a character string in the text for this recording.
     
    424426// --------------------------------------------------------------------------
    425427/*!
     428Reserve space for arguments, but delay placing values there.
     429
     430\param n_arg
     431number of arguements to reserve space for
     432
     433\return
     434point to the first argument; i.e., if arg is the return value,
     435arg[0] throught arg[n_arg-1] are the arguments.
     436*/
     437template <class Base>
     438inline addr_t* recorder<Base>::ReserveArg(size_t n_arg)
     439{
     440        size_t i = rec_op_arg_.extend(n_arg);
     441        CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + n_arg );
     442        return rec_op_arg_.data() + i;
     443}
     444// --------------------------------------------------------------------------
     445/*!
    426446Put a character string in the text for this recording.
    427447
Note: See TracChangeset for help on using the changeset viewer.