bool track_new_del(void) { bool ok = true; // initial count size_t count = CPPAD_TRACK_COUNT(); // allocate an array of lenght 5 double *ptr = CPPAD_NULL; size_t newlen = 5; ptr = CPPAD_TRACK_NEW_VEC(newlen, ptr); // copy data into the array size_t ncopy = newlen; size_t i; for(i = 0; i < ncopy; i++) ptr[i] = double(i); // extend the buffer to be lenght 10 newlen = 10; ptr = CPPAD_TRACK_EXTEND(newlen, ncopy, ptr); // copy data into the new part of the array for(i = ncopy; i < newlen; i++) ptr[i] = double(i); // check the values in the array for(i = 0; i < newlen; i++) ok &= (ptr[i] == double(i)); // free the memory allocated since previous call to TrackCount CPPAD_TRACK_DEL_VEC(ptr); // check for memory leak ok &= (count == CPPAD_TRACK_COUNT()); return ok; }
// main program that runs all the tests int main(int argc, char *argv[]) { bool ok = true; const char *test[]= { "correct", "det_lu", "det_minor", "ode", "poly", "sparse_hessian", "sparse_jacobian", "speed" }; const size_t n_test = sizeof(test) / sizeof(test[0]); const size_t test_correct = 0; const size_t test_det_lu = 1; const size_t test_det_minor = 2; const size_t test_ode = 3; const size_t test_poly = 4; const size_t test_sparse_hessian = 5; const size_t test_sparse_jacobian= 6; const size_t test_speed = 7; assert( n_test == test_speed+1 ); size_t i; size_t match = n_test; int iseed = 0; bool error = argc < 3; if( ! error ) { for(i = 0; i < n_test; i++) if( strcmp(test[i], argv[1]) == 0 ) match = i; error = match == n_test; iseed = std::atoi( argv[2] ); error |= iseed < 0; global_retape = false; global_optimize = false; for(i = 3; i < size_t(argc); i++) { if( strcmp(argv[i], "retape") == 0 ) global_retape = true; else if( strcmp(argv[i], "optimize") == 0 ) global_optimize = true; else error = true; } } if( error ) { cout << "usage: ./" << AD_PACKAGE << " test seed option_list" << endl; cout << "test choices: " << endl; for(i = 0; i < n_test; i++) cout << "\t" << test[i] << endl; cout << "seed choices: "; cout << "a positive integer used as a random seed." << endl; cout << "option choices: "; cout << " \"retape\", \"optimize\"." << endl << endl; return 1; } // initialize the random number simulator CppAD::uniform_01(size_t(iseed)); // arguments needed for speed tests size_t n_size = 5; CppAD::vector<size_t> size_det_lu(n_size); CppAD::vector<size_t> size_det_minor(n_size); CppAD::vector<size_t> size_ode(n_size); CppAD::vector<size_t> size_poly(n_size); CppAD::vector<size_t> size_sparse_hessian(n_size); CppAD::vector<size_t> size_sparse_jacobian(n_size); for(i = 0; i < n_size; i++) { size_det_lu[i] = 3 * i + 1; size_det_minor[i] = i + 1; size_ode[i] = i + 1; size_poly[i] = 8 * i + 1; size_sparse_hessian[i] = 30 * (i + 1); size_sparse_jacobian[i] = 30 * (i + 1); } # ifndef NDEBUG size_t base_count = CPPAD_TRACK_COUNT(); # endif switch(match) { // run all the correctness tests case test_correct: if( available_det_lu() ) ok &= run_correct( correct_det_lu, "det_lu" ); if( available_det_minor() ) ok &= run_correct( correct_det_minor, "det_minor" ); if( available_ode() ) ok &= run_correct( correct_ode, "ode" ); if( available_poly() ) ok &= run_correct( correct_poly, "poly" ); if( available_sparse_hessian() ) ok &= run_correct( correct_sparse_hessian, "sparse_hessian" ); if( available_sparse_jacobian() ) ok &= run_correct( correct_sparse_jacobian, "sparse_jacobian" ); // summarize results assert( ok || (Run_error_count > 0) ); if( ok ) { cout << "All " << int(Run_ok_count) << " correctness tests passed." << endl; } else { cout << int(Run_error_count) << " correctness tests failed." << endl; } break; // --------------------------------------------------------- // run all the speed tests case test_speed: if( available_det_lu() ) Run_speed( speed_det_lu, size_det_lu, "det_lu" ); if( available_det_minor() ) Run_speed( speed_det_minor, size_det_minor, "det_minor" ); if( available_ode() ) Run_speed( speed_ode, size_ode, "ode" ); if( available_poly() ) Run_speed( speed_poly, size_poly, "poly" ); if( available_sparse_hessian() ) Run_speed( speed_sparse_hessian, size_sparse_hessian, "sparse_hessian" ); if( available_sparse_jacobian() ) Run_speed( speed_sparse_jacobian, size_sparse_jacobian, "sparse_jacobian" ); ok = true; break; // --------------------------------------------------------- case test_det_lu: if( ! available_det_lu() ) { cout << AD_PACKAGE << ": test " << argv[1] << " not available" << endl; exit(1); } ok &= run_correct(correct_det_lu, "det_lu"); Run_speed(speed_det_lu, size_det_lu, "det_lu"); break; // --------------------------------------------------------- case test_det_minor: if( ! available_det_minor() ) { cout << AD_PACKAGE << ": test " << argv[1] << " not available" << endl; exit(1); } ok &= run_correct(correct_det_minor, "det_minor"); Run_speed(speed_det_minor, size_det_minor, "det_minor"); break; // --------------------------------------------------------- case test_ode: if( ! available_ode() ) { cout << AD_PACKAGE << ": test " << argv[1] << " not available" << endl; exit(1); } ok &= run_correct(correct_ode, "ode"); Run_speed(speed_ode, size_ode, "ode"); break; // --------------------------------------------------------- case test_poly: if( ! available_poly() ) { cout << AD_PACKAGE << ": test " << argv[1] << " not available" << endl; exit(1); } ok &= run_correct(correct_poly, "poly"); Run_speed(speed_poly, size_poly, "poly"); break; // --------------------------------------------------------- case test_sparse_hessian: if( ! available_sparse_hessian() ) { cout << AD_PACKAGE << ": test " << argv[1] << " not available" << endl; exit(1); } ok &= run_correct(correct_sparse_hessian, "sparse_hessian"); Run_speed( speed_sparse_hessian, size_sparse_hessian, "sparse_hessian"); break; // --------------------------------------------------------- case test_sparse_jacobian: if( ! available_sparse_jacobian() ) { cout << AD_PACKAGE << ": test " << argv[1] << " not available" << endl; exit(1); } ok &= run_correct(correct_sparse_jacobian, "sparse_jacobian"); Run_speed( speed_sparse_jacobian, size_sparse_jacobian, "sparse_jacobian" ); break; // --------------------------------------------------------- default: assert(0); } # ifndef NDEBUG if( CPPAD_TRACK_COUNT() == base_count ) { Run_ok_count++; cout << "No memory leak detected" << endl; } else { ok = false; Run_error_count++; cout << "Memory leak detected" << endl; } # endif return static_cast<int>( ! ok ); }