Is this a memory problem?

[syang8]

hi, folks,

I use Kdevelop to build some scientific simulation on Linux. If I set
the size of an array N = 8000, the program works fine. However, if I
set the array N some number greater than 10000 (actually, what I need
is 80000), the program has segmentation error. The intersting thing is
that the positions reporting segmentation error are different if I set
N to be different values.

What problem is this usually? I guess must be some memory error. I use
Valgrind to check the memory, at the line with segmentation error, it
reports "Access not within mapped region at address 0xxxxxxxx".

Anyone know the solution? How cound I handle this problem? Thanks.

-Steve

[Alf P. Steinbach]

* syang8:

>
I use Kdevelop to build some scientific simulation on Linux. If I set
the size of an array N = 8000, the program works fine. However, if I
set the array N some number greater than 10000 (actually, what I need
is 80000), the program has segmentation error. The intersting thing is
that the positions reporting segmentation error are different if I set
N to be different values.

What problem is this usually? I guess must be some memory error. I use
Valgrind to check the memory, at the line with segmentation error, it
reports "Access not within mapped region at address 0xxxxxxxx".

Anyone know the solution? How cound I handle this problem? Thanks.

It sounds like you're declaring the array as a local variable, where it
uses stack space. Declare it at namespace scope, or allocate it
dynamically. A simple, safe way to allocate an array dynamically is to
use std::vector.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[syang8]

Alf P. Steinbach wrote:

* syang8:

I use Kdevelop to build some scientific simulation on Linux. If I set
the size of an array N = 8000, the program works fine. However, if I
set the array N some number greater than 10000 (actually, what I need
is 80000), the program has segmentation error. The intersting thing is
that the positions reporting segmentation error are different if I set
N to be different values.

What problem is this usually? I guess must be some memory error. I use
Valgrind to check the memory, at the line with segmentation error, it
reports "Access not within mapped region at address 0xxxxxxxx".

Anyone know the solution? How cound I handle this problem? Thanks.

It sounds like you're declaring the array as a local variable, where it
uses stack space. Declare it at namespace scope, or allocate it
dynamically. A simple, safe way to allocate an array dynamically is to
use std::vector.

Isn't the stack used in function calls? The local variable should be in
heap, right? I only have knowledge in basic C/C++ programming. I don't
have advanced knowledge on namespace so far. Where aer the variables
defined in a namespace stored? Also what I know to allocate array
dynamically is to use "new" and "delete". I wonder if you can recommend
any good reference (books or online resources) to me. Thanks.

[Alf P. Steinbach]

* syang8:

Alf P. Steinbach wrote:

>* syang8:

>>I use Kdevelop to build some scientific simulation on Linux. If I set
the size of an array N = 8000, the program works fine. However, if I
set the array N some number greater than 10000 (actually, what I need
is 80000), the program has segmentation error. The intersting thing is
that the positions reporting segmentation error are different if I set
N to be different values.

What problem is this usually? I guess must be some memory error. I use
Valgrind to check the memory, at the line with segmentation error, it
reports "Access not within mapped region at address 0xxxxxxxx".

Anyone know the solution? How cound I handle this problem? Thanks.

It sounds like you're declaring the array as a local variable, where it
uses stack space. Declare it at namespace scope, or allocate it
dynamically. A simple, safe way to allocate an array dynamically is to
use std::vector.

Isn't the stack used in function calls?

Yes, although that's outside the language definition (it's an
implementation detail).

The local variable should be in heap, right?

Not sure what you mean.

I only have knowledge in basic C/C++ programming. I don't
have advanced knowledge on namespace so far. Where aer the variables
defined in a namespace stored?

The compiler knows the total size of all variables declared at namespace
scope (outside any function or class), and this memory is allocated when
the program is loaded.

Also what I know to allocate array
dynamically is to use "new" and "delete".

Use a std::vector, like

#include <vector>

...

std::vector<MyC lassmyArray( 80000 );

Since you're allocating dynamically you can have this as a local
variable; it only uses a small fixed amount of memory locally.

I wonder if you can recommend
any good reference (books or online resources) to me. Thanks.

Accelerated C++.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[BilfFord X]

"syang8" <sy****@gmail.c omwrote in message
news:11******** *************@j 8g2000cwa.googl egroups.com...

>
Alf P. Steinbach wrote:

>* syang8:

>
I use Kdevelop to build some scientific simulation on Linux. If I set
the size of an array N = 8000, the program works fine. However, if I
set the array N some number greater than 10000 (actually, what I need
is 80000), the program has segmentation error. The intersting thing is
that the positions reporting segmentation error are different if I set
N to be different values.

What problem is this usually? I guess must be some memory error. I use
Valgrind to check the memory, at the line with segmentation error, it
reports "Access not within mapped region at address 0xxxxxxxx".

Anyone know the solution? How cound I handle this problem? Thanks.

It sounds like you're declaring the array as a local variable, where it
uses stack space. Declare it at namespace scope, or allocate it
dynamically. A simple, safe way to allocate an array dynamically is to
use std::vector.

Isn't the stack used in function calls? The local variable should be in
heap, right? I only have knowledge in basic C/C++ programming. I don't
have advanced knowledge on namespace so far. Where aer the variables
defined in a namespace stored? Also what I know to allocate array
dynamically is to use "new" and "delete". I wonder if you can recommend
any good reference (books or online resources) to me. Thanks.

Do you bust an int at 32767? bfx

[sandy]

Hi syang,
when u declare a variable as local, it never gets allocated in the
heap.
as someone has suggested, it's better to use new while allocating
memory for ur requiremnet.
namespace is something specific to c++;

hope this helps

BilfFord X wrote:

"syang8" <sy****@gmail.c omwrote in message
news:11******** *************@j 8g2000cwa.googl egroups.com...

Alf P. Steinbach wrote:

* syang8:

I use Kdevelop to build some scientific simulation on Linux. If I set
the size of an array N = 8000, the program works fine. However, if I
set the array N some number greater than 10000 (actually, what I need
is 80000), the program has segmentation error. The intersting thing is
that the positions reporting segmentation error are different if I set
N to be different values.

What problem is this usually? I guess must be some memory error. I use
Valgrind to check the memory, at the line with segmentation error, it
reports "Access not within mapped region at address 0xxxxxxxx".

Anyone know the solution? How cound I handle this problem? Thanks.

It sounds like you're declaring the array as a local variable, where it
uses stack space. Declare it at namespace scope, or allocate it
dynamically. A simple, safe way to allocate an array dynamically is to
use std::vector.

Isn't the stack used in function calls? The local variable should be in
heap, right? I only have knowledge in basic C/C++ programming. I don't
have advanced knowledge on namespace so far. Where aer the variables
defined in a namespace stored? Also what I know to allocate array
dynamically is to use "new" and "delete". I wonder if you can recommend
any good reference (books or online resources) to me. Thanks.

Do you bust an int at 32767? bfx

[Robbie Hatley]

"syang8" wrote:

I use Kdevelop to build some scientific simulation on Linux.

What's "Kdevelop", and what does it have to do with C++? If
this is some sort of software-writing software, be aware that
such programs are very mechanistic and may do stupid things
that a human programmer wouldn't do.

If I set the size of an array N = 8000, the program works fine.

If it has a large stack, yes. Arrays of what, by the way?
What is sizeof(ArrayEle ment)? If you have a 100-byte struct,
and you make a local array of 8000 of that, you're piling
800,000 bytes of data onto the stack.

However, if I set the array N some number greater than
10000 (actually, what I need is 80000)

EWWWWW. Don't do that.

the program has segmentation error.

Of course.

The intersting thing is that the positions reporting segmentation
error are different if I set N to be different values.

Of course.

What problem is this usually?

You're almost certainly overflowing your stack with a huge local
array, like so:

int DorkyFunction(d ouble trouble)
{
BigStruct big_mess[80000]; // dump eight million bytes onto stack
...
}

Instead, declare your array "static" to get it off the stack:

int SmartFunction(d ouble trouble)
{
static BigStruct big_mess[80000];
...
}

--
Cheers,
Robbie Hatley
Tustin, CA, USA
lonewolfintj at pacbell dot net
(put "[usenet]" in subject to bypass spam filter)
http://home.pacbell.net/earnur/

>

[syang8]

hi, Alf, sandy and Robbie,

The suggestions that you gave to me is really helpful. Now I have a
better understanding of local variables and stacks. However, I still
have a problem. I don't know exactly what the size of the array should
be. Therefore, "N" is designed as a parameter in the function call as

fuction(int N, ...)
{
int big_array[N];
}

I cannot change the array to be static. Maybe a good way is to
allocated the array dynamically, any other suggestions?

Robbie Hatley wrote:

"syang8" wrote:

I use Kdevelop to build some scientific simulation on Linux.

What's "Kdevelop", and what does it have to do with C++? If
this is some sort of software-writing software, be aware that
such programs are very mechanistic and may do stupid things
that a human programmer wouldn't do.

If I set the size of an array N = 8000, the program works fine.

If it has a large stack, yes. Arrays of what, by the way?
What is sizeof(ArrayEle ment)? If you have a 100-byte struct,
and you make a local array of 8000 of that, you're piling
800,000 bytes of data onto the stack.

However, if I set the array N some number greater than
10000 (actually, what I need is 80000)

EWWWWW. Don't do that.

the program has segmentation error.

Of course.

The intersting thing is that the positions reporting segmentation
error are different if I set N to be different values.

Of course.

What problem is this usually?

You're almost certainly overflowing your stack with a huge local
array, like so:

int DorkyFunction(d ouble trouble)
{
BigStruct big_mess[80000]; // dump eight million bytes onto stack
...
}

Instead, declare your array "static" to get it off the stack:

int SmartFunction(d ouble trouble)
{
static BigStruct big_mess[80000];
...
}

--
Cheers,
Robbie Hatley
Tustin, CA, USA
lonewolfintj at pacbell dot net
(put "[usenet]" in subject to bypass spam filter)
http://home.pacbell.net/earnur/

[Tom Widmer]

syang8 wrote:

hi, Alf, sandy and Robbie,

The suggestions that you gave to me is really helpful. Now I have a
better understanding of local variables and stacks. However, I still
have a problem. I don't know exactly what the size of the array should
be. Therefore, "N" is designed as a parameter in the function call as

fuction(int N, ...)
{
int big_array[N];
}

I cannot change the array to be static. Maybe a good way is to
allocated the array dynamically, any other suggestions?

#include <vector>
void function(int N, ...)
{
std::vector<int big_vector(N);

//use big_vector like an array, e.g. big_vector[4] is the 5th element

//no need to deallocate it - std::vector's destructor deletes any
//"heap" memory it has allocated.
}

Tom

[Robbie Hatley]

"syang8" <sy****@gmail.c omwrote:

hi, Alf, sandy and Robbie,

The suggestions that you gave to me is really helpful. Now I have a
better understanding of local variables and stacks. However, I still
have a problem. I don't know exactly what the size of the array should
be. Therefore, "N" is designed as a parameter in the function call as

fuction(int N, ...)
{
int big_array[N];
}

I cannot change the array to be static. Maybe a good way is to
allocated the array dynamically, any other suggestions?

Yes. I have 3 suggestions for you, in descending order of
advisibility:

Suggestion #1 (the "C++" way):

Use "std::vecto r".

If you want the vector to still exist between calls to the function
in which it is declared, then you'll have to declare it "static":

#include <vector>
class MyClass {/* stuff */};
MyClass& MyFunction(int ContainerSize)
{
static std::vector<MyC lassMyContainer (ContainerSize) ;
// ... a bunch of code ...
return MyContainer;
} // MyContainer still exists at this point.

But if MyContainer doesn't need to exist between calls to
your function, then you can leave off the "static":

#include <vector>
class MyClass {/* stuff */};
int MyFunction(int ContainerSize)
{
std::vector<MyC lassMyContainer (ContainerSize) ;
// ... a bunch of code ...
return 0;
} // MyContainer dies here.

Suggestion #2 (a more-dangerous "C++" way):

Use "new[]" and "delete[]".

This is dangerous. Memory leaks can result if you "new[]" some
memory and forget to "delete[]" it, and program crashes can
result if you "delete[]" some memory which you didn't "new[]".

But on the other hand, it is a very flexible way of handling
memory.

// Make a dynamic array of MyClass objects:
MyClass* Ptr = new MyClass[ContainerSize];

// Assign stuff to the memory you now own:
Ptr[3756] = Whatever;

// Free-up the memory, later:
delete[] Ptr;

Suggestion #3 (the "C" way):

Dynamically allocate a block of raw memory using malloc().
When you're done with it, free it using free().

Warning: this is VERY dangerous. If you do it wrong, you'll
cause bugs, memory leaks, system crashes, etc.

But it's conceptually the simplest, lowest-level way of handling
memory, so it's alluring because of that:

// Get memory block to hold N copies of MyClass:
MyClass* Ptr = (MyClass*)mallo c(ContainerSize * sizeof(MyClass) );

// Assign stuff to the memory you now own:
Ptr[3756] = Whatever;

// Free-up the memory, later:
free(Ptr);

--
Cheers,
Robbie Hatley
Tustin, CA, USA
lonewolfintj at pacbell dot net
(put "[usenet]" in subject to bypass spam filter)
http://home.pacbell.net/earnur/