Changeset 1948


Ignore:
Timestamp:
May 23, 2011 11:33:43 PM (9 years ago)
Author:
bradbell
Message:

merge -r1920:1947 branches/omp_alloc into trunk

Location:
trunk
Files:
1 deleted
63 edited
6 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/AUTHORS

    r1916 r1948  
    22             ===========================================
    33
    4 To date, 2011-05-11, Bradley M. Bell is the sole author of CppAD.
     4To date, 2011-05-23, Bradley M. Bell is the sole author of CppAD.
    55While Bradley M. Bell worked for the University of Washington during
    66the development of CppAD, the following are also true:
  • trunk/bin/add_copyright.sh

    r1787 r1948  
    3434        cpp | hpp | omh)
    3535        cat << EOF  > bin/add_copyright.$$
     36/* \$Id:\$ */
    3637/* --------------------------------------------------------------------------
    3738CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
     
    5051        cat << EOF  > bin/add_copyright.$$
    5152#! /bin/bash -e
     53# \$Id:\$
    5254# -----------------------------------------------------------------------------
    5355# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
  • trunk/bin/svn_merge.sh

    r1865 r1948  
    3030#
    3131# Name of the directory where the changes have been committed
    32 from_branch=branches/user_atomic
     32from_branch=branches/omp_alloc
    3333#
    3434# Version of the repository corresponding to from_branch just before changes
    35 Start=1836
     35Start=1920
    3636#
    3737# Version of the repository corresponding to from_branch after the changes
    38 End=1864
     38End=1947
    3939#
    4040# the svn merge command
  • trunk/build.sh

    r1917 r1948  
    346346fi
    347347# -----------------------------------------------------------------------------
    348 # omhelp comes after dist becasue dist only includes one help output
     348# omhelp comes after dist because dist only includes one help output
    349349if [ "$1" = "omhelp" ]
    350350then
  • trunk/configure

    r1916 r1948  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.66 for CppAD 20110511.
     3# Generated by GNU Autoconf 2.66 for CppAD 20110523.
    44#
    55# Report bugs to <cppad@list.coin-or.org>.
     
    552552PACKAGE_NAME='CppAD'
    553553PACKAGE_TARNAME='cppad'
    554 PACKAGE_VERSION='20110511'
    555 PACKAGE_STRING='CppAD 20110511'
     554PACKAGE_VERSION='20110523'
     555PACKAGE_STRING='CppAD 20110523'
    556556PACKAGE_BUGREPORT='cppad@list.coin-or.org'
    557557PACKAGE_URL=''
     
    12691269  # This message is too long to be a string in the A/UX 3.1 sh.
    12701270  cat <<_ACEOF
    1271 \`configure' configures CppAD 20110511 to adapt to many kinds of systems.
     1271\`configure' configures CppAD 20110523 to adapt to many kinds of systems.
    12721272
    12731273Usage: $0 [OPTION]... [VAR=VALUE]...
     
    13351335if test -n "$ac_init_help"; then
    13361336  case $ac_init_help in
    1337      short | recursive ) echo "Configuration of CppAD 20110511:";;
     1337     short | recursive ) echo "Configuration of CppAD 20110523:";;
    13381338   esac
    13391339  cat <<\_ACEOF
     
    14481448if $ac_init_version; then
    14491449  cat <<\_ACEOF
    1450 CppAD configure 20110511
     1450CppAD configure 20110523
    14511451generated by GNU Autoconf 2.66
    14521452
     
    17751775running configure, to aid debugging if configure makes a mistake.
    17761776
    1777 It was created by CppAD $as_me 20110511, which was
     1777It was created by CppAD $as_me 20110523, which was
    17781778generated by GNU Autoconf 2.66.  Invocation command line was
    17791779
     
    39023902# Define the identity of the package.
    39033903 PACKAGE='cppad'
    3904  VERSION='20110511'
     3904 VERSION='20110523'
    39053905
    39063906
     
    60986098# values after options handling.
    60996099ac_log="
    6100 This file was extended by CppAD $as_me 20110511, which was
     6100This file was extended by CppAD $as_me 20110523, which was
    61016101generated by GNU Autoconf 2.66.  Invocation command line was
    61026102
     
    61646164ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
    61656165ac_cs_version="\\
    6166 CppAD config.status 20110511
     6166CppAD config.status 20110523
    61676167configured by $0, generated by GNU Autoconf 2.66,
    61686168  with options \\"\$ac_cs_config\\"
  • trunk/configure.ac

    r1916 r1948  
    1313dnl Process this file with autoconf to produce a configure script.
    1414dnl   package   version              bug-report
    15 AC_INIT(CppAD, 20110511, cppad@list.coin-or.org)
     15AC_INIT(CppAD, 20110523, cppad@list.coin-or.org)
    1616AC_SUBST(PACKAGE_URL, "http://www.coin-or.org/CppAD")
    1717AC_SUBST(PACKAGE_DESCRIPTION, "Differentiation of C++ Algorithms")
  • trunk/cppad/config.h

    r1917 r1948  
    2424
    2525/* Define to the full name and version of this package. */
    26 #define PACKAGE_STRING "CppAD 20110511"
     26#define PACKAGE_STRING "CppAD 20110523"
    2727
    2828/* Define to the one symbol short name of this package. */
     
    3333
    3434/* Define to the version of this package. */
    35 #define PACKAGE_VERSION "20110511"
     35#define PACKAGE_VERSION "20110523"
    3636
    3737/* Version number of package */
    38 #define VERSION "20110511"
     38#define VERSION "20110523"
    3939
    4040/* Define to `__inline__' or `__inline' if that's what the C compiler
  • trunk/cppad/configure.hpp

    r1916 r1948  
    6161cppad-yyyymmdd as a C string where yyyy is year, mm is month, and dd is day.
    6262*/
    63 # define CPPAD_PACKAGE_STRING "CppAD 20110511"
     63# define CPPAD_PACKAGE_STRING "CppAD 20110523"
    6464
    6565/*
  • trunk/cppad/cppad.hpp

    r1643 r1948  
    33# define CPPAD_CPPAD_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    3434# include <cppad/ode_gear.hpp>
    3535# include <cppad/ode_gear_control.hpp>
     36# include <cppad/omp_alloc.hpp>
    3637# include <cppad/poly.hpp>
    3738# include <cppad/pow_int.hpp>
  • trunk/cppad/local/ad_fun.hpp

    r1829 r1948  
    104104
    105105        /// results of the forward mode calculations
    106         Base *taylor_;
     106        pod_vector<Base> taylor_;
    107107
    108108        /// packed results of the forward mode Jacobian sparsity calculations
     
    224224        /// copy constructor
    225225        ADFun(const ADFun& g)
    226         : total_num_var_(0), taylor_(CPPAD_NULL)
     226        : total_num_var_(0)
    227227        {       CppAD::ErrorHandler::Call(
    228228                true,
     
    249249        /// destructor
    250250        ~ADFun(void)
    251         {       if( taylor_ != CPPAD_NULL )
    252                         CPPAD_TRACK_DEL_VEC(taylor_);
    253         }
     251        { }
    254252
    255253        /// deprecated: assign a new operation sequence
  • trunk/cppad/local/ad_tape.hpp

    r1865 r1948  
    125125        // place a VecAD object in the tape
    126126        size_t AddVec(
    127                 size_t        length,
    128                 const Base   *data
     127                size_t                   length,
     128                const pod_vector<Base>&  data
    129129        );
    130130
     
    194194*/
    195195template <class Base>
    196 size_t ADTape<Base>::AddVec(size_t length, const Base *data)
     196size_t ADTape<Base>::AddVec(size_t length, const pod_vector<Base>& data)
    197197{       CPPAD_ASSERT_UNKNOWN( length > 0 );
    198198        size_t i;
  • trunk/cppad/local/cap_taylor.hpp

    r1615 r1948  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    122122        size_t i, j, p;
    123123
    124                 // taylor_per_var_,
    125 
    126124        if( c == taylor_col_dim_ )
    127125                return;
    128126
    129127        if( c == 0 )
    130         {       if( taylor_ != CPPAD_NULL )
    131                         CPPAD_TRACK_DEL_VEC(taylor_);
    132                 taylor_ = CPPAD_NULL;
     128        {       taylor_.erase();
    133129                taylor_per_var_ = 0;
    134130                taylor_col_dim_ = 0;
     
    137133       
    138134        // Allocate new matrix will requested number of columns
    139         size_t newlen   = c * total_num_var_;
    140         Base *newptr    = CPPAD_NULL;
    141         newptr          = CPPAD_TRACK_NEW_VEC(newlen, newptr);
     135        size_t new_len   = c * total_num_var_;
     136        pod_vector<Base> new_taylor;
     137        new_taylor.extend(new_len);
    142138
    143139        // number of columns to copy
     
    145141
    146142        // copy the old data into the new matrix
    147         CPPAD_ASSERT_UNKNOWN( (taylor_per_var_ == 0) | (taylor_ != CPPAD_NULL) );
     143        CPPAD_ASSERT_UNKNOWN( (taylor_per_var_ == 0) | (taylor_.size() != 0) );
    148144        for(i = 0; i < total_num_var_; i++)
    149145        {       for(j = 0; j < p; j++)
    150                 {       newptr[i * c + j]  = taylor_[i * taylor_col_dim_ + j];
     146                {       new_taylor[i * c + j]  = taylor_[i * taylor_col_dim_ + j];
    151147                }
    152148        }
    153         // free the old memory
    154         if( taylor_ != CPPAD_NULL )
    155                 CPPAD_TRACK_DEL_VEC(taylor_);
    156149
    157         // use the new pointer
    158         taylor_         = newptr;
    159         taylor_col_dim_   = c;
     150        // replace taylor_ by new_taylor
     151        taylor_.swap(new_taylor);
     152        taylor_col_dim_ = c;
    160153        taylor_per_var_ = p;
    161154
  • trunk/cppad/local/dependent.hpp

    r1598 r1948  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    236236
    237237        // free old buffers
    238         if( taylor_ != CPPAD_NULL )
    239                 CPPAD_TRACK_DEL_VEC(taylor_);
    240238        for_jac_sparse_pack_.resize(0, 0);
    241239        for_jac_sparse_set_.resize(0,0);
    242240
    243         // initialize buffers
    244         taylor_  = CPPAD_NULL;
    245 
    246241        // initial row and column dimensions
    247         // memoryMax  = 0;
     242        taylor_.erase();
    248243        taylor_per_var_   = 0;
    249244        taylor_col_dim_   = 0;
  • trunk/cppad/local/discrete.hpp

    r1865 r1948  
    201201        Can use CppAD::vector for debugging, but it will appear that
    202202        there is a memory leak because this list is not distroyed before
    203         CPPAD_TRACK_COUNT is called by the test routines.
     203        omp_alloc::free_available(thread) is called by the test routines.
    204204        */
    205205        static std::vector<discrete *>& List(void)
  • trunk/cppad/local/for_jac_sweep.hpp

    r1865 r1948  
    1313-------------------------------------------------------------------------- */
    1414# include <set>
     15# include <cppad/local/pod_vector.hpp>
    1516
    1617CPPAD_BEGIN_NAMESPACE
     
    110111        Vector_set  vecad_sparsity;
    111112        vecad_sparsity.resize(num_vecad_vec, limit);
    112         size_t* vecad_ind      = CPPAD_NULL;
     113        pod_vector<size_t> vecad_ind;
    113114        if( num_vecad_vec > 0 )
    114115        {       size_t length;
    115                 vecad_ind     = CPPAD_TRACK_NEW_VEC(num_vecad_ind, vecad_ind);
     116                vecad_ind.extend(num_vecad_ind);
    116117                j             = 0;
    117118                for(i = 0; i < num_vecad_vec; i++)
     
    316317                                arg,
    317318                                num_vecad_ind,
    318                                 vecad_ind,
     319                                vecad_ind.data(),
    319320                                var_sparsity,
    320321                                vecad_sparsity
     
    329330                                arg,
    330331                                num_vecad_ind,
    331                                 vecad_ind,
     332                                vecad_ind.data(),
    332333                                var_sparsity,
    333334                                vecad_sparsity
     
    440441                                arg,
    441442                                num_vecad_ind,
    442                                 vecad_ind,
     443                                vecad_ind.data(),
    443444                                var_sparsity,
    444445                                vecad_sparsity
     
    458459                                arg,
    459460                                num_vecad_ind,
    460                                 vecad_ind,
     461                                vecad_ind.data(),
    461462                                var_sparsity,
    462463                                vecad_sparsity
     
    612613        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_rec_var() );
    613614
    614         if( vecad_ind != CPPAD_NULL )
    615                 CPPAD_TRACK_DEL_VEC(vecad_ind);
    616 
    617615        return;
    618616}
  • trunk/cppad/local/forward.hpp

    r1912 r1948  
    8282# if CPPAD_USE_FORWARD0SWEEP
    8383                compare_change_ = forward0sweep(
    84                         true, n, total_num_var_, &play_, taylor_col_dim_, taylor_
     84                        true, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
    8585                );
    8686# else
    8787                compare_change_ = forward_sweep(
    88                 true, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_
     88                true, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
    8989                );
    9090# endif
    9191        }
    9292        else forward_sweep(
    93                 true, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_
     93                true, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
    9494        );
    9595
  • trunk/cppad/local/forward0sweep.hpp

    r1865 r1948  
    123123
    124124        // This is an order zero calculation, initialize vector indices
    125         size_t *VectorInd = CPPAD_NULL;  // address for each element
    126         bool   *VectorVar = CPPAD_NULL;  // is element a variable
     125        pod_vector<size_t> VectorInd;  // address for each element
     126        pod_vector<bool>   VectorVar;  // is element a variable
    127127        size_t  i = Rec->num_rec_vecad_ind();
    128128        if( i > 0 )
    129         {       VectorInd = CPPAD_TRACK_NEW_VEC(i, VectorInd);
    130                 VectorVar = CPPAD_TRACK_NEW_VEC(i, VectorVar);
     129        {       VectorInd.extend(i);
     130                VectorVar.extend(i);
    131131                while(i--)
    132132                {       VectorInd[i] = Rec->GetVecInd(i);
     
    301301
    302302                        case LdpOp:
    303                         CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
    304                         CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
     303                        CPPAD_ASSERT_UNKNOWN( VectorInd.size() != 0 );
     304                        CPPAD_ASSERT_UNKNOWN( VectorVar.size() != 0 );
    305305                        non_const_arg = Rec->forward_non_const_arg();
    306306                        forward_load_p_op_0(
     
    312312                                Taylor,
    313313                                Rec->num_rec_vecad_ind(),
    314                                 VectorVar,
    315                                 VectorInd
     314                                VectorVar.data(),
     315                                VectorInd.data()
    316316                        );
    317317                        break;
     
    319319
    320320                        case LdvOp:
    321                         CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
    322                         CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
     321                        CPPAD_ASSERT_UNKNOWN( VectorInd.size() != 0 );
     322                        CPPAD_ASSERT_UNKNOWN( VectorVar.size() != 0 );
    323323                        non_const_arg = Rec->forward_non_const_arg();
    324324                        forward_load_v_op_0(
     
    330330                                Taylor,
    331331                                Rec->num_rec_vecad_ind(),
    332                                 VectorVar,
    333                                 VectorInd
     332                                VectorVar.data(),
     333                                VectorInd.data()
    334334                        );
    335335                        break;
     
    417417                                Taylor,
    418418                                Rec->num_rec_vecad_ind(),
    419                                 VectorVar,
    420                                 VectorInd
     419                                VectorVar.data(),
     420                                VectorInd.data()
    421421                        );
    422422                        break;
     
    431431                                Taylor,
    432432                                Rec->num_rec_vecad_ind(),
    433                                 VectorVar,
    434                                 VectorInd
     433                                VectorVar.data(),
     434                                VectorInd.data()
    435435                        );
    436436                        break;
     
    445445                                Taylor,
    446446                                Rec->num_rec_vecad_ind(),
    447                                 VectorVar,
    448                                 VectorInd
     447                                VectorVar.data(),
     448                                VectorInd.data()
    449449                        );
    450450                        break;
     
    459459                                Taylor,
    460460                                Rec->num_rec_vecad_ind(),
    461                                 VectorVar,
    462                                 VectorInd
     461                                VectorVar.data(),
     462                                VectorInd.data()
    463463                        );
    464464                        break;
     
    585585        CPPAD_ASSERT_UNKNOWN( i_var + 1 == Rec->num_rec_var() );
    586586
    587         if( VectorInd != CPPAD_NULL )
    588                 CPPAD_TRACK_DEL_VEC(VectorInd);
    589         if( VectorVar != CPPAD_NULL )
    590                 CPPAD_TRACK_DEL_VEC(VectorVar);
    591 
    592587        return compareCount;
    593588}
  • trunk/cppad/local/forward_sweep.hpp

    r1865 r1948  
    135135
    136136        // if this is an order zero calculation, initialize vector indices
    137         size_t *VectorInd = CPPAD_NULL;  // address for each element
    138         bool   *VectorVar = CPPAD_NULL;  // is element a variable
     137        pod_vector<size_t> VectorInd;  // address for each element
     138        pod_vector<bool>   VectorVar;  // is element a variable
    139139        i = Rec->num_rec_vecad_ind();
    140140        if( i > 0 )
    141         {       VectorInd = CPPAD_TRACK_NEW_VEC(i, VectorInd);
    142                 VectorVar = CPPAD_TRACK_NEW_VEC(i, VectorVar);
     141        {       VectorInd.extend(i);
     142                VectorVar.extend(i);
    143143                while(i--)
    144144                {       VectorInd[i] = Rec->GetVecInd(i);
     
    330330                                        Taylor,
    331331                                        Rec->num_rec_vecad_ind(),
    332                                         VectorVar,
    333                                         VectorInd
     332                                        VectorVar.data(),
     333                                        VectorInd.data()
    334334                                );
    335335                        }
     
    353353                                        Taylor,
    354354                                        Rec->num_rec_vecad_ind(),
    355                                         VectorVar,
    356                                         VectorInd
     355                                        VectorVar.data(),
     356                                        VectorInd.data()
    357357                                );
    358358                        }
     
    456456                                        Taylor,
    457457                                        Rec->num_rec_vecad_ind(),
    458                                         VectorVar,
    459                                         VectorInd
     458                                        VectorVar.data(),
     459                                        VectorInd.data()
    460460                                );
    461461                        }
     
    474474                                        Taylor,
    475475                                        Rec->num_rec_vecad_ind(),
    476                                         VectorVar,
    477                                         VectorInd
     476                                        VectorVar.data(),
     477                                        VectorInd.data()
    478478                                );
    479479                        }
     
    492492                                        Taylor,
    493493                                        Rec->num_rec_vecad_ind(),
    494                                         VectorVar,
    495                                         VectorInd
     494                                        VectorVar.data(),
     495                                        VectorInd.data()
    496496                                );
    497497                        }
     
    510510                                        Taylor,
    511511                                        Rec->num_rec_vecad_ind(),
    512                                         VectorVar,
    513                                         VectorInd
     512                                        VectorVar.data(),
     513                                        VectorInd.data()
    514514                                );
    515515                        }
     
    642642        CPPAD_ASSERT_UNKNOWN( i_var + 1 == Rec->num_rec_var() );
    643643
    644         if( VectorInd != CPPAD_NULL )
    645                 CPPAD_TRACK_DEL_VEC(VectorInd);
    646         if( VectorVar != CPPAD_NULL )
    647                 CPPAD_TRACK_DEL_VEC(VectorVar);
    648 
    649644        return compareCount;
    650645}
  • trunk/cppad/local/fun_construct.hpp

    r1912 r1948  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    262262template <typename Base>
    263263ADFun<Base>::ADFun(void)
    264 : total_num_var_(0), taylor_(CPPAD_NULL)
     264: total_num_var_(0)
    265265{ }
    266266
     
    292292        // (see ad_fun.hpp for meaning of each variable)
    293293        compare_change_            = 0;
     294
     295        taylor_.erase();
    294296        taylor_per_var_            = 0;
    295297        taylor_col_dim_            = 0;
     298
    296299        total_num_var_             = f.total_num_var_;
    297300        ind_taddr_.resize(n);
     
    302305        dep_parameter_             = f.dep_parameter_;
    303306        play_                      = f.play_;
    304         if( taylor_ != CPPAD_NULL )
    305                 CPPAD_TRACK_DEL_VEC(taylor_);
    306         taylor_                    = CPPAD_NULL;
    307307        for_jac_sparse_pack_.resize(0, 0);
    308308        for_jac_sparse_set_.resize(0, 0);
     
    312312        taylor_col_dim_     = f.taylor_col_dim_;
    313313        size_t length       = total_num_var_ * taylor_col_dim_;
    314         if( length > 0 ) taylor_   = CPPAD_TRACK_NEW_VEC(length, taylor_);
     314        if( length > 0 )
     315                taylor_.extend(length);
    315316        size_t i, j;
    316317        for(i = 0; i < total_num_var_; i++)
     
    390391template <typename VectorAD>
    391392ADFun<Base>::ADFun(const VectorAD &x, const VectorAD &y)
    392 : total_num_var_(0), taylor_(CPPAD_NULL)
     393: total_num_var_(0)
    393394{
    394395        CPPAD_ASSERT_KNOWN(
     
    433434        taylor_per_var_  = 1;
    434435        taylor_col_dim_  = 1;
    435         taylor_          = CPPAD_TRACK_NEW_VEC(total_num_var_, taylor_);
     436        taylor_.extend(total_num_var_);
    436437
    437438        // set zero order coefficients corresponding to indpendent variables
     
    446447# if CPPAD_USE_FORWARD0SWEEP
    447448        compare_change_ = forward0sweep(
    448                 false, n, total_num_var_, &play_, taylor_col_dim_, taylor_
     449                false, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
    449450        );
    450451# else
    451452        size_t p = 0;
    452453        compare_change_ = forward_sweep(
    453                 false, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_
     454                false, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
    454455        );
    455456# endif
  • trunk/cppad/local/optimize.hpp

    r1865 r1948  
    17131713
    17141714        // free old Taylor coefficient memory
    1715         if( taylor_ != CPPAD_NULL )
    1716                 CPPAD_TRACK_DEL_VEC(taylor_);
    1717         taylor_         = CPPAD_NULL;
     1715        taylor_.erase();
    17181716        taylor_per_var_ = 0;
    17191717        taylor_col_dim_ = 0;
  • trunk/cppad/local/player.hpp

    r1641 r1948  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    3636        size_t    num_rec_var_;
    3737
    38         /// Number of operators in the recording.
    39         size_t    num_rec_op_;
    40 
    4138        /// The operators in the recording.
    42         OpCode   *rec_op_;
    43 
    44         /// Number of VecAD indices in the recording.
    45         size_t    num_rec_vecad_ind_;
     39        pod_vector<OpCode> rec_op_;
    4640
    4741        /// Number of VecAD vectors in the recording
     
    4943
    5044        /// The VecAD indices in the recording.
    51         size_t   *rec_vecad_ind_;
    52 
    53         /// Number of operation arguments indices in the recording.
    54         size_t    num_rec_op_arg_;
     45        pod_vector<size_t> rec_vecad_ind_;
    5546
    5647        /// The operation argument indices in the recording
    57         size_t   *rec_op_arg_;
    58 
    59         /// Number of parameters in the recording.
    60         size_t    num_rec_par_;
     48        pod_vector<size_t> rec_op_arg_;
    6149
    6250        /// The parameters in the recording.
    63         Base     *rec_par_;
    64 
    65         /// Number of text characters in the recording.
    66         size_t    num_rec_text_;
     51        /// Note that Base may not be plain old data, so use false in consructor.
     52        pod_vector<Base> rec_par_;
    6753
    6854        /// Character strings ('\\0' terminated) in the recording.
    69         char     *rec_text_;
     55        pod_vector<char> rec_text_;
    7056
    7157
     
    7359public:
    7460        /// Default constructor
    75         player(void)
    76         {       
    77                 num_rec_var_       = 0;
    78 
    79                 num_rec_op_        = 0;
    80                 rec_op_            = CPPAD_NULL;
    81 
    82                 num_rec_vecad_ind_ = 0;
    83                 num_rec_vecad_vec_ = 0;
    84                 rec_vecad_ind_     = CPPAD_NULL;
    85 
    86                 num_rec_op_arg_    = 0;
    87                 rec_op_arg_        = CPPAD_NULL;
    88 
    89                 num_rec_par_       = 0;
    90                 rec_par_           = CPPAD_NULL;
    91 
    92                 num_rec_text_      = 0;
    93                 rec_text_          = CPPAD_NULL;
    94 
    95         }
     61        player(void) : num_rec_var_(0), num_rec_vecad_vec_(0)
     62        { }
    9663
    9764        /// Destructor
    9865        ~player(void)
    99         {       if( num_rec_op_ > 0 )
    100                         CPPAD_TRACK_DEL_VEC(rec_op_);
    101                 if( num_rec_vecad_ind_ > 0 )
    102                         CPPAD_TRACK_DEL_VEC(rec_vecad_ind_);
    103                 if( num_rec_op_arg_ > 0 )
    104                         CPPAD_TRACK_DEL_VEC(rec_op_arg_);
    105                 if( num_rec_par_ > 0 )
    106                         CPPAD_TRACK_DEL_VEC(rec_par_);
    107                 if( num_rec_text_ > 0 )
    108                         CPPAD_TRACK_DEL_VEC(rec_text_);
    109         }
     66        { }
    11067
    11168        // ===============================================================
     
    12077        {       size_t i;
    12178
    122                 if( num_rec_op_ > 0 )
    123                         CPPAD_TRACK_DEL_VEC(rec_op_);
    124                 if( num_rec_vecad_ind_ > 0 )
    125                         CPPAD_TRACK_DEL_VEC(rec_vecad_ind_);
    126                 if( num_rec_op_arg_ > 0 )
    127                         CPPAD_TRACK_DEL_VEC(rec_op_arg_);
    128                 if( num_rec_par_ > 0 )
    129                         CPPAD_TRACK_DEL_VEC(rec_par_);
    130                 if( num_rec_text_ > 0 )
    131                         CPPAD_TRACK_DEL_VEC(rec_text_);
    132 
    13379                // Var
    13480                num_rec_var_        = rec.num_rec_var_;
    13581
    13682                // Op
    137                 num_rec_op_         = rec.num_rec_op_;
     83                rec_op_             = rec.rec_op_;
    13884
    13985                // VecInd
    140                 num_rec_vecad_ind_  = rec.num_rec_vecad_ind_;
     86                rec_vecad_ind_      = rec.rec_vecad_ind_;
    14187
    14288                // Arg
    143                 num_rec_op_arg_     = rec.num_rec_op_arg_;
     89                rec_op_arg_         = rec.rec_op_arg_;
    14490
    14591                // Par
    146                 num_rec_par_        = rec.num_rec_par_;
     92                rec_par_            = rec.rec_par_;
    14793
    14894                // Txt
    149                 num_rec_text_       = rec.num_rec_text_;
    150 
    151                 // Allocate the memory
    152                 if( num_rec_op_ == 0 )
    153                         rec_op_ = CPPAD_NULL;
    154                 else    rec_op_ =
    155                         CPPAD_TRACK_NEW_VEC(num_rec_op_,        rec_op_);
    156                 if( num_rec_vecad_ind_ == 0 )
    157                         rec_vecad_ind_ = CPPAD_NULL;
    158                 else    rec_vecad_ind_ =
    159                         CPPAD_TRACK_NEW_VEC(num_rec_vecad_ind_, rec_vecad_ind_);
    160                 if( num_rec_op_arg_ == 0 )
    161                         rec_op_arg_ = CPPAD_NULL;
    162                 else    rec_op_arg_ =
    163                         CPPAD_TRACK_NEW_VEC(num_rec_op_arg_,    rec_op_arg_);
    164                 if( num_rec_par_ == 0 )
    165                         rec_par_ = CPPAD_NULL;
    166                 else    rec_par_ =
    167                         CPPAD_TRACK_NEW_VEC(num_rec_par_,       rec_par_);
    168                 if( num_rec_text_ == 0 )
    169                         rec_text_ = CPPAD_NULL;
    170                 else    rec_text_ =
    171                         CPPAD_TRACK_NEW_VEC(num_rec_text_,      rec_text_);
    172 
    173                 // Copy the data
    174                 i = num_rec_op_;
    175                 while(i--)
    176                         rec_op_[i] = rec.rec_op_[i];
    177                 i = num_rec_vecad_ind_;
    178                 while(i--)
    179                         rec_vecad_ind_[i] = rec.rec_vecad_ind_[i];
    180                 i = num_rec_op_arg_;
    181                 while(i--)
    182                         rec_op_arg_[i] = rec.rec_op_arg_[i];
    183                 i = num_rec_par_;
    184                 while(i--)
    185                         rec_par_[i] = rec.rec_par_[i];
    186                 i = num_rec_text_;
    187                 while(i--)
    188                         rec_text_[i] = rec.rec_text_[i];
     95                rec_text_           = rec.rec_text_;
    18996
    19097                // set the number of VecAD vectors
    19198                num_rec_vecad_vec_ = 0;
    192                 for(i = 0; i < num_rec_vecad_ind_; i += rec_vecad_ind_[i] + 1)
     99                for(i = 0; i < rec_vecad_ind_.size(); i += rec_vecad_ind_[i] + 1)
    193100                        num_rec_vecad_vec_++;
     101                // rec_vecad_ind_ contains size of each VecAD followed by
     102                // the parameter indices used to iniialize it.
     103                CPPAD_ASSERT_UNKNOWN( i == rec_vecad_ind_.size() );
    194104        }
    195105
     
    201111        */
    202112        void operator=(const player& play)
    203         {       size_t i;
    204 
    205                 if( num_rec_op_ > 0 )
    206                         CPPAD_TRACK_DEL_VEC(rec_op_);
    207                 if( num_rec_vecad_ind_ > 0 )
    208                         CPPAD_TRACK_DEL_VEC(rec_vecad_ind_);
    209                 if( num_rec_op_arg_ > 0 )
    210                         CPPAD_TRACK_DEL_VEC(rec_op_arg_);
    211                 if( num_rec_par_ > 0 )
    212                         CPPAD_TRACK_DEL_VEC(rec_par_);
    213                 if( num_rec_text_ > 0 )
    214                         CPPAD_TRACK_DEL_VEC(rec_text_);
    215 
     113        {       
    216114                // Var
    217115                num_rec_var_        = play.num_rec_var_;
    218116
    219117                // Op
    220                 num_rec_op_         = play.num_rec_op_;
     118                rec_op_             = play.rec_op_;
    221119
    222120                // VecInd
    223                 num_rec_vecad_ind_  = play.num_rec_vecad_ind_;
     121                num_rec_vecad_vec_  = play.num_rec_vecad_vec_;
     122                rec_vecad_ind_      = play.rec_vecad_ind_;
    224123
    225124                // Arg
    226                 num_rec_op_arg_     = play.num_rec_op_arg_;
     125                rec_op_arg_         = play.rec_op_arg_;
    227126
    228127                // Par
    229                 num_rec_par_        = play.num_rec_par_;
     128                rec_par_            = play.rec_par_;
    230129
    231130                // Txt
    232                 num_rec_text_       = play.num_rec_text_;
    233 
    234                 // Allocate the memory
    235                 if( num_rec_op_ == 0 )
    236                         rec_op_ = CPPAD_NULL;
    237                 else    rec_op_ =
    238                         CPPAD_TRACK_NEW_VEC(num_rec_op_,        rec_op_);
    239                 if( num_rec_vecad_ind_ == 0 )
    240                         rec_vecad_ind_ = CPPAD_NULL;
    241                 else    rec_vecad_ind_ =
    242                         CPPAD_TRACK_NEW_VEC(num_rec_vecad_ind_, rec_vecad_ind_);
    243                 if( num_rec_op_arg_ == 0 )
    244                         rec_op_arg_ = CPPAD_NULL;
    245                 else    rec_op_arg_ =
    246                         CPPAD_TRACK_NEW_VEC(num_rec_op_arg_,    rec_op_arg_);
    247                 if( num_rec_par_ == 0 )
    248                         rec_par_ = CPPAD_NULL;
    249                 else    rec_par_ =
    250                         CPPAD_TRACK_NEW_VEC(num_rec_par_,       rec_par_);
    251                 if( num_rec_text_ == 0 )
    252                         rec_text_ = CPPAD_NULL;
    253                 else    rec_text_ =
    254                         CPPAD_TRACK_NEW_VEC(num_rec_text_,      rec_text_);
    255 
    256                 // Copy the data
    257                 i = num_rec_op_;
    258                 while(i--)
    259                         rec_op_[i] = play.rec_op_[i];
    260                 i = num_rec_vecad_ind_;
    261                 while(i--)
    262                         rec_vecad_ind_[i] = play.rec_vecad_ind_[i];
    263                 i = num_rec_op_arg_;
    264                 while(i--)
    265                         rec_op_arg_[i] = play.rec_op_arg_[i];
    266                 i = num_rec_par_;
    267                 while(i--)
    268                         rec_par_[i] = play.rec_par_[i];
    269                 i = num_rec_text_;
    270                 while(i--)
    271                         rec_text_[i] = play.rec_text_[i];
    272 
    273                 // set the number of VecAD vectors
    274                 num_rec_vecad_vec_ = 0;
    275                 for(i = 0; i < num_rec_vecad_ind_; i += rec_vecad_ind_[i] + 1)
    276                         num_rec_vecad_vec_++;
     131                rec_text_           = play.rec_text_;
    277132        }
    278133        // End two functions with idential code but different argument types.
     
    283138        {       
    284139                num_rec_var_       = 0;
    285                 num_rec_op_        = 0;
    286                 num_rec_vecad_ind_ = 0;
    287                 num_rec_op_arg_    = 0;
    288                 num_rec_par_       = 0;
    289                 num_rec_text_      = 0;
    290 
    291                 if( num_rec_op_ > 0 )
    292                         CPPAD_TRACK_DEL_VEC(rec_op_);
    293                 if( num_rec_vecad_ind_ > 0 )
    294                         CPPAD_TRACK_DEL_VEC(rec_vecad_ind_);
    295                 if( num_rec_op_arg_ > 0 )
    296                         CPPAD_TRACK_DEL_VEC(rec_op_arg_);
    297                 if( num_rec_par_ > 0 )
    298                         CPPAD_TRACK_DEL_VEC(rec_par_);
    299                 if( num_rec_text_ > 0 )
    300                         CPPAD_TRACK_DEL_VEC(rec_text_);
    301 
    302                 num_rec_op_        = 0;
    303                 num_rec_vecad_ind_ = 0;
    304140                num_rec_vecad_vec_ = 0;
    305                 num_rec_op_arg_    = 0;
    306                 num_rec_par_       = 0;
    307                 num_rec_text_      = 0;
     141
     142                rec_op_.erase();
     143                rec_vecad_ind_.erase();
     144                rec_op_arg_.erase();
     145                rec_par_.erase();
     146                rec_text_.erase();
    308147        }
    309148
     
    321160        */
    322161        OpCode GetOp (size_t i) const
    323         {       CPPAD_ASSERT_UNKNOWN(i < num_rec_op_);
    324                 return rec_op_[i];
    325         }
     162        {       return rec_op_[i]; }
    326163
    327164        /*!
     
    336173        */
    337174        size_t GetVecInd (size_t i) const
    338         {       CPPAD_ASSERT_UNKNOWN(i < num_rec_vecad_ind_);
    339                 return rec_vecad_ind_[i];
    340         }
     175        {       return rec_vecad_ind_[i]; }
    341176
    342177        /*!
     
    351186        */
    352187        Base GetPar(size_t i) const
    353         {       CPPAD_ASSERT_UNKNOWN(i < num_rec_par_);
    354                 return rec_par_[i];
    355         }
     188        {       return rec_par_[i]; }
    356189
    357190        /*!
     
    364197        */
    365198        const Base* GetPar(void) const
    366         {       return rec_par_; }
     199        {       return rec_par_.data(); }
    367200
    368201        /*!
     
    377210        */
    378211        const char *GetTxt(size_t i) const
    379         {       CPPAD_ASSERT_UNKNOWN(i < num_rec_text_);
    380                 return rec_text_ + i;
     212        {       CPPAD_ASSERT_UNKNOWN(i < rec_text_.size() );
     213                return rec_text_.data() + i;
    381214        }
    382215       
     
    392225        */
    393226        void ReplaceInd(size_t i, size_t value)
    394         {       CPPAD_ASSERT_UNKNOWN( i < num_rec_op_arg_);
    395                 rec_op_arg_[i] = value;
    396         }
     227        {       rec_op_arg_[i] = value; }
    397228
    398229        /// Fetch number of variables in the recording.
     
    402233        /// Fetch number of operators in the recording.
    403234        size_t num_rec_op(void) const
    404         {       return num_rec_op_; }
     235        {       return rec_op_.size(); }
    405236
    406237        /// Fetch number of VecAD indices in the recording.
    407238        size_t num_rec_vecad_ind(void) const
    408         {       return num_rec_vecad_ind_; }
     239        {       return rec_vecad_ind_.size(); }
    409240
    410241        /// Fetch number of VecAD vectors in the recording
     
    414245        /// Fetch number of argument indices in the recording.
    415246        size_t num_rec_op_arg(void) const
    416         {       return num_rec_op_arg_; }
     247        {       return rec_op_arg_.size(); }
    417248
    418249        /// Fetch number of parameters in the recording.
    419250        size_t num_rec_par(void) const
    420         {       return num_rec_par_; }
     251        {       return rec_par_.size(); }
    421252
    422253        /// Fetch number of characters (representing strings) in the recording.
    423254        size_t num_rec_text(void) const
    424         {       return num_rec_text_; }
    425 
    426         /// Fetch a rough measure of amount of memory used by the recording.
     255        {       return rec_text_.size(); }
     256
     257        /// Fetch a rough measure of amount of memory used to store recording
     258        /// (just lengths, not capacities).
    427259        size_t Memory(void) const
    428         {       return num_rec_op_        * sizeof(OpCode)
    429                      + num_rec_op_arg_    * sizeof(size_t)
    430                      + num_rec_par_       * sizeof(Base)
    431                      + num_rec_text_      * sizeof(char)
    432                      + num_rec_vecad_ind_ * sizeof(size_t)
     260        {       return rec_op_.size()        * sizeof(OpCode)
     261                     + rec_op_arg_.size()    * sizeof(size_t)
     262                     + rec_par_.size()       * sizeof(Base)
     263                     + rec_text_.size()      * sizeof(char)
     264                     + rec_vecad_ind_.size() * sizeof(size_t)
    433265                ;
    434266        }
     
    442274        size_t    op_index_;
    443275
    444         /// Current offser of the argument indices in rec_op_arg_
     276        /// Current offset of the argument indices in rec_op_arg_
    445277        size_t    op_arg_;
    446278
     
    478310                op        = op_          = rec_op_[0];
    479311                op_arg_   = 0;
    480                 op_arg    = rec_op_arg_;
     312                op_arg    = rec_op_arg_.data();
    481313                op_index  = op_index_    = 0;
    482314                var_index = var_index_   = 0;
     
    525357
    526358                // first argument for next operator
    527                 op_arg_    += NumArg(op_);            // index
    528                 op_arg      = op_arg_ + rec_op_arg_;  // pointer
     359                op_arg_    += NumArg(op_);                   // index
     360                op_arg      = op_arg_ + rec_op_arg_.data();  // pointer
    529361
    530362                // next operator
     
    534366                var_index   = var_index_ += NumRes(op);
    535367
    536                 CPPAD_ASSERT_UNKNOWN( op_index_  < num_rec_op_ );
    537                 CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= num_rec_op_arg_ );
     368                CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
    538369                CPPAD_ASSERT_UNKNOWN( var_index_  < num_rec_var_ );
    539370        }
     
    578409                op_arg_    += op_arg[0] + op_arg[1] + 4;
    579410
    580                 CPPAD_ASSERT_UNKNOWN( op_index_  < num_rec_op_ );
    581                 CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= num_rec_op_arg_ );
     411                CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
    582412                CPPAD_ASSERT_UNKNOWN( var_index_  < num_rec_var_ );
    583413        }
     
    590420        */
    591421        size_t* forward_non_const_arg(void)
    592         {       return op_arg_ + rec_op_arg_; }
     422        {       return op_arg_ + rec_op_arg_.data(); }
    593423
    594424        /*!
     
    621451        OpCode& op, const size_t*& op_arg, size_t& op_index, size_t& var_index)
    622452        {
    623                 op_arg_     = num_rec_op_arg_;                // index
    624                 op_arg      = op_arg_ + rec_op_arg_;          // pointer
    625 
    626                 op_index    = op_index_   = num_rec_op_ - 1;
     453                op_arg_     = rec_op_arg_.size();                // index
     454                op_arg      = op_arg_ + rec_op_arg_.data();      // pointer
     455
     456                op_index    = op_index_   = rec_op_.size() - 1;
    627457                var_index   = var_index_  = num_rec_var_ - 1;
    628458
     
    688518                CPPAD_ASSERT_UNKNOWN( op_arg_ >= NumArg(op)  );
    689519                op_arg_    -= NumArg(op);                            // index
    690                 op_arg      = op_arg_ + rec_op_arg_;                 // pointer
     520                op_arg      = op_arg_ + rec_op_arg_.data();          // pointer
    691521        }
    692522        /*!
     
    725555                --op_arg;
    726556                op_arg_    -= (op_arg[0] + 4);
    727                 op_arg      = op_arg_ + rec_op_arg_;
     557                op_arg      = op_arg_ + rec_op_arg_.data();
    728558
    729559                CPPAD_ASSERT_UNKNOWN(
    730560                op_arg[0] + op_arg[1] == op_arg[ 3 + op_arg[0] + op_arg[1] ]
    731561                );
    732                 CPPAD_ASSERT_UNKNOWN( op_index_  < num_rec_op_ );
    733                 CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= num_rec_op_arg_ );
     562                CPPAD_ASSERT_UNKNOWN( op_index_  < rec_op_.size() );
     563                CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
    734564                CPPAD_ASSERT_UNKNOWN( var_index_  < num_rec_var_ );
    735565        }
  • trunk/cppad/local/prototype_op.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/cppad/local/recorder.hpp

    r1641 r1948  
    33# define CPPAD_RECORDER_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
     
    1313-------------------------------------------------------------------------- */
    1414# include <cppad/local/hash_code.hpp>
     15# include <cppad/local/pod_vector.hpp>
    1516
    1617CPPAD_BEGIN_NAMESPACE
     
    3637        size_t    num_rec_var_;
    3738
    38         /// Length of the operation vector rec_op_.
    39         size_t    len_rec_op_;
    40 
    41         /// Number of operators currently in the recording.
    42         size_t    num_rec_op_;
    43 
    4439        /// The operators in the recording.
    45         OpCode   *rec_op_;
    46 
    47         /// Length of the VecAD index vector rec_vecad_ind_
    48         size_t    len_rec_vecad_ind_;
    49 
    50         /// Number of VecAD indices currently in the recording.
    51         size_t    num_rec_vecad_ind_;
     40        pod_vector<OpCode> rec_op_;
    5241
    5342        /// The VecAD indices in the recording.
    54         size_t   *rec_vecad_ind_;
    55 
    56         /// Length of operation argument index vector rec_op_arg_.
    57         size_t    len_rec_op_arg_;
    58 
    59         /// Number of operation arguments indices currently in the recording.
    60         size_t    num_rec_op_arg_;
     43        pod_vector<size_t> rec_vecad_ind_;
    6144
    6245        /// The argument indices in the recording
    63         size_t   *rec_op_arg_;
    64 
    65         /// Length of parameter vector rec_par_.
    66         size_t    len_rec_par_;
    67 
    68         /// Number of parameters currently in the recording.
    69         size_t    num_rec_par_;
     46        pod_vector<size_t> rec_op_arg_;
    7047
    7148        /// The parameters in the recording.
    72         Base     *rec_par_;
    73 
    74         /// Length of text character vector rec_text_.
    75         size_t    len_rec_text_;
    76 
    77         /// Number of text characters currently in recording.
    78         size_t    num_rec_text_;
     49        /// Note that Base may not be plain old data, so use false in consructor.
     50        pod_vector<Base> rec_par_;
    7951
    8052        /// Character strings ('\\0' terminated) in the recording.
    81         char     *rec_text_;
     53        pod_vector<char> rec_text_;
    8254
    8355// ---------------------- Public Functions -----------------------------------
    8456public:
    8557        /// Default constructor
    86         recorder(void)
    87         {       
    88                 num_rec_var_         = 0;
    89 
    90                 num_rec_op_          = 0;
    91                 len_rec_op_          = 0;
    92                 rec_op_              = CPPAD_NULL;
    93 
    94                 num_rec_vecad_ind_   = 0;
    95                 len_rec_vecad_ind_   = 0;
    96                 rec_vecad_ind_       = CPPAD_NULL;
    97 
    98                 num_rec_op_arg_      = 0;
    99                 len_rec_op_arg_      = 0;
    100                 rec_op_arg_          = CPPAD_NULL;
    101 
    102                 num_rec_par_         = 0;
    103                 len_rec_par_         = 0;
    104                 rec_par_             = CPPAD_NULL;
    105 
    106                 num_rec_text_        = 0;
    107                 len_rec_text_        = 0;
    108                 rec_text_            = CPPAD_NULL;
    109 
    110         }
     58        recorder(void) : num_rec_var_(0)
     59        { }
    11160
    11261        /// Destructor
    11362        ~recorder(void)
    114         {       if( len_rec_op_ > 0 )
    115                         CPPAD_TRACK_DEL_VEC(rec_op_);
    116                 if( len_rec_vecad_ind_ > 0 )
    117                         CPPAD_TRACK_DEL_VEC(rec_vecad_ind_);
    118                 if( len_rec_op_arg_ > 0 )
    119                         CPPAD_TRACK_DEL_VEC(rec_op_arg_);
    120                 if( len_rec_par_ > 0 )
    121                         CPPAD_TRACK_DEL_VEC(rec_par_);
    122                 if( len_rec_text_ > 0 )
    123                         CPPAD_TRACK_DEL_VEC(rec_text_);
    124         }
     63        { }
    12564
    12665        /*!
     
    13372        */
    13473        void Erase(void)
    135         {       
    136                 num_rec_var_          = 0;
    137                 num_rec_op_           = 0;
    138                 num_rec_vecad_ind_    = 0;
    139                 num_rec_op_arg_       = 0;
    140                 num_rec_par_          = 0;
    141                 num_rec_text_         = 0;
    142 
    143                 if( len_rec_op_ > 0 )
    144                         CPPAD_TRACK_DEL_VEC(rec_op_);
    145                 if( len_rec_vecad_ind_ > 0 )
    146                         CPPAD_TRACK_DEL_VEC(rec_vecad_ind_);
    147                 if( len_rec_op_arg_ > 0 )
    148                         CPPAD_TRACK_DEL_VEC(rec_op_arg_);
    149                 if( len_rec_par_ > 0 )
    150                         CPPAD_TRACK_DEL_VEC(rec_par_);
    151                 if( len_rec_text_ > 0 )
    152                         CPPAD_TRACK_DEL_VEC(rec_text_);
    153 
    154                 len_rec_op_           = 0;
    155                 len_rec_vecad_ind_    = 0;
    156                 len_rec_op_arg_       = 0;
    157                 len_rec_par_          = 0;
    158                 len_rec_text_         = 0;
     74        {       num_rec_var_  = 0;
     75                rec_op_.erase();
     76                rec_vecad_ind_.erase();
     77                rec_op_arg_.erase();
     78                rec_par_.erase();
     79                rec_text_.erase();
    15980        }
    16081        /// Start recording the next operator in the operation sequence.
     
    188109        /// Approximate amount of memory used by the recording
    189110        size_t Memory(void) const
    190         {       return len_rec_op_ * sizeof(OpCode)
    191                      + len_rec_vecad_ind_ * sizeof(size_t)
    192                      + len_rec_op_arg_ * sizeof(size_t)
    193                      + len_rec_par_ * sizeof(Base)
    194                      + len_rec_text_ * sizeof(char);
     111        {       return rec_op_.capacity()        * sizeof(OpCode)
     112                     + rec_vecad_ind_.capacity() * sizeof(size_t)
     113                     + rec_op_arg_.capacity()    * sizeof(size_t)
     114                     + rec_par_.capacity()      * sizeof(Base)
     115                     + rec_text_.capacity()      * sizeof(char);
    195116        }
    196117};
     
    225146template <class Base>
    226147inline size_t recorder<Base>::PutOp(OpCode op)
    227 {
    228         CPPAD_ASSERT_UNKNOWN( num_rec_op_ <= len_rec_op_ );
    229         if( num_rec_op_ == len_rec_op_ )
    230         {       len_rec_op_ = 2 * len_rec_op_ + 8;
    231                 rec_op_ = CPPAD_TRACK_EXTEND(
    232                         len_rec_op_, num_rec_op_, rec_op_
    233                 );
    234         }
    235         CPPAD_ASSERT_UNKNOWN( num_rec_op_ < len_rec_op_ );
    236         rec_op_[num_rec_op_++]  = op;
     148{       size_t i    = rec_op_.extend(1);
     149        rec_op_[i]  = op;
     150        CPPAD_ASSERT_UNKNOWN( rec_op_.size() == i + 1 );
     151
     152        // first operator should be a BeginOp and NumRes( BeginOp ) > 0
    237153        num_rec_var_ += NumRes(op);
    238 
    239         // first operator should be a BeginOp and NumRes( BeginOp ) > 0
    240154        CPPAD_ASSERT_UNKNOWN( num_rec_var_ > 0 );
    241155
     
    263177template <class Base>
    264178inline size_t recorder<Base>::PutVecInd(size_t vec_ind)
    265 {       
    266         CPPAD_ASSERT_UNKNOWN( num_rec_vecad_ind_ <= len_rec_vecad_ind_ );
    267         if( num_rec_vecad_ind_ == len_rec_vecad_ind_ )
    268         {       len_rec_vecad_ind_ = 2 * len_rec_vecad_ind_ + 8;
    269                 rec_vecad_ind_ = CPPAD_TRACK_EXTEND(
    270                         len_rec_vecad_ind_, num_rec_vecad_ind_, rec_vecad_ind_
    271                 );
    272         }
    273         CPPAD_ASSERT_UNKNOWN( num_rec_vecad_ind_ < len_rec_vecad_ind_ );
    274         rec_vecad_ind_[num_rec_vecad_ind_++] = vec_ind;
    275 
    276         return num_rec_vecad_ind_ - 1;
     179{       size_t i          = rec_vecad_ind_.extend(1);
     180        rec_vecad_ind_[i] = vec_ind;
     181        CPPAD_ASSERT_UNKNOWN( rec_vecad_ind_.size() == i + 1 );
     182
     183        return i;
    277184}
    278185
     
    294201        size_t          i;
    295202        unsigned short  code;
    296         CPPAD_ASSERT_UNKNOWN( num_rec_par_ <= len_rec_par_ );
    297203
    298204        if( init )
     
    308214        // If we have a match, return the parameter index
    309215        i = hash_table[code];
    310         if( i < num_rec_par_ )
     216        if( i < rec_par_.size() )
    311217        {       if( IdenticalEqualPar(rec_par_[i], par) )
    312218                        return i;
     
    314220       
    315221        // place a new value in the table
    316         if( num_rec_par_ == len_rec_par_ )
    317         {       len_rec_par_ = 2 * len_rec_par_ + 8;
    318                 rec_par_ = CPPAD_TRACK_EXTEND(
    319                         len_rec_par_, num_rec_par_, rec_par_
    320                 );
    321         }
    322         CPPAD_ASSERT_UNKNOWN( num_rec_par_ < len_rec_par_ );
    323         i           = num_rec_par_++;
     222        i           = rec_par_.extend(1);
    324223        rec_par_[i] = par;
     224        CPPAD_ASSERT_UNKNOWN( rec_par_.size() == i + 1 );
    325225
    326226        // make the hash code point to this new value
     
    370270inline void recorder<Base>::PutArg(size_t arg0)
    371271{
    372         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ <= len_rec_op_arg_ );
    373         if( num_rec_op_arg_ == len_rec_op_arg_ )
    374         {       len_rec_op_arg_ = 2 * len_rec_op_arg_ + 8;
    375                 rec_op_arg_ = CPPAD_TRACK_EXTEND(
    376                         len_rec_op_arg_, num_rec_op_arg_, rec_op_arg_
    377                 );
    378         }
    379         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ < len_rec_op_arg_ );
    380         rec_op_arg_[num_rec_op_arg_++] = arg0;
     272        size_t i       = rec_op_arg_.extend(1);
     273        rec_op_arg_[i] = arg0;
     274        CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
    381275}
    382276/*!
     
    394288inline void recorder<Base>::PutArg(size_t arg0, size_t arg1)
    395289{
    396         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ <= len_rec_op_arg_ );
    397         if( num_rec_op_arg_ + 1 >= len_rec_op_arg_ )
    398         {       len_rec_op_arg_ = 2 * len_rec_op_arg_ + 8;
    399                 rec_op_arg_ = CPPAD_TRACK_EXTEND(
    400                         len_rec_op_arg_, num_rec_op_arg_, rec_op_arg_
    401                 );
    402         }
    403         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ + 1 < len_rec_op_arg_ );
    404         rec_op_arg_[num_rec_op_arg_++] = arg0;
    405         rec_op_arg_[num_rec_op_arg_++] = arg1;
     290        size_t i         = rec_op_arg_.extend(2);
     291        rec_op_arg_[i++] = arg0;
     292        rec_op_arg_[i]   = arg1;
     293        CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
    406294}
    407295/*!
     
    422310inline void recorder<Base>::PutArg(size_t arg0, size_t arg1, size_t arg2)
    423311{
    424         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ <= len_rec_op_arg_ );
    425         if( num_rec_op_arg_ + 2 >= len_rec_op_arg_ )
    426         {       len_rec_op_arg_ = 2 * len_rec_op_arg_ + 8;
    427                 rec_op_arg_ = CPPAD_TRACK_EXTEND(
    428                         len_rec_op_arg_, num_rec_op_arg_, rec_op_arg_
    429                 );
    430         }
    431         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ + 2 < len_rec_op_arg_ );
    432         rec_op_arg_[num_rec_op_arg_++] = arg0;
    433         rec_op_arg_[num_rec_op_arg_++] = arg1;
    434         rec_op_arg_[num_rec_op_arg_++] = arg2;
     312        size_t i         = rec_op_arg_.extend(3);
     313        rec_op_arg_[i++] = arg0;
     314        rec_op_arg_[i++] = arg1;
     315        rec_op_arg_[i]   = arg2;
     316        CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
    435317}
    436318/*!
     
    455337        size_t arg3)
    456338{
    457         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ <= len_rec_op_arg_ );
    458         if( num_rec_op_arg_ + 3 >= len_rec_op_arg_ )
    459         {       len_rec_op_arg_ = 2 * len_rec_op_arg_ + 8;
    460                 rec_op_arg_ = CPPAD_TRACK_EXTEND(
    461                         len_rec_op_arg_, num_rec_op_arg_, rec_op_arg_
    462                 );
    463         }
    464         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ + 3 < len_rec_op_arg_ );
    465         rec_op_arg_[num_rec_op_arg_++] = arg0;
    466         rec_op_arg_[num_rec_op_arg_++] = arg1;
    467         rec_op_arg_[num_rec_op_arg_++] = arg2;
    468         rec_op_arg_[num_rec_op_arg_++] = arg3;
     339        size_t i         = rec_op_arg_.extend(4);
     340        rec_op_arg_[i++] = arg0;
     341        rec_op_arg_[i++] = arg1;
     342        rec_op_arg_[i++] = arg2;
     343        rec_op_arg_[i]   = arg3;
     344        CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
    469345
    470346}
     
    493369        size_t arg3, size_t arg4)
    494370{
    495         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ <= len_rec_op_arg_ );
    496         if( num_rec_op_arg_ + 4 >= len_rec_op_arg_ )
    497         {       len_rec_op_arg_ = 2 * len_rec_op_arg_ + 8;
    498                 rec_op_arg_ = CPPAD_TRACK_EXTEND(
    499                         len_rec_op_arg_, num_rec_op_arg_, rec_op_arg_
    500                 );
    501         }
    502         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ + 4 < len_rec_op_arg_ );
    503         rec_op_arg_[num_rec_op_arg_++] = arg0;
    504         rec_op_arg_[num_rec_op_arg_++] = arg1;
    505         rec_op_arg_[num_rec_op_arg_++] = arg2;
    506         rec_op_arg_[num_rec_op_arg_++] = arg3;
    507         rec_op_arg_[num_rec_op_arg_++] = arg4;
     371        size_t i         = rec_op_arg_.extend(5);
     372        rec_op_arg_[i++] = arg0;
     373        rec_op_arg_[i++] = arg1;
     374        rec_op_arg_[i++] = arg2;
     375        rec_op_arg_[i++] = arg3;
     376        rec_op_arg_[i]   = arg4;
     377        CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
    508378
    509379}
     
    535405        size_t arg3, size_t arg4, size_t arg5)
    536406{
    537         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ <= len_rec_op_arg_ );
    538         if( num_rec_op_arg_ + 5 >= len_rec_op_arg_ )
    539         {       len_rec_op_arg_ = 2 * len_rec_op_arg_ + 8;
    540                 rec_op_arg_ = CPPAD_TRACK_EXTEND(
    541                         len_rec_op_arg_, num_rec_op_arg_, rec_op_arg_
    542                 );
    543         }
    544         CPPAD_ASSERT_UNKNOWN( num_rec_op_arg_ + 5 < len_rec_op_arg_ );
    545         rec_op_arg_[num_rec_op_arg_++] = arg0;
    546         rec_op_arg_[num_rec_op_arg_++] = arg1;
    547         rec_op_arg_[num_rec_op_arg_++] = arg2;
    548         rec_op_arg_[num_rec_op_arg_++] = arg3;
    549         rec_op_arg_[num_rec_op_arg_++] = arg4;
    550         rec_op_arg_[num_rec_op_arg_++] = arg5;
     407        size_t i         = rec_op_arg_.extend(6);
     408        rec_op_arg_[i++] = arg0;
     409        rec_op_arg_[i++] = arg1;
     410        rec_op_arg_[i++] = arg2;
     411        rec_op_arg_[i++] = arg3;
     412        rec_op_arg_[i++] = arg4;
     413        rec_op_arg_[i]   = arg5;
     414        CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
    551415}
    552416// --------------------------------------------------------------------------
     
    565429template <class Base>
    566430inline size_t recorder<Base>::PutTxt(const char *text)
    567 {       size_t i;
    568 
     431{
    569432        // determine length of the text including terminating '\0'
    570433        size_t n;
     
    572435                CPPAD_ASSERT_UNKNOWN( n < 1000 ); // should check in PrintFor
    573436        n++;
    574 
    575         CPPAD_ASSERT_UNKNOWN( num_rec_text_ <= len_rec_text_ );
    576 
    577         if( num_rec_text_ + n >= len_rec_text_ )
    578         {       len_rec_text_  = 2 * len_rec_text_ + n + 8;
    579                 rec_text_ = CPPAD_TRACK_EXTEND(
    580                         len_rec_text_, num_rec_text_, rec_text_
    581                 );
    582         }
    583         CPPAD_ASSERT_UNKNOWN( num_rec_text_ + n < len_rec_text_ );
     437        CPPAD_ASSERT_UNKNOWN( text[n-1] == '\0' );
    584438
    585439        // copy text including terminating '\0'
    586         for(i = 0; i < n; i++)
    587                 rec_text_[num_rec_text_++] = text[i];
    588         CPPAD_ASSERT_UNKNOWN( text[i-1] == '\0' );
    589 
    590         return num_rec_text_ - n;
     440        size_t i = rec_text_.extend(n);
     441        size_t j;
     442        for(j = 0; j < n; j++)
     443                rec_text_[i + j] = text[j];
     444        CPPAD_ASSERT_UNKNOWN( rec_text_.size() == i + n );
     445
     446        return i;
    591447}
    592448// -------------------------------------------------------------------------
  • trunk/cppad/local/rev_hes_sweep.hpp

    r1865 r1948  
    142142        Vector_set vecad_sparse;
    143143        vecad_sparse.resize(num_vecad_vec, limit);
    144         size_t* vecad_ind   = CPPAD_NULL;
    145         bool*   vecad_jac   = CPPAD_NULL;
     144        pod_vector<size_t> vecad_ind;
     145        pod_vector<bool>   vecad_jac;
    146146        if( num_vecad_vec > 0 )
    147147        {       size_t length;
    148                 vecad_ind     = CPPAD_TRACK_NEW_VEC(num_vecad_ind, vecad_ind);
    149                 vecad_jac     = CPPAD_TRACK_NEW_VEC(num_vecad_vec, vecad_jac);
     148                vecad_ind.extend(num_vecad_ind);
     149                vecad_jac.extend(num_vecad_vec);
    150150                j             = 0;
    151151                for(i = 0; i < num_vecad_vec; i++)
     
    361361                                arg,
    362362                                num_vecad_ind,
    363                                 vecad_ind,
     363                                vecad_ind.data(),
    364364                                rev_hes_sparse,
    365365                                vecad_sparse,
    366366                                RevJac,
    367                                 vecad_jac
     367                                vecad_jac.data()
    368368                        );
    369369                        break;
     
    376376                                arg,
    377377                                num_vecad_ind,
    378                                 vecad_ind,
     378                                vecad_ind.data(),
    379379                                rev_hes_sparse,
    380380                                vecad_sparse,
    381381                                RevJac,
    382                                 vecad_jac
     382                                vecad_jac.data()
    383383                        );
    384384                        break;
     
    488488                                arg,
    489489                                num_vecad_ind,
    490                                 vecad_ind,
     490                                vecad_ind.data(),
    491491                                rev_hes_sparse,
    492492                                vecad_sparse,
    493493                                RevJac,
    494                                 vecad_jac
     494                                vecad_jac.data()
    495495                        );
    496496                        break;
     
    508508                                arg,
    509509                                num_vecad_ind,
    510                                 vecad_ind,
     510                                vecad_ind.data(),
    511511                                rev_hes_sparse,
    512512                                vecad_sparse,
    513513                                RevJac,
    514                                 vecad_jac
     514                                vecad_jac.data()
    515515                        );
    516516                        break;
     
    692692        CPPAD_ASSERT_UNKNOWN( i_var == 0 );
    693693
    694         if( vecad_jac != CPPAD_NULL )
    695                 CPPAD_TRACK_DEL_VEC(vecad_jac);
    696         if( vecad_ind != CPPAD_NULL )
    697                 CPPAD_TRACK_DEL_VEC(vecad_ind);
    698694        return;
    699695}
  • trunk/cppad/local/rev_jac_sweep.hpp

    r1865 r1948  
    115115        Vector_set  vecad_sparsity;
    116116        vecad_sparsity.resize(num_vecad_vec, limit);
    117         size_t* vecad_ind      = CPPAD_NULL;
     117        pod_vector<size_t> vecad_ind;
    118118        if( num_vecad_vec > 0 )
    119119        {       size_t length;
    120                 vecad_ind     = CPPAD_TRACK_NEW_VEC(num_vecad_ind, vecad_ind);
     120                vecad_ind.extend(num_vecad_ind);
    121121                j             = 0;
    122122                for(i = 0; i < num_vecad_vec; i++)
     
    322322                                arg,
    323323                                num_vecad_ind,
    324                                 vecad_ind,
     324                                vecad_ind.data(),
    325325                                var_sparsity,
    326326                                vecad_sparsity
     
    335335                                arg,
    336336                                num_vecad_ind,
    337                                 vecad_ind,
     337                                vecad_ind.data(),
    338338                                var_sparsity,
    339339                                vecad_sparsity
     
    445445                                arg,
    446446                                num_vecad_ind,
    447                                 vecad_ind,
     447                                vecad_ind.data(),
    448448                                var_sparsity,
    449449                                vecad_sparsity
     
    462462                                arg,
    463463                                num_vecad_ind,
    464                                 vecad_ind,
     464                                vecad_ind.data(),
    465465                                var_sparsity,
    466466                                vecad_sparsity
     
    617617        CPPAD_ASSERT_UNKNOWN( i_var == 0 );
    618618
    619         if( vecad_ind != CPPAD_NULL )
    620                 CPPAD_TRACK_DEL_VEC( vecad_ind);
    621 
    622619        return;
    623620}
  • trunk/cppad/local/rev_sparse_hes.hpp

    r1865 r1948  
    161161*/
    162162# include <algorithm>
     163# include <cppad/local/pod_vector.hpp>
    163164
    164165CPPAD_BEGIN_NAMESPACE
     
    264265        // Array that will hold reverse Jacobian dependency flag.
    265266        // Initialize as true for the dependent variables.
    266         bool *RevJac = CPPAD_NULL;
    267         RevJac       = CPPAD_TRACK_NEW_VEC(total_num_var, RevJac);     
     267        pod_vector<bool> RevJac;
     268        RevJac.extend(total_num_var);   
    268269        for(i = 0; i < total_num_var; i++)
    269270                RevJac[i] = false;
     
    284285                &play,
    285286                for_jac_sparsity,
    286                 RevJac,
     287                RevJac.data(),
    287288                rev_hes_sparsity
    288289        );
     
    310311                }
    311312        }
    312 
    313         // free local memory used for the calculation
    314         CPPAD_TRACK_DEL_VEC(RevJac);
    315313
    316314        return;
     
    423421        // Array that will hold reverse Jacobian dependency flag.
    424422        // Initialize as true for the dependent variables.
    425         bool *RevJac = CPPAD_NULL;
    426         RevJac       = CPPAD_TRACK_NEW_VEC(total_num_var, RevJac);     
     423        pod_vector<bool> RevJac;
     424        RevJac.extend(total_num_var);   
    427425        for(i = 0; i < total_num_var; i++)
    428426                RevJac[i] = false;
     
    450448                &play,
    451449                for_jac_sparsity,
    452                 RevJac,
     450                RevJac.data(),
    453451                rev_hes_sparsity
    454452        );
     
    472470                }
    473471        }
    474 
    475         // free local memory used for the calculation
    476         CPPAD_TRACK_DEL_VEC(RevJac);
    477472
    478473        return;
  • trunk/cppad/local/reverse.hpp

    r1659 r1948  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    3939*/
    4040# include <algorithm>
     41# include <cppad/local/pod_vector.hpp>
    4142
    4243CPPAD_BEGIN_NAMESPACE
     
    114115template <typename VectorBase>
    115116VectorBase ADFun<Base>::Reverse(size_t p, const VectorBase &w)
    116 {       // temporary indices
     117{       // constants
     118        const Base zero(0);
     119
     120        // temporary indices
    117121        size_t i, j, k;
    118122
     
    123127        size_t m = dep_taddr_.size();
    124128
    125         Base *Partial = CPPAD_NULL;
    126         Partial       = CPPAD_TRACK_NEW_VEC(total_num_var_ * p, Partial);
     129        pod_vector<Base> Partial;
     130        Partial.extend(total_num_var_ * p);
    127131
    128132        // update maximum memory requirement
     
    152156        for(i = 0; i < total_num_var_; i++)
    153157                for(j = 0; j < p; j++)
    154                         Partial[i * p + j] = Base(0);
     158                        Partial[i * p + j] = zero;
    155159
    156160        // set the dependent variable direction
     
    162166                else
    163167                {       for(k = 0; k < p; k++)
     168                                // ? should use += here, first make test to demonstrate bug
    164169                                Partial[ dep_taddr_[i] * p + k ] = w[i * p + k ];
    165170                }
     
    173178                &play_,
    174179                taylor_col_dim_,
    175                 taylor_,
     180                taylor_.data(),
    176181                p,
    177                 Partial
     182                Partial.data()
    178183        );
    179184
     
    201206        }
    202207
    203         // done with the Partial array
    204         CPPAD_TRACK_DEL_VEC(Partial);
    205 
    206208        return value;
    207209}
  • trunk/cppad/local/sparse_pack.hpp

    r1889 r1948  
    1414-------------------------------------------------------------------------- */
    1515# include <cppad/local/cppad_assert.hpp>
     16# include <cppad/local/pod_vector.hpp>
    1617
    1718CPPAD_BEGIN_NAMESPACE
     
    4243        /// (set by constructor and resize).
    4344        size_t n_pack_;
    44         /// Is the memory pointed to by \c data_ allocated by this object
    45         /// (set by contructor and resize)
    46         bool   allocated_;   
    47         /// Pointer to the beginning of data for all the sets.
    48         Pack*  data_;
     45        /// Data for all the sets.
     46        pod_vector<Pack>  data_;
    4947        /// index for which we were retrieving next_element
    5048        /// (use n_set_ if no such index exists).
     
    6159        end_(0)                       ,
    6260        n_pack_(0)                    ,
    63         allocated_(false)             ,
    64         data_(CPPAD_NULL)             ,
    6561        next_index_(0)                ,
    6662        next_element_(0)
     
    8177        */
    8278        ~sparse_pack(void)
    83         {       if( allocated_ )
    84                 {       allocated_ = false;
    85                         CPPAD_TRACK_DEL_VEC( data_ );
    86                 }
    87         }
     79        { }
    8880        // -----------------------------------------------------------------
    8981        /*! Change number of sets, set end, and initialize all sets as empty
     
    10193        void resize(size_t n_set_in, size_t end_in)
    10294        {       Pack zero(0);
    103                 if( allocated_ )
    104                 {       allocated_ = false;
    105                         CPPAD_TRACK_DEL_VEC(data_);
    106                 }
     95                data_.erase();
    10796
    10897                n_set_          = n_set_in;
     
    112101
    113102                if( i > 0 )
    114                 {       data_      = CPPAD_TRACK_NEW_VEC(i, data_);
    115                         allocated_ = true;
     103                {       data_.extend(i);
    116104                        while(i--)
    117105                                data_[i] = zero;
     
    221209                static Pack zero(0);
    222210                CPPAD_ASSERT_UNKNOWN( target < n_set_ );
    223                 Pack *t  = data_ + target * n_pack_;
     211                size_t t = target * n_pack_;
    224212
    225213                size_t j = n_pack_;
    226214                while(j--)
    227                         *t++ = zero;
     215                        data_[t++] = zero;
    228216        }
    229217        // -----------------------------------------------------------------
     
    253241                CPPAD_ASSERT_UNKNOWN( other_value  <   other.n_set_  );
    254242                CPPAD_ASSERT_UNKNOWN( n_pack_      ==  other.n_pack_ );
    255                 Pack *t  = data_       + this_target * n_pack_;
    256                 Pack *v  = other.data_ + other_value * n_pack_;
     243                size_t t = this_target * n_pack_;
     244                size_t v = other_value * n_pack_;
    257245
    258246                size_t j = n_pack_;
    259247                while(j--)
    260                         *t++ = *v++;
     248                        data_[t++] = other.data_[v++];
    261249        }
    262250
     
    297285                CPPAD_ASSERT_UNKNOWN( n_pack_    ==  other.n_pack_ );
    298286
    299                 Pack *t  = data_       + this_target * n_pack_;
    300                 Pack *l  = data_       + this_left   * n_pack_;
    301                 Pack *r  = other.data_ + other_right * n_pack_;
     287                size_t t = this_target * n_pack_;
     288                size_t l  = this_left  * n_pack_;
     289                size_t r  = other_right * n_pack_;
    302290
    303291                size_t j = n_pack_;
    304292                while(j--)
    305                         *t++ = (*l++ | *r++);
     293                        data_[t++] = ( data_[l++] | other.data_[r++] );
    306294        }
    307295        // -----------------------------------------------------------------
  • trunk/cppad/local/sparse_set.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/cppad/local/sparse_unary_op.hpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/cppad/local/user_atomic.hpp

    r1899 r1948  
    640640        user_atomic<%Base%>::clear()
    641641%$$
    642 frees this work space. It should be called before using
    643 $cref/CPPAD_COUNT_TRACK/TrackNewDel/TrackCount/$$ to check for
    644 a memory leak.
     642makes to work space available to $cref/omp_alloc/$$
     643for other uses by the same thread.
     644This should be called when you are done using the
     645user atomic functions for a specific value of $icode Base$$.
    645646
    646647$children%
  • trunk/cppad/local/vec_ad.hpp

    r1886 r1948  
    308308------------------------------------------------------------------------
    309309*/
     310# include <cppad/local/pod_vector.hpp>
    310311
    311312# define CPPAD_VEC_AD_COMPUTED_ASSIGNMENT(op, name)                     \
     
    373374
    374375                // AD<Base> value corresponding to this element
    375                 result.value_ = *(vec_->data_ + i);
     376                result.value_ = vec_->data_[i];
    376377
    377378                // this address will be recorded in tape and must be
     
    447448
    448449        // elements of this vector
    449         Base *data_;
     450        pod_vector<Base> data_;
    450451
    451452        // offset in cummulate vector corresponding to this object
     
    462463        VecAD(void)
    463464        : length_(0)
    464         , data_(CPPAD_NULL)
    465465        , offset_(0)
    466466        , id_(CPPAD_MAX_NUM_THREADS)
     
    473473        , offset_(0)
    474474        , id_(CPPAD_MAX_NUM_THREADS)
    475         {       data_  = CPPAD_NULL;
    476                 if( length_ > 0 )
     475        {       if( length_ > 0 )
    477476                {       size_t i;
    478477                        Base zero(0);
    479                         data_  = CPPAD_TRACK_NEW_VEC(length_, data_);
     478                        data_.extend(length_);
    480479
    481480                        // Initialize data to zero so all have same value.
     
    490489        // destructor
    491490        ~VecAD(void)
    492         {       if( data_ != CPPAD_NULL )
    493                         CPPAD_TRACK_DEL_VEC(data_);
    494         }
     491        { }
    495492
    496493        // size
     
    590587
    591588        // assign value for this element (as an AD<Base> object)
    592         *(vec_->data_ + i) = y.value_;
     589        vec_->data_[i] = y.value_;
    593590
    594591        // record the setting of this array element
     
    623620        CPPAD_ASSERT_UNKNOWN( i < vec_->length_ );
    624621
    625         // assign value for this element (target is an AD<Base> object)
    626         *(vec_->data_ + i) = y;
     622        // assign value for this element
     623        vec_->data_[i] = y;
    627624
    628625        // check if this ADVec object is a parameter
  • trunk/cppad/speed_test.hpp

    r1652 r1948  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    9999The $code speed_test$$ argument $italic size_vec$$ has prototype
    100100$syntax%
    101         const %Vector% &%size_vec%
     101        const %Vector%& %size_vec%
    102102%$$
    103103This vector determines the size for each of the tests problems.
     
    163163inline Vector speed_test(
    164164        void test(size_t size, size_t repeat),
    165         Vector size_vec                      ,
     165        const Vector& size_vec               ,
    166166        double time_min                      )
    167167{
  • trunk/cppad/track_new_del.hpp

    r1370 r1948  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    3232$index memory, track$$
    3333
     34$head Deprecated$$
     35$index deprecated, track memory$$
     36This routine has been deprecated.
     37You should use the $cref/omp_alloc/$$ memory allocator instead
     38(which works better in both a single thread and multi-threading environment).
     39
    3440$head Syntax$$
    3541$syntax%# include <cppad/track_new_del.hpp>
     
    263269$head Example$$
    264270$children%
    265         example/track_new_del.cpp
     271        test_more/track_new_del.cpp
    266272%$$
    267273The file $xref/TrackNewDel.cpp/$$
  • trunk/cppad/vector.hpp

    r1370 r1948  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    1717$begin CppAD_vector$$
    1818$spell
     19        omp_alloc
    1920        cppad.hpp
    2021        Bool
     
    3940$code # include <cppad/vector.hpp>$$
    4041
    41 
    42 
    4342$head Description$$
    4443The include file $code cppad/vector.hpp$$ defines the
     
    5150but it can also be included separately with out the rest of the
    5251CppAD include files.
     52
     53$head capacity$$
     54If $icode x$$ is a $codei%CppAD::vector<%Scalar%>%$$,
     55and $icode cap$$ is a $code size_t$$ object,
     56$codei%
     57        %cap% = %x%.capacity()
     58%$$
     59set $icode cap$$ to the number of $icode Scalar$$ objects that
     60could fit in the memory currently allocated for $icode x$$.
     61Note that
     62$codei%
     63        %x%.size() <= %x%.capacity()
     64%$$
    5365
    5466$head Assignment$$
     
    158170value zero, all memory allocated for the vector will be freed.
    159171The can be useful when using very large vectors
    160 and when checking for memory leaks (and there are global vectors).
     172and when checking for memory leaks (and there are global vectors)
     173see the $cref/memory/CppAD_vector/Memory/$$ discussion.
    161174
    162175$head vectorBool$$
     
    197210%$$
    198211is valid.
     212
     213$head Memory$$
     214$index omp_alloc, vector$$
     215$index vector, omp_alloc$$
     216These vectors use the OpenMP fast memory allocator $cref/omp_alloc/$$,
     217thus using them affects the amount of memory $cref/inuse/$$ and
     218$cref/available/$$.
     219Calling $cref/resize/CppAD_vector/resize/$$ with a zero argument,
     220makes the corresponding memory available (though $code omp_alloc$$)
     221to the current thread.
     222It can then be completely freed using $cref/free_available/$$.
    199223
    200224$lend
     
    234258# include <limits>
    235259# include <cppad/local/cppad_assert.hpp>
    236 # include <cppad/track_new_del.hpp>
    237260# include <cppad/check_simple_vector.hpp>
    238 
    239 # ifndef CPPAD_NULL
    240 # define CPPAD_NULL 0
    241 # endif
    242 
    243 namespace CppAD { //  BEGIN CppAD namespace
    244 
    245 // ------------------ CppAD::vector<Type> ----------------------------------
    246 
     261# include <cppad/omp_alloc.hpp>
     262
     263CPPAD_BEGIN_NAMESPACE
     264/*!
     265\file vector.hpp
     266File used to define CppAD::vector and CppAD::vectorBool
     267*/
     268
     269// ---------------------------------------------------------------------------
     270/*!
     271The CppAD Simple Vector template class.
     272*/
    247273template <class Type>
    248274class vector {
    249275private:
    250         size_t capacity;
    251         size_t length;
    252         Type   * data;
     276        /// maximum number of Type elements current allocation can hold
     277        size_t capacity_;
     278        /// number of Type elements currently in this vector
     279        size_t length_;
     280        /// pointer to the first type elements
     281        /// (not defined and should not be used when capacity_ = 0)
     282        Type   * data_;
    253283public:
    254         // type of the elements in the vector
     284        /// type of the elements in the vector
    255285        typedef Type value_type;
    256286
    257         // default constructor
    258         inline vector(void) : capacity(0), length(0) , data(CPPAD_NULL)
     287        /// default constructor sets capacity_ = length_ = data_ = 0
     288        inline vector(void)
     289        : capacity_(0), length_(0), data_(0)
    259290        { }
    260         // constructor with a specified size
    261         inline vector(size_t n) : capacity(n), length(n)
    262         {
    263                 data = CPPAD_NULL;
    264                 if( length > 0 )
    265                         data = CPPAD_TRACK_NEW_VEC(capacity, data);
    266         }
    267         // copy constructor
    268         inline vector(const vector &x) : capacity(x.length), length(x.length)
    269         {       size_t i;
    270                 data = CPPAD_NULL;
    271                 if( length > 0 )
    272                         data = CPPAD_TRACK_NEW_VEC(capacity, data);
    273 
    274                 for(i = 0; i < length; i++)
    275                         data[i] = x.data[i];
    276         }
    277         // destructor
     291        /// sizing constructor
     292        inline vector(
     293                /// number of elements in this vector
     294                size_t n
     295        ) : capacity_(0), length_(n), data_(0)
     296        {       if( length_ > 0 )
     297                {       // set capacity and data
     298                        data_ = omp_alloc::create_array<Type>(length_, capacity_);
     299                }
     300        }
     301        /// copy constructor
     302        inline vector(
     303                /// the *this vector will be a copy of \c x
     304                const vector& x
     305        ) : capacity_(0), length_(x.length_), data_(0)
     306        {       if( length_ > 0 )
     307                {       // set capacity and data       
     308                        data_ = omp_alloc::create_array<Type>(length_, capacity_);
     309
     310                        // copy values using assignment operator
     311                        size_t i;
     312                        for(i = 0; i < length_; i++)
     313                                data_[i] = x.data_[i];
     314                }
     315        }
     316        /// destructor
    278317        ~vector(void)
    279         {       if( data != CPPAD_NULL )
    280                         CPPAD_TRACK_DEL_VEC(data);
    281         }
    282 
    283         // size function
     318        {       if( capacity_ > 0 )
     319                        omp_alloc::delete_array(data_);
     320        }
     321
     322        /// maximum number of elements current allocation can store
     323        inline size_t capacity(void) const
     324        {       return capacity_; }
     325
     326        /// number of elements currently in this vector.
    284327        inline size_t size(void) const
    285         {       return length; }
    286 
    287         // resize function
    288         inline void resize(size_t n)
    289         {       length = n;
    290                 if( (capacity >= n) & (n > 0)  )
     328        {       return length_; }
     329
     330        /// change the number of elements in this vector.
     331        inline void resize(
     332                /// new number of elements for this vector, if zero
     333                /// make sure the memory is returned to omp_alloc.
     334                size_t n
     335        )
     336        {       length_ = n;
     337                // check if we can use current memory
     338                if( (capacity_ >= length_) & (length_ > 0)  )
    291339                        return;
    292                 if( data != CPPAD_NULL  )
    293                         CPPAD_TRACK_DEL_VEC(data);
    294                 capacity = n;
    295                 if( capacity == 0 )
    296                         data = CPPAD_NULL;
    297                 else    data = CPPAD_TRACK_NEW_VEC(capacity, data);
    298         }
    299         // assignment operator
    300         inline vector & operator=(const vector &x)
     340                // check if there is old memory to be freed
     341                if( capacity_ > 0 )
     342                        omp_alloc::delete_array(data_);
     343                // check if we need new memory
     344                if( length_ == 0 )
     345                        capacity_ = 0;
     346                else
     347                {       // get new memory and set capacity
     348                        data_ = omp_alloc::create_array<Type>(length_, capacity_);
     349                }
     350        }
     351        /// vector assignment operator
     352        inline vector& operator=(
     353                /// right hand size of the assingment operation
     354                const vector& x
     355        )
    301356        {       size_t i;
    302357                CPPAD_ASSERT_KNOWN(
    303                         length == x.length ,
    304                         "size miss match in assignment operation"
     358                        length_ == x.length_ ,
     359                        "vector: size miss match in assignment operation"
    305360                );
    306                 for(i = 0; i < length; i++)
    307                         data[i] = x.data[i];
     361                for(i = 0; i < length_; i++)
     362                        data_[i] = x.data_[i];
    308363                return *this;
    309364        }
    310         // non-constant element access
    311         Type & operator[](size_t i)
     365        /// non-constant element access; i.e., we can change this element value
     366        Type& operator[](
     367                /// element index, must be less than length
     368                size_t i
     369        )
    312370        {       CPPAD_ASSERT_KNOWN(
    313                         i < length,
    314                         "vector index greater than or equal vector size"
     371                        i < length_,
     372                        "vector: index greater than or equal vector size"
    315373                );
    316                 return data[i];
    317         }
    318         // constant element access
    319         const Type & operator[](size_t i) const
     374                return data_[i];
     375        }
     376        /// constant element access; i.e., we cannot change this element value
     377        const Type& operator[](
     378                /// element index, must be less than length
     379                size_t i
     380        ) const
    320381        {       CPPAD_ASSERT_KNOWN(
    321                         i < length,
    322                         "vector index greater than or equal vector size"
     382                        i < length_,
     383                        "vector: index greater than or equal vector size"
    323384                );
    324                 return data[i];
    325         }
    326         // add scalar to the back of the array
    327         void push_back(const Type &s)
    328         {       CPPAD_ASSERT_UNKNOWN( length <= capacity );
    329                 if( length + 1 > capacity )
    330                 {       // allocate more capacity
    331                         if( capacity == 0 )
    332                                 capacity = 2;
    333                         else    capacity = 2 * length;
    334                         data = CPPAD_TRACK_EXTEND(capacity, length, data);
    335                 }
    336                 data[length++] = s;
    337                 CPPAD_ASSERT_UNKNOWN( length <= capacity );
    338         }
    339 
    340         // add vector to the back of the array
    341         // (Cannot use push_back becasue MS V++ 7.1 does not resolve
    342         // to non-template member function when scalar is used.)
     385                return data_[i];
     386        }
     387        /// add an element to the back of this vector
     388        void push_back(
     389                /// value of the element
     390                const Type& s
     391        )
     392        {       CPPAD_ASSERT_UNKNOWN( length_ <= capacity_ );
     393                if( length_ + 1 > capacity_ )
     394                {       // store old capacity and data values
     395                        size_t old_capacity = capacity_;
     396                        Type*  old_data     = data_;
     397                        // set new capacity and data values
     398                        data_ = omp_alloc::create_array<Type>(length_ + 1, capacity_);
     399                        // copy old data values
     400                        size_t i;
     401                        for(i = 0; i < length_; i++)
     402                                data_[i] = old_data[i];
     403                        // free old data
     404                        if( old_capacity > 0 )
     405                                omp_alloc::delete_array(old_data);
     406                }
     407                data_[length_++] = s;
     408                CPPAD_ASSERT_UNKNOWN( length_ <= capacity_ );
     409        }
     410
     411        /*! add vector to the back of this vector
     412        (we could not use push_back becasue MS V++ 7.1 did not resolve
     413        to non-template member function when scalar is used.)
     414        */
    343415        template <class Vector>
    344         void push_vector(const Vector &v)
     416        void push_vector(
     417                /// value of the vector that we are adding
     418                const Vector& v
     419        )
    345420        {       CheckSimpleVector<Type, Vector>();
     421                CPPAD_ASSERT_UNKNOWN( length_ <= capacity_ );
    346422                size_t m = v.size();
    347                 CPPAD_ASSERT_UNKNOWN( length <= capacity );
    348                 if( length + m > capacity )
    349                 {       // allocate more capacity
    350                         capacity = length + m;
    351                         data     = CPPAD_TRACK_EXTEND(capacity, length, data);
    352                 }
    353423                size_t i;
     424                if( length_ + m > capacity_ )
     425                {       // store old capacity and data values
     426                        size_t old_capacity = capacity_;
     427                        Type*  old_data     = data_;
     428                        // set new capacity and data values
     429                        data_ = omp_alloc::create_array<Type>(length_ + m, capacity_);
     430                        // copy old data values
     431                        for(i = 0; i < length_; i++)
     432                                data_[i] = old_data[i];
     433                        // free old data
     434                        if( old_capacity > 0 )
     435                                omp_alloc::delete_array(old_data);
     436                }
    354437                for(i = 0; i < m; i++)
    355                         data[length++] = v[i];
    356                 CPPAD_ASSERT_UNKNOWN( length <= capacity );
     438                        data_[length_++] = v[i];
     439                CPPAD_ASSERT_UNKNOWN( length_ <= capacity_ );
    357440        }
    358441};
    359442
    360 // output operator
     443/// output a vector
    361444template <class Type>
    362445inline std::ostream& operator << (
    363         std::ostream              &os  ,
    364         const CppAD::vector<Type> &vec )
     446        /// stream to write the vector to
     447        std::ostream&              os  ,
     448        /// vector that is output
     449        const CppAD::vector<Type>& vec )
    365450{       size_t i = 0;
    366451        size_t n = vec.size();
     
    376461}
    377462
    378 /*
    379 --------------------------- vectorBool -------------------------------------
     463// ---------------------------------------------------------------------------
     464/*!
     465Class that is used to hold a non-constant element of a vector.
    380466*/
    381467class vectorBoolElement {
     468        /// the boolean data is packed with sizeof(UnitType) bits per value
    382469        typedef size_t UnitType;
    383470private:
    384         UnitType *unit;
    385         UnitType mask;
     471        /// pointer to the UnitType value holding this eleemnt
     472        UnitType* unit_;
     473        /// mask for the bit corresponding to this element
     474        /// (all zero except for bit that corresponds to this element)
     475        UnitType mask_;
    386476public:
    387         vectorBoolElement(UnitType *unit_, UnitType mask_)
    388         : unit(unit_) , mask(mask_)
     477        /// constructor from member values
     478        vectorBoolElement(
     479                /// unit for this element
     480                UnitType* unit ,
     481                /// mask for this element
     482                UnitType mask  )
     483        : unit_(unit) , mask_(mask)
    389484        { }
    390         vectorBoolElement(const vectorBoolElement &e)
    391         : unit(e.unit) , mask(e.mask)
     485        /// constuctor from another element
     486        vectorBoolElement(
     487                /// other element
     488                const vectorBoolElement& e )
     489        : unit_(e.unit_) , mask_(e.mask_)
    392490        { }
     491        /// conversion to a boolean value
    393492        operator bool() const
    394         {       return (*unit & mask) != 0; }
    395         vectorBoolElement& operator=(bool bit)
     493        {       return (*unit_ & mask_) != 0; }
     494        /// assignment of this element to a bool
     495        vectorBoolElement& operator=(
     496                /// right hand side for assignment
     497                bool bit
     498        )
    396499        {       if(bit)
    397                         *unit |= mask;
    398                 else    *unit &= ~mask;
     500                        *unit_ |= mask_;
     501                else    *unit_ &= ~mask_;
    399502                return *this;
    400503        }
    401         vectorBoolElement& operator=(const vectorBoolElement &e)
    402         {       if( *(e.unit) & e.mask )
    403                         *unit |= mask;
    404                 else    *unit &= ~mask;
     504        /// assignment of this element to another element
     505        vectorBoolElement& operator=(const vectorBoolElement& e)
     506        {       if( *(e.unit_) & e.mask_ )
     507                        *unit_ |= mask_;
     508                else    *unit_ &= ~mask_;
    405509                return *this;
    406510        }
     
    408512
    409513class vectorBool {
     514        /// the boolean data is packed with sizeof(UnitType) bits per value
    410515        typedef size_t UnitType;
    411516private:
    412         static const  size_t BitPerUnit
     517        /// number of bits packed into each UnitType value in data_
     518        static const  size_t bit_per_unit_
    413519                = std::numeric_limits<UnitType>::digits;
    414         size_t    nunit;
    415         size_t    length;
    416         UnitType *data;
     520        /// number of UnitType values in data_
     521        size_t    n_unit_;
     522        /// number of bits currently stored in this vector
     523        size_t    length_;
     524        /// pointer to where the bits are stored
     525        UnitType *data_;
     526
     527        /// minimum number of UnitType values that can store length_ bits
     528        /// (note that this is really a function of length_)
     529        size_t unit_min(void)
     530        {       if( length_ == 0 )
     531                        return 0;
     532                return (length_ - 1) / bit_per_unit_ + 1;
     533        }
    417534public:
    418         // type of the elements in the vector
     535        /// type corresponding to the elements of this vector
     536        /// (note that non-const elements actually use vectorBoolElement)
    419537        typedef bool value_type;
    420538
    421         // default constructor
    422         inline vectorBool(void) : nunit(0), length(0), data(CPPAD_NULL)
     539        /// default constructor (sets all member data to zero)
     540        inline vectorBool(void) : n_unit_(0), length_(0), data_(0)
    423541        { }
    424         // constructor with a specified size
    425         inline vectorBool(size_t n) : nunit(0), length(0), data(CPPAD_NULL)
    426         {       if( n == 0 )
    427                         data = CPPAD_NULL;
    428                 else
    429                 {       nunit    = (n - 1) / BitPerUnit + 1;
    430                         length   = n;
    431                         data     = CPPAD_TRACK_NEW_VEC(nunit, data);
    432                 }
    433         }
    434         // copy constructor
    435         inline vectorBool(const vectorBool &v)
    436         : nunit(v.nunit), length(v.length)
    437         {       size_t i;
    438                 data = CPPAD_NULL;
    439                 if( nunit > 0 )
    440                         data = CPPAD_TRACK_NEW_VEC(nunit, data);
    441 
    442                 for(i = 0; i < nunit; i++)
    443                         data[i] = v.data[i];
    444         }
    445         // destructor
     542        /// sizing constructor
     543        inline vectorBool(
     544                /// number of bits in this vector
     545                size_t n
     546        ) : n_unit_(0), length_(n), data_(0)
     547        {       if( length_ > 0 )
     548                {       // set n_unit and data
     549                        size_t min_unit = unit_min();
     550                        data_ = omp_alloc::create_array<UnitType>(min_unit, n_unit_);
     551                }
     552        }
     553        /// copy constructor
     554        inline vectorBool(
     555                /// the *this vector will be a copy of \c v
     556                const vectorBool& v
     557        ) : n_unit_(0), length_(v.length_), data_(0)
     558        {       if( length_ > 0 )
     559                {       // set n_unit and data
     560                        size_t min_unit = unit_min();
     561                        data_ = omp_alloc::create_array<UnitType>(min_unit, n_unit_);
     562
     563                        // copy values using UnitType assignment operator
     564                        CPPAD_ASSERT_UNKNOWN( min_unit <= v.n_unit_ );
     565                        size_t i;
     566                        for(i = 0; i < min_unit; i++)
     567                                data_[i] = v.data_[i];
     568                }
     569        }
     570        /// destructor
    446571        ~vectorBool(void)
    447         {       if( data != CPPAD_NULL )
    448                         CPPAD_TRACK_DEL_VEC(data);
    449         }
    450 
    451         // size function
     572        {       if( n_unit_ > 0 )
     573                        omp_alloc::delete_array(data_);
     574        }
     575
     576        /// number of elements in this vector
    452577        inline size_t size(void) const
    453         {       return length; }
    454 
    455         // resize function
    456         inline void resize(size_t n)
    457         {       length = n;
    458                 if( (nunit * BitPerUnit >= n) & (n > 0) )
     578        {       return length_; }
     579
     580        /// maximum number of elements current allocation can store
     581        inline size_t capacity(void) const
     582        {       return n_unit_ * bit_per_unit_; }
     583
     584
     585        /// change number of elements in this vector
     586        inline void resize(
     587                /// new number of elements for this vector, if zero
     588                /// make sure the memory is returned to omp_alloc.
     589                size_t n
     590        )
     591        {       length_ = n;
     592                // check if we can use the current memory
     593                size_t min_unit = unit_min();
     594                if( (n_unit_ >= min_unit) & (length_ > 0) )
    459595                        return;
    460                 if( data != CPPAD_NULL )
    461                         CPPAD_TRACK_DEL_VEC(data);
    462                 if( n == 0 )
    463                 {       nunit = 0;
    464                         data = CPPAD_NULL;
    465                 }
     596                // check if there is old memory to be freed
     597                if( n_unit_ > 0 )
     598                        omp_alloc::delete_array(data_);
     599                // check if we need new memory
     600                if( length_ == 0 )
     601                        n_unit_ = 0;
    466602                else
    467                 {       nunit    = (n - 1) / BitPerUnit + 1;
    468                         data     = CPPAD_TRACK_NEW_VEC(nunit, data);
    469                 }
    470         }
    471         // assignment operator
    472         inline vectorBool & operator=(const vectorBool &v)
     603                {       // get new memory and set n_unit
     604                        data_ = omp_alloc::create_array<UnitType>(min_unit, n_unit_);
     605                }
     606        }
     607        /// vector assignment operator
     608        inline vectorBool& operator=(
     609                /// right hand size of the assingment operation
     610                const vectorBool& v
     611        )
    473612        {       size_t i;
    474613                CPPAD_ASSERT_KNOWN(
    475                         length == v.length ,
    476                         "size miss match in assignment operation"
     614                        length_ == v.length_ ,
     615                        "vectorBool: size miss match in assignment operation"
    477616                );
    478                 CPPAD_ASSERT_UNKNOWN( nunit == v.nunit );
    479                 for(i = 0; i < nunit; i++)
    480                         data[i] = v.data[i];
     617                size_t min_unit = unit_min();
     618                CPPAD_ASSERT_UNKNOWN( min_unit <= n_unit_ );
     619                CPPAD_ASSERT_UNKNOWN( min_unit <= v.n_unit_ );
     620                for(i = 0; i < min_unit; i++)
     621                        data_[i] = v.data_[i];
    481622                return *this;
    482623        }
    483         // non-constant element access
    484         vectorBoolElement operator[](size_t k)
     624        /// non-constant element access; i.e., we can change this element value
     625        vectorBoolElement operator[](
     626                /// element index, must be less than length
     627                size_t k
     628        )
    485629        {       size_t i, j;
    486630                CPPAD_ASSERT_KNOWN(
    487                         k < length,
    488                         "vector index greater than or equal vector size"
     631                        k < length_,
     632                        "vectorBool: index greater than or equal vector size"
    489633                );
    490                 i    = k / BitPerUnit;
    491                 j    = k - i * BitPerUnit;
    492                 return vectorBoolElement(data + i , UnitType(1) << j );
    493         }
    494         // constant element access
     634                i    = k / bit_per_unit_;
     635                j    = k - i * bit_per_unit_;
     636                return vectorBoolElement(data_ + i , UnitType(1) << j );
     637        }
     638        /// constant element access; i.e., we cannot change this element value
    495639        bool operator[](size_t k) const
    496640        {       size_t i, j;
    497                 UnitType unit;
    498                 UnitType mask;
     641                UnitType unit, mask;
    499642                CPPAD_ASSERT_KNOWN(
    500                         k < length,
    501                         "vector index greater than or equal vector size"
     643                        k < length_,
     644                        "vectorBool: index greater than or equal vector size"
    502645                );
    503                 i    = k / BitPerUnit;
    504                 j    = k - i * BitPerUnit;
    505                 unit = data[i];
     646                i    = k / bit_per_unit_;
     647                j    = k - i * bit_per_unit_;
     648                unit = data_[i];
    506649                mask = UnitType(1) << j;
    507650                return (unit & mask) != 0;
    508651        }
    509         // add to the back of the array
    510         void push_back(bool bit)
    511         {       size_t i, j;
     652        /// add an element to the back of this vector
     653        void push_back(
     654                /// value of the element
     655                bool bit
     656        )
     657        {       CPPAD_ASSERT_UNKNOWN( unit_min() <= n_unit_ );
     658                size_t i, j;
    512659                UnitType mask;
    513                 CPPAD_ASSERT_UNKNOWN( length <= nunit * BitPerUnit );
    514                 if( length == nunit * BitPerUnit )
    515                 {       // allocate another unit
    516                         data = CPPAD_TRACK_EXTEND(nunit+1, nunit, data);
    517                         nunit++;
    518                 }
    519                 i    = length / BitPerUnit;
    520                 j    = length - i * BitPerUnit;
     660                if( length_ + 1 > n_unit_ * bit_per_unit_ )
     661                {       CPPAD_ASSERT_UNKNOWN( unit_min() == n_unit_ );
     662                        // store old n_unit and data values
     663                        size_t    old_n_unit = n_unit_;
     664                        UnitType* old_data   = data_;
     665                        // set new n_unit and data values
     666                        data_ = omp_alloc::create_array<UnitType>(n_unit_+1, n_unit_);
     667                        // copy old data values
     668                        for(i = 0; i < old_n_unit; i++)
     669                                data_[i] = old_data[i];
     670                        // free old data
     671                        if( old_n_unit > 0 )
     672                                omp_alloc::delete_array(old_data);
     673                }
     674                i    = length_ / bit_per_unit_;
     675                j    = length_ - i * bit_per_unit_;
    521676                mask = UnitType(1) << j;
    522677                if( bit )
    523                         data[i] |= mask;
    524                 else    data[i] &= ~mask;
    525                 length++;
    526         }
    527         // add vector to back of array
    528         void push_vector(const vectorBool &v)
    529         {       size_t i, j, k;
     678                        data_[i] |= mask;
     679                else    data_[i] &= ~mask;
     680                length_++;
     681        }
     682        /// add vector to the back of this vector
     683        template <class Vector>
     684        void push_vector(
     685                /// value of the vector that we are adding
     686                const Vector& v
     687        )
     688        {        CheckSimpleVector<bool, Vector>();
     689                size_t min_unit = unit_min();
     690                CPPAD_ASSERT_UNKNOWN( length_ <= n_unit_ * bit_per_unit_ );
     691                // some temporaries
     692                size_t i, j, k, ell;
    530693                UnitType mask;
    531694                bool bit;
    532                 CPPAD_ASSERT_UNKNOWN( length <= nunit * BitPerUnit );
    533                 CPPAD_ASSERT_UNKNOWN( v.length <= v.nunit * BitPerUnit );
    534                 if( length + v.length >= nunit * BitPerUnit )
    535                 {       // allocate enough space
    536                         data = CPPAD_TRACK_EXTEND(nunit+v.nunit, nunit, data);
    537                         nunit += v.nunit;
    538                 }
     695                // store old length
     696                size_t old_length = length_;
     697                // new length and minium number of units;
     698                length_    = length_ + v.size();
     699                min_unit   = unit_min();
     700                if( length_ >= n_unit_ * bit_per_unit_ )
     701                {       // store old n_unit and data value
     702                        size_t  old_n_unit = n_unit_;
     703                        UnitType* old_data = data_;
     704                        // set new n_unit and data values
     705                        data_ = omp_alloc::create_array<UnitType>(min_unit, n_unit_);
     706                        // copy old data values
     707                        for(i = 0; i < old_n_unit; i++)
     708                                data_[i] = old_data[i];
     709                        // free old data
     710                        if( old_n_unit > 0 )
     711                                omp_alloc::delete_array(old_data);
     712                }
     713                ell = old_length;
    539714                for(k = 0; k < v.size(); k++)
    540                 {       i    = length / BitPerUnit;
    541                         j    = length - i * BitPerUnit;
     715                {
     716                        i    = ell / bit_per_unit_;
     717                        j    = ell - i * bit_per_unit_;
    542718                        bit  = v[k];
    543719                        mask = UnitType(1) << j;
    544720                        if( bit )
    545                                 data[i] |= mask;
    546                         else    data[i] &= ~mask;
    547                         length++;
    548                 }
    549                 CPPAD_ASSERT_UNKNOWN( length <= nunit * BitPerUnit );
     721                                data_[i] |= mask;
     722                        else    data_[i] &= ~mask;
     723                        ell++;
     724                }
     725                CPPAD_ASSERT_UNKNOWN( length_ == ell );
     726                CPPAD_ASSERT_UNKNOWN( length_ <= n_unit_ * bit_per_unit_ );
    550727        }
    551728};
    552729
    553 // output operator
     730/// output a vector
    554731inline std::ostream& operator << (
    555         std::ostream     &os  ,
    556         const vectorBool &v   )
     732        /// steam to write the vector to
     733        std::ostream&      os  ,
     734        /// vector that is output
     735        const vectorBool&  v   )
    557736{       size_t i = 0;
    558737        size_t n = v.size();
     
    563742}
    564743
    565 } // END CppAD namespace
    566 
    567 
     744CPPAD_END_NAMESPACE
    568745# endif
  • trunk/cppad_ipopt/example/example.cpp

    r1635 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4242                return ok;
    4343        }
     44        // function that checks for memrory leaks after all the tests
     45        bool memory_leak(void)
     46        {       bool leak = false;
     47
     48                // dump the memory pool being held for this thread
     49                using CppAD::omp_alloc;
     50                size_t thread = omp_alloc::get_thread_num();
     51                omp_alloc::free_available(thread);
     52       
     53                leak |= CPPAD_TRACK_COUNT() != 0;
     54                leak |= omp_alloc::available(thread) != 0;
     55                leak |= omp_alloc::inuse(thread) != 0;
     56
     57                return leak;
     58        }
    4459}
    4560
     
    5772        using std::endl;
    5873        assert( ok || (Run_error_count > 0) );
    59         if( CPPAD_TRACK_COUNT() == 0 )
    60         {       Run_ok_count++;
    61                 cout << "Ok:    " << "No memory leak detected" << endl;
    62         }
    63         else
     74        if( memory_leak() )
    6475        {       ok = false;
    6576                Run_error_count++;
    6677                cout << "Error: " << "memory leak detected" << endl;
     78        }
     79        else
     80        {       Run_ok_count++;
     81                cout << "Ok:    " << "No memory leak detected" << endl;
    6782        }
    6883        // convert int(size_t) to avoid warning on _MSC_VER systems
  • trunk/cppad_ipopt/example/get_started.cpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/cppad_ipopt/example/ode_check.cpp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • trunk/cppad_ipopt/test/test_more.cpp

    r1640 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4343                return ok;
    4444        }
     45        // function that checks for memrory leaks after all the tests
     46        bool memory_leak(void)
     47        {       bool leak = false;
     48
     49                // dump the memory pool being held for this thread
     50                using CppAD::omp_alloc;
     51                size_t thread = omp_alloc::get_thread_num();
     52                omp_alloc::free_available(thread);
     53       
     54                leak |= CPPAD_TRACK_COUNT() != 0;
     55                leak |= omp_alloc::available(thread) != 0;
     56                leak |= omp_alloc::inuse(thread) != 0;
     57
     58                return leak;
     59        }
    4560}
    4661
     
    5974        using std::endl;
    6075        assert( ok || (Run_error_count > 0) );
    61         if( CPPAD_TRACK_COUNT() == 0 )
    62         {       Run_ok_count++;
    63                 cout << "Ok:    " << "No memory leak detected" << endl;
    64         }
    65         else
     76
     77        if( memory_leak() )
    6678        {       ok = false;
    6779                Run_error_count++;
    6880                cout << "Error: " << "memory leak detected" << endl;
     81        }
     82        else
     83        {       Run_ok_count++;
     84                cout << "Ok:    " << "No memory leak detected" << endl;
    6985        }
    7086        // convert int(size_t) to avoid warning on _MSC_VER systems
  • trunk/example/cppad_vector.cpp

    r1370 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    7777        ok &= (str == correct);
    7878
    79         // test of push_back scalar
     79        // test of push_back scalar and capacity
    8080        size_t i;
    8181        size_t N = 100;
    8282        x.resize(0);
    8383        for(i = 0; i < N; i++)
     84        {       size_t old_capacity = x.capacity();     
    8485                x.push_back( Type(i) );
    85         ok &= (x.size() == N);
     86                ok &= (i+1) == x.size();
     87                ok &= i < x.capacity();
     88                ok &= (i == old_capacity) || old_capacity == x.capacity();
     89        }
    8690        for(i = 0; i < N; i++)
    8791                ok &= ( x[i] == Type(i) );
  • trunk/example/example.cpp

    r1892 r1948  
    118118extern bool ode_taylor(void);
    119119extern bool ode_taylor_adolc(void);
     120extern bool omp_alloc(void);
    120121extern bool opt_val_hes(void);
    121122extern bool optimize(void);
     
    151152extern bool Tanh(void);
    152153extern bool TapeIndex(void);
    153 extern bool TrackNewDel(void);
    154154extern bool UnaryMinus(void);
    155155extern bool UnaryPlus(void);
     
    180180                }
    181181                return ok;
     182        }
     183        // function that checks for memrory leaks after all the tests
     184        bool memory_leak(void)
     185        {       bool leak = false;
     186
     187                // dump the memory pool being held for this thread
     188                using CppAD::omp_alloc;
     189                size_t thread = omp_alloc::get_thread_num();
     190                omp_alloc::free_available(thread);
     191       
     192                leak |= CPPAD_TRACK_COUNT() != 0;
     193                leak |= omp_alloc::available(thread) != 0;
     194                leak |= omp_alloc::inuse(thread) != 0;
     195
     196                return leak;
    182197        }
    183198}
     
    265280        ok &= Run( OdeStiff,          "OdeStiff"         );
    266281        ok &= Run( ode_taylor,        "ode_taylor"       );
     282        ok &= Run( omp_alloc,         "omp_alloc"        );
    267283        ok &= Run( opt_val_hes,       "opt_val_hes"      );
    268284        ok &= Run( optimize,          "optimize"         );
     
    298314        ok &= Run( Tanh,              "Tanh"             );
    299315        ok &= Run( TapeIndex,         "TapeIndex"        );
    300         ok &= Run( TrackNewDel,       "TrackNewDel"      );
    301316        ok &= Run( UnaryMinus,        "UnaryMinus"       );
    302317        ok &= Run( UnaryPlus,         "UnaryPlus"        );
     
    315330        using std::endl;
    316331        assert( ok || (Run_error_count > 0) );
    317         if( CPPAD_TRACK_COUNT() == 0 )
    318         {       Run_ok_count++;
    319                 cout << "Ok:    " << "No memory leak detected" << endl;
    320         }
    321         else
     332        if( memory_leak() )
    322333        {       ok = false;
    323334                Run_error_count++;
    324335                cout << "Error: " << "memory leak detected" << endl;
     336        }
     337        else
     338        {       Run_ok_count++;
     339                cout << "Ok:    " << "No memory leak detected" << endl;
    325340        }
    326341        // convert int(size_t) to avoid warning on _MSC_VER systems
  • trunk/example/makefile.am

    r1914 r1948  
    141141        ode_stiff.cpp \
    142142        ode_taylor.cpp \
     143        omp_alloc.cpp \
    143144        opt_val_hes.cpp \
    144145        optimize.cpp \
     
    174175        tanh.cpp \
    175176        tape_index.cpp \
    176         track_new_del.cpp \
    177177        unary_minus.cpp \
    178178        unary_plus.cpp \
  • trunk/example/makefile.in

    r1916 r1948  
    6565        numeric_type.cpp ode_err_control.cpp ode_err_maxabs.cpp \
    6666        ode_gear.cpp ode_gear_control.cpp ode_stiff.cpp ode_taylor.cpp \
    67         opt_val_hes.cpp optimize.cpp output.cpp par_var.cpp poly.cpp \
    68         pow.cpp pow_int.cpp reverse_any.cpp reverse_one.cpp \
    69         reverse_three.cpp reverse_two.cpp rev_one.cpp \
     67        omp_alloc.cpp opt_val_hes.cpp optimize.cpp output.cpp \
     68        par_var.cpp poly.cpp pow.cpp pow_int.cpp reverse_any.cpp \
     69        reverse_one.cpp reverse_three.cpp reverse_two.cpp rev_one.cpp \
    7070        rev_sparse_hes.cpp rev_sparse_jac.cpp rev_two.cpp \
    7171        romberg_mul.cpp romberg_one.cpp rosen_34.cpp runge_45_1.cpp \
     
    7373        sinh.cpp sparse_hessian.cpp sparse_jacobian.cpp sqrt.cpp \
    7474        stack_machine.cpp sub.cpp sub_eq.cpp tan.cpp tanh.cpp \
    75         tape_index.cpp track_new_del.cpp unary_minus.cpp \
    76         unary_plus.cpp value.cpp var_2par.cpp vec_ad.cpp
     75        tape_index.cpp unary_minus.cpp unary_plus.cpp value.cpp \
     76        var_2par.cpp vec_ad.cpp
    7777@CppAD_ADOLC_TRUE@am__objects_1 = mul_level_adolc.$(OBJEXT) \
    7878@CppAD_ADOLC_TRUE@      ode_taylor_adolc.$(OBJEXT)
     
    108108        ode_err_maxabs.$(OBJEXT) ode_gear.$(OBJEXT) \
    109109        ode_gear_control.$(OBJEXT) ode_stiff.$(OBJEXT) \
    110         ode_taylor.$(OBJEXT) opt_val_hes.$(OBJEXT) optimize.$(OBJEXT) \
    111         output.$(OBJEXT) par_var.$(OBJEXT) poly.$(OBJEXT) \
    112         pow.$(OBJEXT) pow_int.$(OBJEXT) reverse_any.$(OBJEXT) \
    113         reverse_one.$(OBJEXT) reverse_three.$(OBJEXT) \
    114         reverse_two.$(OBJEXT) rev_one.$(OBJEXT) \
    115         rev_sparse_hes.$(OBJEXT) rev_sparse_jac.$(OBJEXT) \
    116         rev_two.$(OBJEXT) romberg_mul.$(OBJEXT) romberg_one.$(OBJEXT) \
    117         rosen_34.$(OBJEXT) runge_45_1.$(OBJEXT) runge_45_2.$(OBJEXT) \
     110        ode_taylor.$(OBJEXT) omp_alloc.$(OBJEXT) opt_val_hes.$(OBJEXT) \
     111        optimize.$(OBJEXT) output.$(OBJEXT) par_var.$(OBJEXT) \
     112        poly.$(OBJEXT) pow.$(OBJEXT) pow_int.$(OBJEXT) \
     113        reverse_any.$(OBJEXT) reverse_one.$(OBJEXT) \
     114        reverse_three.$(OBJEXT) reverse_two.$(OBJEXT) \
     115        rev_one.$(OBJEXT) rev_sparse_hes.$(OBJEXT) \
     116        rev_sparse_jac.$(OBJEXT) rev_two.$(OBJEXT) \
     117        romberg_mul.$(OBJEXT) romberg_one.$(OBJEXT) rosen_34.$(OBJEXT) \
     118        runge_45_1.$(OBJEXT) runge_45_2.$(OBJEXT) \
    118119        seq_property.$(OBJEXT) simple_vector.$(OBJEXT) sin.$(OBJEXT) \
    119120        sinh.$(OBJEXT) sparse_hessian.$(OBJEXT) \
     
    121122        stack_machine.$(OBJEXT) sub.$(OBJEXT) sub_eq.$(OBJEXT) \
    122123        tan.$(OBJEXT) tanh.$(OBJEXT) tape_index.$(OBJEXT) \
    123         track_new_del.$(OBJEXT) unary_minus.$(OBJEXT) \
    124         unary_plus.$(OBJEXT) value.$(OBJEXT) var_2par.$(OBJEXT) \
    125         vec_ad.$(OBJEXT)
     124        unary_minus.$(OBJEXT) unary_plus.$(OBJEXT) value.$(OBJEXT) \
     125        var_2par.$(OBJEXT) vec_ad.$(OBJEXT)
    126126example_OBJECTS = $(am_example_OBJECTS)
    127127example_LDADD = $(LDADD)
     
    390390        ode_stiff.cpp \
    391391        ode_taylor.cpp \
     392        omp_alloc.cpp \
    392393        opt_val_hes.cpp \
    393394        optimize.cpp \
     
    423424        tanh.cpp \
    424425        tape_index.cpp \
    425         track_new_del.cpp \
    426426        unary_minus.cpp \
    427427        unary_plus.cpp \
     
    557557@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ode_taylor.Po@am__quote@
    558558@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ode_taylor_adolc.Po@am__quote@
     559@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/omp_alloc.Po@am__quote@
    559560@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/opt_val_hes.Po@am__quote@
    560561@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/optimize.Po@am__quote@
     
    590591@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tanh.Po@am__quote@
    591592@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tape_index.Po@am__quote@
    592 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/track_new_del.Po@am__quote@
    593593@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/unary_minus.Po@am__quote@
    594594@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/unary_plus.Po@am__quote@
  • trunk/example/mul_level_adolc.cpp

    r1697 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    4949$code AD< AD<double> >$$ and $code AD<double>$$.
    5050
    51 $head Tracking New and Delete$$
     51$head Memory Management$$
    5252Adolc uses raw memory arrays that depend on the number of
    53 dependent and independent variables, hence $code new$$ and $code delete$$
    54 are used to allocate this memory.
    55 The preprocessor macros
    56 $small
    57 $cref/CPPAD_TRACK_NEW_VEC/TrackNewDel/TrackNewVec/$$
    58 $$
    59 and
    60 $small
    61 $cref/CPPAD_TRACK_DEL_VEC/TrackNewDel/TrackDelVec/$$
    62 $$
    63 are used to check for errors in the
    64 use of $code new$$ and $code delete$$ when the example is compiled for
    65 debugging (when $code NDEBUG$$ is not defined).
    66 
     53dependent and independent variables.
     54The memory management utility $cref/omp_alloc/$$
     55is used to manage this memory allocation.
    6756
    6857$head Configuration Requirement$$
     
    10493
    10594bool mul_level_adolc(void)
    106 {       bool ok = true;                         // initialize test result
     95{       bool ok = true;                // initialize test result
     96        using CppAD::omp_alloc;        // The CppAD memory allocator
    10797
    10898        typedef adouble             ADdouble;  // for first level of taping
     
    154144        // compute the d/dx of f'(x) * v = f''(x) * v
    155145        size_t m      = 1;                     // # dependent in f'(x) * v
    156         double *w = 0, *dw = 0;
    157         w     = CPPAD_TRACK_NEW_VEC(m, w);     // track w  = new double[m]
    158         dw    = CPPAD_TRACK_NEW_VEC(n, dw);    // track dw = new double[n]
     146
     147        // w = new double[capacity] where capacity >= m
     148        size_t capacity;
     149        double* w  = omp_alloc::create_array<double>(m, capacity);
     150        // w = new double[capacity] where capacity >= n
     151        double* dw = omp_alloc::create_array<double>(n, capacity);
     152
    159153        w[0]  = 1.;
    160154        fos_reverse(tag, int(m), int(n), w, dw);
     
    165159        }
    166160
    167         CPPAD_TRACK_DEL_VEC(w);                 // check usage of delete
    168         CPPAD_TRACK_DEL_VEC(dw);
     161        // make memory avaialble for other use by this thread
     162        omp_alloc::delete_array(w);
     163        omp_alloc::delete_array(dw);
    169164        return ok;
    170165}
  • trunk/example/ode_taylor_adolc.cpp

    r1613 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    150150is $code adolc$$.
    151151
    152 
    153 $head Tracking New and Delete$$
     152$head Memory Management$$
    154153Adolc uses raw memory arrays that depend on the number of
    155 dependent and independent variables, hence $code new$$ and $code delete$$
    156 are used to allocate this memory.
    157 The preprocessor macros
    158 $small
    159 $cref/CPPAD_TRACK_NEW_VEC/TrackNewDel/TrackNewVec/$$
    160 $$
    161 and
    162 $small
    163 $cref/CPPAD_TRACK_DEL_VEC/TrackNewDel/TrackDelVec/$$
    164 $$
    165 are used to check for errors in the
    166 use of $code new$$ and $code delete$$ when the example is compiled for
    167 debugging (when $code NDEBUG$$ is not defined).
     154dependent and independent variables.
     155The memory management utility $cref/omp_alloc/$$
     156is used to manage this memory allocation.
    168157
    169158$head Configuration Requirement$$
     
    295284        size_t i, j;
    296285
    297         // parameter vector in both double and ADdouble
    298         double *x = 0;
    299         x = CPPAD_TRACK_NEW_VEC(n, x);  // track x = new double[n];
     286        // set up for omp_alloc memory allocator
     287        using CppAD::omp_alloc; // the allocator
     288        size_t capacity;        // capacity of an allocation
     289
     290        // the vector x with lenght n (or greater) in double
     291        double* x = omp_alloc::create_array<double>(n, capacity);
     292        // the vector x with lenght n in ADouble
    300293        CPPAD_TEST_VECTOR<ADdouble> X(n);
    301294        for(i = 0; i < n; i++)
     
    325318        // declare the differentiable fucntion f : A -> Y_FINAL
    326319        // (corresponding to the tape of adouble operations)
    327         double *y_final= 0;
    328         y_final = CPPAD_TRACK_NEW_VEC(n, y_final); // y_final= new double[m]
     320        double* y_final = omp_alloc::create_array<double>(n, capacity);
    329321        for(i = 0; i < n; i++)
    330322                Y_FINAL[i] >>= y_final[i];
     
    340332
    341333        // memory where Jacobian will be returned
    342         double *jac_= 0;
    343         jac_ = CPPAD_TRACK_NEW_VEC(n * n, jac_); // jac_ = new double[n*n]
    344         double **jac = 0;
    345         jac  = CPPAD_TRACK_NEW_VEC(n, jac);      // jac = new (*double)[n]
     334        double* jac_ = omp_alloc::create_array<double>(n * n, capacity);
     335        double** jac = omp_alloc::create_array<double*>(n, capacity);
    346336        for(i = 0; i < n; i++)
    347337                jac[i] = jac_ + i * n;
     
    361351        }
    362352
    363         CPPAD_TRACK_DEL_VEC(x);        // check usage of delete
    364         CPPAD_TRACK_DEL_VEC(y_final);
    365         CPPAD_TRACK_DEL_VEC(jac_);
    366         CPPAD_TRACK_DEL_VEC(jac);
     353        // make memroy avaiable for other use by this thread
     354        omp_alloc::delete_array(x);
     355        omp_alloc::delete_array(y_final);
     356        omp_alloc::delete_array(jac_);
     357        omp_alloc::delete_array(jac);
    367358        return ok;
    368359}
  • trunk/makefile.am

    r1914 r1948  
    192192        cppad/local/par_var.hpp \
    193193        cppad/local/player.hpp \
     194        cppad/local/pod_vector.hpp \
    194195        cppad/local/pow.hpp \
    195196        cppad/local/pow_op.hpp \
     
    239240        cppad/ode_gear_control.hpp \
    240241        cppad/ode_gear.hpp \
     242        cppad/omp_alloc.hpp \
    241243        cppad/poly.hpp \
    242244        cppad/pow_int.hpp \
  • trunk/makefile.in

    r1916 r1948  
    433433        cppad/local/par_var.hpp \
    434434        cppad/local/player.hpp \
     435        cppad/local/pod_vector.hpp \
    435436        cppad/local/pow.hpp \
    436437        cppad/local/pow_op.hpp \
     
    480481        cppad/ode_gear_control.hpp \
    481482        cppad/ode_gear.hpp \
     483        cppad/omp_alloc.hpp \
    482484        cppad/poly.hpp \
    483485        cppad/pow_int.hpp \
  • trunk/omh/example_list.omh

    r1892 r1948  
    170170$rref ode_taylor.cpp$$
    171171$rref ode_taylor_adolc.cpp$$
     172$rref omp_alloc.cpp$$
    172173$rref opt_val_hes.cpp$$
    173174$rref optimize.cpp$$
     
    207208$rref Tanh.cpp$$
    208209$rref TapeIndex.cpp$$
    209 $rref TrackNewDel.cpp$$
    210210$rref UnaryMinus.cpp$$
    211211$rref UnaryPlus.cpp$$
  • trunk/omh/library.omh

    r1643 r1948  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    5353        cppad/std_math_unary.hpp%
    5454        cppad/vector.hpp%
     55        omh/omp_alloc.omh%
     56
    5557        cppad/track_new_del.hpp
    5658%$$
     
    117119$rref std_math_unary$$
    118120$rref CppAD_vector$$
    119 $rref TrackNewDel$$
     121$rref omp_alloc$$
    120122$tend
    121123
     124$head Deprecated Library routines$$
     125The memory management routine $cref/TrackNewDel/$$ has been deprecated,
     126use $cref/omp_alloc/$$ instead.
     127
    122128$end
  • trunk/omh/seq_property.omh

    r1598 r1948  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    218218            + %f%.size_VecAD()  * sizeof(size_t)
    219219%$$
     220Note that this is the minimal amount of memory that can hold
     221the information corresponding to an operation sequence.
     222The actual amount of memory allocated ($cref/inuse/$$)
     223for the operations sequence may be larger.
    220224
    221225$head Example$$
  • trunk/omh/simple_vector.omh

    r1475 r1948  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2929
    3030$head Template Class Requirements$$
    31 A simple vector template class $italic SimpleVector$$,
     31A simple vector template class $icode SimpleVector$$,
    3232is any template class
    3333that satisfies the requirements below.
     
    3636$bold Name$$ $cnext $bold Documentation$$   $rnext
    3737$code std::vector$$      $cnext Section 16.3 of
    38 $xref/Bib/The C++ Programming Language/The C++ Programming Language/$$
     38$cref/The C++ Programming Language/Bib/The C++ Programming Language/$$
    3939$rnext
    4040$code std::valarray$$    $cnext Section 22.4 of 
    41 $xref/Bib/The C++ Programming Language/The C++ Programming Language/$$
     41$cref/The C++ Programming Language/Bib/The C++ Programming Language/$$
    4242$rnext
    4343$code CppAD::vector$$    $cnext $tref CppAD_vector$$
     
    4545
    4646$head Elements of Specified Type$$
    47 A simple vector class with elements of type $italic Scalar$$,
     47A simple vector class with elements of type $icode Scalar$$,
    4848is any class that satisfies the requirements for a class of the form
    49 $syntax%
     49$codei%
    5050        %SimpleVector%<%Scalar%>
    5151%$$
    52 The routine $xref/CheckSimpleVector/$$ can be used to check
     52The routine $cref/CheckSimpleVector/$$ can be used to check
    5353that a class is a simple vector class with a specified element type.
    5454
     
    5757$index constructor, vector default$$
    5858The syntax
    59 $syntax%
     59$codei%
    6060        %SimpleVector%<%Scalar%> %x%;
    6161%$$
    62 creates an empty vector $italic x$$ ($syntax%%x%.size()%$$ is zero)
     62creates an empty vector $icode x$$ ($icode%x%.size()%$$ is zero)
    6363that can later contain elements of the specified type
    64 (see $xref/SimpleVector/Resize/resize/$$ below).
     64(see $cref/resize/SimpleVector/Resize/$$ below).
    6565
    6666$head Sizing Constructor$$
    6767$index size, vector constructor$$
    6868$index constructor, size vector$$
    69 If $italic n$$ has type $code size_t$$,
    70 $syntax%
     69If $icode n$$ has type $code size_t$$,
     70$codei%
    7171        %SimpleVector%<%Scalar%> %x%(%n%)
    7272%$$
    73 creates a vector $italic x$$ with $italic n$$ elements
     73creates a vector $icode x$$ with $italic n$$ elements
    7474each of the specified type.
    7575
     
    7777$index copy, vector constructor$$
    7878$index constructor, copy vector$$
    79 If $italic x$$ is a $syntax%%SimpleVector%<%Scalar%>%$$ object,
    80 $syntax%
     79If $icode x$$ is a $icode%SimpleVector%<%Scalar%>%$$ object,
     80$codei%
    8181        %SimpleVector%<%Scalar%> %y%(%x%)
    8282%$$
    8383creates a vector with the same type and number of elements
    84 as $italic x$$.
    85 The $italic Scalar$$ assignment operator ( $code =$$ )
    86 is used to set each element of $italic y$$
    87 equal to the corresponding element of $italic x$$.
     84as $icode x$$.
     85The $icode Scalar$$ assignment operator ( $code =$$ )
     86is used to set each element of $icode y$$
     87equal to the corresponding element of $icode x$$.
    8888This is a `deep copy' in that the values of the elements
    89 of $italic x$$ and $italic y$$ can be set independently after the copy.
    90 The argument $italic x$$ is passed by reference
     89of $icode x$$ and $italic y$$ can be set independently after the copy.
     90The argument $icode x$$ is passed by reference
    9191and may be $code const$$.
    9292
     
    9494$index constructor, element$$
    9595$index destructor, element$$
    96 The constructor for every element in a vector is called
    97 when the vector element is created and
    98 the corresponding destructor is called when it is removed
     96The default constructor for type $icode Scalar$$ is called
     97for every element in a vector when the vector element is created.
     98The $icode Scalar$$ destructor is called when it is removed
    9999from the vector (this includes when the vector is destroyed).
    100 
    101100
    102101$head Assignment$$
    103102$index assignment, vector$$
    104 If $italic x$$ and $italic y$$ are
    105 $syntax%%SimpleVector%<%Scalar%>%$$ objects,
    106 $syntax%
     103If $icode x$$ and $italic y$$ are
     104$icode%SimpleVector%<%Scalar%>%$$ objects,
     105$codei%
    107106        %y% = %x%
    108107%$$
    109 uses the $italic Scalar$$ assignment operator ( $code =$$ )
    110 to set each element of $italic y$$ equal to
    111 the corresponding element of $italic x$$.
     108uses the $icode Scalar$$ assignment operator ( $code =$$ )
     109to set each element of $icode y$$ equal to
     110the corresponding element of $icode x$$.
    112111This is a `deep assignment' in that the values of the elements
    113 of $italic x$$ and $italic y$$ can be set independently after the assignment.
    114 The vectors $italic x$$ and $italic y$$ must have
     112of $icode x$$ and $italic y$$ can be set independently after the assignment.
     113The vectors $icode x$$ and $italic y$$ must have
    115114the same number of elements.
    116 The argument $italic x$$ is passed by reference
     115The argument $icode x$$ is passed by reference
    117116and may be $code const$$.
    118117$pre
     
    121120The type returned by this assignment is unspecified; for example,
    122121it might be void in which case the syntax
    123 $syntax%
     122$codei%
    124123        %z% = %y% = %x%
    125124%$$
     
    128127$head Size$$
    129128$index size, vector$$
    130 If $italic x$$ is a $syntax%%SimpleVector%<%Scalar%>%$$ object
     129If $icode x$$ is a $icode%SimpleVector%<%Scalar%>%$$ object
    131130and $code n$$ has type $code size_t$$,
    132 $syntax%
     131$codei%
    133132        %n% = %x%.size()
    134133%$$
    135 sets $italic n$$ to the number of elements in the vector $italic x$$.
    136 The object $italic x$$ may be $code const$$.
     134sets $icode n$$ to the number of elements in the vector $italic x$$.
     135The object $icode x$$ may be $code const$$.
    137136
    138137$head Resize$$
    139138$index resize, vector$$
    140 If $italic x$$ is a $syntax%%SimpleVector%<%Scalar%>%$$ object
     139If $icode x$$ is a $icode%SimpleVector%<%Scalar%>%$$ object
    141140and $code n$$ has type $code size_t$$,
    142 $syntax%
     141$codei%
    143142        %x%.resize(%n%)
    144143%$$
    145 changes the number of elements contained in the vector $italic x$$
    146 to be $italic n$$.
    147 The value of the elements of $italic x$$
     144changes the number of elements contained in the vector $icode x$$
     145to be $icode n$$.
     146The value of the elements of $icode x$$
    148147are not specified after this operation; i.e.,
    149 any values previously stored in $italic x$$ are lost.
    150 (The object $italic x$$ can not be $code const$$.)
     148any values previously stored in $icode x$$ are lost.
     149(The object $icode x$$ can not be $code const$$.)
    151150
    152151$head Value Type$$
    153152$index value_type, vector$$
    154 If $italic Vector$$ is any simple vector class,
     153If $icode Vector$$ is any simple vector class,
    155154the syntax
    156 $syntax%
     155$codei%
    157156        %Vector%::value_type
    158157%$$
    159158is the type of the elements corresponding to the vector class; i.e.,
    160 $syntax%
     159$codei%
    161160        %SimpleVector%<%Scalar%>::value_type
    162161%$$
    163 is equal to $italic Scalar$$.
     162is equal to $icode Scalar$$.
    164163
    165164$head Element Access$$
    166165$index [], vector$$
    167 If $italic x$$ is a $syntax%%SimpleVector%<%Scalar%>%$$ object
    168 and $italic i$$ has type $code size_t$$,
    169 $syntax%
     166If $icode x$$ is a $icode%SimpleVector%<%Scalar%>%$$ object
     167and $icode i$$ has type $code size_t$$,
     168$codei%
    170169        %x%[%i%]
    171170%$$
    172171returns an object of an unspecified type,
    173 referred to here as $italic elementType$$.
     172referred to here as $icode elementType$$.
    174173
    175174$subhead Using Value$$
    176 If $italic elementType$$ is not the same as $italic Scalar$$,
     175If $icode elementType$$ is not the same as $italic Scalar$$,
    177176the conversion operator
    178 $syntax%
     177$codei%
    179178        static_cast<%Scalar%>(%x%[%i%])
    180179%$$
    181 is used implicitly when $syntax%%x%[%i%]%$$ is used in an expression
    182 with values of type $italic Scalar$$.
    183 For this type of usage, the object $italic x$$ may be $code const$$.
     180is used implicitly when $icode%x%[%i%]%$$ is used in an expression
     181with values of type $icode Scalar$$.
     182For this type of usage, the object $icode x$$ may be $code const$$.
    184183
    185184$subhead Assignment$$
    186 If $italic y$$ is an object of type $italic Scalar$$,
    187 $syntax%
     185If $icode y$$ is an object of type $italic Scalar$$,
     186$codei%
    188187        %x%[%i%] = %y%
    189188%$$
    190 assigns the $th i$$ element of $italic x$$ to have value $italic y$$.
    191 For this type of usage, the object $italic x$$ can not be $code const$$.
     189assigns the $th i$$ element of $icode x$$ to have value $italic y$$.
     190For this type of usage, the object $icode x$$ can not be $code const$$.
    192191The type returned by this assignment is unspecified; for example,
    193192it might be void in which case the syntax
    194 $syntax%
     193$codei%
    195194        %z% = %x%[%i%] = %y%
    196195%$$
     
    202201%$$
    203202The file
    204 $xref/SimpleVector.cpp/$$
     203$cref/SimpleVector.cpp/$$
    205204contains an example and test of a Simple template class.
    206205It returns true if it succeeds and false otherwise.
     
    210209$index exercise, simple vector$$
    211210$list number$$
    212 If $italic Vector$$ is a simple vector template class,
     211If $icode Vector$$ is a simple vector template class,
    213212the following code may not be valid:
    214 $syntax%
     213$codei%
    215214        %Vector%<double> x(2);
    216215        x[2] = 1.;
    217216%$$
    218217Create and run a program that executes the code segment
    219 above where $italic Vector$$ is each of the following cases:
     218above where $icode Vector$$ is each of the following cases:
    220219$code std::vector$$,
    221220$code CppAD::vector$$.
     
    224223$code -DNDEBUG$$ is and is not present on the compilation command line.
    225224$lnext
    226 If $italic Vector$$ is a simple vector template class,
     225If $icode Vector$$ is a simple vector template class,
    227226the following code may not be valid:
    228 $syntax%
     227$codei%
    229228        %Vector%<int> x(2);
    230229        %Vector%<int> y(1);
     
    234233%$$
    235234Create and run a program that executes the code segment
    236 above where $italic Vector$$ is each of the following cases:
     235above where $icode Vector$$ is each of the following cases:
    237236$code std::valarray$$,
    238237$code CppAD::vector$$.
  • trunk/omh/whats_new_11.omh

    r1917 r1948  
    1313$begin whats_new_11$$
    1414$spell
     15        vec
     16        Bool
     17        op
     18        omp_alloc
    1519        isnan
    1620        gcc
     
    4448assist you in learning about changes between various versions of CppAD.
    4549
     50$head 05-22$$
     51$list number$$
     52The old memory tracking routines $cref/TrackNewDel/$$ have been deprecated.
     53Their use should be replaced using the $cref/omp_alloc/$$
     54a memory allocator which is designed to work well in a multi-threading OpenMP
     55environment; see $cref/purpose/omp_alloc/Purpose/$$.
     56$lnext
     57The replacement of $code TrackNewDel$$ by $code omp_alloc$$
     58has been throughout the CppAD source code, including the examples
     59that used $code TrackNewDel$$; namely,
     60$cref/mul_level_adolc.cpp/$$, $cref/ode_taylor_adolc.cpp/$$.
     61$lnext
     62The CppAD vector template class
     63and the $cref/vectorBool/CppAD_vector/vectorBool/$$ class
     64were modified to use the $code omp_alloc$$
     65$cref/memory/CppAD_vector/Memory/$$ manager.
     66This should improves its speed of memory allocation
     67$cref/in_parallel/$$ sections of a program.
     68$lnext
     69The $cref/speed_test/$$ argument
     70$cref/size_vec/speed_test/size_vec/$$ call was by value,
     71instead of by reference (as documented).
     72This has been fixed and the call is now by reference.
     73$lnext
     74The $cref/capacity/CppAD_vector/capacity/$$ function has been added
     75to the CppAD vector class.
     76$lnext
     77The simple vector
     78$cref/
     79        element constructor and destructor/
     80        SimpleVector/
     81        Element Constructor and Destructor
     82/$$
     83description has been changed to explicitly specify that the
     84default constructor is used to initialize elements of the array.
     85$lnext
     86The $cref/size_op_seq/seq_property/size_op_seq/$$ documentation
     87has been improved to mention that the allocated memory may be larger.
     88$lend
     89
    4690$head 05-11$$
    4791$list number$$
  • trunk/openmp/multi_newton.cpp

    r1910 r1948  
    115115        size_t n_zero; // number of zeros of f(x) in the total interval
    116116        bool   use_ad; // compute derivatives using AD
     117
     118        // function that checks for memrory leaks after all the tests
     119        bool memory_leak(void)
     120        {       bool leak = false;
     121
     122                // dump the memory pool being held for this thread
     123                using CppAD::omp_alloc;
     124                size_t thread = omp_alloc::get_thread_num();
     125                omp_alloc::free_available(thread);
     126       
     127                leak |= CPPAD_TRACK_COUNT() != 0;
     128                leak |= omp_alloc::available(thread) != 0;
     129                leak |= omp_alloc::inuse(thread) != 0;
     130
     131                return leak;
     132        }
     133
    117134}
    118135
     
    319336        }
    320337        // check all the threads for a CppAD memory leak
    321         if( CPPAD_TRACK_COUNT() != 0 )
     338        if( memory_leak() )
    322339        {       ok = false;
    323340                cout << "Error: memory leak detected" << endl;
  • trunk/openmp/sum_i_inv.cpp

    r1910 r1948  
    8383namespace { // empty namespace
    8484        int n_thread;
     85
     86        // function that checks for memrory leaks after all the tests
     87        bool memory_leak(void)
     88        {       bool leak = false;
     89
     90                // dump the memory pool being held for this thread
     91                using CppAD::omp_alloc;
     92                size_t thread = omp_alloc::get_thread_num();
     93                omp_alloc::free_available(thread);
     94       
     95                leak |= CPPAD_TRACK_COUNT() != 0;
     96                leak |= omp_alloc::available(thread) != 0;
     97                leak |= omp_alloc::inuse(thread) != 0;
     98
     99                return leak;
     100        }
    85101}
    86102
     
    242258        }
    243259        // check all the threads for a CppAD memory leak
    244         if( CPPAD_TRACK_COUNT() != 0 )
     260        if( memory_leak() )
    245261        {       ok = false;
    246262                cout << "Error: memory leak detected" << endl;
  • trunk/speed/adolc/det_lu.cpp

    r1369 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1313$begin adolc_det_lu.cpp$$
    1414$spell
     15        omp_alloc
    1516        cppad
    1617        fos
     
    4344# include <cppad/speed/det_by_lu.hpp>
    4445# include <cppad/speed/uniform_01.hpp>
     46# include <cppad/track_new_del.hpp>
    4547
    4648# include <adolc/adouble.h>
     
    6365        int j;                // temporary index
    6466
     67        // set up for omp_alloc memory allocator (fast and checks for leaks)
     68        using CppAD::omp_alloc; // the allocator
     69        size_t capacity;        // capacity of an allocation
     70
    6571        // object for computing determinant
    6672        typedef adouble    ADScalar;
     
    7278
    7379        // AD version of matrix
    74         ADVector   A = 0;
    75         A            = CPPAD_TRACK_NEW_VEC(n, A);
     80        ADVector A  = omp_alloc::create_array<ADScalar>(n, capacity);
    7681       
    7782        // vectors of reverse mode weights
    78         double *u = 0;
    79         u         = CPPAD_TRACK_NEW_VEC(m, u);
     83        double* u   = omp_alloc::create_array<double>(m, capacity);
    8084        u[0] = 1.;
    8185
    8286        // vector with matrix value
    83         double *mat = 0;
    84         mat         = CPPAD_TRACK_NEW_VEC(n, mat);
     87        double* mat  = omp_alloc::create_array<double>(n, capacity);
    8588
    8689        // vector to receive gradient result
    87         double *grad = 0;
    88         grad         = CPPAD_TRACK_NEW_VEC(n, grad);
     90        double* grad = omp_alloc::create_array<double>(n, capacity);
    8991        // ------------------------------------------------------
    9092        while(repeat--)
     
    115117        }
    116118        // tear down
    117         CPPAD_TRACK_DEL_VEC(grad);
    118         CPPAD_TRACK_DEL_VEC(mat);
    119         CPPAD_TRACK_DEL_VEC(u);
    120         CPPAD_TRACK_DEL_VEC(A);
     119        omp_alloc::delete_array(grad);
     120        omp_alloc::delete_array(mat);
     121        omp_alloc::delete_array(u);
     122        omp_alloc::delete_array(A);
    121123
    122124        return true;
  • trunk/speed/adolc/det_minor.cpp

    r1497 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1313$begin adolc_det_minor.cpp$$
    1414$spell
     15        omp_alloc
    1516        retape
    1617        cppad
     
    4243# include <cppad/speed/det_by_minor.hpp>
    4344# include <cppad/speed/uniform_01.hpp>
     45# include <cppad/track_new_del.hpp>
    4446
    4547# include <adolc/adouble.h>
     
    6264        int j;                // temporary index
    6365
     66        // set up for omp_alloc memory allocator (fast and checks for leaks)
     67        using CppAD::omp_alloc; // the allocator
     68        size_t capacity;        // capacity of an allocation
     69
    6470        // object for computing determinant
    6571        typedef adouble    ADScalar;
     
    7177
    7278        // AD version of matrix
    73         ADVector   A = 0;
    74         A            = CPPAD_TRACK_NEW_VEC(n, A);
     79        ADVector A  = omp_alloc::create_array<ADScalar>(n, capacity);
    7580       
    7681        // vectors of reverse mode weights
    77         double *u = 0;
    78         u         = CPPAD_TRACK_NEW_VEC(m, u);
     82        double* u   = omp_alloc::create_array<double>(m, capacity);
    7983        u[0] = 1.;
    8084
    8185        // vector with matrix value
    82         double *mat = 0;
    83         mat         = CPPAD_TRACK_NEW_VEC(n, mat);
     86        double* mat  = omp_alloc::create_array<double>(n, capacity);
    8487
    8588        // vector to receive gradient result
    86         double *grad = 0;
    87         grad         = CPPAD_TRACK_NEW_VEC(n, grad);
    88 
     89        double* grad = omp_alloc::create_array<double>(n, capacity);
    8990
    9091        extern bool global_retape;
     
    151152
    152153        // tear down
    153         CPPAD_TRACK_DEL_VEC(grad);
    154         CPPAD_TRACK_DEL_VEC(mat);
    155         CPPAD_TRACK_DEL_VEC(u);
    156         CPPAD_TRACK_DEL_VEC(A);
     154        omp_alloc::delete_array(grad);
     155        omp_alloc::delete_array(mat);
     156        omp_alloc::delete_array(u);
     157        omp_alloc::delete_array(A);
    157158        return true;
    158159}
  • trunk/speed/adolc/poly.cpp

    r1497 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1313$begin adolc_poly.cpp$$
    1414$spell
     15        omp_alloc
    1516        retape
    1617        coef
     
    4849# include <cppad/poly.hpp>
    4950# include <cppad/vector.hpp>
     51# include <cppad/track_new_del.hpp>
    5052
    5153# include <adolc/adouble.h>
     
    7072        int i;         // temporary index
    7173
     74        // set up for omp_alloc memory allocator (fast and checks for leaks)
     75        using CppAD::omp_alloc; // the allocator
     76        size_t capacity;        // capacity of an allocation
     77
    7278        // choose a vector of polynomial coefficients
    7379        CppAD::uniform_01(size, a);
     
    8288
    8389        // allocate arguments to hos_forward
    84         double *x0 = 0;
    85         x0         = CPPAD_TRACK_NEW_VEC(n, x0);
    86         double *y0 = 0;
    87         y0         = CPPAD_TRACK_NEW_VEC(m, y0);
    88         double **x = 0;
    89         x          = CPPAD_TRACK_NEW_VEC(n, x);
    90         double **y = 0;
    91         y          = CPPAD_TRACK_NEW_VEC(m, y);
     90        double* x0 = omp_alloc::create_array<double>(n, capacity);
     91        double* y0 = omp_alloc::create_array<double>(m, capacity);
     92        double** x = omp_alloc::create_array<double*>(n, capacity);
     93        double** y = omp_alloc::create_array<double*>(m, capacity);
    9294        for(i = 0; i < n; i++)
    93         {       x[i] = 0;
    94                 x[i] = CPPAD_TRACK_NEW_VEC(d, x[i]);
    95         }
     95                x[i] = omp_alloc::create_array<double>(d, capacity);
    9696        for(i = 0; i < m; i++)
    97         {       y[i] = 0;
    98                 y[i] = CPPAD_TRACK_NEW_VEC(d, y[i]);
    99         }
     97                y[i] = omp_alloc::create_array<double>(d, capacity);
     98
    10099        // Taylor coefficient for argument
    101100        x[0][0] = 1.;  // first order
     
    158157        // ------------------------------------------------------
    159158        // tear down
    160         CPPAD_TRACK_DEL_VEC(x0);
    161         CPPAD_TRACK_DEL_VEC(y0);
     159        omp_alloc::delete_array(x0);
     160        omp_alloc::delete_array(y0);
    162161        for(i = 0; i < n; i++)
    163                 CPPAD_TRACK_DEL_VEC(x[i]);
     162                omp_alloc::delete_array(x[i]);
    164163        for(i = 0; i < m; i++)
    165                 CPPAD_TRACK_DEL_VEC(y[i]);
    166         CPPAD_TRACK_DEL_VEC(x);
    167         CPPAD_TRACK_DEL_VEC(y);
     164                omp_alloc::delete_array(y[i]);
     165        omp_alloc::delete_array(x);
     166        omp_alloc::delete_array(y);
    168167
    169168        return true;
  • trunk/speed/adolc/sparse_hessian.cpp

    r1497 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1313$begin adolc_sparse_hessian.cpp$$
    1414$spell
     15        omp_alloc
    1516        arg
    1617        cppad
     
    6970        double f;                 // function value
    7071
     72        // set up for omp_alloc memory allocator (fast and checks for leaks)
     73        using CppAD::omp_alloc; // the allocator
     74        size_t capacity;        // capacity of an allocation
     75
    7176        typedef CppAD::vector<double>  DblVector;
    7277        typedef CppAD::vector<adouble> ADVector;
     
    7479
    7580        ADVector   X(n);    // AD domain space vector
    76         double       *x;    // double domain space vector
    77         double      **H;    // Hessian
    7881        ADVector   Y(1);    // AD range space value
    7982        DblVector tmp(2 * ell);       // double temporary vector
    8083
    81         x = 0;
    82         x = CPPAD_TRACK_NEW_VEC(n, x);
    83         H = 0;
    84         H = CPPAD_TRACK_NEW_VEC(n, H);
     84        // double version of domain space vector
     85        double* x  = omp_alloc::create_array<double>(n, capacity);
     86        // Hessian as computed by adolc
     87        double** H = omp_alloc::create_array<double*>(n, capacity);
    8588        for(k = 0; k < n; k++)
    86         {       H[k] = 0;
    87                 H[k] = CPPAD_TRACK_NEW_VEC(n, H[k]);
    88         }
     89                H[k] = omp_alloc::create_array<double>(n, capacity);
    8990
    9091        // choose a value for x
     
    126127                        h[ m * n + k] = H[k][m];
    127128                }
    128                 CPPAD_TRACK_DEL_VEC(H[k]);
     129                omp_alloc::delete_array(H[k]);
    129130        }
    130         CPPAD_TRACK_DEL_VEC(H);
    131         CPPAD_TRACK_DEL_VEC(x);
     131        omp_alloc::delete_array(H);
     132        omp_alloc::delete_array(x);
    132133        return true;
    133134}
  • trunk/speed/main.cpp

    r1890 r1948  
    2222# include <cppad/speed/uniform_01.hpp>
    2323# include <cppad/poly.hpp>
     24# include <cppad/track_new_del.hpp>
     25# include <cppad/omp_alloc.hpp>
    2426
    2527# ifdef SPEED_ADOLC
     
    290292                cout << endl;
    291293                return;
     294        }
     295        // function that checks for memrory leaks after all the tests
     296        bool memory_leak(void)
     297        {       bool leak = false;
     298
     299                // dump the memory pool being held for this thread
     300                using CppAD::omp_alloc;
     301                size_t thread = omp_alloc::get_thread_num();
     302                omp_alloc::free_available(thread);
     303       
     304                leak |= CPPAD_TRACK_COUNT() != 0;
     305                leak |= omp_alloc::available(thread) != 0;
     306                leak |= omp_alloc::inuse(thread) != 0;
     307
     308                return leak;
    292309        }
    293310}
     
    384401                size_sparse_jacobian[i] = 30 * (i + 1);
    385402        }
    386 # ifndef NDEBUG
    387         size_t base_count = CPPAD_TRACK_COUNT();
    388 # endif
    389403
    390404        switch(match)
     
    536550        }
    537551# ifndef NDEBUG
    538         if( CPPAD_TRACK_COUNT() == base_count )
    539         {       Run_ok_count++;
    540                 cout << "No memory leak detected" << endl;
    541         }
    542         else
     552        // return memory for vectors that are still in scope
     553        size_det_lu.resize(0);
     554        size_det_minor.resize(0);
     555        size_mat_mul.resize(0);
     556        size_ode.resize(0);
     557        size_poly.resize(0);
     558        size_sparse_hessian.resize(0);
     559        size_sparse_jacobian.resize(0);
     560        // now check for a memory leak
     561        if( memory_leak() )
    543562        {       ok = false;
    544563                Run_error_count++;
    545564                cout << "Memory leak detected" << endl;
    546         }
     565        }
     566        else
     567        {       Run_ok_count++;
     568                cout << "No memory leak detected" << endl;
     569        }
    547570# endif
    548571        return static_cast<int>( ! ok );
  • trunk/test_more/makefile.am

    r1914 r1948  
    113113        sub_eq.cpp \
    114114        sub_zero.cpp \
     115        track_new_del.cpp \
    115116        value.cpp \
    116117        vec_ad.cpp \
  • trunk/test_more/makefile.in

    r1916 r1948  
    5959        sparse_hessian.cpp sparse_jacobian.cpp sparse_vec_ad.cpp \
    6060        sqrt.cpp std_math.cpp sub.cpp sub_eq.cpp sub_zero.cpp \
    61         value.cpp vec_ad.cpp vec_ad_par.cpp vec_unary.cpp
     61        track_new_del.cpp value.cpp vec_ad.cpp vec_ad_par.cpp \
     62        vec_unary.cpp
    6263@CppAD_ADOLC_TRUE@am__objects_1 = base_adolc.$(OBJEXT)
    6364am_test_more_OBJECTS = $(am__objects_1) test_more.$(OBJEXT) \
     
    8384        sparse_jacobian.$(OBJEXT) sparse_vec_ad.$(OBJEXT) \
    8485        sqrt.$(OBJEXT) std_math.$(OBJEXT) sub.$(OBJEXT) \
    85         sub_eq.$(OBJEXT) sub_zero.$(OBJEXT) value.$(OBJEXT) \
    86         vec_ad.$(OBJEXT) vec_ad_par.$(OBJEXT) vec_unary.$(OBJEXT)
     86        sub_eq.$(OBJEXT) sub_zero.$(OBJEXT) track_new_del.$(OBJEXT) \
     87        value.$(OBJEXT) vec_ad.$(OBJEXT) vec_ad_par.$(OBJEXT) \
     88        vec_unary.$(OBJEXT)
    8789test_more_OBJECTS = $(am_test_more_OBJECTS)
    8890test_more_LDADD = $(LDADD)
     
    321323        sub_eq.cpp \
    322324        sub_zero.cpp \
     325        track_new_del.cpp \
    323326        value.cpp \
    324327        vec_ad.cpp \
     
    438441@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sub_zero.Po@am__quote@
    439442@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_more.Po@am__quote@
     443@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/track_new_del.Po@am__quote@
    440444@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/value.Po@am__quote@
    441445@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vec_ad.Po@am__quote@
  • trunk/test_more/test_more.cpp

    r1717 r1948  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    8080extern bool SubEq(void);
    8181extern bool SubZero(void);
     82extern bool track_new_del(void);
    8283extern bool Value(void);
    8384extern bool VecAD(void);
     
    107108                }
    108109                return ok;
     110        }
     111        // function that checks for memrory leaks after all the tests
     112        bool memory_leak(void)
     113        {       bool leak = false;
     114
     115                // dump the memory pool being held for this thread
     116                using CppAD::omp_alloc;
     117                size_t thread = omp_alloc::get_thread_num();
     118                omp_alloc::free_available(thread);
     119       
     120                leak |= CPPAD_TRACK_COUNT() != 0;
     121                leak |= omp_alloc::available(thread) != 0;
     122                leak |= omp_alloc::inuse(thread) != 0;
     123
     124                return leak;
    109125        }
    110126}
     
    178194        ok &= Run( SubEq,           "SubEq"          );
    179195        ok &= Run( SubZero,         "SubZero"        );
     196        ok &= Run( track_new_del,   "track_new_del"  );
    180197        ok &= Run( Value,           "Value"          );
    181198        ok &= Run( VecAD,           "VecAD"          );
     
    191208        using std::endl;
    192209        assert( ok || (Run_error_count > 0) );
    193         if( CPPAD_TRACK_COUNT() == 0 )
    194         {       Run_ok_count++;
    195                 cout << "Ok:    " << "No memory leak detected" << endl;
    196         }
    197         else
     210        if( memory_leak() )
    198211        {       ok = false;
    199212                Run_error_count++;
    200213                cout << "Error: " << "memory leak detected" << endl;
     214        }
     215        else
     216        {       Run_ok_count++;
     217                cout << "Ok:    " << "No memory leak detected" << endl;
    201218        }
    202219        // convert int(size_t) to avoid warning on _MSC_VER systems
Note: See TracChangeset for help on using the changeset viewer.