Thread: is there anything technicaly wrong with this

the task is to write a program that adds up all the prime numbers between 1 and 2,000,000

here is my solution

Code:

int main()
{
    //declare variables
    int i, j, iLimit = 2000000, iMultiples[2000000] = { 0 }; //imultiples is used to mark off multiples of i
    unsigned long long int iSum = 0;

    //loop from 2 to iLimit
    for ( i = 2; i < iLimit; i++ )
    {
        //check if i is a multiple of a previous itteration of i
        if ( iMultiples[i] == 0 )
        {
            //i is a new prime so add it to the running total isum
            iSum += i;

            //loop from i to ilimit in all multiples of i
            for ( j = i * 2; j < iLimit; j += i )
            {
               //mark off i * j
               iMultiples[j] = 1;
            }
        }
    }
    //print the sum of primes from 1 to ilimit to the screen
    printf("The sum of primes between 1 and %d is %llu\n", iLimit, iSum);

    return 0;
}

this runs in 0.063 seconds

If i change the variable declarations at the top to

Code:

int i, j, iLimit = 2000000; 
    unsigned long long int iSum = 0;
    char iMultiples[2000000] = { '\0' }; //imultiples is used to mark off multiples of i

ie the array is now type char it cuts the run time approximately in half

Looking at the "official" solution they used pointers of type char and calloc'ed the memory and treated it as an array which doesn't appear to be any quicker than using a predefined array of type char so i don't see the point

sorry meant to say the official answer also declares iLimit as size_t what ever size_t is

out of interest what is your machine roughly or have you tweaked your settings.
i get this

Code:

$ ulimit -a
real-time non-blocking time  (microseconds, -R) unlimited
core file size              (blocks, -c) 0
data seg size               (kbytes, -d) unlimited
scheduling priority                 (-e) 0
file size                   (blocks, -f) unlimited
pending signals                     (-i) 30345
max locked memory           (kbytes, -l) 64
max memory size             (kbytes, -m) unlimited
open files                          (-n) 1024
pipe size                (512 bytes, -p) 8
POSIX message queues         (bytes, -q) 819200
real-time priority                  (-r) 0
stack size                  (kbytes, -s) 8192
cpu time                   (seconds, -t) unlimited
max user processes                  (-u) 30345
virtual memory              (kbytes, -v) unlimited
file locks                          (-x) unlimited

i have an i5 with 4 cores and 8 threads

sorry got side tracked by ulimit. back to the program if i used dynamic memory would that get around the stack problem. or does dynamic memory still come from the stack....

is there a simple way of overcoming this issue as im sure there are numerous applications for using large arrays to sort/ store large amounts of data for processing rather than reading it off a disk a few mb at a time

You can use static storage duration to declare an array that is not allocated on the stack, and also not dynamic. Just write static char instead of char in your declaration. Beware, however, that visibility rules still apply, so if you want to use the array by name in multiple functions, you'll have to declare the array at file scope. For now, with just the one main function, you're okay.

is there a command or utility for mx Linux (Debian based) that shows memory usage at runtime