void chpl_sync_waitEmptyAndLock(chpl_sync_aux_t *s,
int32_t lineno,
chpl_string filename)
{
PROFILE_INCR(profile_sync_waitEmptyAndLock, 1);
if (blockreport) { about_to_block(lineno, filename); }
chpl_sync_lock(s);
while (s->is_full != 0) {
chpl_sync_unlock(s);
qthread_syncvar_readFE(NULL, &(s->signal_empty));
chpl_sync_lock(s);
}
}
void chpl_printMemStat(int32_t lineno, c_string filename) {
if (!chpl_memTrack)
chpl_error("invalid call to printMemStat(); rerun with --memTrack",
lineno, filename);
chpl_sync_lock(&memTrack_sync);
fprintf(memLogFile, "=================\n");
fprintf(memLogFile, "Memory Statistics\n");
if (chpl_numNodes == 1) {
fprintf(memLogFile, "==============================================================\n");
fprintf(memLogFile, "Current Allocated Memory %zd\n", totalMem);
fprintf(memLogFile, "Maximum Simultaneous Allocated Memory %zd\n", maxMem);
fprintf(memLogFile, "Total Allocated Memory %zd\n", totalAllocated);
fprintf(memLogFile, "Total Freed Memory %zd\n", totalFreed);
fprintf(memLogFile, "==============================================================\n");
} else {
int i;
fprintf(memLogFile, "==============================================================\n");
fprintf(memLogFile, "Locale\n");
fprintf(memLogFile, " Current Allocated Memory\n");
fprintf(memLogFile, " Maximum Simultaneous Allocated Memory\n");
fprintf(memLogFile, " Total Allocated Memory\n");
fprintf(memLogFile, " Total Freed Memory\n");
fprintf(memLogFile, "==============================================================\n");
for (i = 0; i < chpl_numNodes; i++) {
static size_t m1, m2, m3, m4;
chpl_gen_comm_get(&m1, i, &totalMem, sizeof(size_t), -1 /* broke for hetero */, 1, lineno, filename);
chpl_gen_comm_get(&m2, i, &maxMem, sizeof(size_t), -1 /* broke for hetero */, 1, lineno, filename);
chpl_gen_comm_get(&m3, i, &totalAllocated, sizeof(size_t), -1 /* broke for hetero */, 1, lineno, filename);
chpl_gen_comm_get(&m4, i, &totalFreed, sizeof(size_t), -1 /*broke for hetero */, 1, lineno, filename);
fprintf(memLogFile, "%-9d %-9zu %-9zu %-9zu %-9zu\n", i, m1, m2, m3, m4);
}
fprintf(memLogFile, "==============================================================\n");
}
chpl_sync_unlock(&memTrack_sync);
}
// Note that this function can be called in parallel and more notably it can be
// called with non-monotonic pid's. e.g. this may be called with pid 27, and
// then pid 2, so it has to ensure that the privatized array has at least pid+1
// elements. Be __very__ careful if you have to update it.
void chpl_newPrivatizedClass(void* v, int64_t pid) {
chpl_sync_lock(&privatizationSync);
// initialize array to a default size
if (chpl_privateObjects == NULL) {
chpl_capPrivateObjects = 2*max(pid, 4);
chpl_privateObjects =
chpl_mem_allocMany(chpl_capPrivateObjects, sizeof(void *),
CHPL_RT_MD_COMM_PRV_OBJ_ARRAY, 0, 0);
} else {
// if we're out of space, double (or more) the array size
if (pid >= chpl_capPrivateObjects) {
void** tmp;
int64_t oldCap;
oldCap = chpl_capPrivateObjects;
chpl_capPrivateObjects = 2*max(pid, oldCap);
tmp = chpl_mem_allocMany(chpl_capPrivateObjects, sizeof(void *),
CHPL_RT_MD_COMM_PRV_OBJ_ARRAY, 0, 0);
chpl_memcpy((void*)tmp, (void*)chpl_privateObjects, (oldCap)*sizeof(void*));
chpl_privateObjects = tmp;
// purposely leak old copies of chpl_privateObject to avoid the need to
// lock chpl_getPrivatizedClass; TODO: fix with lock free data structure
}
}
chpl_privateObjects[pid] = v;
chpl_sync_unlock(&privatizationSync);
}
void chpl_newPrivatizedClass(void* v, int64_t pid) {
// We need to lock around this operation so two calls in rapid succession
// that pass the chpl_capPrivateObjects limit don't both try to create a new
// array. If they do, one of the calls will be leaked and an invalid pointer
// to be placed in the table.
chpl_sync_lock(&privatizationSync);
pid += 1;
if (pid == 1) {
chpl_capPrivateObjects = 8;
// "private" means "node-private", so we can use the system allocator.
chpl_privateObjects = chpl_mem_allocMany(chpl_capPrivateObjects, sizeof(void*), CHPL_RT_MD_COMM_PRIVATE_OBJECTS_ARRAY, 0, "");
} else {
if (pid > chpl_capPrivateObjects) {
void** tmp;
chpl_capPrivateObjects *= 2;
tmp = chpl_mem_allocMany(chpl_capPrivateObjects, sizeof(void*), CHPL_RT_MD_COMM_PRIVATE_OBJECTS_ARRAY, 0, "");
memcpy((void*)tmp, (void*)chpl_privateObjects, (pid-1)*sizeof(void*));
chpl_privateObjects = tmp;
// purposely leak old copies of chpl_privateObject to avoid the need to
// lock chpl_getPrivatizedClass; TODO: fix with lock free data structure
}
}
chpl_privateObjects[pid-1] = v;
chpl_sync_unlock(&privatizationSync);
}
/* ChapelBase.chpl:719 */
uint64_t readXX(_syncvar_uint64_t _this_671669) {
uint64_t T2;
uint64_t T1;
chpl_sync_lock(&((_this_671669)->sync_aux));
T1 = (_this_671669->value);
chpl_sync_unlock(&((_this_671669)->sync_aux));
T2 = T1;
return T2;
}
void chpl_track_realloc_pre(void* memAlloc, size_t size,
chpl_mem_descInt_t description,
int32_t lineno, c_string filename) {
memTableEntry* memEntry = NULL;
if (chpl_memTrack && size > memThreshold) {
chpl_sync_lock(&memTrack_sync);
if (memAlloc) {
memEntry = removeMemTableEntry(memAlloc);
if (memEntry)
free(memEntry);
}
chpl_sync_unlock(&memTrack_sync);
}
}
void chpl_track_malloc(void* memAlloc, size_t number, size_t size,
chpl_mem_descInt_t description,
int32_t lineno, c_string filename) {
if (number * size > memThreshold) {
if (chpl_memTrack) {
chpl_sync_lock(&memTrack_sync);
addMemTableEntry(memAlloc, number, size, description, lineno, filename);
chpl_sync_unlock(&memTrack_sync);
}
if (chpl_verbose_mem) {
fprintf(memLogFile,
"%" FORMAT_c_nodeid_t ": %s:%" PRId32
": allocate %zuB of %s at %p\n",
chpl_nodeID, (filename ? filename : "--"), lineno,
number*size, chpl_mem_descString(description), memAlloc);
}
}
}
void chpl_track_free(void* memAlloc, int32_t lineno, c_string filename) {
memTableEntry* memEntry = NULL;
if (chpl_memTrack) {
chpl_sync_lock(&memTrack_sync);
memEntry = removeMemTableEntry(memAlloc);
if (memEntry) {
if (chpl_verbose_mem) {
fprintf(memLogFile,
"%" FORMAT_c_nodeid_t ": %s:%" PRId32
": free %zuB of %s at %p\n",
chpl_nodeID, (filename ? filename : "--"), lineno,
memEntry->number*memEntry->size,
chpl_mem_descString(memEntry->description), memAlloc);
}
free(memEntry);
}
chpl_sync_unlock(&memTrack_sync);
} else if (chpl_verbose_mem && !memEntry) {
fprintf(memLogFile,
"%" FORMAT_c_nodeid_t ": %s:%" PRId32 ": free at %p\n",
chpl_nodeID, (filename ? filename : "--"), lineno, memAlloc);
}
}
/* ChapelBase.chpl:780 */
void reset(_syncvar_uint64_t _this_672840) {
chpl_sync_lock(&((_this_672840)->sync_aux));
_this_672840->value = UINT64(0);
chpl_sync_mark_and_signal_empty(&((_this_672840)->sync_aux));
return;
}
