openmpi/orte/runtime/orte_locks.h

/*
 * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
 *                         University Research and Technology
 *                         Corporation.  All rights reserved.
 * Copyright (c) 2004-2006 The University of Tennessee and The University
 *                         of Tennessee Research Foundation.  All rights
 *                         reserved.
 * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, 
 *                         University of Stuttgart.  All rights reserved.
 * Copyright (c) 2004-2005 The Regents of the University of California.
 *                         All rights reserved.
 * $COPYRIGHT$
 * 
 * Additional copyrights may follow
 * 
 * $HEADER$
 */

/**
 * @file
 *
 * Locks to prevent loops inside ORTE
 */
#ifndef ORTE_LOCKS_H
#define ORTE_LOCKS_H

#include "orte_config.h"

#include "opal/sys/atomic.h"

BEGIN_C_DECLS

/* for everyone */
ORTE_DECLSPEC extern opal_atomic_lock_t orte_finalize_lock;

/* for HNPs */
ORTE_DECLSPEC extern opal_atomic_lock_t orte_abort_inprogress_lock;
ORTE_DECLSPEC extern opal_atomic_lock_t orte_jobs_complete_lock;
ORTE_DECLSPEC extern opal_atomic_lock_t orte_quit_lock;

/**
 * Initialize the locks
 */
ORTE_DECLSPEC int orte_locks_init(void);

END_C_DECLS

#endif /* #ifndef ORTE_LOCKS_H */
Afraid this has a couple of things mixed into the commit. Couldn't be helped - had missed one commit prior to running out the door on vacation. Fix race conditions in abnormal terminations. We had done a first-cut at this in a prior commit. However, the window remained partially open due to the fact that the HNP has multiple paths leading to orte_finalize. Most of our frameworks don't care if they are finalized more than once, but one of them does, which meant we segfaulted if orte_finalize got called more than once. Besides, we really shouldn't be doing that anyway. So we now introduce a set of atomic locks that prevent us from multiply calling abort, attempting to call orte_finalize, etc. My initial tests indicate this is working cleanly, but since it is a race condition issue, more testing will have to be done before we know for sure that this problem has been licked. Also, some updates relevant to the tool comm library snuck in here. Since those also touched the orted code (as did the prior changes), I didn't want to attempt to separate them out - besides, they are coming in soon anyway. More on them later as that functionality approaches completion. This commit was SVN r17843. 2008-03-17 20:58:59 +03:00			`/*`
			`* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana`
			`* University Research and Technology`
			`* Corporation. All rights reserved.`
			`* Copyright (c) 2004-2006 The University of Tennessee and The University`
			`* of Tennessee Research Foundation. All rights`
			`* reserved.`
			`* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,`
			`* University of Stuttgart. All rights reserved.`
			`* Copyright (c) 2004-2005 The Regents of the University of California.`
			`* All rights reserved.`
			`* $COPYRIGHT$`
			`*`
			`* Additional copyrights may follow`
			`*`
			`* $HEADER$`
			`*/`

			`/**`
			`* @file`
			`*`
			`* Locks to prevent loops inside ORTE`
			`*/`
			`#ifndef ORTE_LOCKS_H`
			`#define ORTE_LOCKS_H`

			`#include "orte_config.h"`

			`#include "opal/sys/atomic.h"`

			`BEGIN_C_DECLS`

			`/* for everyone */`
Add the declspec's in here so that they're visible. This commit was SVN r17846. 2008-03-17 21:37:03 +03:00			`ORTE_DECLSPEC extern opal_atomic_lock_t orte_finalize_lock;`
Afraid this has a couple of things mixed into the commit. Couldn't be helped - had missed one commit prior to running out the door on vacation. Fix race conditions in abnormal terminations. We had done a first-cut at this in a prior commit. However, the window remained partially open due to the fact that the HNP has multiple paths leading to orte_finalize. Most of our frameworks don't care if they are finalized more than once, but one of them does, which meant we segfaulted if orte_finalize got called more than once. Besides, we really shouldn't be doing that anyway. So we now introduce a set of atomic locks that prevent us from multiply calling abort, attempting to call orte_finalize, etc. My initial tests indicate this is working cleanly, but since it is a race condition issue, more testing will have to be done before we know for sure that this problem has been licked. Also, some updates relevant to the tool comm library snuck in here. Since those also touched the orted code (as did the prior changes), I didn't want to attempt to separate them out - besides, they are coming in soon anyway. More on them later as that functionality approaches completion. This commit was SVN r17843. 2008-03-17 20:58:59 +03:00
			`/* for HNPs */`
Add the declspec's in here so that they're visible. This commit was SVN r17846. 2008-03-17 21:37:03 +03:00			`ORTE_DECLSPEC extern opal_atomic_lock_t orte_abort_inprogress_lock;`
Start reducing our dependency on the event library by removing at least one instance where we use it to redirect the program counter. Rolf reported occasional hangs of mpirun in very specific circumstances after all daemons were done. A review of MTT results indicates this may have been happening more generally in a small fraction of cases. The problem was tracked to use of the grpcomm.onesided_barrier to control daemon/mpirun termination. This relied on messaging -and- required that the program counter jump from the errmgr back to grpcomm. On rare occasions, this jump did not occur, causing mpirun to hang. This patch looks more invasive than it is - most of the affected files simply had one or two lines removed. The essence of the change is: * pulled the job_complete and quit routines out of orterun and orted_main and put them in a common place * modified the errmgr to directly call the new routines when termination is detected * removed the grpcomm.onesided_barrier and its associated RML tag * add a new "num_routes" API to the routed framework that reports back the number of dependent routes. When route_lost is called, the daemon's list of "children" is checked and adjusted if that route went to a "leaf" in the routing tree * use connection termination between daemons to track rollup of the daemon tree. Daemons and HNP now terminate once num_routes returns zero Also picked up in this commit is the addition of a new bool flag to the app_context struct, and increasing the job_control field from 8 to 16 bits. Both trivial. This commit was SVN r23429. 2010-07-18 01:03:27 +04:00			`ORTE_DECLSPEC extern opal_atomic_lock_t orte_jobs_complete_lock;`
			`ORTE_DECLSPEC extern opal_atomic_lock_t orte_quit_lock;`
Afraid this has a couple of things mixed into the commit. Couldn't be helped - had missed one commit prior to running out the door on vacation. Fix race conditions in abnormal terminations. We had done a first-cut at this in a prior commit. However, the window remained partially open due to the fact that the HNP has multiple paths leading to orte_finalize. Most of our frameworks don't care if they are finalized more than once, but one of them does, which meant we segfaulted if orte_finalize got called more than once. Besides, we really shouldn't be doing that anyway. So we now introduce a set of atomic locks that prevent us from multiply calling abort, attempting to call orte_finalize, etc. My initial tests indicate this is working cleanly, but since it is a race condition issue, more testing will have to be done before we know for sure that this problem has been licked. Also, some updates relevant to the tool comm library snuck in here. Since those also touched the orted code (as did the prior changes), I didn't want to attempt to separate them out - besides, they are coming in soon anyway. More on them later as that functionality approaches completion. This commit was SVN r17843. 2008-03-17 20:58:59 +03:00
			`/**`
			`* Initialize the locks`
			`*/`
			`ORTE_DECLSPEC int orte_locks_init(void);`

			`END_C_DECLS`

			`#endif /* #ifndef ORTE_LOCKS_H */`