Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/group__Process.html below:

NCBI C++ ToolKit: Process Management

Lock/guard interface (to use with CGuard<> or CInterProcessLock_Guard)

Try to acquire the lock.

On any error, or if the lock is already held by another process and it could not be acquired within the allotted time period, throw CInterProcessLockException.

Parameters

timeout How much time Lock() should wait before giving up (with error). Default timeout value is interpreted as infinite. granularity On the systems (such as Unix) where there is no support for waiting for the lock with a timeout, the waiting is implemented using a loop of "try to lock" calls. This parameter specifies how much time to wait between these calls. It will be auto-limited to the closest whole delimiter of the 'timeout' value (and it will never exceed it). Default or infinite granularity timeout is converted into: MIN(timeout/5, 0.5sec).

Note

If 'timeout' is passed infinite, then the 'granularity' parameter actually will not be used at all – both on Windows and on Unix – as they both support a "honest" infinite waiting.

One process can acquire the lock more than once – but it need to use the same CInterProcessLock object for Lock(), and then it will need to call Unlock() as many times in order to release the lock for other processes.

If the lock object (such as file on UNIX or system mutex on Windows) doesn't exist it will be created.

See also

TryLock, SetLockTimeout

Process identifier (PID) and process handle.

Definition at line 77 of file ncbi_process.hpp.

Error types that file operations can generate.

The lock could not be acquired in the time allotted.

Incorrect name for a lock.

Cannot create the lock object in the OS.

Cannot acquire a lock (not eLockTimeout, eCreateError)

Cannot release the lock.

Attempt to lock already locked object in the same process.

Attempt to unlock a not-yet-acquired lock.

Definition at line 244 of file interprocess_lock.hpp.

The process listed in the file is still around.

Unable to write into the PID file.

Definition at line 811 of file ncbi_process.hpp.

How to interpret the used process identifier.

A real process identifier (pid).

A process handle (MS Windows).

Definition at line 392 of file ncbi_process.hpp.

Process information "target".

Current process.

All children of the calling process.

Current thread.

Definition at line 100 of file ncbi_process.hpp.

Daemonization flags.

Don't change CWD to "/".

Keep stdin open as "/dev/null" (RO)

Keep stdout open as "/dev/null" (WO)

Make daemon immune to re-acquiring a controlling terminal.

Do not exit the parent process but return.

Throw an exception in case of an error.

Do not fail if pre-existing threads are detected.

Definition at line 318 of file ncbi_process.hpp.

Daemonization flags @ deprecated Please use CCurrentProcess::FDaemonFlags instead.

Definition at line 732 of file ncbi_process.hpp.

Forking flags.

Reset diagnostics timer and log an app-start message in the child process.

User plans to use exec(3) or execve(2) to "replace" forked child process with another program as soon as possible after fork, so we can skip some initialization and checks.

Cancels fFF_UpdateDiag.

Throw an exception on error.

Definition at line 255 of file ncbi_process.hpp.

Parameters

name Name of the lock. The name must be a Unix-path like, and its length must not exceed the maximum path length that is specific for the OS where the application runs.

Note

This constructor will not try to acquire a lock on creation.

• On Unix, if a pathless file name is given, then the corresponding file will be created in a well-known system-specific location (usually as '/var/tmp/<name>'); if the name represents an absolute file path, then the exact path will be used to create the lock file.
• On Windows, no actual files will be created at the specified path.

Attention

• Relative paths are not allowed (regardless of the OS).
• Empty name is not allowed.
• Locking may not work for the files located on network filesystems (like NFS).

See also

Lock, TryLock, GetName

Definition at line 72 of file interprocess_lock.cpp.

References CDirEntry::IsAbsolutePath(), kInvalidLockHandle, CInterProcessLock::m_Handle, CInterProcessLock::m_Name, CInterProcessLock::m_SystemName, NCBI_THROW, NPOS, PATH_MAX, and NStr::Replace().

Default constructor. Uses the current process pid.

Definition at line 540 of file ncbi_process.cpp.

Go daemon.

Return TPid(-1) in the daemon thread (the parent thread doesn't return unless fKeepParent is set), or TPid(daemon) in the parent thread. On error return 0 in the parent thread (no daemon created), see errno.

Reopen stderr/cerr in the daemon thread if "logfile" specified as non-NULL (stderr will open to "/dev/null" if "logfile" has been passed as ""), otherwise stderr is closed in the daemon thread.

Unless instructed by the "flags" parameter, the daemon thread has its stdin/cin and stdout/cout closed, and the current working directory changed to the root directory ("/").

If kept open, stdin and stdout are both redirected to "/dev/null". Opening a terminal device as a controlling terminal is allowed, unless fImmuneTTY is specified in the flags, which then causes a second fork() so that the resultant process won't be allowed to open a TTY as its controlling TTY (but only with an explicit O_NOCTTY, see open(2)), thus protecting the process from any blocking via TTY signaling.

Note that this call is somewhat destructive and may not be able to restore the process that called it to a state prior to the call in case of an error. So that calling process can find the standard

Definition at line 509 of file ncbi_process.cpp.

References ERR_POST_X, CCurrentProcess::fDF_AllowExceptions, flags, NCBI_THROW, s_Daemonize(), and CException::what().

Referenced by CProcess::Daemonize(), SGridWorkerNodeImpl::Run(), CBDBEnvKeeperApp::Run(), CNetScheduleDApp::Run(), CNetStorageDApp::Run(), and CPubseqGatewayApp::Run().

Go daemon.

Return TPid(-1) in the daemon thread (the parent thread doesn't return unless fKeepParent is set), or TPid(daemon) in the parent thread. On error return 0 in the parent thread (no daemon created), see errno.

Reopen stderr/cerr in the daemon thread if "logfile" specified as non-NULL (stderr will open to "/dev/null" if "logfile" has been passed as ""), otherwise stderr is closed in the daemon thread.

Unless instructed by the "flags" parameter, the daemon thread has its stdin/cin and stdout/cout closed, and the current working directory changed to the root directory ("/").

If kept open, stdin and stdout are both redirected to "/dev/null". Opening a terminal device as a controlling terminal is allowed, unless fImmuneTTY is specified in the flags, which then causes a second fork() so that the resultant process won't be allowed to open a TTY as its controlling TTY (but only with an explicit O_NOCTTY, see open(2)), thus protecting the process from any blocking via TTY signaling.

Note that this call is somewhat destructive and may not be able to restore the process that called it to a state prior to the call in case of an error. So that calling process can find the standard

Deprecated:

Please use CCurrentProcess::Daemonize() instead

Definition at line 778 of file ncbi_process.hpp.

References CCurrentProcess::Daemonize(), and flags.

Referenced by Daemonize(), and main().

Fork the process.

Update PID and GUID used for logging (by default).

Warning

The child process is created with a single thread, the one that called fork(). The entire virtual address space of the parent is replicated in the child, including the states of mutexes, condition variables, open file descriptors, pthreads objects, and etc. But child process doesn't inherit or reset many other properties. Be aware. Consult fork(2) man-pages for a full details.

Fork() should be called from a single-threaded application, even if it built in MT configurations. If you have many running threads in the parent process, this can lead to unpredictable results and various deadlocks. "After a fork() in a multithreaded program, the child can safely call only async-signal-safe functions." until it calls execve(2) to replace a forked child process as soon as possible after Fork(). See https://man7.org/linux/man-pages/man2/fork.2.html

Returns

In the parent process, the call returns the child process ID. In the child process, the call returns zero. In case of an error, unless the fFF_AllowExceptions flag is specified, the call returns -1.

Exceptions

If the fFF_AllowExceptions flag is specified, throws a CCoreException in case of a fork(2) failure. If the platform does not support process forking, an exception is always thrown regardless of whether the fFF_AllowExceptions flag is specified.

Note

Implemented for Unix only.

See also

ForkForExec

Definition at line 308 of file ncbi_process.cpp.

References ERR_POST_X, f, CProcess::fFF_AllowExceptions, CProcess::fFF_UpdateDiag, flags, CDiagContext::fOnFork_AsyncSafe, CDiagContext::fOnFork_PrintStart, CDiagContext::fOnFork_ResetTimer, CCurrentProcess::GetThreadCount(), NCBI_THROW, NCBI_THROW_FMT, s_ErrnoToString(), CDiagContext::UpdateOnFork(), and Warning().

Referenced by CProcess::Fork(), CCurrentProcess::ForkForExec(), SGridWorkerNodeImpl::Run(), and s_Daemonize().

Fork the process for "replacing" a child process with a new process.

Special version of Fork() with a different name for easier recognizing. Assumes that the user will replace child process after this call with using exec(3) or execve(2) calls as soon as possible. The child can safely call only async-signal-safe functions after Fork() until the child process has replaced. This mean no memory allocation, streams, logging and etc. Please consult the list of sync-signal-safe functions before using, like: https://man7.org/linux/man-pages/man7/signal-safety.7.html

Returns

In the parent process, the call returns the child process ID. In the child process, the call returns zero. In case of an error, unless the fFF_AllowExceptions flag is specified, the call returns -1.

See also

Fork

Definition at line 315 of file ncbi_process.hpp.

References CCurrentProcess::fFF_Exec, flags, and CCurrentProcess::Fork().

Get current process memory usage.

See also

CProcess::GetMemoryUsage, SMemoryUsage

Definition at line 1498 of file ncbi_process.cpp.

References _TROUBLE, CNcbiError::eNotSupported, CNcbiError::eUnknown, CFile::GetLength(), GetMemoryUsage(), len, s_Win_GetMemoryUsage(), CNcbiError::Set(), CNcbiError::SetFromErrno(), and usage.

Referenced by CCgiApplication::CheckMemoryLimit(), CProcess::GetMemoryUsage(), CWNJobWatcher::Notify(), CPubseqGatewayApp::OnInfo(), ReportMemoryUsage(), CAsnSubCacheCreateApplication::Run(), CAlignSort::SortAlignments(), CNcbiApplicationAPI::x_LogOptions(), and CNetScheduleHandler::x_ProcessHealth().

Get process memory usage.

For current process pid/handle it is the same as CCurrentProcess::GetMemoryUsage().

Parameters

usage Total memory usage by a process, in bytes. See SMemoryUsage structure. resident Resident set size (RSS), in bytes. RSS is the portion of memory occupied by a process that is held in main memory (RAM). shared (optional) Shared memory usage, in bytes. data (optional) Data + stack usage, in bytes.

Returns

TRUE on success; or FALSE otherwise.

Note

NULL arguments will not be filled in.

See also

CCurrentProcess::GetMemoryUsage, SMemoryUsage

Definition at line 1469 of file ncbi_process.cpp.

References CNcbiError::eNotSupported, GetMemoryUsage(), CCurrentProcess::GetMemoryUsage(), CProcess::GetPid(), HANDLE, CProcess::IsCurrent(), s_Win_GetMemoryUsage(), CNcbiError::Set(), usage, CProcess::x_CloseHandle(), and CProcess::x_GetHandle().

Returns non-zero if there was a stale file.

Always return 0, because new implementation don't allow any stale file left on the file system.

Deprecated:

Definition at line 928 of file ncbi_process.hpp.

Get process identifier (pid) for the current process.

See also

GetHandle

Definition at line 247 of file ncbi_process.cpp.

Referenced by CDbapiSampleApp::CDbapiSampleApp(), CMessageDumperSender::CMessageDumperSender(), CFileIO::CreateTemporary(), CRtProfiler::DoReport(), CProcess::GetCurrentPid(), CAppExplorerDataObject::GetDataHere(), CCgiApplication::GetFastCGIWatchFileRestartDelay(), CCurrentProcess::GetFileDescriptorsCount(), CDiagContext::GetPID(), CNcbiTest::GetRandomSeed(), TDataExchange< T >::Init(), CProcess::IsCurrent(), TDataExchange< T >::IsLocal(), SProjectSelectorParams::LoadSettings(), CBDB_Cache::Open(), CNCStat::PrintToSocket(), CGetStatisticsProcessor::Process(), CRandom::Randomize(), SGridWorkerNodeImpl::Run(), s_GenerateSessionTag(), s_InitConstants(), s_LockInstanceGuard(), s_ReportPid(), SProjectSelectorParams::SaveSettings(), CAppExplorerDataObject::SetData(), CPIDGuard::UpdatePID(), CDiagContext::UpdatePID_AsyncSafe(), CNCServer::WriteEnvInfo(), CNetScheduleServer::x_GenerateGUID(), CNetStorageServer::x_GenerateGUID(), CAgpFastaComparator::CTmpSeqVecStorage::x_GetTmpDir(), CWNJobWatcher::x_KillNode(), and CFastCgiApplicationMT::x_ProcessThreadedRequest().

Get stored process identifier (pid).

See also

GetCurrentPid

Definition at line 424 of file ncbi_process.hpp.

References CProcess::m_Process.

Referenced by CProcess::GetFileDescriptorsCount(), CCurrentProcess::GetHandle(), CProcess::GetMemoryUsage(), CProcess::GetThreadCount(), CProcess::GetTimes(), CProcess::IsAlive(), CProcess::IsCurrent(), CProcess::Kill(), CProcess::KillGroup(), CProcess::Wait(), CProcess::x_GetHandle(), and CProcess::x_GetPid().

Get current process execution times.

Parameters

real Pointer to a variable that receives the amount of time in second that the current process/thread has executed, when available.

Note

Here is no portable solution to get 'real' process execution time, not all OS have an API to get such information from the system, or it can include children times as well... but it is available on some platforms like Windows, Linux and BSD.

Parameters

user Pointer to a variable that receives the amount of time in seconds that the process, process tree or thread has executed in user mode. Note, that this value can exceed the amount of "real" time if the process executes across multiple CPU cores (OS dependent). sys Pointer to a variable that receives the amount of time in second that the current process, process tree or thread has executed in kernel mode. what Applies to user and system time parameters only, real time calculates for the current process only. Defines what times to measure: current thread, process or children processes:

• eProcess: Current process, which is the sum of resources used by all threads in the process.
• eChildren: (limited support) All children of the calling process that have terminated already and been waited for. These statistics will include the resources used by grandchildren, and further removed descendants, if all of the intervening descendants waited on their terminated children.
• eThread: (limited support) Usage statistics for the calling thread.

Returns

TRUE on success; or FALSE on error. If some value cannot be calculated on a current platform for "what" target, it will be set to a negative value.

Note

NULL arguments will not be filled in.

See also

CProcess::GetTimes

Definition at line 1300 of file ncbi_process.cpp.

References _TROUBLE, buf, CProcessBase::eChildren, CNcbiError::eNotSupported, CProcessBase::eProcess, CProcessBase::eThread, CSystemInfo::GetClockTicksPerSecond(), kUndefined, s_Win_GetHandleTimes(), CNcbiError::Set(), CNcbiError::SetFromErrno(), and t.

Referenced by CProcess::GetTimes(), CPubseqGatewayApp::OnInfo(), CNcbiApplicationAPI::x_LogOptions(), and CNetScheduleHandler::x_ProcessHealth().

Get process execution times.

For current process pid/handle it is the same as CCurrentProcess::GetTimes().

Parameters

real Pointer to a variable that receives the amount of time in second that the process/thread has executed, when available.

Note

Here is no portable solution to get 'real' process execution time, not all OS have an API to get such information from the system, or it can include children times as well... but it is available on some platforms like Windows, Linux and BSD.

Parameters

user Pointer to a variable that receives the amount of time in seconds that the process, process tree or thread has executed in user mode. Note, that this value can exceed the amount of "real" time if the process executes across multiple CPU cores (OS dependent). sys Pointer to a variable that receives the amount of time in second that the current process, process tree or thread has executed in kernel mode. what Defines what times to measure: current thread, process or children processes:

• eProcess: Current process, which is the sum of resources used by all threads in the process.
• eChildren: (limited support) All children of the process that have terminated already and been waited for. These statistics will include the resources used by grandchildren, and further removed descendants, if all of the intervening descendants waited on their terminated children.
• eThread: (limited support) Usage statistics for the calling thread. CProcess should be initialized with the current process pid/handle, or result is undefined.

Returns

TRUE on success; or FALSE on error. If some value cannot be calculated on a current platform for "what" target, it will be set to a negative value.

Note

NULL arguments will not be filled in.

Usually it is possible to query information from users own processes, but you should have an appropriate permissions to query other processes.

On Windows it is possible to get process times even for terminated processes, that are Wait()-ed for, even if IsAlive() returns false.

See also

CCurrentProcess::GetTimes

Definition at line 1249 of file ncbi_process.cpp.

References CProcessBase::eChildren, CNcbiError::eNotSupported, CProcessBase::eProcess, CProcessBase::eThread, CProcess::GetPid(), CCurrentProcess::GetTimes(), HANDLE, CProcess::IsCurrent(), kUndefined, s_Win_GetHandleTimes(), CNcbiError::Set(), CProcess::x_CloseHandle(), and CProcess::x_GetHandle().

Checks that stored process identifier (pid) represent the current process.

See also

GetCurrentPid

Definition at line 613 of file ncbi_process.cpp.

References CProcess::eHandle, CProcess::ePid, eTriState_False, eTriState_True, CCurrentProcess::GetHandle(), CProcess::GetHandle(), CCurrentProcess::GetPid(), CProcess::GetPid(), CProcess::GetType(), and CProcess::m_IsCurrent.

Referenced by CProcess::GetFileDescriptorsCount(), CProcess::GetMemoryUsage(), CProcess::GetTimes(), and CProcess::Kill().

Terminate process.

First try "soft" and then try "hard" attempt to terminate the process.

Note

Even the "hard" attempt does not guarantee that the process will be actually killed. Process termination can take some time, and the process may remain "alive" even after the "hard" termination attempt.

Parameters

timeout Wait time in milliseconds between first "soft" and second "hard" attempts to terminate the process. If timeout is zero then use an unsafe process termination: just try to terminate the process without checks that it is really gone.

Note

On UNIX in case of a zero or very small timeout, the killed process may not be released immediately (and continue to persist as a zombie process) even after this call.

Returns

TRUE - if the process did not exist or was successfully terminated. FALSE - if the process is still running, cannot be terminated, or it is terminating right now (but is still incomplete).

See also

KillGroup, KillGroupById

Definition at line 652 of file ncbi_process.cpp.

References _ASSERT, CStopWatch::Elapsed(), CProcess::ePid, FALSE, CProcess::GetPid(), CProcess::GetType(), HANDLE, INVALID_HANDLE_VALUE, CProcess::IsAlive(), CProcess::IsCurrent(), kMilliSecondsPerSecond, kWaitPrecisionMs, NULL, CNcbiError::SetFromErrno(), CNcbiError::SetFromWindowsError(), CNcbiError::SetWindowsError(), SleepMilliSec(), CStopWatch::Start(), CProcess::x_CloseHandle(), and CProcess::x_GetHandle().

Referenced by CBLASTSeqToolJob::RequestCancel(), CWindowMaskerJob::RequestCancel(), s_Close(), s_Win_KillGroup(), CBamLoadingJob::x_CreateDataLoader(), and CWNJobWatcher::x_KillNode().

Terminate a group of processes.

This method tries to terminate all processes in the group to which process, specified in the constructor, belongs.

Parameters

timeout Wait time in milliseconds between first "soft" and second "hard" attempts to terminate the process group. If timeout is zero then use an unsafe process termination: just try to terminate the group without checks that it is really gone.

Note

On UNIX in case of a zero or very small timeout, some processes may not be released (and continue to persist as zombie processes) even after this call. On MS Windows this method tries to terminate the process itself and all of its children. But in case when one of the processes, which should be terminated, spawns a new process at the very moment that this method gets called, the new process may not be terminated.

Returns

TRUE - if the process group did not exist or was successfully terminated. FALSE - if the process group is still running, cannot be terminated, or it is terminating right now (but is still incomplete).

See also

Kill

Definition at line 943 of file ncbi_process.cpp.

References CProcess::GetPid(), CProcess::KillGroupById(), result, s_Win_KillGroup(), CNcbiError::SetFromErrno(), CStopWatch::Start(), and CProcess::x_GetPid().

Referenced by CRemoteAppReaperTask::operator()(), and s_Close().

Terminate a group of processes with specified ID.

Note: Implemented on UNIX only, on Windows returns FALSE.

Parameters

pgid Process group ID to terminate. if "pgid" parameter is zero, terminate the process group of the current process timeout Wait time in milliseconds between first "soft" and second "hard" attempts to terminate the process group. If timeout is zero then use an unsafe process termination: just try to terminate the process group without checks whether it is really gone.

Note

On UNIX in case of a zero or very small timeout, some processes from the process group to be killed may not be released immediately (and continue to persist as zombie processes) even after this call.

Returns

TRUE - if the process group did not exist or was successfully terminated. FALSE - if the process group is still running, cannot be terminated, or it is terminating right now (but is still incomplete).

See also

Kill

Definition at line 975 of file ncbi_process.cpp.

References _ASSERT, CNcbiError::eNotSupported, kWaitPrecisionMs, CNcbiError::Set(), CNcbiError::SetFromErrno(), and SleepMilliSec().

Referenced by CProcess::KillGroup().

Definition at line 142 of file interprocess_lock.cpp.

References _T_XCSTRING, _VERIFY, close(), CDirEntry::fRead, CDirEntry::fWrite, CTimeout::GetAsMilliSeconds(), HANDLE, CTimeout::IsDefault(), CTimeout::IsInfinite(), kInvalidLockHandle, CInterProcessLock::m_Handle, CInterProcessLock::m_SystemName, CDirEntry::MakeModeT(), min(), ms(), NCBI_THROW, NULL, s_Locks, s_UnixLock(), SleepMilliSec(), strerror(), and TRUE.

Referenced by PInterProcessLock::operator()(), and CInterProcessLock::TryLock().

Release PID.

Decrease reference counter for current PID and remove the file if it is not used more (reference counter is 0).

Definition at line 1792 of file ncbi_process.cpp.

References _T_CSTRING, in(), CPIDGuard::m_MTGuard, CPIDGuard::m_Path, CPIDGuard::m_PID, CPIDGuard::m_PIDGuard, NCBI_THROW, NcbiSys_strerror, out(), CGuard< Resource, Lock, Unlock, ReportExceptions >::Release(), CDirEntry::Remove(), and trunc.

Referenced by CPIDGuard::~CPIDGuard().

Call Unlock() and removes lock object from the system.

On Unix, the Unlock() method do not remove used lock file from the system, it just release a lock. If you don't need this file anymore, use this method to remove it. We cannot remove it automaticaly in the Unlock(), because on Unix locking/unlocking is not an atomic operations and race condition is possible if at time of deleting some other process wait to acquire a lock using the same lock file.

Note

On Windows, it works almost as Unlock().

See also

Unlock

Definition at line 373 of file interprocess_lock.cpp.

References _T_XCSTRING, kInvalidLockHandle, CInterProcessLock::m_Handle, CInterProcessLock::m_SystemName, NcbiSys_unlink, and CInterProcessLock::Unlock().

Try to acquire the lock.

Acquire the lock if it can be done right away. Return immediately.

Returns

• TRUE, if the lock has been successfully acquired.
• FALSE, if the lock is already held by another process or if any error occurs.

See also

Lock

Definition at line 382 of file interprocess_lock.cpp.

References CInterProcessLock::Lock().

Release the lock.

On any error (including when the lock is not held by the process), throw CInterProcessLockException.

See also

Lock, TryLock, Remove

Definition at line 320 of file interprocess_lock.cpp.

References _VERIFY, close(), kInvalidLockHandle, CInterProcessLock::m_Handle, CInterProcessLock::m_SystemName, NCBI_THROW, s_Locks, and SEEK_SET.

Referenced by CInterProcessLock::Remove(), and CInterProcessLock::~CInterProcessLock().

Update PID in the file.

Parameters

pid The new process ID to store (defaults to the current PID); useful when the real work occurs in a child process that outlives the parent.

Definition at line 1866 of file ncbi_process.cpp.

References _T_CSTRING, CProcess::ePid, CCurrentProcess::GetPid(), in(), CPIDGuard::m_MTGuard, CPIDGuard::m_Path, CPIDGuard::m_PID, CPIDGuard::m_PIDGuard, NCBI_THROW, NCBI_THROW2, NcbiSys_strerror, out(), and trunc.

Referenced by CPIDGuard::CPIDGuard().

Wait until process terminates.

Wait until the process terminates or timeout expires. Return immediately if the specified process has already terminated.

Parameters

timeout Time interval in milliseconds (infinite by default) to wait. info Extended exit information for terminated process. Note that if CProcess::Kill() was used to terminate the process then the extended information may not be available.

Returns

• Exit code of the process, if the call completed without errors.
• (-1) if an error occurred or it was impossible to get the exit code of the process. If 'info' parameter is specified, then it is filled with additional information about the process.

Note

It is recommended to call this method for all processes started in eNoWait or eDetach modes (except on Windows for eDetach), because it releases "zombie" processes, i.e. those finished running and waiting for their parent to obtain their exit code. If Wait() is not called somewhere, then the child process will be completely removed from the system only when its parent process ends.

Infinite timeout can cause an application to stop responding.

See also

IsAlive, CExitInfo, CExec, WaitInfinite, WaitTimeout

Definition at line 1037 of file ncbi_process.cpp.

References _ASSERT, eExitInfo_Alive, eExitInfo_Terminated, eExitInfo_Unknown, CProcess::GetPid(), HANDLE, info, CProcessBase::kInfiniteTimeoutMs, kWaitPrecisionMs, CNcbiError::SetFromErrno(), SleepMilliSec(), CProcess::x_CloseHandle(), and CProcess::x_GetHandle().

Referenced by CRemoteAppReaperTask::operator()(), SGridWorkerNodeImpl::Run(), s_Close(), s_GetBigBedFeats(), s_GetBigBedSummary(), s_GetData(), CExec::Wait(), CProcess::WaitInfinite(), CProcess::WaitTimeout(), CBamLoadingJob::x_CreateDataLoader(), CBLASTSeqToolJob::x_CreateProjectItems(), and CWigGraph::x_RunBigWigScript().

Definition at line 572 of file ncbi_process.cpp.

References CNcbiError::eBadAddress, CProcess::eHandle, FALSE, CProcess::GetHandle(), CProcess::GetPid(), CProcess::GetType(), INVALID_HANDLE_VALUE, NULL, CNcbiError::Set(), CNcbiError::SetFromWindowsError(), and CNcbiError::SetWindowsError().

Referenced by CProcess::GetMemoryUsage(), CProcess::GetTimes(), CProcess::IsAlive(), CProcess::Kill(), and CProcess::Wait().

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4