Quick way to zero array

[rocketman768]

Man, that title should be in a poem, but anyways...So, I have this
program, and it has an array of 40 million elements. The problem is
that I have a for loop that continually is doing stuff to this array,
and for each iteration, I have to zero out the array. This is how I am
currently doing it: // Zero out the lnscores for( count=0; count <
chunksize; count++ ) lnscores[count] = 0; Is there no quicker way
to do this? I know there must be a trick since this array is one big
contiguous chunk of memory right?

[prax]

memset( lnscores, 0, chunksize )

[Vladimir Oka]

ro**********@gm ail.com opined:

Man, that title should be in a poem, but anyways...So, I have this
program, and it has an array of 40 million elements. The problem is
that I have a for loop that continually is doing stuff to this array,
and for each iteration, I have to zero out the array. This is how I
am
currently doing it: // Zero out the lnscores for( count=0; count <
chunksize; count++ ) lnscores[count] = 0; Is there no quicker
way to do this? I know there must be a trick since this array is one
big contiguous chunk of memory right?

If your array has file scope you don't even have to zero it yourself.
All such variables get zeroed at startup. Otherwise, declare it and
initialise thus:

int lnscores[WHATEVER_SIZE] = {0};

If you have to re-zero it afterwards, you could use `memset()`.

--
Worlds are conquered, galaxies destroyed -- but a woman is always a
woman.
-- Kirk, "Conscience of the King", stardate unknown

<http://clc-wiki.net/wiki/Introduction_to _comp.lang.c>

[Ben C]

On 2006-05-12, ro**********@gm ail.com <ro**********@g mail.com> wrote:

Man, that title should be in a poem, but anyways...So, I have this
program, and it has an array of 40 million elements. The problem is
that I have a for loop that continually is doing stuff to this array,
and for each iteration, I have to zero out the array. This is how I am
currently doing it: // Zero out the lnscores for( count=0; count <
chunksize; count++ ) lnscores[count] = 0; Is there no quicker way
to do this? I know there must be a trick since this array is one big
contiguous chunk of memory right?

memset(lnscores , 0, chunksize * sizeof lnscores[0]);

Assuming 0 is represented by 0... what type is lnscores?

[Michael Mair]

ro**********@gm ail.com schrieb:

Man, that title should be in a poem, but anyways...So, I have this
program, and it has an array of 40 million elements. The problem is
that I have a for loop that continually is doing stuff to this array,
and for each iteration, I have to zero out the array. This is how I am
currently doing it: // Zero out the lnscores for( count=0; count <
chunksize; count++ ) lnscores[count] = 0; Is there no quicker way
to do this? I know there must be a trick since this array is one big
contiguous chunk of memory right?

As you did not tell us what type lnscores has, there is no
definite "quickest" way.
If lnscores[count] = 0 means that all bits of lnscores[count] are
set to zero, you can use memset() to zero out all bits.

Otherwise, you can use memcpy():
-zero out lnscores[0]
-memcpy() lnscores[0] to lnscores[1]
-memcpy() lnscores[0] and lnscores[1] to lnscores[2] and lnscores[3]
....
-memcpy() lnscores[0], ..., and lnscores[16777215] to
lnscores[16777215], ..., and lnscores[33554431]
- Last step (no doubling):
memcpy() lnscores[0], ..., and lnscores[6445567] to
lnscores[33554431], ..., and lnscores[39999999]

This _may_ be quicker than the loop itself. It may be slower if
your compiler recognizes the "zero out" pattern and does something
intelligent.

Try it out and measure.

Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[shisheng li]

if not all elements will be used, there are some methods to just zero out as
fewer as needed
<ro**********@g mail.com> wrote in message
news:11******** **************@ d71g2000cwd.goo glegroups.com.. .

Man, that title should be in a poem, but anyways...So, I have this
program, and it has an array of 40 million elements. The problem is
that I have a for loop that continually is doing stuff to this array,
and for each iteration, I have to zero out the array. This is how I am
currently doing it: // Zero out the lnscores for( count=0; count <
chunksize; count++ ) lnscores[count] = 0; Is there no quicker way
to do this? I know there must be a trick since this array is one big
contiguous chunk of memory right?

[Julian V. Noble]

ro**********@gm ail.com wrote:

Man, that title should be in a poem, but anyways...So, I have this
program, and it has an array of 40 million elements. The problem is
that I have a for loop that continually is doing stuff to this array,
and for each iteration, I have to zero out the array. This is how I am
currently doing it: // Zero out the lnscores for( count=0; count <
chunksize; count++ ) lnscores[count] = 0; Is there no quicker way
to do this? I know there must be a trick since this array is one big
contiguous chunk of memory right?

Why do you have to zero the array? Are you only doing something to a
few elements at each iteration? While there may be a fast C function
that zeros arrays, unless you have a parallel machine you can't zero
all cells at once, so this is likely to be costly. I suggest you
seek a better algorithm--for example, whenever you update an element
in an iteration, before you leave that loop, zero that element, so
the whole array returns to the zeroed state.

--
Julian V. Noble
Professor Emeritus of Physics
University of Virginia

[Himanshu Chauhan]

Julian V. Noble wrote:

Why do you have to zero the array?
Zeroing out any piece of allocated memory is necessary to avoid
unforeseen results, which are annoying most of the time.
Are you only doing something to a
few elements at each iteration? While there may be a fast C function
that zeros arrays, unless you have a parallel machine you can't zero
all cells at once, so this is likely to be costly. I suggest you
seek a better algorithm--for example, whenever you update an element
in an iteration, before you leave that loop, zero that element, so
the whole array returns to the zeroed state.

That's a good idea.

You can use "calloc" for allocating for the first time. It already
returns memory region fillled with zero. Then memset or bzero are also
good option.
I mostly use bzero for such things.

BTW, 40 million elements array, are u doing image processing or some
other kind of signal processing?

cheers,

--Himanshu

--
+-----------------------------------+
| Himanshu Singh Chauhan |
| MCA (Final Year) |
| I.G. National Open University |
| Delhi (India) |
| |
| Contact: hs********@gmai l.com |
+-----------------------------------+

[Keith Thompson]

Himanshu Chauhan <hs********@gma il.com> writes:

Julian V. Noble wrote:

Why do you have to zero the array?
Zeroing out any piece of allocated memory is necessary to avoid
unforeseen results, which are annoying most of the time.

It's not always necessary. For example, if you can keep track of
which elements of the array you're currently using, you don't have to
worry about what's in the other elements. The best approach depends
on what you're actually doing with the array.

[...] You can use "calloc" for allocating for the first time. It already
returns memory region fillled with zero. Then memset or bzero are also
good option.
I mostly use bzero for such things.

calloc() and memset() will set the array contents to all-bits-zero.
If you have an array of integers, it will set each element to 0. If
it's an array of some pointer or floating-point type, it will
*probably* do so, but it's no guaranteed (the language doesn't
guarantee that a floating-point 0.0 is represented as all-bits-zero).

bzero() is non-standard, and might not exist on all systems.

It's not obvious that memset() will be faster than a loop explicitly
setting each element to zero. You should measure the performance of
the code.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Flash Gordon]

Himanshu Chauhan wrote:

Julian V. Noble wrote:

Why do you have to zero the array?
Zeroing out any piece of allocated memory is necessary to avoid
unforeseen results, which are annoying most of the time.

Depends on whether all bits zero is a valid initialiser. It is not
necessarily valid for floats, doubles or pointers.

Are you only doing something to a
few elements at each iteration? While there may be a fast C function
that zeros arrays, unless you have a parallel machine you can't zero
all cells at once, so this is likely to be costly. I suggest you
seek a better algorithm--for example, whenever you update an element
in an iteration, before you leave that loop, zero that element, so
the whole array returns to the zeroed state.

That's a good idea.

You can use "calloc" for allocating for the first time. It already
returns memory region fillled with zero. Then memset or bzero are also
good option.
I mostly use bzero for such things.

Why choose the non-standard bzero when there is a perfectly standard memset?
BTW, 40 million elements array, are u doing image processing or some
other kind of signal processing?

Please don't use stupid contractions like u for you.
--
Flash Gordon, living in interesting times.
Web site - http://home.flash-gordon.me.uk/
comp.lang.c posting guidelines and intro:
http://clc-wiki.net/wiki/Intro_to_clc

Inviato da X-Privat.Org - Registrazione gratuita http://www.x-privat.org/join.php