Changeset 2979


Ignore:
Timestamp:
Oct 20, 2013 2:00:28 PM (6 years ago)
Author:
bradbell
Message:
  1. Add operator index to trace output.
  2. Check that new operator values have been set and are valid.
  3. Reinitialize cskip_op_ after optimization.

optimize.hpp: Add test of entirely removing an atomic call.

Location:
branches/opt_cond_exp
Files:
10 edited

Legend:

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

    r2978 r2979  
    273273        cskip_op_.clear();
    274274        cskip_op_.resize( tape->Rec_.num_rec_op() );
    275         for(i = 0; i < tape->Rec_.num_rec_op(); i++)
     275        for(i = 0; i < cskip_op_.size(); i++)
    276276                cskip_op_[i] = false;
    277277
  • branches/opt_cond_exp/cppad/local/for_jac_sweep.hpp

    r2910 r2979  
    698698                        std::cout,
    699699                        play,
     700                        i_op,
    700701                        i_var,
    701702                        op,
  • branches/opt_cond_exp/cppad/local/forward0sweep.hpp

    r2978 r2979  
    7575
    7676\param Rec
     772DO: change this name from Rec to play (becuase it is a player
     78and not a recorder).
    7779The information stored in \a Rec
    7880is a recording of the operations corresponding to the function
     
    664666                        std::cout,
    665667                        Rec,
     668                        i_op,
    666669                        i_tmp,
    667670                        op,
  • branches/opt_cond_exp/cppad/local/forward_sweep.hpp

    r2978 r2979  
    8383
    8484\param Rec
     852DO: change this name from Rec to play (becuase it is a player
     86and not a recorder).
    8587The information stored in \a Rec
    8688is a recording of the operations corresponding to the function
     
    744746                        std::cout,
    745747                        Rec,
     748                        i_op,
    746749                        i_tmp,
    747750                        op,
  • branches/opt_cond_exp/cppad/local/op_code.hpp

    r2978 r2979  
    395395
    396396\param Rec
     3972DO: change this name from Rec to play (becuase it is a player
     398and not a recorder).
    397399Is the entire recording for the tape that this operator is in.
     400
     401\param i_op
     402is the index for the operator corresponding to this operation.
    398403
    399404\param i_var
     
    435440        std::ostream          &os     ,
    436441        const player<Base>   *Rec     ,
     442        size_t                 i_op   ,
    437443        size_t                 i_var  ,
    438444        OpCode                 op     ,
     
    505511
    506512        // print operator
    507         printOpField(os,  "i=",      i_var, 5);
    508         if( op == CExpOp )
    509         {       printOpField(os, "op=", OpName[op], 4);
     513        printOpField(os,  "o=",      i_op,  5);
     514        printOpField(os,  "v=",      i_var, 5);
     515        if( op == CExpOp || op == CSkipOp || op == ComOp )
     516        {       printOpField(os, "", OpName[op], 5);
    510517                printOpField(os, "", CompareOpName[ ind[0] ], 3);
    511518        }
    512         else if( op == CSkipOp )
    513         {       printOpField(os, "op=", OpName[op], 5);
    514                 printOpField(os, "", CompareOpName[ ind[0] ], 3);
    515         }
    516         else if( op == ComOp )
    517         {       printOpField(os, "op=", OpName[op], 3);
    518                 printOpField(os, "", CompareOpName[ ind[0] ], 4);
    519         }
    520         else    printOpField(os, "op=", OpName[op], 7);
     519        else    printOpField(os, "", OpName[op], 8);
    521520
    522521        // print other fields
     
    546545                else    printOpField(os, " pr=", Rec->GetPar(ind[3]), ncol);
    547546                for(i = 0; i < size_t(ind[4]); i++)
    548                          printOpField(os, " st=", ind[6+i], ncol);
     547                         printOpField(os, " ot=", ind[6+i], ncol);
    549548                for(i = 0; i < size_t(ind[5]); i++)
    550                          printOpField(os, " sf=", ind[6+ind[4]+i], ncol);
     549                         printOpField(os, " of=", ind[6+ind[4]+i], ncol);
    551550                break;
    552551
  • branches/opt_cond_exp/cppad/local/optimize.hpp

    r2978 r2979  
    17691769        // operator and variable index
    17701770        for(i = 0; i < num_var; i++)
    1771         {       tape[i].new_op  = rec->num_rec_op(); // invalid index
    1772                 tape[i].new_var = num_var;           // invalid index
     1771        {       tape[i].new_op  = 0;       // invalid index (except for BeginOp)
     1772                tape[i].new_var = num_var; // invalid index
    17731773        }
    17741774
     
    23062306        }
    23072307
     2308# ifndef NDEBUG
     2309        size_t num_new_op = rec->num_rec_op();
     2310        for(i_var = 0; i_var < tape.size(); i_var++)
     2311                CPPAD_ASSERT_UNKNOWN( tape[i_var].new_op < num_new_op );
     2312# endif
     2313
    23082314        // fill in the arguments for the CSkip operations
    23092315        CPPAD_ASSERT_UNKNOWN( cskip_info_next == cskip_info.size() );
     
    23212327                        for(j = 0; j < n_true; j++)
    23222328                        {       i_var = info.skip_on_true[j];
     2329                                CPPAD_ASSERT_UNKNOWN( tape[i_var].new_op > 0 );
    23232330                                info.arg[6 + j] = tape[i_var].new_op;
    23242331                        }
    23252332                        for(j = 0; j < n_false; j++)
    23262333                        {       i_var = info.skip_on_false[j];
     2334                                CPPAD_ASSERT_UNKNOWN( tape[i_var].new_op > 0 );
    23272335                                info.arg[6 + n_true + j] = tape[i_var].new_op;
    23282336                        }
     
    23532361        size_t n = ind_taddr_.size();
    23542362
     2363        size_t i;
    23552364# ifndef NDEBUG
    2356         size_t i, j, m = dep_taddr_.size();
     2365        size_t j, m = dep_taddr_.size();
    23572366        CppAD::vector<Base> x(n), y(m), check(m);
    23582367        bool check_zero_order = taylor_per_var_ > 0;
     
    23982407        taylor_col_dim_ = 0;
    23992408
     2409        // resize and initilaize conditional skip vector
     2410        // (must use player size because it now has the recoreder information)
     2411        cskip_op_.resize( play_.num_rec_op() );
     2412        for(i = 0; i < cskip_op_.size(); i++)
     2413                cskip_op_[i] = false;
     2414
    24002415# ifndef NDEBUG
    24012416        if( check_zero_order )
  • branches/opt_cond_exp/cppad/local/rev_hes_sweep.hpp

    r2910 r2979  
    783783                        std::cout,
    784784                        play,
     785                        i_op,
    785786                        i_var,
    786787                        op,
  • branches/opt_cond_exp/cppad/local/rev_jac_sweep.hpp

    r2910 r2979  
    698698                        std::cout,
    699699                        play,
     700                        i_op,
    700701                        i_var,
    701702                        op,
  • branches/opt_cond_exp/cppad/local/reverse_sweep.hpp

    r2910 r2979  
    231231                        std::cout,
    232232                        Rec,
     233                        i_op,
    233234                        i_tmp,
    234235                        op,
  • branches/opt_cond_exp/test_more/optimize.cpp

    r2977 r2979  
    1919        // -------------------------------------------------------------------
    2020        // Test of optimizing out arguments to an atomic function
    21         void algo(
     21        void g_algo(
    2222                const CppAD::vector< CppAD::AD<double> >& ax ,
    2323                      CppAD::vector< CppAD::AD<double> >& ay )
    2424        {       ay = ax; }
    2525
     26        bool atomic_no_used(void)
     27        {       bool ok = true;
     28                using CppAD::AD;
     29                using CppAD::vector;
     30       
     31                // Create a checkpoint version of the function g
     32                vector< AD<double> > ax(2), ay(1), az(1);
     33                ax[0] = 0.;
     34                ax[1] = 1.;
     35                CppAD::checkpoint<double> g_check("g_check", g_algo, ax, ay);
     36       
     37                // independent variable vector
     38                Independent(ax);
     39       
     40                // call atomic function that does not get used
     41                g_check(ax, ay);
     42       
     43                // conditional expression
     44                az[0] = CondExpLt(ax[0], ax[1], ax[0] + ax[1], ax[0] - ax[1]);
     45               
     46                // create function object f : ax -> az
     47                CppAD::ADFun<double> f;
     48                f.Dependent(ax, az);
     49
     50                // number of variables before optimization
     51                size_t n_before = f.size_var();
     52               
     53                // now optimize the operation sequence
     54                f.optimize();
     55
     56                // number of variables before optimization
     57                size_t n_after = f.size_var();
     58                ok            &= n_after + 1 == n_before;
     59       
     60                // check optimization works ok
     61                vector<double> x(2), z(1);
     62                x[0] = 4.;
     63                x[1] = 3.;
     64                z    = f.Forward(0, x);
     65                ok   = z[0] == x[0] - x[1];
     66               
     67                return ok;
     68        }
     69
    2670        bool atomic_arguments(void)
    2771        {       bool ok = true;
     
    3074                vector< AD<double> > au(2), aw(2), ax(2), ay(1);
    3175
    32                 // create atomic function corresponding to algo
     76                // create atomic function corresponding to g_algo
    3377                au[0] = 1.0;
    3478                au[1] = 2.0;
    35                 CppAD::checkpoint<double> algo_check("algo", algo, au, ax);
     79                CppAD::checkpoint<double> g_check("g_algo", g_algo, au, ax);
    3680
    3781                // start recording a new function
    3882                CppAD::Independent(ax);
    3983
    40                 // now use algo_check during the recording
     84                // now use g_check during the recording
    4185                au[0] = ax[0] + ax[1]; // this argument requires a new variable
    4286                au[1] = ax[0] - ax[1]; // this argument also requires a new variable
    43                 algo_check(au, aw);
     87                g_check(au, aw);
    4488
    4589                // now create f(x) = x_0 - x_1
Note: See TracChangeset for help on using the changeset viewer.