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 );
}
