Changeset 3332


Ignore:
Timestamp:
Sep 15, 2014 7:49:49 AM (6 years ago)
Author:
bradbell
Message:

Simplify using detection of which arguments are varialbes as a function.

File:
1 edited

Legend:

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

    r3331 r3332  
    99
    1010namespace CppAD { // BEGIN_CPPAD_NAMESPACE
     11
     12inline bool arg_is_variable(OpCode op, const addr_t* arg, size_t i_arg)
     13{       bool ret = false;
     14        switch(op)
     15        {
     16                // --------------------------------------------------------------
     17                // no argument variables for this operation
     18                case BeginOp:
     19                case CSkipOp:
     20                case CSumOp:
     21                case EndOp:
     22                case InvOp:
     23                case LdpOp:
     24                case StppOp:
     25                break;
     26
     27                // --------------------------------------------------------------
     28                // first argument is only variable for this operation
     29                case AbsOp:
     30                case AcosOp:
     31                case AsinOp:
     32                case AtanOp:
     33                case CosOp:
     34                case CoshOp:
     35                case DivvpOp:
     36                case ExpOp:
     37                case LogOp:
     38                case ParOp:
     39                case PowvpOp:
     40                case SignOp:
     41                case SinOp:
     42                case SinhOp:
     43                case SqrtOp:
     44                case SubvpOp:
     45                case TanOp:
     46                case TanhOp:
     47                ret |= i_arg == 0;
     48                break;
     49
     50                // --------------------------------------------------------------
     51                // second argument is only variable for this operation
     52                case AddpvOp:
     53                case DisOp:
     54                case DivpvOp:
     55                case LdvOp:
     56                case MulpvOp:
     57                case PowpvOp:
     58                case StvpOp:
     59                case SubpvOp:
     60                ret |= i_arg == 1;
     61                break;
     62
     63                // --------------------------------------------------------------
     64                // first and second arguments are only variables for this operation
     65                case AddvvOp:
     66                case DivvvOp:
     67                case MulvvOp:
     68                case PowvvOp:
     69                case SubvvOp:
     70                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
     71                ret |= true;
     72                break;
     73
     74                // --------------------------------------------------------------
     75                // third argument is only variables for this operation
     76                case StpvOp:
     77                ret |= i_arg == 2;
     78                break;
     79
     80                // --------------------------------------------------------------
     81                // second and third arguments are only variables for this operation
     82                case StvvOp:
     83                ret |= (i_arg == 1) | (i_arg == 2);
     84                break;
     85
     86                // --------------------------------------------------------------
     87                // Comparison operator
     88                case ComOp:
     89                ret = false;
     90                ret |= (i_arg == 2) & (arg[1] & 2);
     91                ret |= (i_arg == 3) & (arg[1] & 4);
     92                break;
     93
     94                // --------------------------------------------------------------
     95                // Print operator
     96                case PriOp:
     97                ret |= (i_arg == 1) & (arg[0] & 1);
     98                ret |= (i_arg == 3) & (arg[0] & 2);
     99                break;
     100
     101                // --------------------------------------------------------------
     102                // Conditional expression
     103                case CExpOp:
     104                ret |= (i_arg == 2) & (arg[1] & 1);
     105                ret |= (i_arg == 3) & (arg[1] & 2);
     106                ret |= (i_arg == 4) & (arg[1] & 4);
     107                ret |= (i_arg == 5) & (arg[1] & 8);
     108                break;
     109
     110                // --------------------------------------------------------------
     111                // user atomic operations
     112                case UserOp:
     113                case UsrapOp:
     114                case UsrrpOp:
     115                case UsrrvOp:
     116                break;
     117
     118                case UsravOp:
     119                ret |= true;
     120                break;
     121
     122                default:
     123                CPPAD_ASSERT_UNKNOWN(false);
     124                break;
     125        }
     126        return ret;
     127}
     128
    11129
    12130template <class Base>
     
    42160                play.forward_next(op, arg, i_op, i_var);
    43161                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
    44                 switch(op)
    45                 {
    46                         // --------------------------------------------------------------
    47                         // no argument variables for this operation
    48                         case BeginOp:
    49                         case CSkipOp:
    50                         case CSumOp:
    51                         case EndOp:
    52                         case InvOp:
    53                         case LdpOp:
    54                         case StppOp:
    55                         break;
    56        
    57                         // --------------------------------------------------------------
    58                         // first argument is only variable for this operation
    59                         case AbsOp:
    60                         case AcosOp:
    61                         case AsinOp:
    62                         case AtanOp:
    63                         case CosOp:
    64                         case CoshOp:
    65                         case DivvpOp:
    66                         case ExpOp:
    67                         case LogOp:
    68                         case ParOp:
    69                         case PowvpOp:
    70                         case SignOp:
    71                         case SinOp:
    72                         case SinhOp:
    73                         case SqrtOp:
    74                         case SubvpOp:
    75                         case TanOp:
    76                         case TanhOp:
    77                         last_use[ arg[0] ] = i_var;
    78                         break;
    79        
    80                         // --------------------------------------------------------------
    81                         // second argument is only variable for this operation
    82                         case AddpvOp:
    83                         case DisOp:
    84                         case DivpvOp:
    85                         case LdvOp:
    86                         case MulpvOp:
    87                         case PowpvOp:
    88                         case StvpOp:
    89                         case SubpvOp:
    90                         last_use[ arg[1] ] = i_var;
    91                         break;
    92        
    93                         // --------------------------------------------------------------
    94                         // first and second arguments are only variables for this operation
    95                         case AddvvOp:
    96                         case DivvvOp:
    97                         case MulvvOp:
    98                         case PowvvOp:
    99                         case SubvvOp:
    100                         last_use[ arg[0] ] = i_var;
    101                         last_use[ arg[1] ] = i_var;
    102                         break;
    103        
    104                         // --------------------------------------------------------------
    105                         // third argument is only variables for this operation
    106                         case StpvOp:
    107                         last_use[ arg[2] ] = i_var;
    108                         break;
    109        
    110                         // --------------------------------------------------------------
    111                         // second and third arguments are only variables for this operation
    112                         case StvvOp:
    113                         last_use[ arg[1] ] = i_var;
    114                         last_use[ arg[2] ] = i_var;
    115                         break;
    116        
    117                         // --------------------------------------------------------------
    118                         // Comparison operator
    119                         case ComOp:
    120                         if( arg[1] & 2 )
    121                         {       last_use[ arg[2] ] = i_var;
    122                         }
    123                         if( arg[1] & 4 )
    124                         {       last_use[ arg[3] ] = i_var;
    125                         }
    126                         break;
    127        
    128                         // --------------------------------------------------------------
    129                         // Print operator
    130                         case PriOp:
    131                         if( arg[0] & 1 )
    132                         {       last_use[ arg[1] ] = i_var;
    133                         }
    134                         if( arg[0] & 2 )
    135                         {       last_use[ arg[3] ] = i_var;
    136                         }
    137                         break;
    138        
    139                         // --------------------------------------------------------------
    140                         // Conditional expression
    141                         case CExpOp:
    142                         if( arg[1] & 1 )
    143                         {       last_use[ arg[2] ] = i_var;
    144                         }
    145                         if( arg[1] & 2 )
    146                         {       last_use[ arg[3] ] = i_var;
    147                         }
    148                         if( arg[1] & 4 )
    149                         {       last_use[ arg[4] ] = i_var;
    150                         }
    151                         if( arg[1] & 8 )
    152                         {       last_use[ arg[5] ] = i_var;
    153                         }
    154                         break;
    155        
    156                         // --------------------------------------------------------------
    157                         // user atomic operations
    158                         case UserOp:
    159                         in_user_atomic = ! in_user_atomic;
     162
     163                if( op == UserOp )
     164                {       in_user_atomic = ! in_user_atomic;
    160165                        if( in_user_atomic )
    161166                                user_i_var     = i_var + size_t( arg[3] );
    162                         break;
    163        
    164                         case UsrapOp:
    165                         break;
    166        
    167                         case UsravOp:
    168                         // all the results may depend on this argument value
    169                         // (would be slightly better to use sparsity pattern as in optimize)
    170                         CPPAD_ASSERT_UNKNOWN( in_user_atomic );
    171                         last_use[ arg[0] ] = user_i_var;
    172                         break;
    173        
    174                         case UsrrpOp:
    175                         case UsrrvOp:
    176                         break;
    177        
    178                         default:
    179                         CPPAD_ASSERT_UNKNOWN(false);
    180                         break;
    181                 }
    182 
     167                        else
     168                                user_i_var     = i_var;
     169                }
     170                //
     171                size_t n_arg = NumArg(op);
     172                for(size_t i_arg = 0; i_arg < n_arg; i_arg++)
     173                {       if( arg_is_variable(op, arg, i_arg) )
     174                                last_use[ arg[i_arg] ] = i_var;
     175                }
    183176        }
    184177
     
    255248
    256249                rec.PutOp(op);
     250                //
    257251                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] ] );
     252                for(size_t i_arg = 0; i_arg < n_arg; i_arg++)
     253                {       if( arg_is_variable(op, arg, i_arg) )
     254                                rec.PutArg( cache[ arg[i_arg] ] );
    363255                        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 
     256                                rec.PutArg( arg[i_arg] );
     257                }
     258        }
    441259        return;
    442260}
Note: See TracChangeset for help on using the changeset viewer.