int main(void)
{
/* Setup */
identifier = (int *)calloc_safe(1, sizeof(int));
*identifier = PARENT_IDENTIFIER;
process_number = -1;
/* Open file for reading */
FILE *input_file = fopen_safe("input.txt", "r");
/* Create necessary pipes */
create_pipes();
/* Fork children processes */
pid_t main_id = getpid(); // main_id contains parent process ID
create_mappers(main_id);
if (getpid() == main_id) // more efficient to include this statement
create_reducers(main_id);
/* Close proper pipe ends */
close_pipe_ends();
/* Parse the input file. Processes handle properly. */
parse_file(input_file);
// free heap ptrs
return 0;
}
GC_profileData profileMalloc (GC_state s) {
GC_profileData p;
uint32_t profileMasterLength;
p = (GC_profileData)(malloc_safe (sizeof(*p)));
p->total = 0;
p->totalGC = 0;
profileMasterLength = s->sourceMaps.sourcesLength + s->sourceMaps.sourceNamesLength;
p->countTop = (uintmax_t*)(calloc_safe(profileMasterLength, sizeof(*(p->countTop))));
if (s->profiling.stack)
p->stack =
(struct GC_profileStack *)
(calloc_safe(profileMasterLength, sizeof(*(p->stack))));
if (DEBUG_PROFILE)
fprintf (stderr, FMTPTR" = profileMalloc ()\n", (uintptr_t)p);
return p;
}
GC_objectHashTable allocHashTable (GC_state s) {
uint32_t elementsLengthMax;
pointer regionStart;
pointer regionEnd;
GC_objectHashTable t;
t = (GC_objectHashTable)(malloc_safe (sizeof(*t)));
// Try to use space in the heap for the elements.
if (not (isHeapInit (&s->secondaryHeap))) {
if (DEBUG_SHARE)
fprintf (stderr, "using secondaryHeap\n");
regionStart = s->secondaryHeap.start;
regionEnd = s->secondaryHeap.start + s->secondaryHeap.size;
} else if (s->amInGC or not s->canMinor) {
if (DEBUG_SHARE)
fprintf (stderr, "using end of heap\n");
regionStart = s->frontier;
regionEnd = s->limitPlusSlop;
} else {
if (DEBUG_SHARE)
fprintf (stderr, "using minor space\n");
assert (s->canMinor);
regionStart = s->heap.start + s->heap.oldGenSize;
regionEnd = s->heap.nursery;
}
elementsLengthMax = (regionEnd - regionStart) / sizeof (*(t->elements));
if (DEBUG_SHARE)
fprintf (stderr, "elementsLengthMax = %"PRIu32"\n", elementsLengthMax);
t->elementsLengthMax = 64; // some small power of two
t->elementsLengthMaxLog2 = 6; // and its log base 2
if (elementsLengthMax < t->elementsLengthMax) {
if (DEBUG_SHARE)
fprintf (stderr, "elementsLengthMax too small -- using calloc\n");
t->elementsIsInHeap = FALSE;
t->elements =
(struct GC_objectHashElement *)
(calloc_safe(t->elementsLengthMax, sizeof(*(t->elements))));
} else {
if (DEBUG_SHARE)
fprintf (stderr, "elementsLengthMax big enough -- using heap\n");
t->elementsIsInHeap = TRUE;
t->elements = (struct GC_objectHashElement*)regionStart;
// Find the largest power of two that fits.
for ( ;
t->elementsLengthMax <= elementsLengthMax;
t->elementsLengthMax <<= 1, t->elementsLengthMaxLog2++)
; // nothing
t->elementsLengthMax >>= 1;
t->elementsLengthMaxLog2--;
assert (t->elementsLengthMax <= elementsLengthMax);
for (unsigned int i = 0; i < t->elementsLengthMax; ++i)
t->elements[i].object = NULL;
}
t->elementsLengthCur = 0;
t->mayInsert = TRUE;
if (DEBUG_SHARE) {
fprintf (stderr, "elementsIsInHeap = %s\n",
boolToString (t->elementsIsInHeap));
fprintf (stderr, "elementsLengthMax = %"PRIu32"\n", t->elementsLengthMax);
fprintf (stderr, FMTPTR" = allocHashTable ()\n", (uintptr_t)t);
}
return t;
}
