int add_steps(pState state, unsigned int numSteps, pStep steps ){
//steps is pointer to the program buf
if (numSteps>10){
return 5;
}
//each step for numSteps must be read, checked and added to pstate->programList
for (unsigned int i=0;i<numSteps;i++){
// int allows bad type that isn't checked for valid timeval, allowing the
// program to run for indeterminated time, which writes off the end of history buffer
#ifdef PATCHED_1
unsigned short int type = steps[i].type;
#else
short int type = (short int)steps[i].type;
#endif
unsigned int sensorID = steps[i].sensorID;
unsigned int timeVal = steps[i].timeVal;
unsigned int temp = steps[i].temp;
//type and sensorID/timeval check
if (type == 0 ){
//sensorID check
if (sensorID > 12){
return 3;
}
if ( (temp < 175 ) || (temp > 350) ){
return 1;
}
}
if ( type == 1 ){
//timeval check
if ( ( timeVal < (30*60) ) || ( timeVal > (240*60) ) ){
return 2;
}
if ( (temp < 175 ) || (temp > 350) ){
return 1;
}
}
if (type > 1 ){
//bad type
return 4;
}
}
//if all is ok, add steps
new_state(state);
for (unsigned int i=0;i<numSteps;i++){
unsigned int type = steps[i].type;
unsigned int sensorID = steps[i].sensorID;
unsigned int timeVal = steps[i].timeVal;
unsigned int temp = steps[i].temp;
int retval = add_step(state, type, sensorID, temp);
}
state->currentStep = 0;
state->numSteps = numSteps;
return 0;
}
bool BooleanTool::executeForObjects(PathObject* subject, PathObjects& in_objects, PathObjects& out_objects, CombinedUndoStep& undo_step)
{
if (!executeForObjects(subject, in_objects, out_objects))
{
Q_ASSERT(out_objects.size() == 0);
return false; // in release build
}
// Add original objects to undo step, and remove them from map.
QScopedPointer<AddObjectsUndoStep> add_step(new AddObjectsUndoStep(map));
for (PathObject* object : in_objects)
{
if (op != Difference || object == subject)
{
add_step->addObject(object, object);
}
}
// Keep as separate loop to get the correct index in the previous loop
for (PathObject* object : in_objects)
{
if (op != Difference || object == subject)
{
map->removeObjectFromSelection(object, false);
map->getCurrentPart()->deleteObject(object, true);
object->setMap(map); // necessary so objects are saved correctly
}
}
// Add resulting objects to map, and create delete step for them
QScopedPointer<DeleteObjectsUndoStep> delete_step(new DeleteObjectsUndoStep(map));
MapPart* part = map->getCurrentPart();
for (PathObject* object : out_objects)
{
map->addObject(object);
map->addObjectToSelection(object, false);
}
// Keep as separate loop to get the correct index in the previous loop
for (PathObject* object : out_objects)
{
delete_step->addObject(part->findObjectIndex(object));
}
undo_step.push(add_step.take());
undo_step.push(delete_step.take());
return true;
}
{}void AStarPath::create_path()
{ astar_node *i = final_node; // iterator through steps, from back
delete_path();
std::vector<astar_node *> reverse_list;
while(i)
{
reverse_list.push_back(i);
i = i->parent;
}
while(!reverse_list.empty())
{
i = reverse_list.back();
add_step(i->loc);
reverse_list.pop_back();
}
set_path_size(step_count);
}/* Get a new neighbor to nnode and score it, returning true if it's usable. */
void CTestTlsObjectApp::RunTest(void)
{
const size_t OBJECT_SIZE = sizeof(CObjectWithNew);
for ( int t = 0; t < 1; ++t ) {
// prealloc
{
size_t size = (OBJECT_SIZE+16)*COUNT;
void* p = ::operator new(size);
memset(p, 1, size);
::operator delete(p);
}
{
const size_t COUNT2 = COUNT*2;
void** p = new void*[COUNT2];
for ( size_t i = 0; i < COUNT2; ++i ) {
add_alloc(1);
add_step();
p[i] = ::operator new(OBJECT_SIZE);
}
for ( size_t i = 0; i < COUNT2; ++i ) {
add_alloc(-1);
add_step();
::operator delete(p[i]);
}
delete[] p;
}
{
const size_t COUNT2 = COUNT*2;
int** p = new int*[COUNT2];
for ( size_t i = 0; i < COUNT2; ++i ) {
add_alloc(1);
add_step();
p[i] = new int(int(i));
}
for ( size_t i = 0; i < COUNT2; ++i ) {
add_alloc(-1);
add_step();
delete p[i];
}
delete[] p;
}
}
//return;
CStopWatch sw;
check_cnts();
for ( int t = 0; t < 1; ++t ) {
void** ptr = new void*[COUNT];
sw.Start();
for ( size_t i = 0; i < COUNT; ++i ) {
add_alloc(1);
add_step();
ptr[i] = ::operator new(OBJECT_SIZE);
}
double t1 = sw.Elapsed();
sw.Start();
for ( size_t i = 0; i < COUNT; ++i ) {
add_alloc(-1);
add_step();
::operator delete(ptr[i]);
}
double t2 = sw.Elapsed();
message("plain malloc", "create", t1, "delete", t2, COUNT);
delete[] ptr;
}
check_cnts();
{
sw.Start();
int* ptr = new int;
sx_PushLastNewPtr(ptr, 2);
double t1 = sw.Elapsed();
sw.Start();
_VERIFY(sx_PopLastNewPtr(ptr));
delete ptr;
double t2 = sw.Elapsed();
message("tls", "set", t1, "get", t2, COUNT);
}
check_cnts();
{
CObjectWithNew** ptr = new CObjectWithNew*[COUNT];
for ( size_t i = 0; i < COUNT; ++i ) {
ptr[i] = 0;
}
sw.Start();
s_CurrentStep = "new CObjectWithNew";
s_CurrentInHeap = true;
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
ptr[i] = new CObjectWithNew;
}
s_CurrentInHeap = false;
double t1 = sw.Elapsed();
check_cnts(COUNT);
for ( size_t i = 0; i < COUNT; ++i ) {
_ASSERT(ptr[i]->IsInHeap());
}
sw.Start();
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
CObjectWithNew::Delete(ptr[i]);
}
double t2 = sw.Elapsed();
message("new CObjectWithNew", "create", t1, "delete", t2, COUNT);
delete[] ptr;
}
check_cnts();
{
CObjectWithTLS** ptr = new CObjectWithTLS*[COUNT];
sw.Start();
s_CurrentStep = "new CObjectWithTLS";
s_CurrentInHeap = true;
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
try {
switch ( rand()%3 ) {
case 0: ptr[i] = new CObjectWithTLS; break;
case 1: ptr[i] = new CObjectWithTLS2; break;
case 2: ptr[i] = new CObjectWithTLS3; break;
}
}
catch ( exception& ) {
ptr[i] = 0;
}
_ASSERT(!sx_HaveLastNewPtr());
_ASSERT(!ptr[i] || ptr[i]->IsInHeap());
}
s_CurrentInHeap = false;
double t1 = sw.Elapsed();
check_cnts(COUNT);
sw.Start();
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
CObjectWithTLS::Delete(ptr[i]);
}
double t2 = sw.Elapsed();
message("new CObjectWithTLS", "create", t1, "delete", t2, COUNT);
delete[] ptr;
}
check_cnts();
{
CRef<CObjectWithRef>* ptr = new CRef<CObjectWithRef>[COUNT];
sw.Start();
s_CurrentStep = "new CObjectWithRef";
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
try {
switch ( rand()%2 ) {
case 0: ptr[i] = new CObjectWithRef; break;
case 1: ptr[i] = new CObjectWithRef2; break;
}
}
catch ( exception& ) {
ptr[i] = 0;
}
_ASSERT(!sx_HaveLastNewPtr());
_ASSERT(!ptr[i] || ptr[i]->CanBeDeleted());
}
double t1 = sw.Elapsed();
check_cnts(COUNT);
sw.Start();
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
ptr[i].Reset();
}
double t2 = sw.Elapsed();
message("new CObjectWithRef", "create", t1, "delete", t2, COUNT);
delete[] ptr;
}
check_cnts();
{
CObjectWithNew** ptr = new CObjectWithNew*[COUNT];
for ( size_t i = 0; i < COUNT; ++i ) {
ptr[i] = 0;
}
sw.Start();
s_CurrentStep = "new CObjectWithNew()";
s_CurrentInHeap = true;
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
ptr[i] = new CObjectWithNew();
}
s_CurrentInHeap = false;
double t1 = sw.Elapsed();
check_cnts(COUNT);
for ( size_t i = 0; i < COUNT; ++i ) {
_ASSERT(ptr[i]->IsInHeap());
}
sw.Start();
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
CObjectWithNew::Delete(ptr[i]);
}
double t2 = sw.Elapsed();
message("new CObjectWithNew()", "create", t1, "delete", t2, COUNT);
delete[] ptr;
}
check_cnts();
{
CObjectWithTLS** ptr = new CObjectWithTLS*[COUNT];
sw.Start();
s_CurrentStep = "new CObjectWithTLS()";
s_CurrentInHeap = true;
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
try {
switch ( rand()%4 ) {
case 0: ptr[i] = new CObjectWithTLS(); break;
case 1: ptr[i] = new CObjectWithTLS2(); break;
case 2: ptr[i] = new CObjectWithTLS3(); break;
case 3: ptr[i] = new CObjectWithTLS3(RecursiveNewTLS(rand()%4)); break;
}
}
catch ( exception& ) {
ptr[i] = 0;
}
_ASSERT(!sx_HaveLastNewPtr());
_ASSERT(!ptr[i] || ptr[i]->IsInHeap());
}
s_CurrentInHeap = false;
double t1 = sw.Elapsed();
check_cnts(COUNT);
sw.Start();
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
CObjectWithTLS::Delete(ptr[i]);
}
double t2 = sw.Elapsed();
message("new CObjectWithTLS()", "create", t1, "delete", t2, COUNT);
delete[] ptr;
}
check_cnts();
{
CRef<CObjectWithRef>* ptr = new CRef<CObjectWithRef>[COUNT];
sw.Start();
s_CurrentStep = "new CObjectWithRef()";
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
try {
size_t j = rand()%COUNT;
switch ( rand()%4 ) {
case 0: ptr[j] = new CObjectWithRef(); break;
case 1: ptr[j] = new CObjectWithRef(RecursiveNewRef(rand()%4)); break;
case 2: ptr[j] = new CObjectWithRef2(); break;
case 3: ptr[j] = new CObjectWithRef2(RecursiveNewRef(rand()%4)); break;
}
}
catch ( exception& ) {
ptr[i] = 0;
}
_ASSERT(!sx_HaveLastNewPtr());
_ASSERT(!ptr[i] || ptr[i]->CanBeDeleted());
}
double t1 = sw.Elapsed();
check_cnts(COUNT);
sw.Start();
for ( size_t i = 0; i < COUNT; ++i ) {
add_step();
ptr[i] = 0;
}
double t2 = sw.Elapsed();
message("new CObjectWithRef()", "create", t1, "delete", t2, COUNT);
delete[] ptr;
}
check_cnts();
{
sw.Start();
s_CurrentStep = "CObjectWithNew[]";
CArray<CObjectWithNew, COUNT>* arr =
new CArray<CObjectWithNew, COUNT>;
double t1 = sw.Elapsed();
check_cnts(COUNT, COUNT);
for ( size_t i = 0; i < COUNT; ++i ) {
_ASSERT(!arr->m_Array[i].IsInHeap());
}
sw.Start();
delete arr;
double t2 = sw.Elapsed();
message("static CObjectWithNew", "create", t1, "delete", t2, COUNT);
}
check_cnts();
{
sw.Start();
s_CurrentStep = "CObjectWithTLS[]";
CArray<CObjectWithTLS, COUNT, false>* arr =
new CArray<CObjectWithTLS, COUNT, false>;
double t1 = sw.Elapsed();
check_cnts(COUNT, COUNT);
for ( size_t i = 0; i < COUNT; ++i ) {
_ASSERT(!arr->m_Array[i].IsInHeap());
}
sw.Start();
delete arr;
double t2 = sw.Elapsed();
message("static CObjectWithTLS", "create", t1, "delete", t2, COUNT);
}
check_cnts();
{
sw.Start();
s_CurrentStep = "CObjectWithRef[]";
CArray<CObjectWithRef, COUNT, false>* arr =
new CArray<CObjectWithRef, COUNT, false>;
double t1 = sw.Elapsed();
check_cnts(COUNT, COUNT);
for ( size_t i = 0; i < COUNT; ++i ) {
_ASSERT(!arr->m_Array[i].CanBeDeleted());
}
sw.Start();
delete arr;
double t2 = sw.Elapsed();
message("static CObjectWithRef", "create", t1, "delete", t2, COUNT);
}
check_cnts();
}
