Changeset 3331


Ignore:
Timestamp:
Sep 15, 2014 6:29:25 AM (6 years ago)
Author:
bradbell
Message:
  1. Change type of cache to addr_t.
  2. Complete new recording with variable addresses replaced by cache values.
File:
1 edited

Legend:

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

    r3330 r3331  
    1212template <class Base>
    1313void create_cache(
    14         player<Base>&       play
    15 )
    16 {       size_t i;
     14        player<Base>&       play )
     15{       size_t i, j, k;
    1716
    1817        // number of variables in operation sequence
     
    189188
    190189        // initialize the cache vector and available flags as empty
    191         CppAD::vector<size_t> cache(num_var);
    192         std::list<size_t> available;
    193         std::list<size_t>::iterator itr;
     190        CppAD::vector<addr_t> cache(num_var);
     191        std::list<addr_t> available;
     192        std::list<addr_t>::iterator itr;
    194193
    195194        // compute the cache index corresponding to each variable index
     
    215214        }
    216215        std::cout << "num_cache = " << i_cache - num_var << std::endl;
     216
     217
     218        // 2DO: make rec an argument
     219        recorder<Base> rec;
     220        rec.free();
     221
     222        // Copy parameters to new recording
     223        size_t num_par = play.num_par_rec();
     224        for(i = 0; i < num_par; i++)
     225                rec.PutPar( play.GetPar(i) );
     226
     227        // Copy VecAD indices in to new recording
     228        size_t num_vecad_vec = play.num_vecad_vec_rec();
     229        j                    = 0;
     230        for(i = 0; i < num_vecad_vec; i++)
     231        {       // lenght of the VecAD object
     232                size_t length = play.GetVecInd(j);
     233                for(k = 1; k <= length; k++)
     234                        rec.PutVecInd( play.GetVecInd(j+k)  );
     235                // start of the next VecAD entry
     236                j += length + 1;
     237        }
     238        CPPAD_ASSERT_UNKNOWN( j == play.num_vec_ind_rec() );
     239
     240        // Initilalize forward sweep through the operation sequence
     241        play.forward_start(op, arg, i_op, i_var);
     242        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
     243
     244        // playing forward skips BeginOp at the beginning, but not EndOp at
     245        // the end.  Put BeginOp at beginning of recording
     246        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
     247        CPPAD_ASSERT_NARG_NRES(BeginOp, 1, 1);
     248        rec.PutOp(BeginOp);
     249        rec.PutArg(0);
     250
     251        while( op != EndOp )
     252        {       // next op
     253                play.forward_next(op, arg, i_op, i_var);
     254                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
     255
     256                rec.PutOp(op);
     257                size_t n_arg = NumArg(op);
     258                switch(op)
     259                {
     260                        // --------------------------------------------------------------
     261                        // no argument variables for this operation
     262                        case CSkipOp:
     263                        case CSumOp:
     264                        case EndOp:
     265                        case InvOp:
     266                        case LdpOp:
     267                        case StppOp:
     268                        for(i = 0; i < n_arg; i++)
     269                                rec.PutArg( arg[i] );
     270                        break;
     271       
     272                        // --------------------------------------------------------------
     273                        // first argument is only variable for this operation
     274                        case AbsOp:
     275                        case AcosOp:
     276                        case AsinOp:
     277                        case AtanOp:
     278                        case CosOp:
     279                        case CoshOp:
     280                        case DivvpOp:
     281                        case ExpOp:
     282                        case LogOp:
     283                        case ParOp:
     284                        case PowvpOp:
     285                        case SignOp:
     286                        case SinOp:
     287                        case SinhOp:
     288                        case SqrtOp:
     289                        case SubvpOp:
     290                        case TanOp:
     291                        case TanhOp:
     292                        for(i = 0; i < n_arg; i++)
     293                        {       if( i = 0 )
     294                                        rec.PutArg( cache[ arg[i] ] );
     295                                else
     296                                        rec.PutArg( arg[i] );
     297                        }
     298                        break;
     299       
     300                        // --------------------------------------------------------------
     301                        // second argument is only variable for this operation
     302                        case AddpvOp:
     303                        case DisOp:
     304                        case DivpvOp:
     305                        case LdvOp:
     306                        case MulpvOp:
     307                        case PowpvOp:
     308                        case StvpOp:
     309                        case SubpvOp:
     310                        for(i = 0; i < n_arg; i++)
     311                        {       if( i = 1 )
     312                                        rec.PutArg( cache[ arg[i] ] );
     313                                else
     314                                        rec.PutArg( arg[i] );
     315                        }
     316                        break;
     317       
     318                        // --------------------------------------------------------------
     319                        // first and second arguments are only variables for this operation
     320                        case AddvvOp:
     321                        case DivvvOp:
     322                        case MulvvOp:
     323                        case PowvvOp:
     324                        case SubvvOp:
     325                        for(i = 0; i < n_arg; i++)
     326                        {       if( i == 0 || i == 1 )
     327                                        rec.PutArg( cache[ arg[i] ] );
     328                                else
     329                                        rec.PutArg( arg[i] );
     330                        }
     331                        break;
     332       
     333                        // --------------------------------------------------------------
     334                        // third argument is only variables for this operation
     335                        case StpvOp:
     336                        for(i = 0; i < n_arg; i++)
     337                        {       if( i == 3 )
     338                                        rec.PutArg( cache[ arg[i] ] );
     339                                else
     340                                        rec.PutArg( arg[i] );
     341                        }
     342                        break;
     343       
     344                        // --------------------------------------------------------------
     345                        // second and third arguments are only variables for this operation
     346                        case StvvOp:
     347                        for(i = 0; i < n_arg; i++)
     348                        {       if( i == 1 || i == 2 )
     349                                        rec.PutArg( cache[ arg[i] ] );
     350                                else
     351                                        rec.PutArg( arg[i] );
     352                        }
     353                        break;
     354       
     355                        // --------------------------------------------------------------
     356                        // Comparison operator
     357                        case ComOp:
     358                        rec.PutArg( arg[0] );
     359                        rec.PutArg( arg[1] );
     360                        //
     361                        if( arg[1] & 2 )
     362                                rec.PutArg( cache[ arg[2] ] );
     363                        else
     364                                rec.PutArg( arg[2] );
     365                        //
     366                        if( arg[1] & 4 )
     367                                rec.PutArg( cache[ arg[3] ] );
     368                        else
     369                                rec.PutArg( arg[3] );
     370                        break;
     371       
     372                        // --------------------------------------------------------------
     373                        // Print operator
     374                        case PriOp:
     375                        rec.PutArg( arg[0] );
     376                        //
     377                        if( arg[0] & 1 )
     378                                rec.PutArg( cache[ arg[1] ]  );
     379                        else
     380                                rec.PutArg( arg[1] );
     381                        //
     382                        rec.PutArg( arg[2] );
     383                        //
     384                        if( arg[0] & 2 )
     385                                rec.PutArg( cache[ arg[3] ] );
     386                        else
     387                                rec.PutArg( arg[3] );
     388                        //
     389                        rec.PutArg( arg[4] );
     390                        break;
     391       
     392                        // --------------------------------------------------------------
     393                        // Conditional expression
     394                        case CExpOp:
     395                        rec.PutArg( arg[0] );
     396                        rec.PutArg( arg[1] );
     397                        //
     398                        if( arg[1] & 1 )
     399                                rec.PutArg( cache[ arg[2] ] );
     400                        else
     401                                rec.PutArg( arg[2] );
     402                        //
     403                        if( arg[1] & 2 )
     404                                rec.PutArg( cache[ arg[3] ] );
     405                        else
     406                                rec.PutArg( arg[3] );
     407                        //
     408                        if( arg[1] & 4 )
     409                                rec.PutArg( cache[ arg[4] ] );
     410                        else
     411                                rec.PutArg( arg[4] );
     412                        //
     413                        if( arg[1] & 8 )
     414                                rec.PutArg( cache[ arg[5] ] );
     415                        else
     416                                rec.PutArg( arg[5] );
     417                        //
     418                        break;
     419       
     420                        // --------------------------------------------------------------
     421                        // user atomic operations
     422                        case UserOp:
     423                        case UsrapOp:
     424                        case UsrrpOp:
     425                        case UsrrvOp:
     426                        for(i = 0; i < n_arg; i++)
     427                                rec.PutArg( arg[i] );
     428                        break;
     429       
     430                        case UsravOp:
     431                        rec.PutArg( cache[ arg[0] ] );
     432                        break;
     433       
     434                        default:
     435                        CPPAD_ASSERT_UNKNOWN(false);
     436                        break;
     437                }
     438        }
     439
     440
    217441        return;
    218442}
Note: See TracChangeset for help on using the changeset viewer.