int chpl_launch_handle_arg(int argc, char* argv[], int argNum,
int32_t lineno, c_string filename) {
int numArgs = 0;
if (!strcmp(argv[argNum], CHPL_WALLTIME_FLAG)) {
walltime = argv[argNum+1];
return 2;
} else if (!strncmp(argv[argNum], CHPL_WALLTIME_FLAG"=", strlen(CHPL_WALLTIME_FLAG))) {
walltime = &(argv[argNum][strlen(CHPL_WALLTIME_FLAG)+1]);
return 1;
}
if (!strcmp(argv[argNum], CHPL_QUEUE_FLAG)) {
queue = argv[argNum+1];
return 2;
} else if (!strncmp(argv[argNum], CHPL_QUEUE_FLAG"=", strlen(CHPL_QUEUE_FLAG))) {
queue = &(argv[argNum][strlen(CHPL_QUEUE_FLAG)+1]);
return 1;
}
if (!strcmp(argv[argNum], CHPL_GENERATE_QSUB_SCRIPT)) {
generate_qsub_script = 1;
return 1;
}
if (!strcmp(argv[argNum], CHPL_CC_ARG)) {
_ccArg = argv[argNum+1];
numArgs = 2;
} else if (!strncmp(argv[argNum], CHPL_CC_ARG"=", strlen(CHPL_CC_ARG))) {
_ccArg = &(argv[argNum][strlen(CHPL_CC_ARG)+1]);
numArgs = 1;
}
if (numArgs > 0) {
if (strcmp(_ccArg, "none") &&
strcmp(_ccArg, "numa_node") &&
strcmp(_ccArg, "cpu")) {
char msg[256];
snprintf(msg, 256, "'%s' is not a valid cpu assignment", _ccArg);
chpl_error(msg, 0, 0);
}
return numArgs;
}
return 0;
}
static void chpl_launch_sanity_checks(const char* argv0) {
// Do sanity checks just before launching.
struct stat statBuf;
// Make sure the _real binary exists
// (this should be called after someone has called
// chpl_compute_real_binary_name() )
if (stat(chpl_get_real_binary_name(), &statBuf) != 0) {
char errorMsg[256];
int wanted_to_write = snprintf(errorMsg, sizeof(errorMsg),
"unable to locate file: %s",
chpl_get_real_binary_name());
if (wanted_to_write < 0) {
const char fallbackMsg[] =
"character encoding error in name of executable to be launched";
strcpy(errorMsg, fallbackMsg);
} else if ((size_t)wanted_to_write >= sizeof(errorMsg)) {
strcpy(&errorMsg[sizeof(errorMsg) - 4], "...");
}
chpl_error(errorMsg, 0, 0);
}
}
void chpl_mem_layerInit(void) {
void* start;
size_t size;
chpl_comm_desired_shared_heap(&start, &size);
//
// TODO (EJR 12/17/15): add support for shared heaps. I think we basically
// need to create a custom chunk allocator.
//
// HPX-5 did this so I think we can too:
// http://jemalloc-discuss.canonware.narkive.com/FzSQ4Qv4/need-help-in-porting-jemalloc
//
// http://www.canonware.com/pipermail/jemalloc-discuss/2015-October/001179.html
//
// TODO (EJR 12/17/15): when we support shared heaps, I need to remember to
// update the third-party README
//
if (start || size)
chpl_error("set CHPL_MEM to a more appropriate mem type", 0, 0);
//
// Do a first allocation, to allow jemalloc to set up:
//
// """
// Once, when the first call is made to one of the memory allocation
// routines, the allocator initializes its internals based in part on various
// options that can be specified at compile- or run-time.
// """
//
{
void* p;
if ((p = je_malloc(1)) == NULL)
chpl_internal_error("cannot init heap: je_malloc() failed");
je_free(p);
}
}
/* Error.chpl:55 */
static void ioerror(syserr error, chpl_string msg, chpl_string path, int64_t _ln, c_string _fn) {
int32_t call_tmp;
chpl_bool call_tmp2;
int32_t strerror_err;
c_string call_tmp3;
_ref_int32_t _ref_tmp_ = NULL;
c_string call_tmp4;
int64_t call_tmp5;
c_string call_tmp6;
c_string_copy call_tmp7;
c_string call_tmp8;
c_string call_tmp9;
c_string_copy call_tmp10;
c_string call_tmp11;
c_string_copy call_tmp12;
c_string call_tmp13;
c_string_copy call_tmp14;
call_tmp = qio_err_iserr(error);
call_tmp2 = (call_tmp != INT32(0));
if (call_tmp2) {
strerror_err = INT32(0);
_ref_tmp_ = &strerror_err;
call_tmp3 = sys_strerror_syserr_str(error, _ref_tmp_);
c_string_from_string(&call_tmp4, &path, _ln, _fn);
call_tmp5 = string_length(call_tmp4);
call_tmp6 = quote_string(path, call_tmp5, _ln, _fn);
call_tmp7 = string_concat(call_tmp3, " ", _ln, _fn);
c_string_from_string(&call_tmp8, &msg, _ln, _fn);
call_tmp9 = ((c_string)(call_tmp7));
call_tmp10 = string_concat(call_tmp9, call_tmp8, _ln, _fn);
call_tmp11 = ((c_string)(call_tmp10));
call_tmp12 = string_concat(call_tmp11, " with path ", _ln, _fn);
call_tmp13 = ((c_string)(call_tmp12));
call_tmp14 = string_concat(call_tmp13, call_tmp6, _ln, _fn);
chpl_error(call_tmp14, _ln, _fn);
}
return;
}
int handleNonstandardArg(int* argc, char* argv[], int argNum,
int32_t lineno, int32_t filename) {
int numHandled = chpl_launch_handle_arg(*argc, argv, argNum,
lineno, filename);
if (numHandled == 0) {
if (mainHasArgs) {
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = argv[argNum];
chpl_gen_main_arg.argc++;
} else {
char* message;
message = chpl_glom_strings(3,"Unexpected flag: \"",argv[argNum],"\"");
chpl_error(message, lineno, filename);
}
return 0;
} else {
int i;
for (i=argNum+numHandled; i<*argc; i++) {
argv[i-numHandled] = argv[i];
}
*argc -= numHandled;
return -1; // back the cursor up in order to re-parse this arg
}
}
// Check what version of slurm is on the system
static sbatchVersion determineSlurmVersion(void) {
const int buflen = 256;
char version[buflen];
char *argv[3];
argv[0] = (char *) "sbatch";
argv[1] = (char *) "--version";
argv[2] = NULL;
memset(version, 0, buflen);
if (chpl_run_utility1K("sbatch", argv, version, buflen) <= 0) {
chpl_error("Error trying to determine slurm version", 0, 0);
}
if (strstr(version, "SBATCHPro")) {
return slurmpro;
} else if (strstr(version, "wrapper sbatch SBATCH UMA 1.0")) {
return uma;
} else if (strstr(version, "slurm")) {
return slurm;
} else {
return unknown;
}
}
static qsubVersion determineQsubVersion(void) {
const int buflen = 256;
char version[buflen];
char *argv[3];
argv[0] = (char *) "qsub";
argv[1] = (char *) "--version";
argv[2] = NULL;
memset(version, 0, buflen);
if (chpl_run_utility1K("qsub", argv, version, buflen) <= 0) {
chpl_error("Error trying to determine qsub version", 0, 0);
}
if (strstr(version, "NCCS")) {
return nccs;
} else if (strstr(version, "PBSPro")) {
return pbspro;
} else if (strstr(version, "version:") || strstr(version, "Version:")) {
return torque;
} else {
return unknown;
}
}
void* _chpl_gc_malloc(size_t number, size_t size, const char* description,
int32_t lineno, chpl_string filename) {
char* current = NULL;
size_t chunk = number * size;
if (_from_space->current + chunk > _from_space->tail) {
// Garbage collect, then allocate
_chpl_gc_copy_collect();
if (_from_space->current + chunk > _from_space->tail) {
// out of memory. Should probably realloc the heap.
// For now, throw an error
char message[1024];
sprintf(message, "Out of memory allocating \"%s\"", description);
chpl_error(message, lineno, filename);
} else {
current = _from_space->current;
_from_space->current += chunk;
}
} else {
current = _from_space->current;
_from_space->current += chunk;
}
return (void*)current;
}
c_string_copy
integral_to_c_string_copy(int64_t x, uint32_t size, chpl_bool isSigned)
{
char buffer[256];
const char* format = "";
enum {UNSIGNED = 0<<16, SIGNED = 1<<16 };
switch (SIGNED * isSigned + size)
{
default:
chpl_error("Unexpected case in integral_to_c_string_copy", -1, "");
break;
case UNSIGNED + 1: format = "%" PRIu8; break;
case UNSIGNED + 2: format = "%" PRIu16; break;
case UNSIGNED + 4: format = "%" PRIu32; break;
case UNSIGNED + 8: format = "%" PRIu64; break;
case SIGNED + 1: format = "%" PRId8; break;
case SIGNED + 2: format = "%" PRId16; break;
case SIGNED + 4: format = "%" PRId32; break;
case SIGNED + 8: format = "%" PRId64; break;
}
sprintf(buffer, format, x);
return string_copy(buffer, 0, NULL);
}
static void halt3(string* const _e0_args, int64_t _e1_args, int64_t _ln, int32_t _fn) {
#line 693 "ChapelIO.chpl"
string local__str_literal_302;
#line 693 "ChapelIO.chpl"
string local__str_literal_1508;
#line 693 "ChapelIO.chpl"
string tmpstring;
#line 693 "ChapelIO.chpl"
string call_tmp;
#line 693 "ChapelIO.chpl"
string _autoCopy_tmp_;
#line 693 "ChapelIO.chpl"
_ref_string ret_to_arg_ref_tmp_ = NULL;
#line 693 "ChapelIO.chpl"
string call_tmp2;
#line 693 "ChapelIO.chpl"
_ref_string ret_to_arg_ref_tmp_2 = NULL;
#line 693 "ChapelIO.chpl"
int32_t coerce_tmp;
#line 693 "ChapelIO.chpl"
chpl_bool call_tmp3;
#line 693 "ChapelIO.chpl"
c_ptr_uint8_t coerce_tmp2 = NULL;
#line 693 "ChapelIO.chpl"
c_string call_tmp4;
#line 693 "ChapelIO.chpl"
_ref_string _ref_tmp_ = NULL;
#line 693 "ChapelIO.chpl"
_ref_string _ref_tmp_2 = NULL;
#line 704 "ChapelIO.chpl"
local__str_literal_302 = _str_literal_302;
#line 703 "ChapelIO.chpl"
local__str_literal_1508 = _str_literal_1508;
#line 703 "ChapelIO.chpl"
ret_to_arg_ref_tmp_ = &_autoCopy_tmp_;
#line 703 "ChapelIO.chpl"
stringify_chpl(_e0_args, _e1_args, ret_to_arg_ref_tmp_, _ln, _fn);
#line 703 "ChapelIO.chpl"
call_tmp = _autoCopy_tmp_;
#line 703 "ChapelIO.chpl"
ret_to_arg_ref_tmp_2 = &call_tmp2;
#line 703 "ChapelIO.chpl"
chpl___PLUS_(&local__str_literal_1508, &_autoCopy_tmp_, ret_to_arg_ref_tmp_2, _ln, _fn);
#line 703 "ChapelIO.chpl"
tmpstring = call_tmp2;
#line 704 "ChapelIO.chpl"
coerce_tmp = (&tmpstring)->locale_id;
#line 704 "ChapelIO.chpl"
call_tmp3 = (coerce_tmp != chpl_nodeID);
#line 704 "ChapelIO.chpl"
if (call_tmp3) /* ZLINE: 704 /home/agobin/Documents/chapel-1.13.0/modules/internal/ChapelIO.chpl */
#line 704 "ChapelIO.chpl"
{
#line 704 "ChapelIO.chpl"
halt(&local__str_literal_302, _ln, _fn);
#line 704 "ChapelIO.chpl"
}
#line 704 "ChapelIO.chpl"
coerce_tmp2 = (&tmpstring)->buff;
#line 704 "ChapelIO.chpl"
call_tmp4 = ((c_string)(coerce_tmp2));
#line 704 "ChapelIO.chpl"
chpl_error(call_tmp4, _ln, _fn);
#line 703 "ChapelIO.chpl"
_ref_tmp_ = &call_tmp;
#line 703 "ChapelIO.chpl"
chpl___TILDE_string(_ref_tmp_, _ln, _fn);
#line 703 "ChapelIO.chpl"
_ref_tmp_2 = &tmpstring;
#line 703 "ChapelIO.chpl"
chpl___TILDE_string(_ref_tmp_2, _ln, _fn);
#line 702 "ChapelIO.chpl"
return;
#line 702 "ChapelIO.chpl"
}
void parseArgs(chpl_bool isLauncher, chpl_parseArgsMode_t mode,
int* argc, char* argv[]) {
int i;
int printHelp = 0;
int printAbout = 0;
int origargc = *argc;
int stop_parsing = 0;
//
// Handle the pre-parse for '-E' arguments separately.
//
if (mode == parse_dash_E) {
assert(!isLauncher);
parseDashEArgs(argc, argv);
return;
}
for (i = 1; i < *argc; i++) {
const char* filename = "<command-line arg>";
int lineno = i + (origargc - *argc);
int argLength = 0;
const char* currentArg = argv[i];
argLength = strlen(currentArg);
if (mainHasArgs && (stop_parsing || argLength < 2)) {
/* update the argv structure passed to a Chapel program, but don't parse
* the arguments
*/
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = argv[i];
chpl_gen_main_arg.argc++;
continue;
}
/* if the Chapel main takes arguments, then "--" is a magic argument that
* will prevent parsing of any additional arguments
*/
if (mainHasArgs && strcmp(currentArg, "--") == 0) {
stop_parsing = 1;
continue;
}
if (argLength < 2) {
const char* message = chpl_glom_strings(3, "\"", currentArg,
"\" is not a valid argument");
chpl_error(message, lineno, filename);
}
switch (currentArg[0]) {
case '-':
switch (currentArg[1]) {
case '-':
{
const char* flag = currentArg + 2;
if (strcmp(flag, "gdb") == 0) {
gdbFlag = i;
break;
}
if (strcmp(flag, "help") == 0) {
printHelp = 1;
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = "--help";
chpl_gen_main_arg.argc++;
break;
}
if (strcmp(flag, "about") == 0) {
printAbout = 1;
break;
}
if (strcmp(flag, "verbose") == 0) {
verbosity=2;
break;
}
if (strcmp(flag, "blockreport") == 0) {
blockreport = 1;
break;
}
if (strcmp(flag, "taskreport") == 0) {
taskreport = 1;
break;
}
if (strcmp(flag, "quiet") == 0) {
verbosity = 0;
break;
}
if (argLength < 3) {
char* message = chpl_glom_strings(3, "\"", currentArg,
"\" is not a valid argument");
chpl_error(message, lineno, filename);
}
i += handlePossibleConfigVar(argc, argv, i, lineno, filename);
break;
}
case 'a':
if (currentArg[2] == '\0') {
printAbout = 1;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 'b':
if (currentArg[2] == '\0') {
blockreport = 1;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 'E':
if (isLauncher) {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
} else {
//
// We parse -E only in parse_dash_E mode, which is handled above.
//
if (currentArg[2] == '\0') {
i++;
}
}
break;
case 'f':
if (currentArg[2] == '\0') {
i++;
if (i >= *argc) {
chpl_error("-f flag is missing <filename> argument",
lineno, filename);
}
currentArg = argv[i];
parseConfigFile(currentArg, lineno, filename);
} else {
parseConfigFile(currentArg + 2, lineno, filename);
}
break;
case 'h':
if (currentArg[2] == '\0') {
printHelp = 1;
chpl_gen_main_arg.argv[chpl_gen_main_arg.argc] = "-h";
chpl_gen_main_arg.argc++;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 'n':
if (currentArg[2] == 'l') {
const char* numPtr;
if (currentArg[3] == '\0') {
i++;
if (i >= *argc) {
chpl_error("-nl flag is missing <numLocales> argument",
lineno, filename);
}
currentArg = argv[i];
numPtr = currentArg;
} else {
numPtr = &(currentArg[3]);
}
initSetValue("numLocales", numPtr, "Built-in", lineno, filename);
break;
}
i += handleNonstandardArg(argc, argv, i, lineno, filename);
break;
case 'q':
if (currentArg[2] == '\0') {
verbosity = 0;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 's':
{
if (argLength < 3) {
char* message = chpl_glom_strings(3, "\"", currentArg,
"\" is not a valid argument");
chpl_error(message, lineno, filename);
}
i += handlePossibleConfigVar(argc, argv, i, lineno, filename);
break;
}
case 't':
if (currentArg[2] == '\0') {
taskreport = 1;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
case 'v':
if (currentArg[2] == '\0') {
verbosity = 2;
} else {
i += handleNonstandardArg(argc, argv, i, lineno, filename);
}
break;
default:
i += handleNonstandardArg(argc, argv, i, lineno, filename);
break;
}
break;
default:
i += handleNonstandardArg(argc, argv, i, lineno, filename);
break;
}
}
if (printAbout) {
chpl_program_about();
chpl_exit_any(0);
}
if (printHelp) {
if (!mainHasArgs) {
printHelpTable();
printConfigVarTable();
chpl_exit_any(0);
}
}
}
int chpl_specify_locales_error(void) {
chpl_error("Specify number of locales via -nl <#> or --numLocales=<#>", 0, 0);
return 0;
}
int getCoresPerLocale() {
int numCores = -1;
char* numCoresString = getenv("CHPL_LAUNCHER_CORES_PER_LOCALE");
if (numCoresString) {
numCores = atoi(numCoresString);
if (numCores <= 0)
chpl_warning("CHPL_LAUNCHER_CORES_PER_LOCALE set to invalid value.", 0, 0);
}
if (numCores > 0)
return numCores;
if (strstr(CNA, "numcores") != NULL) {
const int buflen = 1024;
char buf[buflen];
char* argv[3];
argv[0] = (char *) "cnselect";
argv[1] = (char *) "-Lnumcores";
argv[2] = NULL;
memset(buf, 0, buflen);
if (chpl_run_utility1K("cnselect", argv, buf, buflen) <= 0)
chpl_error("Error trying to determine number of cores per node", 0, 0);
if (sscanf(buf, "%d", &numCores) != 1)
chpl_error("unable to determine number of cores per locale; "
"please set CHPL_LAUNCHER_CORES_PER_LOCALE", 0, 0);
return numCores;
}
if (strstr(CNA, "coremask") != NULL) {
const int buflen = 1024;
char buf[buflen];
char* argv[3];
argv[0] = (char *) "cnselect";
argv[1] = (char *) "-Lcoremask";
argv[2] = NULL;
memset(buf, 0, buflen);
if (chpl_run_utility1K("cnselect", argv, buf, buflen) <= 0)
chpl_error("Error trying to determine number coremask on node", 0, 0);
{
int coreMask;
int bitMask = 0x1;
if (sscanf(buf, "%d", &coreMask) != 1)
chpl_error("unable to determine coremask for locale; "
"please set CHPL_LAUNCHER_CORES_PER_LOCALE", 0, 0);
coreMask >>= 1;
numCores = 1;
while (coreMask & bitMask) {
coreMask >>= 1;
numCores += 1;
}
}
return numCores;
}
// neither numcores nor coremask is available in this version
chpl_error("Error trying to determine number of cores per node", 0, 0);
return 0;
}
/* This function parses a config var of type string, and sets its value in
the hash table.
*/
static int aParsedString(FILE* argFile, char* setConfigBuffer,
int32_t lineno, int32_t filename) {
char* equalsSign = strchr(setConfigBuffer, '=');
int stringLength = strlen(setConfigBuffer);
char firstChar;
char* value;
char lastChar;
const char* moduleName;
char* varName;
if (!equalsSign || !(equalsSign + 1)) {
return 0;
}
firstChar = equalsSign[1];
if ((firstChar != '"') && (firstChar != '\'')) {
return 0;
}
value = equalsSign + 2;
*equalsSign = '\0';
lastChar = setConfigBuffer[stringLength - 1];
parseModVarName(setConfigBuffer, &moduleName, &varName);
if ((firstChar != lastChar) || (strlen(value) == 0)) {
int nextChar = fgetc(argFile);
do {
switch (nextChar) {
case EOF:
{
char* message;
setConfigBuffer[stringLength] = '\0';
message = chpl_glom_strings(2, "Found end of file while reading string: ",
equalsSign + 1);
chpl_error(message, lineno, filename);
break;
}
case '\n':
{
char* message;
setConfigBuffer[stringLength] = '\0';
message = chpl_glom_strings(2, "Found newline while reading string: ",
equalsSign + 1);
chpl_error(message, lineno, filename);
break;
}
default:
{
if (stringLength >= _default_string_length - 1) {
char dsl[1024];
char* message;
sprintf(dsl, "%d", _default_string_length);
message = chpl_glom_strings(2, "String exceeds the maximum string length of ",
dsl);
chpl_error(message, lineno, filename);
}
setConfigBuffer[stringLength] = nextChar;
stringLength++;
nextChar = fgetc(argFile);
}
}
} while (nextChar != firstChar);
} else {
stringLength--;
}
setConfigBuffer[stringLength] = '\0';
initSetValue(varName, value, moduleName, lineno, filename);
return 1;
}
static void
printMemAllocs(chpl_mem_descInt_t description, int64_t threshold,
int32_t lineno, int32_t filename) {
const int numberWidth = 9;
const int precision = sizeof(uintptr_t) * 2;
const int addressWidth = precision+4;
const int descWidth = 33;
int filenameWidth = strlen("Allocated Memory (Bytes)");
int totalWidth;
int filenameLength;
memTableEntry* memEntry;
c_string memEntryFilename;
int n, i;
char* loc;
memTableEntry** table;
if (!chpl_memTrack) {
chpl_warning("invalid call to printMemAllocs(); rerun with --memTrack",
lineno, filename);
return;
}
n = 0;
filenameWidth = strlen("Allocated Memory (Bytes)");
for (i = 0; i < hashSize; i++) {
for (memEntry = memTable[i]; memEntry != NULL; memEntry = memEntry->nextInBucket) {
size_t chunk = memEntry->number * memEntry->size;
if (chunk < threshold)
continue;
if (description != -1 && memEntry->description != description)
continue;
n += 1;
if (memEntry->filename) {
memEntryFilename = chpl_lookupFilename(memEntry->filename);
filenameLength = strlen(memEntryFilename);
if (filenameLength > filenameWidth)
filenameWidth = filenameLength;
}
}
}
totalWidth = filenameWidth+numberWidth*4+descWidth+20;
for (i = 0; i < totalWidth; i++)
fprintf(memLogFile, "=");
fprintf(memLogFile, "\n");
fprintf(memLogFile, "%-*s%-*s%-*s%-*s%-*s%-*s\n",
filenameWidth+numberWidth, "Allocated Memory (Bytes)",
numberWidth, "Number",
numberWidth, "Size",
numberWidth, "Total",
descWidth, "Description",
20, "Address");
for (i = 0; i < totalWidth; i++)
fprintf(memLogFile, "=");
fprintf(memLogFile, "\n");
table = (memTableEntry**)sys_malloc(n*sizeof(memTableEntry*));
if (!table)
chpl_error("out of memory printing memory table", lineno, filename);
n = 0;
for (i = 0; i < hashSize; i++) {
for (memEntry = memTable[i]; memEntry != NULL; memEntry = memEntry->nextInBucket) {
size_t chunk = memEntry->number * memEntry->size;
if (chunk < threshold)
continue;
if (description != -1 && memEntry->description != description)
continue;
table[n++] = memEntry;
}
}
qsort(table, n, sizeof(memTableEntry*), descCmp);
loc = (char*)sys_malloc((filenameWidth+numberWidth+1)*sizeof(char));
for (i = 0; i < n; i++) {
memEntry = table[i];
if (memEntry->filename) {
memEntryFilename = chpl_lookupFilename(memEntry->filename);
sprintf(loc, "%s:%" PRId32, memEntryFilename, memEntry->lineno);
} else {
sprintf(loc, "--");
}
fprintf(memLogFile, "%-*s%-*zu%-*zu%-*zu%-*s%#-*.*" PRIxPTR "\n",
filenameWidth+numberWidth, loc,
numberWidth, memEntry->number,
numberWidth, memEntry->size,
numberWidth, memEntry->size*memEntry->number,
descWidth, chpl_mem_descString(memEntry->description),
addressWidth, precision, (uintptr_t)memEntry->memAlloc);
}
for (i = 0; i < totalWidth; i++)
fprintf(memLogFile, "=");
fprintf(memLogFile, "\n");
putchar('\n');
sys_free(table);
sys_free(loc);
}
uint64_t chpl_memoryUsed(int32_t lineno, c_string filename) {
if (!chpl_memTrack)
chpl_error("invalid call to memoryUsed(); rerun with --memTrack",
lineno, filename);
return (uint64_t)totalMem;
}
//
// If generate_qsub_script, return the filename of the qsub script that
// was written with the qsub options
// else return the qsub options for the command line as a string
//
static char* genQsubOptions(char* genFilename, char* projectString, qsubVersion qsub,
int32_t numLocales, int32_t numCoresPerLocale) {
const size_t maxOptLength = 256;
char* optionString = NULL;
int length = 0;
FILE *qsubScript = NULL;
char *qsubFilename = expectFilename;
if (!queue) {
queue = getenv("CHPL_LAUNCHER_QUEUE");
}
if (!walltime) {
walltime = getenv("CHPL_LAUNCHER_WALLTIME");
}
if (generate_qsub_script) {
pid_t mypid = debug ? 0 : getpid();
sprintf(qsubFilename, "qsub.%s-%d", genFilename, (int) mypid);
qsubScript = fopen(qsubFilename, "w");
fprintf(qsubScript, "#PBS -j oe\n");
fprintf(qsubScript, "#PBS -zV\n");
fprintf(qsubScript, "#PBS -N Chpl-%.10s\n", genFilename);
} else {
optionString = chpl_mem_allocMany(maxOptLength, sizeof(char),
CHPL_RT_MD_COMMAND_BUFFER, -1, "");
length += snprintf(optionString + length, maxOptLength - length,
"-z -V -I -N Chpl-%.10s", genFilename);
}
if (projectString && strlen(projectString) != 0) {
if (generate_qsub_script) {
fprintf(qsubScript, "#PBS -A %s\n", projectString);
} else {
length += snprintf(optionString + length, maxOptLength - length,
" -A %s", projectString);
}
}
if (queue) {
if (generate_qsub_script) {
fprintf(qsubScript, "#PBS -q %s\n", queue);
} else {
length += snprintf(optionString + length, maxOptLength - length,
" -q %s", queue);
}
}
if (walltime) {
if (generate_qsub_script) {
fprintf(qsubScript, "#PBS -l walltime=%s\n", walltime);
} else {
length += snprintf(optionString + length, maxOptLength - length,
" -l walltime=%s", walltime);
}
}
switch (qsub) {
case pbspro:
case unknown:
if (generate_qsub_script) {
fprintf(qsubScript, "#PBS -l mppwidth=%d\n", numLocales);
fprintf(qsubScript, "#PBS -l mppnppn=%d\n", procsPerNode);
fprintf(qsubScript, "#PBS -l mppdepth=%d\n", numCoresPerLocale);
} else {
length += snprintf(optionString + length, maxOptLength - length,
" -l mppwidth=%d -l mppnppn=%d -l mppdepth=%d",
numLocales, procsPerNode, numCoresPerLocale);
}
break;
case moab:
if (generate_qsub_script) {
fprintf(qsubScript, "#PBS -l nodes=%d\n", numLocales);
} else {
length += snprintf(optionString + length, maxOptLength - length,
" -l nodes=%d", numLocales);
}
break;
case nccs:
if (generate_qsub_script) {
fprintf(qsubScript, "#PBS -l nodes=%d\n", numLocales);
} else {
if (!queue && !walltime)
chpl_error("An execution time must be specified for the NCCS launcher if no queue is\n"
"specified -- use the CHPL_LAUNCHER_WALLTIME and/or CHPL_LAUNCHER_QUEUE\n"
"environment variables", 0, 0);
length += snprintf(optionString + length, maxOptLength - length,
" -l nodes=%d\n", numLocales);
}
break;
}
if (generate_qsub_script) {
fclose(qsubScript);
optionString = qsubFilename;
}
return optionString;
}
void chpl_printMemTable(int64_t threshold, int32_t lineno, c_string filename) {
const int numberWidth = 9;
const int precision = sizeof(uintptr_t) * 2;
const int addressWidth = precision+4;
const int descWidth = 33;
int filenameWidth = strlen("Allocated Memory (Bytes)");
int totalWidth;
memTableEntry* memEntry;
int n, i;
char* loc;
memTableEntry** table;
if (!chpl_memTrack)
chpl_error("The printMemTable function only works with the --memTrack flag", lineno, filename);
n = 0;
filenameWidth = strlen("Allocated Memory (Bytes)");
for (i = 0; i < hashSize; i++) {
for (memEntry = memTable[i]; memEntry != NULL; memEntry = memEntry->nextInBucket) {
size_t chunk = memEntry->number * memEntry->size;
if (chunk >= threshold) {
n += 1;
if (memEntry->filename) {
int filenameLength = strlen(memEntry->filename);
if (filenameLength > filenameWidth)
filenameWidth = filenameLength;
}
}
}
}
totalWidth = filenameWidth+numberWidth*4+descWidth+20;
for (i = 0; i < totalWidth; i++)
fprintf(memLogFile, "=");
fprintf(memLogFile, "\n");
fprintf(memLogFile, "%-*s%-*s%-*s%-*s%-*s%-*s\n",
filenameWidth+numberWidth, "Allocated Memory (Bytes)",
numberWidth, "Number",
numberWidth, "Size",
numberWidth, "Total",
descWidth, "Description",
20, "Address");
for (i = 0; i < totalWidth; i++)
fprintf(memLogFile, "=");
fprintf(memLogFile, "\n");
table = (memTableEntry**)malloc(n*sizeof(memTableEntry*));
if (!table)
chpl_error("out of memory printing memory table", lineno, filename);
n = 0;
for (i = 0; i < hashSize; i++) {
for (memEntry = memTable[i]; memEntry != NULL; memEntry = memEntry->nextInBucket) {
size_t chunk = memEntry->number * memEntry->size;
if (chunk >= threshold) {
table[n++] = memEntry;
}
}
}
qsort(table, n, sizeof(memTableEntry*), descCmp);
loc = (char*)malloc((filenameWidth+numberWidth+1)*sizeof(char));
for (i = 0; i < n; i++) {
memEntry = table[i];
if (memEntry->filename)
sprintf(loc, "%s:%"PRId32, memEntry->filename, memEntry->lineno);
else
sprintf(loc, "--");
fprintf(memLogFile, "%-*s%-*zu%-*zu%-*zu%-*s%#-*.*" PRIxPTR "\n",
filenameWidth+numberWidth, loc,
numberWidth, memEntry->number,
numberWidth, memEntry->size,
numberWidth, memEntry->size*memEntry->number,
descWidth, chpl_mem_descString(memEntry->description),
addressWidth, precision, (uintptr_t)memEntry->memAlloc);
}
for (i = 0; i < totalWidth; i++)
fprintf(memLogFile, "=");
fprintf(memLogFile, "\n");
putchar('\n');
free(table);
free(loc);
}
static char* chpl_launch_create_command(int argc, char* argv[],
int32_t numLocales) {
int i;
int size;
char baseCommand[256];
char* command;
FILE* llFile;
// char* projectString = getenv(launcherAccountEnvvar);
char* basenamePtr = strrchr(argv[0], '/');
pid_t mypid;
if (!walltime) {
chpl_error("You must specify the wall clock time limit of your job using --walltime\n"
"or CHPL_LAUNCHER_WALLTIME (HH:MM:SS)", 0, NULL);
}
if (basenamePtr == NULL) {
basenamePtr = argv[0];
} else {
basenamePtr++;
}
chpl_compute_real_binary_name(argv[0]);
if (debug) {
mypid = 0;
} else {
mypid = getpid();
}
sprintf(llFilename, "%s%d", baseLLFilename, (int)mypid);
llFile = fopen(llFilename, "w");
fprintf(llFile, "#!/bin/bash\n");
if (queue) {
fprintf(llFile, "# @ class = %s\n", queue);
}
fprintf(llFile, "# @ job_name = %s\n", basenamePtr);
fprintf(llFile, "# @ initialdir = .\n");
fprintf(llFile, "# @ output = %s_%%j.out\n", basenamePtr);
fprintf(llFile, "# @ error = %s_%%j.out\n", basenamePtr);
fprintf(llFile, "# @ total_tasks = %d\n", numLocales);
fprintf(llFile, "# @ cpus_per_task = 4\n");
fprintf(llFile, "# @ tasks_per_node = 1\n");
fprintf(llFile, "# @ wall_clock_limit = %s\n", walltime);
fprintf(llFile, "\n");
#if CHPL_COMM_SUBSTRATE == udp
fprintf(llFile, "MLIST=$(/opt/perf/bin/sl_get_machine_list -j=\\$SLURM_JOB_ID )\n");
fprintf(llFile, "\n");
fprintf(llFile, "export -n SSH_SERVERS\n");
fprintf(llFile, "for i in $MLIST ; do\n");
fprintf(llFile, " export SSH_SERVERS=\"$SSH_SERVERS $i\" ;\n");
fprintf(llFile, "done\n");
if (debug) {
fprintf(llFile, "echo $SSH_SERVERS\n");
}
fprintf(llFile, "\n");
fprintf(llFile, "%samudprun ", WRAP_TO_STR(LAUNCH_PATH));
#elif CHPL_COMM_SUBSTRATE == mpi
fprintf(llFile, "export MPIRUN_CMD='srun --kill-on-bad-exit %%C'\n");
fprintf(llFile, "export MPIRUN_CMD_OK=true\n");
fprintf(llFile, "\n");
fprintf(llFile, "%sgasnetrun_mpi ", WRAP_TO_STR(LAUNCH_PATH));
#elif CHPL_COMM_SUBSTRATE == none
#else
#error "Unknown CHPL_COMM_SUBSTRATE"
#endif
#if CHPL_COMM_SUBSTRATE != none
fprintf(llFile, "-n %d ", numLocales);
#endif
fprintf(llFile, "%s", chpl_get_real_binary_name());
for (i=1; i<argc; i++) {
fprintf(llFile, " '%s'", argv[i]);
}
fprintf(llFile, " || echo -n \"\"\n");
fclose(llFile);
sprintf(baseCommand, "mnsubmit %s", llFilename);
size = strlen(baseCommand) + 1;
command = chpl_mem_allocMany(size, sizeof(char), CHPL_RT_MD_COMMAND_BUFFER, -1, 0);
sprintf(command, "%s", baseCommand);
if (strlen(command)+1 > size) {
chpl_internal_error("buffer overflow");
}
return command;
}
