topic [CRASH] new char[480MB] in ObjectARX Forum

[CRASH] new char[480MB]

Anonymous — Fri, 16 Sep 2005 22:02:06 GMT

When I attempt to allocate something about 480MB of memory AutoCAD crash
with the following message "Runtime Error! The application has requested the
Runtime to terminate it in an unusual way". So, my question, how to allocate
a large block of memory by ObjectARX application?

Thanks

Re: [CRASH] new char[480MB]

Anonymous — Sat, 17 Sep 2005 15:30:39 GMT

This is my working solution to work with big tables in case not enough
contiguous memory.





/*************************************************************************

* START: class HokusVector

*************************************************************************/



template

class HokusVector

{



// typedefs

//



public:

typedef T Value;







// konstruktory / destruktory

//



public:

HokusVector();

~HokusVector();





// operatory

//

public:

Value& operator[](const unsigned int& i);

const Value& operator[](const unsigned int& i) const;





// funkcje uzytkowe

//

public:

void reserve( unsigned int size );

unsigned int size() const;

bool empty() const;

void clear();

void resize( unsigned int size );

void push_back( const T& value );





// dane klasy

//

private:

std::vector< std::vector > m_banks;

unsigned int m_banksize;



};



/*************************************************************************

* END: class HokusVector

*************************************************************************/











/*************************************************************************

* START: class HokusVector

*************************************************************************/



//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template

HokusVector::HokusVector()

{ // set

m_banksize = __max( 10, 20000000/sizeof(T) );

}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template

HokusVector::~HokusVector()

{ //



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template HokusVector::Value&

HokusVector::operator[](const unsigned int& i)

{ // success

return m_banks[i/m_banksize][i-(i/m_banksize)*m_banksize];

}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template const HokusVector::Value&

HokusVector::operator[](const unsigned int& i) const

{ // success

return m_banks[i/m_banksize][i-(i/m_banksize)*m_banksize];

}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template void

HokusVector::reserve( unsigned int size )

{

// test

if( m_banks.size()*m_banksize >= size )

{ // ERROR: nothing to reserve

return;

}



// resize vectors

m_banks.resize( (size-1 )/m_banksize +1 );



// reserve all vectors

for( unsigned int i=0 ; i
{ //

m_banks.reserve( m_banksize );

}



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template unsigned int

HokusVector::size() const

{



// variables

unsigned int

i, size=0;



// calc

for( i=0 ; i
{ //

size += m_banks.size();

}



// success

return size;



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template bool

HokusVector::empty() const

{

// test

for( unsigned int i=0 ; i
{

//

if( !m_banks.empty() )

{ // ERROR: not empty

return false;

}



}



// success: empty

return true;



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template void

HokusVector::clear()

{

// clear

for( unsigned int i=0 ; i
{ //

m_banks.clear();

}



// clear

m_banks.clear();



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template void

HokusVector::resize( unsigned int size )

{

// test

if( 0 == size )

{ // just clear

return clear();

}



// resize vectors

m_banks.resize( (size-1)/m_banksize +1 );



// resize all vectors

for( unsigned int i=0 ; i
{ //

m_banks.resize( m_banksize );

}



// resize last vector

m_banks[m_banks.size()-1].reserve( m_banksize );

m_banks[m_banks.size()-1].resize( size - (m_banks.size()-1)*m_banksize );



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template void

HokusVector::push_back( const HokusVector::Value& value )

{

// get size

unsigned int newsize = this->size() +1;



// calc nvectors

unsigned int ivector = (newsize-1) / m_banksize;



// add new vector

if( m_banks.size() <= ivector )

{

//

m_banks.push_back( std::vector() );

m_banks.back().reserve( m_banksize );

assert( m_banks.size() == ivector+1 );

}



// assert

assert( !m_banks.empty() );



// add new item

m_banks[ivector].push_back( value );

assert( m_banks[ivector].size() <= m_banksize );



}





/*************************************************************************

* END: class HokusVector

*************************************************************************/

Re: [CRASH] new char[480MB]

Anonymous — Sat, 17 Sep 2005 19:35:37 GMT

Why are you using one of std::vector<>, std::deque<> or std::list<>?

Dan

"HokuS" wrote in message
news:4959532@discussion.autodesk.com...
This is my working solution to work with big tables in case not enough
contiguous memory.





/*************************************************************************

* START: class HokusVector

*************************************************************************/



template

class HokusVector

{



// typedefs

//



public:

typedef T Value;







// konstruktory / destruktory

//



public:

HokusVector();

~HokusVector();





// operatory

//

public:

Value& operator[](const unsigned int& i);

const Value& operator[](const unsigned int& i) const;





// funkcje uzytkowe

//

public:

void reserve( unsigned int size );

unsigned int size() const;

bool empty() const;

void clear();

void resize( unsigned int size );

void push_back( const T& value );





// dane klasy

//

private:

std::vector< std::vector > m_banks;

unsigned int m_banksize;



};



/*************************************************************************

* END: class HokusVector

*************************************************************************/











/*************************************************************************

* START: class HokusVector

*************************************************************************/



//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template

HokusVector::HokusVector()

{ // set

m_banksize = __max( 10, 20000000/sizeof(T) );

}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template

HokusVector::~HokusVector()

{ //



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template HokusVector::Value&

HokusVector::operator[](const unsigned int& i)

{ // success

return m_banks[i/m_banksize][i-(i/m_banksize)*m_banksize];

}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template const HokusVector::Value&

HokusVector::operator[](const unsigned int& i) const

{ // success

return m_banks[i/m_banksize][i-(i/m_banksize)*m_banksize];

}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template void

HokusVector::reserve( unsigned int size )

{

// test

if( m_banks.size()*m_banksize >= size )

{ // ERROR: nothing to reserve

return;

}



// resize vectors

m_banks.resize( (size-1 )/m_banksize +1 );



// reserve all vectors

for( unsigned int i=0 ; i
{ //

m_banks.reserve( m_banksize );

}



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template unsigned int

HokusVector::size() const

{



// variables

unsigned int

i, size=0;



// calc

for( i=0 ; i
{ //

size += m_banks.size();

}



// success

return size;



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template bool

HokusVector::empty() const

{

// test

for( unsigned int i=0 ; i
{

//

if( !m_banks.empty() )

{ // ERROR: not empty

return false;

}



}



// success: empty

return true;



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template void

HokusVector::clear()

{

// clear

for( unsigned int i=0 ; i
{ //

m_banks.clear();

}



// clear

m_banks.clear();



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template void

HokusVector::resize( unsigned int size )

{

// test

if( 0 == size )

{ // just clear

return clear();

}



// resize vectors

m_banks.resize( (size-1)/m_banksize +1 );



// resize all vectors

for( unsigned int i=0 ; i
{ //

m_banks.resize( m_banksize );

}



// resize last vector

m_banks[m_banks.size()-1].reserve( m_banksize );

m_banks[m_banks.size()-1].resize( size - (m_banks.size()-1)*m_banksize );



}





//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//

template void

HokusVector::push_back( const HokusVector::Value& value )

{

// get size

unsigned int newsize = this->size() +1;



// calc nvectors

unsigned int ivector = (newsize-1) / m_banksize;



// add new vector

if( m_banks.size() <= ivector )

{

//

m_banks.push_back( std::vector() );

m_banks.back().reserve( m_banksize );

assert( m_banks.size() == ivector+1 );

}



// assert

assert( !m_banks.empty() );



// add new item

m_banks[ivector].push_back( value );

assert( m_banks[ivector].size() <= m_banksize );



}





/*************************************************************************

* END: class HokusVector

*************************************************************************/

Re: [CRASH] new char[480MB]

Anonymous — Sat, 17 Sep 2005 19:50:48 GMT

When I attempt to call std::vector::reserve(480000000) or
std::list::resize(480000000) CRASH occurs. Do you think 480MB is too
much for ObjectARX applications? Of course no, when I use my vector class
everything is fine and I am able to allocate more than 1GB of memory.

Regards

Re: [CRASH] new char[480MB]

Anonymous — Tue, 20 Sep 2005 15:57:43 GMT

When I try
malloc(480 * 1024 * 1024);
I get a "CAcadMemoryException"

In a 'normal' environment I can allocate 2 G's
(And aCad itself eats only about 50Mb's)

So maybe you should allocate large chunk in a
separate thread