int main(int argc, char **argv)
{
struct timeval tv;
int i;
#ifdef WIN32
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
#endif
/* Initialize the event library */
opal_init(&argc, &argv);
for (i = 0; i < NEVENT; i++) {
/* Initalize one event */
ev[i] = (opal_event_t*)malloc(sizeof(opal_event_t));
opal_event_evtimer_set(opal_event_base, ev[i], time_cb, ev[i]);
tv.tv_sec = 0;
tv.tv_usec = rand_int(50000);
opal_event_evtimer_add(ev[i], &tv);
}
opal_event_dispatch(opal_event_base);
opal_finalize();
return (called < NEVENT);
}
int
main(int argc, char *argv[])
{
int ret;
int support;
opal_init();
/* this printf needs to be here for the test to work! */
printf("running malloc hooks test\n");
support = opal_mem_hooks_support_level();
if (0 == support) {
printf("no memory registration supported. skipping test.\n");
ret = 77;
} else if ((OPAL_MEMORY_FREE_SUPPORT|OPAL_MEMORY_MALLOC_SUPPORT) ==
((OPAL_MEMORY_FREE_SUPPORT|OPAL_MEMORY_MALLOC_SUPPORT) & support)) {
ret = alloc_free_test();
} else if (OPAL_MEMORY_FREE_SUPPORT & support) {
ret = free_only_test();
} else {
printf("Odd support response: %d\n", support);
ret = 1;
}
opal_finalize();
return ret;
}
int main (int argc, char* argv[])
{
opal_init(&argc, &argv);
test_out = stderr;
/* run the tests */
fprintf(test_out, "executing test1\n");
if (test1()) {
fprintf(test_out, "Test1 succeeded\n");
}
else {
fprintf(test_out, "Test1 failed\n");
}
fprintf(test_out, "executing test2\n");
if (test2()) {
fprintf(test_out, "Test2 succeeded\n");
}
else {
fprintf(test_out, "Test2 failed\n");
}
opal_finalize();
return(0);
}
int main(int argc, char* argv[])
{
opal_init(&argc, &argv);
test_init("opal_os_create_dirpath_t");
/* All done */
if (test1()) {
test_success();
}
else {
test_failure("opal_os_create_dirpath test1 failed");
}
if (test2()) {
test_success();
}
else {
test_failure("opal_os_create_dirpath test2 failed");
}
if (test3()) {
test_success();
}
else {
test_failure("opal_os_create_dirpath test3 failed");
}
test_finalize();
opal_finalize();
return 0;
}
static int setupOrcm(void)
{
int ret;
/* Call enough of orcm/orte so that the configuration file is
* read and we know if we are an aggregator or a compute node daemon.
*/
if (ORTE_SUCCESS != (ret = opal_init(NULL, NULL))) {
printf("FAIL Error in opal_init()\n");
return 1;
}
orte_process_info.proc_type = ORCM_DAEMON;
if (ORTE_SUCCESS != (ret = orte_proc_info())) {
printf("FAIL Error in orte_proc_info()\n");
return 1;
}
orte_event_base = opal_sync_event_base;
orcm_clusters = OBJ_NEW(opal_list_t);
orcm_schedulers = OBJ_NEW(opal_list_t);
if (ORCM_SUCCESS != (ret = mca_base_framework_open(&orcm_cfgi_base_framework, 0))) {
printf("FAIL orcm_cfgi_base_open\n");
return 1;
}
if (ORCM_SUCCESS != (ret = orcm_cfgi_base_select())) {
printf("FAIL orcm_cfgi_select\n"); /* bad configuration file */
return 99;
}
if (ORCM_SUCCESS != (ret = mca_base_framework_open(&orcm_sst_base_framework, 0))) {
printf("FAIL orcm_sst_base_framework\n");
return 1;
}
if (ORCM_SUCCESS != (ret = orcm_sst_base_select())) {
printf("FAIL orcm_sst_base_select\n");
return 1;
}
/* We need to set up the ESS framework because when ft_tester kills
* itself it calls the abort function.
*/
if (ORTE_SUCCESS != (ret = mca_base_framework_open(&orte_ess_base_framework, 0))) {
printf("FAIL orte_ess_base_open\n");
return 1;
}
if (ORTE_SUCCESS != (ret = orte_ess_base_select())) {
printf("FAIL orte_ess_base_select\n");
return 1;
}
if (ORTE_SUCCESS != (ret = orte_ess.init())) {
printf("FAIL orte_ess_init\n");
return 1;
}
return 0;
}
int main(int argc, char **argv)
{
opal_list_t *local_list, *remote_list;
opal_reachable_t *results;
uint32_t i, j;
int successful_connections = 0;
int local_ifs;
int remote_ifs;
opal_if_t *local_if;
opal_init(&argc, &argv);
/* List of interfaces generated by opal */
local_list = &opal_if_list;
/* Create test interfaces */
remote_list = build_if_list();
local_ifs = opal_list_get_size(local_list);
remote_ifs = opal_list_get_size(remote_list);
/* Tests reachability by looking up entries in routing table.
* Tests routes to localhost and google's nameservers.
*/
results = opal_reachable.reachable(local_list, remote_list);
printf("Local interfaces:\n");
i = 0;
OPAL_LIST_FOREACH(local_if, local_list, opal_if_t) {
char addr[128];
char *family;
switch (local_if->af_family) {
case AF_INET:
family = "IPv4";
inet_ntop(AF_INET, &(((struct sockaddr_in*) &local_if->if_addr))->sin_addr,
addr, sizeof(addr));
break;
case AF_INET6:
family = "IPv6";
inet_ntop(AF_INET6, &(((struct sockaddr_in6*) &local_if->if_addr))->sin6_addr,
addr, sizeof(addr));
break;
default:
family = "Unknown";
strcpy(addr, "Unknown");
break;
}
printf(" %3d: %s\t%s\t%s/%d\n", i, local_if->if_name,
family, addr, local_if->if_mask);
i++;
}
int main(int argc, char* argv[])
{
int rc, idx;
uint32_t addr, netmask, netaddr;
struct sockaddr_in inaddr;
char **aliases=NULL;
if (0 > (rc = opal_init(&argc, &argv))) {
fprintf(stderr, "orte_interface: couldn't init opal - error code %d\n", rc);
return rc;
}
if (2 == argc) {
rc = opal_iftupletoaddr(argv[1], &netaddr, &netmask);
fprintf(stderr, "netaddr %03d.%03d.%03d.%03d netmask %03d.%03d.%03d.%03d rc %d\n",
OPAL_IF_FORMAT_ADDR(netaddr), OPAL_IF_FORMAT_ADDR(netmask), rc);
/* search for a matching interface - take the first one within the returned scope */
idx = opal_ifbegin();
while (0 < idx) {
/* ignore the loopback interface */
if (opal_ifisloopback(idx)) {
fprintf(stderr, "LOOPBACK IGNORED\n");
idx = opal_ifnext(idx);
continue;
}
if (0 != (rc = opal_ifindextoaddr(idx, (struct sockaddr*)&inaddr, sizeof(inaddr)))) {
break;
}
addr = ntohl(inaddr.sin_addr.s_addr);
fprintf(stderr, "checking netaddr %03d.%03d.%03d.%03d addr %03d.%03d.%03d.%03d netmask %03d.%03d.%03d.%03d rc %d\n",
OPAL_IF_FORMAT_ADDR(netaddr), OPAL_IF_FORMAT_ADDR(addr), OPAL_IF_FORMAT_ADDR(netmask), rc);
if (netaddr == (addr & netmask)) {
fprintf(stderr, "MATCH FOUND\n");
}
idx = opal_ifnext(idx);
}
}
/* check the aliases */
opal_ifgetaliases(&aliases);
idx = 0;
while (NULL != aliases[idx]) {
fprintf(stderr, "alias: %s\n", aliases[idx]);
idx++;
}
opal_finalize();
return 0;
}
int
main(int argc, char **argv)
{
opal_event_t ev1, ev2;
orte_state_caddy_t *caddy;
opal_init(&argc, &argv);
/* assign some signal traps */
if (opal_event_signal_set(orte_event_base, &ev1, SIGTERM, cbfunc, &ev1) < 0) {
die("event_assign");
}
if (opal_event_set_priority(&ev1, ORTE_ERROR_PRI) < 0) {
die("event_set_pri");
}
if (opal_event_signal_add(&ev1, NULL) < 0) {
die("event_add");
}
if (opal_event_signal_set(orte_event_base, &ev2, SIGPIPE, cbfunc, &ev2) < 0) {
die("event_assign");
}
if (opal_event_set_priority(&ev2, ORTE_ERROR_PRI) < 0) {
die("event_assign");
}
if (opal_event_signal_add(&ev2, NULL) < 0) {
die("event_assign");
}
fprintf(stderr, "SIGNAL EVENTS DEFINED\n");
fflush(stderr);
/* assign a state event */
caddy = OBJ_NEW(orte_state_caddy_t);
opal_event_set(orte_event_base, &caddy->ev, -1, OPAL_EV_READ, t1func, caddy);
opal_event_set_priority(&caddy->ev, ORTE_SYS_PRI);
opal_event_active(&caddy->ev, OPAL_EV_WRITE, 1);
fprintf(stderr, "FIRST EVENT DEFINED AND ACTIVATED\n");
fflush(stderr);
/* event_dispatch(base); */
while (run) {
opal_event_loop(orte_event_base, OPAL_EVLOOP_ONCE);
}
fprintf(stderr, "EXITED LOOP - FINALIZING\n");
fflush(stderr);
opal_finalize();
return 0;
}
int
main(int argc, char *argv[])
{
int ret;
ret = opal_init(&argc, &argv);
if (OPAL_SUCCESS != ret) {
return (-1 * ret);
}
ret = opal_finalize();
if (OPAL_SUCCESS != ret) {
return (-1 * ret);
}
return 0;
}
int main(int argc, char** argv)
{
int rc;
opal_thread_t* thr1;
opal_thread_t* thr2;
test_init("opal_condition_t");
rc = opal_init(&argc, &argv);
test_verify_int(OPAL_SUCCESS, rc);
if (OPAL_SUCCESS != rc) {
test_finalize();
exit(1);
}
opal_set_using_threads(true);
OBJ_CONSTRUCT(&mutex, opal_mutex_t);
OBJ_CONSTRUCT(&thr1_cond, opal_condition_t);
OBJ_CONSTRUCT(&thr2_cond, opal_condition_t);
thr1 = OBJ_NEW(opal_thread_t);
thr2 = OBJ_NEW(opal_thread_t);
thr1->t_run = thr1_run;
thr2->t_run = thr2_run;
rc = opal_thread_start(thr1);
test_verify_int(OPAL_SUCCESS, rc);
rc = opal_thread_start(thr2);
test_verify_int(OPAL_SUCCESS, rc);
rc = opal_thread_join(thr1, NULL);
test_verify_int(OPAL_SUCCESS, rc);
test_verify_int(TEST_COUNT, thr1_count);
rc = opal_thread_join(thr2, NULL);
test_verify_int(OPAL_SUCCESS, rc);
test_verify_int(TEST_COUNT, thr2_count);
opal_finalize();
return test_finalize();
}
int orte_init(int* pargc, char*** pargv, orte_proc_type_t flags)
{
int ret;
char *error = NULL;
if (0 < orte_initialized) {
/* track number of times we have been called */
orte_initialized++;
return ORTE_SUCCESS;
}
orte_initialized++;
/* initialize the opal layer */
if (ORTE_SUCCESS != (ret = opal_init(pargc, pargv))) {
error = "opal_init";
goto error;
}
/* ensure we know the type of proc for when we finalize */
orte_process_info.proc_type = flags;
/* setup the locks */
if (ORTE_SUCCESS != (ret = orte_locks_init())) {
error = "orte_locks_init";
goto error;
}
/* Register all MCA Params */
if (ORTE_SUCCESS != (ret = orte_register_params())) {
error = "orte_register_params";
goto error;
}
/* setup the orte_show_help system */
if (ORTE_SUCCESS != (ret = orte_show_help_init())) {
error = "opal_output_init";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORTE", ORTE_ERR_BASE, ORTE_ERR_MAX, orte_err2str);
/* Ensure the rest of the process info structure is initialized */
if (ORTE_SUCCESS != (ret = orte_proc_info())) {
error = "orte_proc_info";
goto error;
}
/* open the ESS and select the correct module for this environment */
if (ORTE_SUCCESS != (ret = orte_ess_base_open())) {
error = "orte_ess_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess_base_select())) {
error = "orte_ess_base_select";
goto error;
}
#if ORTE_ENABLE_PROGRESS_THREADS
#if OPAL_EVENT_HAVE_THREAD_SUPPORT
/* get a separate orte event base */
orte_event_base = opal_event_base_create();
/* construct the thread object */
OBJ_CONSTRUCT(&orte_progress_thread, opal_thread_t);
/* fork off a thread to progress it */
orte_progress_thread.t_run = orte_progress_thread_engine;
if (OPAL_SUCCESS != (ret = opal_thread_start(&orte_progress_thread))) {
error = "orte progress thread start";
goto error;
}
#else
error = "event thread support is not configured";
ret = ORTE_ERROR;
goto error;
#endif
#else
/* set the event base to the opal one */
orte_event_base = opal_event_base;
#endif
/* initialize the RTE for this environment */
if (ORTE_SUCCESS != (ret = orte_ess.init())) {
error = "orte_ess_init";
goto error;
}
/* All done */
return ORTE_SUCCESS;
error:
if (ORTE_ERR_SILENT != ret) {
orte_show_help("help-orte-runtime",
"orte_init:startup:internal-failure",
true, error, ORTE_ERROR_NAME(ret), ret);
}
return ret;
}
int main(int argc, char* argv[])
{
hwloc_obj_t obj;
unsigned j, k;
struct hwloc_topology_support *support;
int rc;
if (2 != argc) {
fprintf(stderr, "Usage: opal_hwloc <topofile>\n");
exit(1);
}
if (0 > (rc = opal_init(&argc, &argv))) {
fprintf(stderr, "opal_hwloc: couldn't init opal - error code %d\n", rc);
return rc;
}
if (0 != hwloc_topology_init(&my_topology)) {
return OPAL_ERR_NOT_SUPPORTED;
}
if (0 != hwloc_topology_set_xml(my_topology, argv[1])) {
hwloc_topology_destroy(my_topology);
return OPAL_ERR_NOT_SUPPORTED;
}
/* since we are loading this from an external source, we have to
* explicitly set a flag so hwloc sets things up correctly
*/
if (0 != hwloc_topology_set_flags(my_topology,
(HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM |
HWLOC_TOPOLOGY_FLAG_WHOLE_SYSTEM |
HWLOC_TOPOLOGY_FLAG_IO_DEVICES))) {
hwloc_topology_destroy(my_topology);
return OPAL_ERR_NOT_SUPPORTED;
}
if (0 != hwloc_topology_load(my_topology)) {
hwloc_topology_destroy(my_topology);
return OPAL_ERR_NOT_SUPPORTED;
}
/* remove the hostname from the topology. Unfortunately, hwloc
* decided to add the source hostname to the "topology", thus
* rendering it unusable as a pure topological description. So
* we remove that information here.
*/
obj = hwloc_get_root_obj(my_topology);
for (k=0; k < obj->infos_count; k++) {
if (NULL == obj->infos[k].name ||
NULL == obj->infos[k].value) {
continue;
}
if (0 == strncmp(obj->infos[k].name, "HostName", strlen("HostName"))) {
free(obj->infos[k].name);
free(obj->infos[k].value);
/* left justify the array */
for (j=k; j < obj->infos_count-1; j++) {
obj->infos[j] = obj->infos[j+1];
}
obj->infos[obj->infos_count-1].name = NULL;
obj->infos[obj->infos_count-1].value = NULL;
obj->infos_count--;
break;
}
}
/* unfortunately, hwloc does not include support info in its
* xml output :-(( We default to assuming it is present as
* systems that use this option are likely to provide
* binding support
*/
support = (struct hwloc_topology_support*)hwloc_topology_get_support(my_topology);
support->cpubind->set_thisproc_cpubind = true;
/* filter the cpus thru any default cpu set */
opal_hwloc_base_filter_cpus(my_topology);
/* fill opal_cache_line_size global with the smallest L1 cache
line size */
fill_cache_line_size();
/* test it */
if (NULL == hwloc_get_obj_by_type(my_topology, HWLOC_OBJ_CORE, 0)) {
fprintf(stderr, "DIDN'T FIND A CORE\n");
}
hwloc_topology_destroy(my_topology);
opal_finalize();
return 0;
}
int
main(int argc, char *argv[])
{
char hostname[OPAL_MAXHOSTNAMELEN];
opal_init(&argc, &argv);
test_init("opal_if");
/* 127.0.0.1 */
if (test_ifaddrtoname("127.0.0.1")) {
test_success();
} else {
test_failure("ifaddrtoname test failed for 127.0.0.1");
}
if (opal_ifislocal("127.0.0.1")) {
test_success();
} else {
test_failure("ifislocal test failed for 127.0.0.1");
}
/* localhost */
if (test_ifaddrtoname("localhost")) {
test_success();
} else {
test_failure("ifaddrtoname test failed for localhost");
}
if (opal_ifislocal("localhost")) {
test_success();
} else {
test_failure("ifislocal test failed for localhost");
}
/* 0.0.0.0 */
if (test_ifaddrtoname("0.0.0.0")) {
test_failure("ifaddrtoname test failed for 0.0.0.0");
} else {
test_success();
}
if (opal_ifislocal("0.0.0.0")) {
test_failure("opal_ifislocal test failed for 0.0.0.0");
} else {
test_success();
}
/* foo.example.com */
printf("This should generate a warning:\n");
fflush(stdout);
if (test_ifaddrtoname("foo.example.com")) {
test_failure("ifaddrtoname test failed for foo.example.com");
} else {
test_success();
}
printf("This should generate a warning:\n");
fflush(stdout);
if (opal_ifislocal("foo.example.com")) {
test_failure("ifislocal test failed for foo.example.com");
} else {
test_success();
}
/* local host name */
gethostname(hostname, sizeof(hostname));
if (test_ifaddrtoname(hostname)) {
test_success();
} else {
test_failure("ifaddrtoname test failed for local host name");
}
if (opal_ifislocal(hostname)) {
test_success();
} else {
test_failure("ifislocal test failed for local host name");
}
test_finalize();
opal_finalize();
return 0;
}
static int initialize(int argc, char *argv[])
{
int ret, exit_status = OPAL_SUCCESS;
char * tmp_env_var = NULL;
/*
* Make sure to init util before parse_args
* to ensure installdirs is setup properly
* before calling mca_base_open();
*/
if( OPAL_SUCCESS != (ret = opal_init_util(&argc, &argv)) ) {
return ret;
}
/*
* Parse Command line arguments
*/
if (OPAL_SUCCESS != (ret = parse_args(argc, argv))) {
exit_status = ret;
goto cleanup;
}
/*
* Setup OPAL Output handle from the verbose argument
*/
if( opal_restart_globals.verbose ) {
opal_restart_globals.output = opal_output_open(NULL);
opal_output_set_verbosity(opal_restart_globals.output, 10);
} else {
opal_restart_globals.output = 0; /* Default=STDOUT */
}
/*
* Turn off the selection of the CRS component,
* we need to do that later
*/
(void) mca_base_var_env_name("crs_base_do_not_select", &tmp_env_var);
opal_setenv(tmp_env_var,
"1", /* turn off the selection */
true, &environ);
free(tmp_env_var);
tmp_env_var = NULL;
/*
* Make sure we select the proper compress component.
*/
if( NULL != opal_restart_globals.snapshot_compress ) {
(void) mca_base_var_env_name("compress", &tmp_env_var);
opal_setenv(tmp_env_var,
opal_restart_globals.snapshot_compress,
true, &environ);
free(tmp_env_var);
tmp_env_var = NULL;
}
/*
* Initialize the OPAL layer
*/
if (OPAL_SUCCESS != (ret = opal_init(&argc, &argv))) {
exit_status = ret;
goto cleanup;
}
/*
* If the checkpoint was compressed, then decompress it before continuing
*/
if( NULL != opal_restart_globals.snapshot_compress ) {
char * zip_dir = NULL;
char * tmp_str = NULL;
/* Make sure to clear the selection for the restart,
* this way the user can swich compression mechanism
* across restart
*/
(void) mca_base_var_env_name("compress", &tmp_env_var);
opal_unsetenv(tmp_env_var, &environ);
free(tmp_env_var);
tmp_env_var = NULL;
opal_asprintf(&zip_dir, "%s/%s%s",
opal_restart_globals.snapshot_loc,
opal_restart_globals.snapshot_ref,
opal_restart_globals.snapshot_compress_postfix);
if (0 > (ret = access(zip_dir, F_OK)) ) {
opal_output(opal_restart_globals.output,
"Error: Unable to access the file [%s]!",
zip_dir);
exit_status = OPAL_ERROR;
goto cleanup;
}
opal_output_verbose(10, opal_restart_globals.output,
"Decompressing (%s)",
zip_dir);
opal_compress.decompress(zip_dir, &tmp_str);
if( NULL != zip_dir ) {
free(zip_dir);
zip_dir = NULL;
}
if( NULL != tmp_str ) {
free(tmp_str);
tmp_str = NULL;
}
}
/*
* If a cache directory has been suggested, see if it exists
*/
if( NULL != opal_restart_globals.snapshot_cache ) {
if(0 == (ret = access(opal_restart_globals.snapshot_cache, F_OK)) ) {
opal_output_verbose(10, opal_restart_globals.output,
"Using the cached snapshot (%s) instead of (%s)",
opal_restart_globals.snapshot_cache,
opal_restart_globals.snapshot_loc);
if( NULL != opal_restart_globals.snapshot_loc ) {
free(opal_restart_globals.snapshot_loc);
opal_restart_globals.snapshot_loc = NULL;
}
opal_restart_globals.snapshot_loc = opal_dirname(opal_restart_globals.snapshot_cache);
} else {
opal_show_help("help-opal-restart.txt", "cache_not_avail", true,
opal_restart_globals.snapshot_cache,
opal_restart_globals.snapshot_loc);
}
}
/*
* Mark this process as a tool
*/
opal_cr_is_tool = true;
cleanup:
return exit_status;
}
static int initialize(int argc, char *argv[]) {
int ret, exit_status = OPAL_SUCCESS;
char * tmp_env_var = NULL;
/*
* Make sure to init util before parse_args
* to ensure installdirs is setup properly
* before calling mca_base_open();
*/
if( OPAL_SUCCESS != (ret = opal_init_util(&argc, &argv)) ) {
return ret;
}
/*
* Parse Command Line Arguments
*/
if (OPAL_SUCCESS != (ret = parse_args(argc, argv))) {
exit_status = ret;
goto cleanup;
}
/*
* Setup OPAL Output handle from the verbose argument
*/
if( opal_checkpoint_globals.verbose ) {
opal_checkpoint_globals.quiet = false; /* Automaticly turn off quiet if it is set */
opal_checkpoint_globals.output = opal_output_open(NULL);
opal_output_set_verbosity(opal_checkpoint_globals.output, 10);
} else {
opal_checkpoint_globals.output = 0; /* Default=STDOUT */
}
/*
* Disable the checkpoint notification routine for this
* tool. As we will never need to checkpoint this tool.
* Note: This must happen before opal_init().
*/
opal_cr_set_enabled(false);
/*
* Select the 'none' CRS component,
* since we don't actually use a checkpointer
*/
(void) mca_base_var_env_name("crs", &tmp_env_var);
opal_setenv(tmp_env_var,
"none",
true, &environ);
free(tmp_env_var);
tmp_env_var = NULL;
/*
* Initialize OPAL
*/
if (OPAL_SUCCESS != (ret = opal_init(&argc, &argv))) {
exit_status = ret;
goto cleanup;
}
cleanup:
return exit_status;
}
int main(int argc, char **argv)
{
/* local variables */
opal_list_t list, x;
size_t indx,i,list_size, tmp_size_1, tmp_size_2,size_elements;
int error_cnt;
test_data_t *elements, *ele;
opal_list_item_t *item;
opal_init();
test_init("opal_list_t");
/* initialize list */
OBJ_CONSTRUCT(&list, opal_list_t);
OBJ_CONSTRUCT(&x, opal_list_t);
/* check length of list */
list_size=opal_list_get_size(&list);
if( 0 == list_size ) {
test_success();
} else {
test_failure(" opal_list_get_size");
}
/* check for empty */
if (opal_list_is_empty(&list)) {
test_success();
} else {
test_failure(" opal_list_is_empty(empty list)");
}
/* create test elements */
size_elements=4;
elements=(test_data_t *)malloc(sizeof(test_data_t)*size_elements);
assert(elements);
for(i=0 ; i < size_elements ; i++) {
OBJ_CONSTRUCT(elements + i, test_data_t);
(elements+i)->data=i;
}
/* populate list */
for(i=0 ; i < size_elements ; i++) {
opal_list_append(&list,(opal_list_item_t *)(elements+i));
}
list_size=opal_list_get_size(&list);
if( list_size == size_elements ) {
test_success();
} else {
test_failure(" populating list");
}
/* checking for empty on non-empty list */
if (!opal_list_is_empty(&list)) {
test_success();
} else {
test_failure(" opal_list_is_empty(non-empty list)");
}
/* check that list is ordered as expected */
i=0;
error_cnt=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
if( ele->data != i )
error_cnt++;
i++;
}
if( 0 == error_cnt ) {
test_success();
} else {
test_failure(" error in list order ");
}
/* check opal_list_get_first */
ele = (test_data_t *)NULL;
ele = (test_data_t *) opal_list_get_first(&list);
assert(ele);
if( 0 == ele->data ) {
test_success();
} else {
test_failure(" error in opal_list_get_first");
}
i=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
i++;
}
if( size_elements == i ) {
test_success();
} else {
test_failure(" error in opal_list_get_first - list size changed ");
}
/* check opal_list_get_last */
ele = (test_data_t *)NULL;
ele = (test_data_t *) opal_list_get_last(&list);
assert(ele);
if( (size_elements-1) == ele->data ) {
test_success();
} else {
test_failure(" error in opal_list_get_last");
}
i=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
i++;
}
if( size_elements == i ) {
test_success();
} else {
test_failure(" error in opal_list_get_first - list size changed ");
}
/* check opal_list_remove_first */
ele = (test_data_t *)NULL;
ele = (test_data_t *) opal_list_remove_first(&list);
assert(ele);
if( 0 == ele->data ) {
test_success();
} else {
test_failure(" error in opal_list_remove_first");
}
i=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
i++;
}
if( (size_elements-1) == i ) {
test_success();
} else {
test_failure(" error in opal_list_remove_first - list size changed ");
}
/* test opal_list_prepend */
opal_list_prepend(&list,(opal_list_item_t *)elements);
ele = (test_data_t *)NULL;
ele = (test_data_t *) opal_list_get_first(&list);
assert(ele);
if( 0 == ele->data ) {
test_success();
} else {
test_failure(" error in opal_list_prepend");
}
i=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
i++;
}
if( size_elements == i ) {
test_success();
} else {
test_failure(" error in opal_list_prepend - list size changed ");
}
/* check opal_list_remove_last */
ele = (test_data_t *)NULL;
ele = (test_data_t *) opal_list_remove_last(&list);
assert(ele);
if( (size_elements-1) == ele->data ) {
test_success();
} else {
test_failure(" error in opal_list_remove_last");
}
i=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
i++;
}
if( (size_elements-1) == i ) {
test_success();
} else {
test_failure(" error in opal_list_remove_last - list size changed ");
}
/* test opal_list_append */
opal_list_append(&list,(opal_list_item_t *)(elements+size_elements-1));
ele = (test_data_t *)NULL;
ele = (test_data_t *) opal_list_get_last(&list);
assert(ele);
if( (size_elements-1) == ele->data ) {
test_success();
} else {
test_failure(" error in opal_list_append");
}
i=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
i++;
}
if( size_elements == i ) {
test_success();
} else {
test_failure(" error in opal_list_append - list size changed ");
}
/* remove element from list */
indx=size_elements/2;
if( 0 == indx )
indx=1;
assert(2 <= size_elements);
ele = (test_data_t *)NULL;
ele = (test_data_t *)
opal_list_remove_item(&list,(opal_list_item_t *)(elements+indx));
assert(ele);
if( (indx-1) == ele->data ) {
test_success();
} else {
test_failure(" error in opal_list_remove - previous");
}
ele=(test_data_t *)(((opal_list_item_t *)ele)->opal_list_next);
if( (indx+1) == ele->data ) {
test_success();
} else {
test_failure(" error in opal_list_remove - next");
}
i=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
i++;
}
if( (size_elements-1) == i ) {
test_success();
} else {
test_failure(" error in opal_list_remove - list size changed incorrectly");
}
/* test the insert function */
i=opal_list_insert(&list,(opal_list_item_t *)(elements+indx),indx);
if( 1 == i ) {
test_success();
} else {
test_failure(" error in opal_list_remove_item \n");
}
i=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
i++;
}
if( size_elements == i ) {
test_success();
} else {
test_failure(" error in opal_list_insert - incorrect list length");
}
i=0;
error_cnt=0;
for(ele = (test_data_t *) opal_list_get_first(&list);
ele != (test_data_t *) opal_list_get_end(&list);
ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) {
if( ele->data != i )
error_cnt++;
i++;
}
if( 0 == error_cnt ) {
test_success();
} else {
test_failure(" error in list order - opal_list_remove_item ");
}
/* test the splice and join functions */
list_size = opal_list_get_size(&list);
for (i = 0, item = opal_list_get_first(&list) ;
i < list_size / 2 ; ++i, item = opal_list_get_next(item)) {
}
opal_list_splice(&x, opal_list_get_end(&x),
&list, item, opal_list_get_end(&list));
tmp_size_1 = opal_list_get_size(&list);
tmp_size_2 = opal_list_get_size(&x);
if (tmp_size_1 != i) {
test_failure(" error in splice (size of list)");
} else if (tmp_size_2 != list_size - tmp_size_1) {
test_failure(" error in splice (size of x)");
} else {
test_success();
}
opal_list_join(&list, opal_list_get_end(&list), &x);
tmp_size_1 = opal_list_get_size(&list);
tmp_size_2 = opal_list_get_size(&x);
if (tmp_size_1 != list_size) {
test_failure(" error in join (size of list)");
} else if (tmp_size_2 != 0) {
test_failure(" error in join (size of x)");
} else {
test_success();
}
if (NULL != elements) free(elements);
opal_finalize();
return test_finalize();
}
int main (int argc, char* argv[])
{
opal_init(&argc, &argv);
test_out = stderr;
/* run the tests */
fprintf(test_out, "executing test1\n");
if (test1()) {
fprintf(test_out, "Test1 succeeded\n");
}
else {
fprintf(test_out, "Test1 failed\n");
}
fprintf(test_out, "executing test2\n");
if (test2()) {
fprintf(test_out, "Test2 succeeded\n");
}
else {
fprintf(test_out, "Test2 failed\n");
}
fprintf(test_out, "executing test3\n");
if (test3()) {
fprintf(test_out, "Test3 succeeded\n");
}
else {
fprintf(test_out, "Test3 failed\n");
}
fprintf(test_out, "executing test4\n");
if (test4()) {
fprintf(test_out, "Test4 succeeded\n");
}
else {
fprintf(test_out, "Test4 failed\n");
}
fprintf(test_out, "executing test5\n");
if (test5()) {
fprintf(test_out, "Test5 succeeded\n");
}
else {
fprintf(test_out, "Test5 failed\n");
}
fprintf(test_out, "executing test6\n");
if (test6()) {
fprintf(test_out, "Test6 succeeded\n");
}
else {
fprintf(test_out, "Test6 failed\n");
}
fprintf(test_out, "executing test7\n");
if (test7()) {
fprintf(test_out, "Test7 succeeded\n");
}
else {
fprintf(test_out, "Test7 failed\n");
}
fprintf(test_out, "executing test8\n");
if (test8()) {
fprintf(test_out, "Test8 succeeded\n");
}
else {
fprintf(test_out, "Test8 failed\n");
}
fprintf(test_out, "executing test9\n");
if (test9()) {
fprintf(test_out, "Test9 succeeded\n");
}
else {
fprintf(test_out, "opal_dss test9 failed\n");
}
fprintf(test_out, "executing test10\n");
if (test10()) {
fprintf(test_out, "Test10 succeeded\n");
}
else {
fprintf(test_out, "opal_dss test10 failed\n");
}
fprintf(test_out, "executing test11\n");
if (test11()) {
fprintf(test_out, "Test11 succeeded\n");
}
else {
fprintf(test_out, "opal_dss test11 failed\n");
}
fprintf(test_out, "executing test12\n");
if (test12()) {
fprintf(test_out, "Test12 succeeded\n");
}
else {
fprintf(test_out, "opal_dss test12 failed\n");
}
fclose(test_out);
opal_finalize();
return(0);
}
int orcm_init(orcm_proc_type_t flags)
{
int ret;
char *error;
int spin;
opal_output_stream_t lds;
if (0 < orcm_initialized) {
/* track number of times we have been called */
orcm_initialized++;
return ORCM_SUCCESS;
}
orcm_initialized++;
if (NULL != getenv("ORCM_MCA_spin")) {
spin = 1;
/* spin until a debugger can attach */
while (0 != spin) {
ret = 0;
while (ret < 10000) {
ret++;
};
}
}
/* initialize the opal layer */
if (ORTE_SUCCESS != (ret = opal_init(NULL, NULL))) {
error = "opal_init";
goto error;
}
orcm_debug_verbosity = -1;
(void) mca_base_var_register ("orcm", "orcm", NULL, "debug_verbose",
"Verbosity level for ORCM debug messages (default: 1)",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orcm_debug_verbosity);
if (0 <= orcm_debug_verbosity) {
/* get a debug output channel */
OBJ_CONSTRUCT(&lds, opal_output_stream_t);
lds.lds_want_stdout = true;
orcm_debug_output = opal_output_open(&lds);
OBJ_DESTRUCT(&lds);
/* set the verbosity */
opal_output_set_verbosity(orcm_debug_output, orcm_debug_verbosity);
}
/* ensure we know the type of proc for when we finalize */
orte_process_info.proc_type = flags;
/* setup the locks */
if (ORTE_SUCCESS != (ret = orte_locks_init())) {
error = "orte_locks_init";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORTE", ORTE_ERR_BASE, ORTE_ERR_MAX, orte_err2str);
/* Ensure the rest of the process info structure is initialized */
if (ORTE_SUCCESS != (ret = orte_proc_info())) {
error = "orte_proc_info";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORCM", ORCM_ERR_BASE, ORCM_ERR_MAX, orcm_err2str);
/* register handler for attr key -> string conversion */
if (ORTE_SUCCESS != (ret = orte_attr_register("orcm", ORCM_ATTR_KEY_BASE, ORCM_ATTR_KEY_MAX,
orcm_attr_key_print))) {
error = "register attr print";
goto error;
}
/* we don't need a progress thread as all our tools loop inside themselves,
* so define orte_event_base to be the base opal_event_base
*/
orte_event_base = opal_sync_event_base;
/* setup the globals */
orcm_clusters = OBJ_NEW(opal_list_t);
orcm_schedulers = OBJ_NEW(opal_list_t);
/* everyone must open the cfgi framework */
if (ORCM_SUCCESS != (ret = mca_base_framework_open(&orcm_cfgi_base_framework, 0))) {
error = "orcm_cfgi_base_open";
goto error;
}
if (ORCM_SUCCESS != (ret = orcm_cfgi_base_select())) {
error = "orcm_cfgi_select";
goto error;
}
/* everyone must open the sst framework */
if (ORCM_SUCCESS != (ret = mca_base_framework_open(&orcm_sst_base_framework, 0))) {
error = "orcm_sst_base_open";
goto error;
}
if (ORCM_SUCCESS != (ret = orcm_sst_base_select())) {
error = "orcm_sst_select";
goto error;
}
/* open the ESS and select the correct module for this environment - the
* orcm module is basically a no-op, but we need the framework defined
* as other parts of ORTE will want to call it
*/
if (ORTE_SUCCESS != (ret = mca_base_framework_open(&orte_ess_base_framework, 0))) {
ORTE_ERROR_LOG(ret);
error = "orte_ess_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess_base_select())) {
error = "orte_ess_base_select";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess.init())) {
error = "orte_ess_init";
goto error;
}
/* initialize us - we will register the ORTE-level MCA params in there */
if (ORTE_SUCCESS != (ret = orcm_sst.init())) {
error = "orte_init";
goto error;
}
/* setup the orte_show_help system - don't do this until the
* end as otherwise show_help messages won't appear
*/
if (ORTE_SUCCESS != (ret = orte_show_help_init())) {
error = "opal_output_init";
goto error;
}
/* initialize orcm datatype support */
if (ORCM_SUCCESS != (ret = orcm_dt_init())) {
error = "orcm_dt_init";
goto error;
}
/* flag that orte is initialized so things can work */
orte_initialized = true;
return ORCM_SUCCESS;
error:
if (ORCM_ERR_SILENT != ret) {
opal_show_help("help-orcm-runtime.txt",
"orcm_init:startup:internal-failure",
true, error, ORTE_ERROR_NAME(ret), ret);
}
return ret;
}
int orcm_init(orcm_proc_type_t flags)
{
int ret;
char *error, *envar;
int spin;
opal_output_stream_t lds;
if (0 < orcm_initialized) {
/* track number of times we have been called */
orcm_initialized++;
return ORCM_SUCCESS;
}
orcm_initialized++;
if (NULL != getenv("ORCM_MCA_spin")) {
spin = 1;
/* spin until a debugger can attach */
while (0 != spin) {
ret = 0;
while (ret < 10000) {
ret++;
};
}
}
/* prior to initializing the OPAL layer, check to see
* if the OPAL (and friends) install location has been
* moved. In order to avoid conflicts with any other
* OPAL-using software, the relocation point will have
* been expressed as a set of "ORCM_foo" envars. We
* therefore check for the ORCM_foo values, and name-shift
* any we find to OPAL_foo so that OPAL will find them.
* Since all ORCM tools will have already copied their
* local environment, these name-shifted vars will not
* appear in the environment of any launched processes */
if (NULL != (envar = getenv("ORCM_PREFIX"))) {
opal_unsetenv("ORCM_PREFIX", &environ);
opal_setenv("OPAL_PREFIX", envar, true, &environ);
}
if (NULL != (envar = getenv("ORCM_LIBDIR"))) {
opal_unsetenv("ORCM_LIBDIR", &environ);
opal_setenv("OPAL_LIBDIR", envar, true, &environ);
}
if (NULL != (envar = getenv("ORCM_DATADIR"))) {
opal_unsetenv("ORCM_DATADIR", &environ);
opal_setenv("OPAL_DATADIR", envar, true, &environ);
}
/* initialize the opal layer */
if (ORTE_SUCCESS != (ret = opal_init(NULL, NULL))) {
error = "opal_init";
goto error;
}
orcm_debug_verbosity = -1;
(void) mca_base_var_register ("orcm", "orcm", NULL, "debug_verbose",
"Verbosity level for ORCM debug messages (default: 1)",
MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
OPAL_INFO_LVL_9, MCA_BASE_VAR_SCOPE_ALL,
&orcm_debug_verbosity);
if (0 <= orcm_debug_verbosity) {
/* get a debug output channel */
OBJ_CONSTRUCT(&lds, opal_output_stream_t);
lds.lds_want_stdout = true;
orcm_debug_output = opal_output_open(&lds);
OBJ_DESTRUCT(&lds);
/* set the verbosity */
opal_output_set_verbosity(orcm_debug_output, orcm_debug_verbosity);
}
/* ensure we know the type of proc for when we finalize */
orte_process_info.proc_type = flags;
/* setup the locks */
if (ORTE_SUCCESS != (ret = orte_locks_init())) {
error = "orte_locks_init";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORTE", ORTE_ERR_BASE, ORTE_ERR_MAX, orte_err2str);
/* Ensure the rest of the process info structure is initialized */
if (ORTE_SUCCESS != (ret = orte_proc_info())) {
error = "orte_proc_info";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORCM", ORCM_ERR_BASE, ORCM_ERR_MAX, orcm_err2str);
/* register handler for attr key -> string conversion */
if (ORTE_SUCCESS != (ret = orte_attr_register("orcm", ORCM_ATTR_KEY_BASE, ORCM_ATTR_KEY_MAX,
orcm_attr_key_print))) {
error = "register attr print";
goto error;
}
/* we don't need a progress thread as all our tools loop inside themselves,
* so define orte_event_base to be the base opal_event_base
*/
orte_event_base = opal_sync_event_base;
/* setup the globals */
orcm_clusters = OBJ_NEW(opal_list_t);
orcm_schedulers = OBJ_NEW(opal_list_t);
if (ORTE_SUCCESS != (ret = mca_base_framework_open(&orcm_parser_base_framework, 0))) {
ORTE_ERROR_LOG(ret);
error = "orcm_parser_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = orcm_parser_base_select())) {
ORTE_ERROR_LOG(ret);
error = "orcm_parser_select";
goto error;
}
/* everyone must open the cfgi framework */
if (ORCM_SUCCESS != (ret = mca_base_framework_open(&orcm_cfgi_base_framework, 0))) {
error = "orcm_cfgi_base_open";
goto error;
}
if (ORCM_SUCCESS != (ret = orcm_cfgi_base_select())) {
error = "orcm_cfgi_select";
goto error;
}
envar = getenv("ORCM_MCA_logical_group_config_file");
if (ORCM_SUCCESS != (ret = orcm_logical_group_load_to_memory(envar))) {
error = "orcm_logical_group_load_to_memory";
goto error;
}
if (ORCM_SCHED == flags) {
if (NULL == (envar = getenv("ORCM_MCA_event_exec_path"))) {
asprintf(&orcm_event_exec_path, "%s/bin", opal_install_dirs.prefix);
} else {
orcm_event_exec_path = strdup(envar);
}
if (NULL == orcm_event_exec_path) {
error = "orcm_event_exec_path";
goto error;
}
}
/* everyone must open the sst framework */
if (ORCM_SUCCESS != (ret = mca_base_framework_open(&orcm_sst_base_framework, 0))) {
error = "orcm_sst_base_open";
goto error;
}
if (ORCM_SUCCESS != (ret = orcm_sst_base_select())) {
error = "orcm_sst_select";
goto error;
}
/* open the ESS and select the correct module for this environment - the
* orcm module is basically a no-op, but we need the framework defined
* as other parts of ORTE will want to call it
*/
if (ORTE_SUCCESS != (ret = mca_base_framework_open(&orte_ess_base_framework, 0))) {
ORTE_ERROR_LOG(ret);
error = "orte_ess_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess_base_select())) {
error = "orte_ess_base_select";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess.init())) {
error = "orte_ess_init";
goto error;
}
/* initialize us - we will register the ORTE-level MCA params in there */
if (ORTE_SUCCESS != (ret = orcm_sst.init())) {
error = "orte_init";
goto error;
}
/* setup the orte_show_help system - don't do this until the
* end as otherwise show_help messages won't appear
*/
if (ORTE_SUCCESS != (ret = orte_show_help_init())) {
error = "opal_output_init";
goto error;
}
/* initialize orcm datatype support */
if (ORCM_SUCCESS != (ret = orcm_dt_init())) {
error = "orcm_dt_init";
goto error;
}
/* flag that orte is initialized so things can work */
orte_initialized = true;
orte_help_want_aggregate = false;
return ORCM_SUCCESS;
error:
if (ORCM_ERR_SILENT != ret) {
opal_show_help("help-orcm-runtime.txt",
"orcm_init:startup:internal-failure",
true, error, ORTE_ERROR_NAME(ret), ret);
}
return ret;
}
int main(int argc, char* argv[])
{
int rc, idx;
uint32_t addr, netmask, netaddr;
struct sockaddr_in inaddr, *paddr;
char **aliases=NULL;
opal_if_t *intf;
if (0 > (rc = opal_init(&argc, &argv))) {
fprintf(stderr, "opal_interface: couldn't init opal - error code %d\n", rc);
return rc;
}
if (OPAL_SUCCESS != mca_base_framework_open(&opal_if_base_framework, 0)) {
fprintf(stderr, "opal_interface: couldn't get interfaces\n");
return 1;
}
for (intf = (opal_if_t*)opal_list_get_first(&opal_if_list);
intf != (opal_if_t*)opal_list_get_end(&opal_if_list);
intf = (opal_if_t*)opal_list_get_next(intf)) {
paddr = (struct sockaddr_in*) &intf->if_addr;
fprintf(stderr, "intf: %s AF: %s indx: %d kindx: %d\n", intf->if_name,
(AF_INET == paddr->sin_family) ? "v4" : "v6",
intf->if_index, intf->if_kernel_index);
}
if (2 == argc) {
rc = opal_iftupletoaddr(argv[1], &netaddr, &netmask);
fprintf(stderr, "netaddr %03d.%03d.%03d.%03d netmask %03d.%03d.%03d.%03d rc %d\n",
OPAL_IF_FORMAT_ADDR(netaddr), OPAL_IF_FORMAT_ADDR(netmask), rc);
/* search for a matching interface - take the first one within the returned scope */
idx = opal_ifbegin();
while (0 < idx) {
/* ignore the loopback interface */
if (opal_ifisloopback(idx)) {
fprintf(stderr, "LOOPBACK IGNORED\n");
idx = opal_ifnext(idx);
continue;
}
if (0 != (rc = opal_ifindextoaddr(idx, (struct sockaddr*)&inaddr, sizeof(inaddr)))) {
break;
}
addr = ntohl(inaddr.sin_addr.s_addr);
fprintf(stderr, "checking netaddr %03d.%03d.%03d.%03d addr %03d.%03d.%03d.%03d netmask %03d.%03d.%03d.%03d rc %d\n",
OPAL_IF_FORMAT_ADDR(netaddr), OPAL_IF_FORMAT_ADDR(addr), OPAL_IF_FORMAT_ADDR(netmask), rc);
if (netaddr == (addr & netmask)) {
fprintf(stderr, "MATCH FOUND\n");
}
idx = opal_ifnext(idx);
}
}
/* check the aliases */
opal_ifgetaliases(&aliases);
idx = 0;
while (NULL != aliases[idx]) {
fprintf(stderr, "alias: %s\n", aliases[idx]);
idx++;
}
opal_finalize();
return 0;
}
int orte_init(int* pargc, char*** pargv, orte_proc_type_t flags)
{
int ret;
char *error = NULL;
if (0 < orte_initialized) {
/* track number of times we have been called */
orte_initialized++;
return ORTE_SUCCESS;
}
orte_initialized++;
/* initialize the opal layer */
if (ORTE_SUCCESS != (ret = opal_init(pargc, pargv))) {
error = "opal_init";
goto error;
}
/* Convince OPAL to use our naming scheme */
opal_process_name_print = _process_name_print_for_opal;
opal_process_name_vpid = _process_name_vpid_for_opal;
opal_process_name_jobid = _process_name_jobid_for_opal;
opal_compare_proc = _process_name_compare;
/* ensure we know the type of proc for when we finalize */
orte_process_info.proc_type = flags;
/* setup the locks */
if (ORTE_SUCCESS != (ret = orte_locks_init())) {
error = "orte_locks_init";
goto error;
}
/* Register all MCA Params */
if (ORTE_SUCCESS != (ret = orte_register_params())) {
error = "orte_register_params";
goto error;
}
/* setup the orte_show_help system */
if (ORTE_SUCCESS != (ret = orte_show_help_init())) {
error = "opal_output_init";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORTE", ORTE_ERR_BASE, ORTE_ERR_MAX, orte_err2str);
/* Ensure the rest of the process info structure is initialized */
if (ORTE_SUCCESS != (ret = orte_proc_info())) {
error = "orte_proc_info";
goto error;
}
/* open the ESS and select the correct module for this environment */
if (ORTE_SUCCESS != (ret = mca_base_framework_open(&orte_ess_base_framework, 0))) {
ORTE_ERROR_LOG(ret);
error = "orte_ess_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess_base_select())) {
error = "orte_ess_base_select";
goto error;
}
if (!ORTE_PROC_IS_APP) {
/* ORTE tools "block" in their own loop over the event
* base, so no progress thread is required - apps will
* start their progress thread in ess_base_std_app.c
* at the appropriate point
*/
orte_event_base = opal_event_base;
}
/* initialize the RTE for this environment */
if (ORTE_SUCCESS != (ret = orte_ess.init())) {
error = "orte_ess_init";
goto error;
}
/* All done */
return ORTE_SUCCESS;
error:
if (ORTE_ERR_SILENT != ret) {
orte_show_help("help-orte-runtime",
"orte_init:startup:internal-failure",
true, error, ORTE_ERROR_NAME(ret), ret);
}
return ret;
}
int orcm_init_util(void)
{
int ret, i;
char *error;
char *destdir, *tmp, *mcp, *new_mcp;
/* Setup OPAL */
if( ORTE_SUCCESS != (ret = opal_init(NULL, NULL)) ) {
error = "opal_init_util";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("OPENRCM", ORCM_ERR_BASE, ORCM_ERR_MAX, orcm_err2str);
/* register where the OPENRCM show_help files are located */
if (NULL != (destdir = getenv("ORCM_DESTDIR"))) {
asprintf(&tmp, "%s%s", destdir, ORCM_PKGHELPDIR);
} else {
tmp = strdup(ORCM_PKGHELPDIR);
}
if (ORTE_SUCCESS != (ret = opal_show_help_add_dir(tmp))) {
error = "register show_help_dir";
goto error;
}
free(tmp);
/* Add ORCM's component directory into the
mca_base_param_component_path */
i = mca_base_param_find("mca", NULL, "component_path");
if (i < 0) {
ret = ORCM_ERR_NOT_FOUND;
error = "Could not find mca_component_path";
goto error;
}
mca_base_param_lookup_string(i, &mcp);
if (NULL == mcp) {
ret = ORCM_ERR_NOT_FOUND;
error = "Could not find mca_component_path";
goto error;
}
if (NULL != destdir) {
asprintf(&new_mcp, "%s%s:%s", destdir, ORCM_PKGLIBDIR, mcp);
} else {
asprintf(&new_mcp, "%s:%s", ORCM_PKGLIBDIR, mcp);
}
mca_base_param_set_string(i, new_mcp);
free(new_mcp);
free(mcp);
orcm_util_initialized = true;
return ORCM_SUCCESS;
error:
if (ORCM_ERR_SILENT != ret) {
orte_show_help("help-openrcm-runtime.txt",
"orcm_init:startup:internal-failure",
true, error, ORTE_ERROR_NAME(ret), ret);
}
return ret;
}
void
engine_init (Ekiga::ServiceCorePtr service_core,
int argc,
char *argv [])
{
// FIRST we add a few things by hand
// (for speed and because that's less code)
Ekiga::ServicePtr notification_core(new Ekiga::NotificationCore);
service_core->add (notification_core);
boost::shared_ptr<Ekiga::AccountCore> account_core (new Ekiga::AccountCore);
boost::shared_ptr<Ekiga::ContactCore> contact_core (new Ekiga::ContactCore);
boost::shared_ptr<Ekiga::CallCore> call_core (new Ekiga::CallCore);
boost::shared_ptr<Ekiga::ChatCore> chat_core (new Ekiga::ChatCore);
boost::shared_ptr<Ekiga::VideoOutputCore> videooutput_core (new Ekiga::VideoOutputCore);
boost::shared_ptr<Ekiga::VideoInputCore> videoinput_core (new Ekiga::VideoInputCore (*service_core, videooutput_core));
boost::shared_ptr<Ekiga::AudioOutputCore> audiooutput_core (new Ekiga::AudioOutputCore (*service_core));
boost::shared_ptr<Ekiga::AudioInputCore> audioinput_core (new Ekiga::AudioInputCore(*service_core));
boost::shared_ptr<Ekiga::HalCore> hal_core (new Ekiga::HalCore);
boost::shared_ptr<Ekiga::FriendOrFoe> friend_or_foe (new Ekiga::FriendOrFoe);
boost::shared_ptr<Gmconf::PersonalDetails> details(new Gmconf::PersonalDetails);
boost::shared_ptr<Ekiga::PresenceCore> presence_core(new Ekiga::PresenceCore (details));
service_core->add (contact_core);
service_core->add (chat_core);
service_core->add (friend_or_foe);
service_core->add (videoinput_core);
service_core->add (videooutput_core);
service_core->add (audioinput_core);
service_core->add (audiooutput_core);
service_core->add (hal_core);
service_core->add (call_core);
service_core->add (account_core);
service_core->add (details);
service_core->add (presence_core);
if (!videoinput_mlogo_init (*service_core, &argc, &argv)) {
return;
}
if (!videooutput_clutter_gst_init (*service_core, &argc, &argv)) {
return;
}
// THEN we use the kickstart scheme
Ekiga::KickStart kickstart;
audioinput_null_init (kickstart);
audiooutput_null_init (kickstart);
videoinput_ptlib_init (kickstart);
audioinput_ptlib_init (kickstart);
audiooutput_ptlib_init (kickstart);
#ifdef HAVE_GUDEV
hal_gudev_init (kickstart);
#endif
#ifdef HAVE_DBUS
hal_dbus_init (kickstart);
#endif
opal_init (kickstart);
history_init (kickstart);
local_roster_init (kickstart);
local_roster_bridge_init (kickstart);
plugin_init (kickstart);
// FIXME: Some parts in the kickstart need the gui. The gui needs
// some parts in the kickstart. So we will kick a first time to
// get things not needing the gui up and running, then start the
// gui (which will hence find what it needs) and kick a second time
// to really make the engine go vroom. It would be nicer to either
// push the parts needed by the gui in the hand-crafted part of
// this initialization, or put the gui in the kickstart too.
kickstart.kick (*service_core, &argc, &argv);
// FIXME: can't we have a single function for the whole gui?
gtk_core_init (*service_core, &argc, &argv);
if (!gtk_frontend_init (*service_core, &argc, &argv)) {
return;
}
kickstart.kick (*service_core, &argc, &argv);
/* FIXME: everything that follows except the debug output shouldn't
be there, as that means we're doing the work of initializing
those in the correct order here instead of having the specific
code in question to do it itself
*/
videoinput_core->setup ("any");
audioinput_core->setup ();
audiooutput_core->setup ();
hal_core->videoinput_device_added.connect (boost::bind (&Ekiga::VideoInputCore::add_device, boost::ref (*videoinput_core), _1, _2, _3, _4));
hal_core->videoinput_device_removed.connect (boost::bind (&Ekiga::VideoInputCore::remove_device, boost::ref (*videoinput_core), _1, _2, _3, _4));
hal_core->audiooutput_device_added.connect (boost::bind (&Ekiga::AudioOutputCore::add_device, boost::ref (*audiooutput_core), _1, _2, _3));
hal_core->audiooutput_device_removed.connect (boost::bind (&Ekiga::AudioOutputCore::remove_device, boost::ref (*audiooutput_core), _1, _2, _3));
hal_core->audioinput_device_added.connect (boost::bind (&Ekiga::AudioInputCore::add_device, boost::ref (*audioinput_core), _1, _2, _3));
hal_core->audioinput_device_removed.connect (boost::bind (&Ekiga::AudioInputCore::remove_device, boost::ref (*audioinput_core), _1, _2, _3));
#if DEBUG_STARTUP
std::cout << "Here is what ekiga is made of for this run :" << std::endl;
service_core->dump (std::cout);
#endif
}
int orte_init(int* pargc, char*** pargv, orte_proc_type_t flags)
{
int ret;
char *error = NULL;
if (orte_initialized) {
return ORTE_SUCCESS;
}
/* initialize the opal layer */
if (ORTE_SUCCESS != (ret = opal_init(pargc, pargv))) {
ORTE_ERROR_LOG(ret);
return ret;
}
/* ensure we know the type of proc for when we finalize */
orte_process_info.proc_type = flags;
/* setup the locks */
if (ORTE_SUCCESS != (ret = orte_locks_init())) {
error = "orte_locks_init";
goto error;
}
/* Register all MCA Params */
if (ORTE_SUCCESS != (ret = orte_register_params())) {
error = "orte_register_params";
goto error;
}
/* setup the orte_show_help system */
if (ORTE_SUCCESS != (ret = orte_show_help_init())) {
ORTE_ERROR_LOG(ret);
error = "opal_output_init";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORTE", ORTE_ERR_BASE, ORTE_ERR_MAX, orte_err2str);
/* Ensure the rest of the process info structure is initialized */
if (ORTE_SUCCESS != (ret = orte_proc_info())) {
error = "orte_proc_info";
goto error;
}
/* open the ESS and select the correct module for this environment */
if (ORTE_SUCCESS != (ret = orte_ess_base_open())) {
ORTE_ERROR_LOG(ret);
error = "orte_ess_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess_base_select())) {
ORTE_ERROR_LOG(ret);
error = "orte_ess_base_select";
goto error;
}
/* initialize the RTE for this environment */
if (ORTE_SUCCESS != (ret = orte_ess.init())) {
ORTE_ERROR_LOG(ret);
error = "orte_ess_set_name";
goto error;
}
/* All done */
orte_initialized = true;
return ORTE_SUCCESS;
error:
if (ORTE_ERR_SILENT != OPAL_SOS_GET_ERROR_CODE(ret)) {
orte_show_help("help-orte-runtime",
"orte_init:startup:internal-failure",
true, error, ORTE_ERROR_NAME(ret), ret);
}
return ret;
}
int orte_init(int* pargc, char*** pargv, orte_proc_type_t flags)
{
int ret;
char *error = NULL;
if (0 < orte_initialized) {
/* track number of times we have been called */
orte_initialized++;
return ORTE_SUCCESS;
}
orte_initialized++;
/* initialize the opal layer */
if (ORTE_SUCCESS != (ret = opal_init(pargc, pargv))) {
error = "opal_init";
goto error;
}
/* ensure we know the type of proc for when we finalize */
orte_process_info.proc_type = flags;
/* setup the locks */
if (ORTE_SUCCESS != (ret = orte_locks_init())) {
error = "orte_locks_init";
goto error;
}
/* Register all MCA Params */
if (ORTE_SUCCESS != (ret = orte_register_params())) {
error = "orte_register_params";
goto error;
}
/* setup the orte_show_help system */
if (ORTE_SUCCESS != (ret = orte_show_help_init())) {
error = "opal_output_init";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORTE", ORTE_ERR_BASE, ORTE_ERR_MAX, orte_err2str);
/* Ensure the rest of the process info structure is initialized */
if (ORTE_SUCCESS != (ret = orte_proc_info())) {
error = "orte_proc_info";
goto error;
}
/* open the ESS and select the correct module for this environment */
if (ORTE_SUCCESS != (ret = orte_ess_base_open())) {
error = "orte_ess_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess_base_select())) {
error = "orte_ess_base_select";
goto error;
}
if (ORTE_PROC_IS_APP) {
#if !ORTE_DISABLE_FULL_SUPPORT && ORTE_ENABLE_PROGRESS_THREADS
#if OPAL_EVENT_HAVE_THREAD_SUPPORT
/* get a separate orte event base */
orte_event_base = opal_event_base_create();
/* setup the finalize event - we'll need it
* to break the thread out of the event lib
* when we want to stop it
*/
opal_event_set(orte_event_base, &orte_finalize_event, -1, OPAL_EV_WRITE, ignore_callback, NULL);
opal_event_set_priority(&orte_finalize_event, ORTE_ERROR_PRI);
#if 0
{
/* seems strange, but wake us up once a second just so we can check for new events */
opal_event_t *ev;
struct timeval tv = {1,0};
ev = opal_event_alloc();
opal_event_evtimer_set(orte_event_base,
ev, ignore_callback, ev);
opal_event_set_priority(ev, ORTE_INFO_PRI);
opal_event_evtimer_add(ev, &tv);
}
#endif
/* construct the thread object */
OBJ_CONSTRUCT(&orte_progress_thread, opal_thread_t);
/* fork off a thread to progress it */
orte_progress_thread.t_run = orte_progress_thread_engine;
if (OPAL_SUCCESS != (ret = opal_thread_start(&orte_progress_thread))) {
error = "orte progress thread start";
goto error;
}
#else
error = "event thread support is not configured";
ret = ORTE_ERROR;
goto error;
#endif
#else
/* set the event base to the opal one */
orte_event_base = opal_event_base;
#endif
} else {
/* set the event base to the opal one */
orte_event_base = opal_event_base;
}
/* initialize the RTE for this environment */
if (ORTE_SUCCESS != (ret = orte_ess.init())) {
error = "orte_ess_init";
goto error;
}
/* All done */
return ORTE_SUCCESS;
error:
if (ORTE_ERR_SILENT != ret) {
orte_show_help("help-orte-runtime",
"orte_init:startup:internal-failure",
true, error, ORTE_ERROR_NAME(ret), ret);
}
return ret;
}
int orte_init(int* pargc, char*** pargv, orte_proc_type_t flags)
{
int ret;
char *error = NULL;
if (0 < orte_initialized) {
/* track number of times we have been called */
orte_initialized++;
return ORTE_SUCCESS;
}
orte_initialized++;
/* initialize the opal layer */
if (ORTE_SUCCESS != (ret = opal_init(pargc, pargv))) {
error = "opal_init";
goto error;
}
/* Convince OPAL to use our naming scheme */
opal_process_name_print = _process_name_print_for_opal;
opal_vpid_print = _vpid_print_for_opal;
opal_jobid_print = _jobid_print_for_opal;
opal_compare_proc = _process_name_compare;
opal_convert_string_to_process_name = _convert_string_to_process_name;
/* ensure we know the type of proc for when we finalize */
orte_process_info.proc_type = flags;
/* setup the locks */
if (ORTE_SUCCESS != (ret = orte_locks_init())) {
error = "orte_locks_init";
goto error;
}
/* Register all MCA Params */
if (ORTE_SUCCESS != (ret = orte_register_params())) {
error = "orte_register_params";
goto error;
}
/* setup the orte_show_help system */
if (ORTE_SUCCESS != (ret = orte_show_help_init())) {
error = "opal_output_init";
goto error;
}
/* register handler for errnum -> string conversion */
opal_error_register("ORTE", ORTE_ERR_BASE, ORTE_ERR_MAX, orte_err2str);
/* Ensure the rest of the process info structure is initialized */
if (ORTE_SUCCESS != (ret = orte_proc_info())) {
error = "orte_proc_info";
goto error;
}
/* we may have modified the local nodename according to
* request to retain/strip the FQDN and prefix, so update
* it here. The OPAL layer will strdup the hostname, so
* we have to free it first to avoid a memory leak */
if (NULL != opal_process_info.nodename) {
free(opal_process_info.nodename);
}
/* opal_finalize_util will call free on this pointer so set from strdup */
opal_process_info.nodename = strdup (orte_process_info.nodename);
/* setup the dstore framework */
if (ORTE_SUCCESS != (ret = mca_base_framework_open(&opal_dstore_base_framework, 0))) {
ORTE_ERROR_LOG(ret);
error = "opal_dstore_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = opal_dstore_base_select())) {
ORTE_ERROR_LOG(ret);
error = "opal_dstore_base_select";
goto error;
}
/* create the handle */
if (0 > (opal_dstore_internal = opal_dstore.open("INTERNAL", "hash", NULL))) {
error = "opal dstore internal";
ret = ORTE_ERR_FATAL;
goto error;
}
if (ORTE_PROC_IS_APP) {
if (0 > (opal_dstore_modex = opal_dstore.open("MODEX", "sm,hash", NULL))) {
error = "opal dstore modex";
ret = ORTE_ERR_FATAL;
goto error;
}
}
if (ORTE_PROC_IS_DAEMON || ORTE_PROC_IS_HNP) {
/* let the pmix server register params */
pmix_server_register();
}
/* open the ESS and select the correct module for this environment */
if (ORTE_SUCCESS != (ret = mca_base_framework_open(&orte_ess_base_framework, 0))) {
ORTE_ERROR_LOG(ret);
error = "orte_ess_base_open";
goto error;
}
if (ORTE_SUCCESS != (ret = orte_ess_base_select())) {
error = "orte_ess_base_select";
goto error;
}
if (!ORTE_PROC_IS_APP) {
/* ORTE tools "block" in their own loop over the event
* base, so no progress thread is required - apps will
* start their progress thread in ess_base_std_app.c
* at the appropriate point
*/
orte_event_base = opal_event_base;
}
/* initialize the RTE for this environment */
if (ORTE_SUCCESS != (ret = orte_ess.init())) {
error = "orte_ess_init";
goto error;
}
/* set the remaining opal_process_info fields. Note that
* the OPAL layer will have initialized these to NULL, and
* anyone between us would not have strdup'd the string, so
* we cannot free it here */
opal_process_info.job_session_dir = orte_process_info.job_session_dir;
opal_process_info.proc_session_dir = orte_process_info.proc_session_dir;
opal_process_info.num_local_peers = (int32_t)orte_process_info.num_local_peers;
opal_process_info.my_local_rank = (int32_t)orte_process_info.my_local_rank;
#if OPAL_HAVE_HWLOC
opal_process_info.cpuset = orte_process_info.cpuset;
#endif /* OPAL_HAVE_HWLOC */
#if OPAL_ENABLE_TIMING
opal_timing_set_jobid(ORTE_NAME_PRINT(ORTE_PROC_MY_NAME));
#endif
/* All done */
return ORTE_SUCCESS;
error:
if (ORTE_ERR_SILENT != ret) {
orte_show_help("help-orte-runtime",
"orte_init:startup:internal-failure",
true, error, ORTE_ERROR_NAME(ret), ret);
}
return ret;
}
int main(int argc, char *argv[])
{
int rc, i, j;
opal_cmd_line_t cmd_line;
char *param, *value;
orte_job_t *jdata=NULL;
orte_app_context_t *app;
char *uri, *ptr;
/* Setup and parse the command line */
memset(&myglobals, 0, sizeof(myglobals));
/* find our basename (the name of the executable) so that we can
use it in pretty-print error messages */
myglobals.basename = opal_basename(argv[0]);
opal_cmd_line_create(&cmd_line, cmd_line_init);
mca_base_cmd_line_setup(&cmd_line);
if (OPAL_SUCCESS != (rc = opal_cmd_line_parse(&cmd_line, true,
argc, argv)) ) {
if (OPAL_ERR_SILENT != rc) {
fprintf(stderr, "%s: command line error (%s)\n", argv[0],
opal_strerror(rc));
}
return rc;
}
/* print version if requested. Do this before check for help so
that --version --help works as one might expect. */
if (myglobals.version) {
char *str;
str = opal_info_make_version_str("all",
OPAL_MAJOR_VERSION, OPAL_MINOR_VERSION,
OPAL_RELEASE_VERSION,
OPAL_GREEK_VERSION,
OPAL_REPO_REV);
if (NULL != str) {
fprintf(stdout, "%s %s\n\nReport bugs to %s\n",
myglobals.basename, str, PACKAGE_BUGREPORT);
free(str);
}
exit(0);
}
/* check if we are running as root - if we are, then only allow
* us to proceed if the allow-run-as-root flag was given. Otherwise,
* exit with a giant warning flag
*/
if (0 == geteuid() && !myglobals.run_as_root) {
fprintf(stderr, "--------------------------------------------------------------------------\n");
if (myglobals.help) {
fprintf(stderr, "%s cannot provide the help message when run as root\n", myglobals.basename);
} else {
/* show_help is not yet available, so print an error manually */
fprintf(stderr, "%s has detected an attempt to run as root.\n", myglobals.basename);
}
fprintf(stderr, " This is *strongly* discouraged as any mistake (e.g., in defining TMPDIR) or bug can\n");
fprintf(stderr, "result in catastrophic damage to the OS file system, leaving\n");
fprintf(stderr, "your system in an unusable state.\n\n");
fprintf(stderr, "You can override this protection by adding the --allow-run-as-root\n");
fprintf(stderr, "option to your cmd line. However, we reiterate our strong advice\n");
fprintf(stderr, "against doing so - please do so at your own risk.\n");
fprintf(stderr, "--------------------------------------------------------------------------\n");
exit(1);
}
/*
* Since this process can now handle MCA/GMCA parameters, make sure to
* process them.
* NOTE: It is "safe" to call mca_base_cmd_line_process_args() before
* opal_init_util() since mca_base_cmd_line_process_args() does *not*
* depend upon opal_init_util() functionality.
*/
if (OPAL_SUCCESS != mca_base_cmd_line_process_args(&cmd_line, &environ, &environ)) {
exit(1);
}
/* Need to initialize OPAL so that install_dirs are filled in */
if (OPAL_SUCCESS != opal_init(&argc, &argv)) {
exit(1);
}
/* Check for help request */
if (myglobals.help) {
char *str, *args = NULL;
char *project_name = NULL;
if (0 == strcmp(myglobals.basename, "mpirun")) {
project_name = "Open MPI";
} else {
project_name = "OpenRTE";
}
args = opal_cmd_line_get_usage_msg(&cmd_line);
str = opal_show_help_string("help-orterun.txt", "orterun:usage", false,
myglobals.basename, project_name, OPAL_VERSION,
myglobals.basename, args,
PACKAGE_BUGREPORT);
if (NULL != str) {
printf("%s", str);
free(str);
}
free(args);
/* If someone asks for help, that should be all we do */
exit(0);
}
/* flag that I am the HNP */
orte_process_info.proc_type = ORTE_PROC_HNP;
/* Setup MCA params */
orte_register_params();
/* specify the DVM state machine */
opal_setenv("OMPI_MCA_state", "dvm", true, &environ);
/* Intialize our Open RTE environment */
if (ORTE_SUCCESS != (rc = orte_init(&argc, &argv, ORTE_PROC_HNP))) {
/* cannot call ORTE_ERROR_LOG as it could be the errmgr
* never got loaded!
*/
return rc;
}
/* finalize OPAL. As it was opened again from orte_init->opal_init
* we continue to have a reference count on it. So we have to finalize it twice...
*/
opal_finalize();
/* check for request to report uri */
uri = orte_rml.get_contact_info();
if (NULL != myglobals.report_uri) {
FILE *fp;
if (0 == strcmp(myglobals.report_uri, "-")) {
/* if '-', then output to stdout */
printf("VMURI: %s\n", uri);
} else if (0 == strcmp(myglobals.report_uri, "+")) {
/* if '+', output to stderr */
fprintf(stderr, "VMURI: %s\n", uri);
} else if (0 == strncasecmp(myglobals.report_uri, "file:", strlen("file:"))) {
ptr = strchr(myglobals.report_uri, ':');
++ptr;
fp = fopen(ptr, "w");
if (NULL == fp) {
orte_show_help("help-orterun.txt", "orterun:write_file", false,
myglobals.basename, "pid", ptr);
exit(0);
}
fprintf(fp, "%s\n", uri);
fclose(fp);
} else {
fp = fopen(myglobals.report_uri, "w");
if (NULL == fp) {
orte_show_help("help-orterun.txt", "orterun:write_file", false,
myglobals.basename, "pid", myglobals.report_uri);
exit(0);
}
fprintf(fp, "%s\n", uri);
fclose(fp);
}
free(uri);
} else {
printf("VMURI: %s\n", uri);
}
/* get the daemon job object - was created by ess/hnp component */
if (NULL == (jdata = orte_get_job_data_object(ORTE_PROC_MY_NAME->jobid))) {
orte_show_help("help-orterun.txt", "bad-job-object", true,
myglobals.basename);
exit(0);
}
/* also should have created a daemon "app" */
if (NULL == (app = (orte_app_context_t*)opal_pointer_array_get_item(jdata->apps, 0))) {
orte_show_help("help-orterun.txt", "bad-app-object", true,
myglobals.basename);
exit(0);
}
/* Did the user specify a prefix, or want prefix by default? */
if (opal_cmd_line_is_taken(&cmd_line, "prefix") || want_prefix_by_default) {
size_t param_len;
/* if both the prefix was given and we have a prefix
* given above, check to see if they match
*/
if (opal_cmd_line_is_taken(&cmd_line, "prefix") &&
NULL != myglobals.prefix) {
/* if they don't match, then that merits a warning */
param = strdup(opal_cmd_line_get_param(&cmd_line, "prefix", 0, 0));
/* ensure we strip any trailing '/' */
if (0 == strcmp(OPAL_PATH_SEP, &(param[strlen(param)-1]))) {
param[strlen(param)-1] = '\0';
}
value = strdup(myglobals.prefix);
if (0 == strcmp(OPAL_PATH_SEP, &(value[strlen(value)-1]))) {
value[strlen(value)-1] = '\0';
}
if (0 != strcmp(param, value)) {
orte_show_help("help-orterun.txt", "orterun:app-prefix-conflict",
true, myglobals.basename, value, param);
/* let the global-level prefix take precedence since we
* know that one is being used
*/
free(param);
param = strdup(myglobals.prefix);
}
free(value);
} else if (NULL != myglobals.prefix) {
param = myglobals.prefix;
} else if (opal_cmd_line_is_taken(&cmd_line, "prefix")){
/* must be --prefix alone */
param = strdup(opal_cmd_line_get_param(&cmd_line, "prefix", 0, 0));
} else {
/* --enable-orterun-prefix-default was given to orterun */
param = strdup(opal_install_dirs.prefix);
}
if (NULL != param) {
/* "Parse" the param, aka remove superfluous path_sep. */
param_len = strlen(param);
while (0 == strcmp (OPAL_PATH_SEP, &(param[param_len-1]))) {
param[param_len-1] = '\0';
param_len--;
if (0 == param_len) {
orte_show_help("help-orterun.txt", "orterun:empty-prefix",
true, myglobals.basename, myglobals.basename);
return ORTE_ERR_FATAL;
}
}
orte_set_attribute(&app->attributes, ORTE_APP_PREFIX_DIR, ORTE_ATTR_GLOBAL, param, OPAL_STRING);
free(param);
}
}
/* Did the user specify a hostfile. Need to check for both
* hostfile and machine file.
* We can only deal with one hostfile per app context, otherwise give an error.
*/
if (0 < (j = opal_cmd_line_get_ninsts(&cmd_line, "hostfile"))) {
if(1 < j) {
orte_show_help("help-orterun.txt", "orterun:multiple-hostfiles",
true, myglobals.basename, NULL);
return ORTE_ERR_FATAL;
} else {
value = opal_cmd_line_get_param(&cmd_line, "hostfile", 0, 0);
orte_set_attribute(&app->attributes, ORTE_APP_HOSTFILE, ORTE_ATTR_LOCAL, value, OPAL_STRING);
}
}
if (0 < (j = opal_cmd_line_get_ninsts(&cmd_line, "machinefile"))) {
if(1 < j || orte_get_attribute(&app->attributes, ORTE_APP_HOSTFILE, NULL, OPAL_STRING)) {
orte_show_help("help-orterun.txt", "orterun:multiple-hostfiles",
true, myglobals.basename, NULL);
return ORTE_ERR_FATAL;
} else {
value = opal_cmd_line_get_param(&cmd_line, "machinefile", 0, 0);
orte_set_attribute(&app->attributes, ORTE_APP_HOSTFILE, ORTE_ATTR_LOCAL, value, OPAL_STRING);
}
}
/* Did the user specify any hosts? */
if (0 < (j = opal_cmd_line_get_ninsts(&cmd_line, "host"))) {
char **targ=NULL, *tval;
for (i = 0; i < j; ++i) {
value = opal_cmd_line_get_param(&cmd_line, "host", i, 0);
opal_argv_append_nosize(&targ, value);
}
tval = opal_argv_join(targ, ',');
orte_set_attribute(&app->attributes, ORTE_APP_DASH_HOST, ORTE_ATTR_LOCAL, tval, OPAL_STRING);
opal_argv_free(targ);
free(tval);
}
OBJ_DESTRUCT(&cmd_line);
/* setup to listen for commands sent specifically to me, even though I would probably
* be the one sending them! Unfortunately, since I am a participating daemon,
* there are times I need to send a command to "all daemons", and that means *I* have
* to receive it too
*/
orte_rml.recv_buffer_nb(ORTE_NAME_WILDCARD, ORTE_RML_TAG_DAEMON,
ORTE_RML_PERSISTENT, orte_daemon_recv, NULL);
/* override the notify_completed state so we can send a message
* back to anyone who submits a job to us telling them the job
* completed */
if (ORTE_SUCCESS != (rc = orte_state.set_job_state_callback(ORTE_JOB_STATE_NOTIFY_COMPLETED, notify_requestor))) {
ORTE_ERROR_LOG(rc);
ORTE_UPDATE_EXIT_STATUS(rc);
exit(orte_exit_status);
}
/* spawn the DVM - we skip the initial steps as this
* isn't a user-level application */
ORTE_ACTIVATE_JOB_STATE(jdata, ORTE_JOB_STATE_ALLOCATE);
/* loop the event lib until an exit event is detected */
while (orte_event_base_active) {
opal_event_loop(orte_event_base, OPAL_EVLOOP_ONCE);
}
/* cleanup and leave */
orte_finalize();
if (orte_debug_flag) {
fprintf(stderr, "exiting with status %d\n", orte_exit_status);
}
exit(orte_exit_status);
}
int main(int argc, char **argv)
{
char byte='a';
struct timespec tp= {0, 100};
int count=0;
foo_caddy_t *foo;
/* Initialize the event library */
opal_init(&argc, &argv);
/* setup for threads */
opal_event_use_threads();
/* create a new base */
my_base = orte_event_base_create();
/* launch a progress thread on that base*/
pipe(progress_thread_pipe);
OBJ_CONSTRUCT(&lock, opal_mutex_t);
OBJ_CONSTRUCT(&cond, opal_condition_t);
OBJ_CONSTRUCT(&progress_thread, opal_thread_t);
progress_thread.t_run = progress_engine;
if (OPAL_SUCCESS != opal_thread_start(&progress_thread)) {
fprintf(stderr, "Unable to start progress thread\n");
orte_event_base_finalize(my_base);
exit(1);
}
/* wait a little while - reflects reality in an async system */
while (count < 100) {
nanosleep(&tp, NULL);
count++;
}
count=0;
/* make a dummy event */
fprintf(stderr, "activating the write_event");
foo = OBJ_NEW(foo_caddy_t);
opal_event_set(my_base,
&foo->write_event,
-1,
0,
send_handler,
foo);
/* activate it. */
opal_event_active(&foo->write_event, EV_WRITE, 1);
/* wait for it to trigger */
while (!fd_written && count < 1000) {
if (0 == (count % 100)) {
fprintf(stderr, "Waiting...\n");
}
nanosleep(&tp, NULL);
count++;
}
/* stop the thread */
OPAL_ACQUIRE_THREAD(&lock, &cond, &active);
progress_thread_stop = true;
OPAL_RELEASE_THREAD(&lock, &cond, &active);
opal_fd_write(progress_thread_pipe[1], 1, &byte);
opal_thread_join(&progress_thread, NULL);
/* release the base */
fprintf(stderr, "Cleaning up\n");
opal_finalize();
fprintf(stderr, "Cleanup completed\n");
return 0;
}
