Heap related questions - c

Question

I know the forum has many questions about heap etc. but nothing helped me this much (except for the understanding of why it doesn't work).
I have a huge quantity of data and of course the heap can't follow. The data I need to store are only integers. Malloc starts returning null quite early.
4 arrays of size: (allocation by malloc)
875715
875715
875715
5105043 cells (but it's a 2D array)
Here are my questions:
1) To know the quantity of memory needed, is it:
875715 * 3 * 4 + 5105043 * 4 = 62454492 ? (because integer is 4)
Does it mean around 62 MB? (Sorry if it seems dumb)
2) How can we know the size of the heap available? Is there a way to increase it?
3) I have 3 arrays of the same size, is there an advantage of merging them into one 2D array?
For example, array[875715][3] instead of 3 different arrays (of course, by using malloc)
I use Window seven, 64 bit, 8GB of RAM.
EDIT: Here is a typical allocation I do for the 1D array and for the beginning of the 2D array (first level):
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define FILE_NAME "SCC.txt"
#define ARRAY_SIZE 875714
void getGgraph(int mode,int **graph,int *sizeGraph);
int sizeOfArray(int *array);
void getGraphSize(int mode,int *arr);
void runThroughGraph(int node,int **graph,int *exploredNode,int *magicalPath,int *sizeGraph);
void getMagicalPath(int *magicalPath,int **graph,int *sizeGraph);
void main()
{
int i, *magicalPath,*sizeGraph, **graph;
/* ------------- creation of the array sizeGraph ------------------ */ // contain the size of each level to initiate the array
if ((sizeGraph =(int*) malloc((ARRAY_SIZE + 1) * sizeof(sizeGraph[0]))) == NULL) {
printf("malloc of sizeGraph error\n");
return;
}
memset(sizeGraph, 0, (ARRAY_SIZE + 1) * sizeof(sizeGraph[0]));
/* ------------- create reverse G graph, this will be a 2D array ------------------ */
if ((graph =(int**) malloc((ARRAY_SIZE + 1) * sizeof(*graph))) == NULL) {
printf("malloc of graph error\n");
return;
}
getGgraph(1,graph,sizeGraph);
// [..... Some more code .....]
// end of main()
}
void getGgraph(int mode,int **graph,int *sizeGraph) {
char int_string[40];
char stringToAdd[10];
FILE *integerFile = NULL;
int i = 0, j = 0, n = 0,stCurrentInt, tail,head,*temp;
getGraphSize(mode,sizeGraph);
for (i = 0; i < (ARRAY_SIZE + 1); i++) {
if ((graph[i] =(int*) malloc((ARRAY_SIZE + 1) * sizeof(graph[i][0]))) == NULL) {
// THIS IS WHERE IT STOPS (i = 594)
printf("Malloc of graph[%d] error\n",i);
return;
}
}
if ((temp =(int*) malloc((ARRAY_SIZE + 1) * sizeof(temp[0]))) == NULL) {
printf("malloc of temp in getGgraph function error\n");
return;
}
memset(temp, 0, (ARRAY_SIZE + 1) * sizeof(temp[0]));
if ((integerFile = fopen(FILE_NAME, "r")) != NULL) {
while (fgets(int_string,40, integerFile) != NULL) {
n = 0, i = 0, stCurrentInt = 0,head = 0; // initialisation
while (int_string[n] != NULL) {
if (int_string[n] == ' ') {
for (j = stCurrentInt; j < n; j++) {
stringToAdd[j - stCurrentInt] = int_string[j];
}
if (stCurrentInt == 0) // first integer is the index
tail = (int) atoi(stringToAdd);
else {
head = atoi(stringToAdd);
if (mode == 0) {
graph[tail][temp[tail]] = head;
temp[tail]++;
}
else if (mode == 1) {
graph[head][temp[head]] = tail;
temp[head]++;
}
}
for (j = 0; j < 10; j++) { // empty the string for next iteration
stringToAdd[j] = NULL;
}
stCurrentInt = n + 1;
}
n++;
}
}
free(temp);
fclose(integerFile);
}
else {
printf("\n File missing in getGgraph.\n");
return;
}
}
void getGraphSize(int mode,int *arr) {
char int_string[40],stringToAdd[10];
FILE *integerFile = NULL;
int i = 0, j = 0, n = 0,stCurrentInt,tail,head;
if ((integerFile = fopen(FILE_NAME, "r")) != NULL) {
while (fgets(int_string,40, integerFile) != NULL) {
n = 0, i = 0, stCurrentInt = 0,head = 0; // initialisation
while (int_string[n] != NULL) {
if (int_string[n] == ' ') {
for (j = stCurrentInt; j < n; j++) {
stringToAdd[j - stCurrentInt] = int_string[j];
}
if (stCurrentInt == 0) // first integer is the index
tail = (int) atoi(stringToAdd);
else
head = atoi(stringToAdd);
for (j = 0; j < 10; j++) { // empty the string for next iteration
stringToAdd[j] = NULL;
}
stCurrentInt = n + 1;
}
n++;
}
if (mode == 0 && head != 0)
arr[tail]++;
else if (mode == 1 && head != 0)
arr[head]++;
}
}
else {
printf("\n File missing in getGraphSize.\n");
return;
}
}
EDIT2: My program actually works like a charm for smaller inputs.
[..... Some more code .....]: this is after the issue. The failing malloc is inside getGraph, so I don't think the rest is relevant. I free() the arrays later on in the program.

Answer 1

without pulling out a calculator, and without your code, your analysis looks right.
The HEAP will grow as needed, constrained only by OS process limits.. By default, under windows, you get no more that 2Gig. Here's a more specific link.
no significant advantage.
In your case you'd be better served by adjusting your memory allocation algorithms to allocate what you need and no more.