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

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

NCBI C++ ToolKit: src/corelib/ncbi_process.cpp Source File

\

"Please check CExitInfo::IsPresent() first."); \

WIFEXITED(status) != 0;

WIFSIGNALED(status) != 0;

WEXITSTATUS(status);

( !IsSignaled() ) {

WTERMSIG(status);

CCurrentProcess::sx_GetPid(EGetPidFlag flag)

( flag == ePID_GetThread ) {

s_CurrentPid = 0;

s_ParentPid = 0;

s_CurrentPid = getpid();

s_ParentPid = getppid();

thr_pid = CThread::sx_GetThreadPid();

(thr_pid && thr_pid != pid) {

CThread::sx_SetThreadPid(pid);

s_ParentPid = getppid();

flag == ePID_GetCurrent ? s_CurrentPid : s_ParentPid;

return ::GetCurrentProcess();

return ::GetCurrentProcessId();

sx_GetPid(ePID_GetCurrent);

PROCESSENTRY32 entry;

entry.th32ParentProcessID;

sx_GetPid(ePID_GetParent);

CErrnoKeeper() : m_Errno(errno) {}

GetErrno()

{

m_Errno;}

~CErrnoKeeper() {errno = m_Errno;}

CErrnoKeeper x_errno;

(!(

& fFF_Exec) && use_async_safe) {

(3,

<<

);

(!(

& fFF_Exec)) {

(use_async_safe) {

);

CSafeRedirect(

fd,

* success_flag) :

m_OrigFD(fd), m_SuccessFlag(success_flag), m_Redirected(

)

((m_DupFD = ::fcntl(fd, F_DUPFD, STDERR_FILENO + 1)) < 0) {

<< fd <<

Redirect(

new_fd)

(new_fd != m_OrigFD) {

= ::dup2(new_fd, m_OrigFD);

CErrnoKeeper x_errno;

<< m_OrigFD <<

m_Redirected =

;

CErrnoKeeper x_errno;

(m_Redirected && !*m_SuccessFlag) {

::dup2(m_DupFD, m_OrigFD);

* m_SuccessFlag;

CBoolResetter {

CBoolResetter(

&

)

<<

);

success_flag =

;

CSafeRedirect stdin_redirector (

, &success_flag);

CSafeRedirect stdout_redirector(

, &success_flag);

CSafeRedirect stderr_redirector(STDERR_FILENO, &success_flag);

((new_fd = ::open(

, O_RDONLY)) < 0) {

stdin_redirector.Redirect(new_fd);

((new_fd = ::open(

, O_WRONLY)) < 0) {

stdout_redirector.Redirect(new_fd);

((new_fd = ::open(

, O_WRONLY | O_APPEND)) < 0) {

((new_fd = ::open(logfile, O_WRONLY | O_APPEND | O_CREAT, 0666)) < 0) {

<< logfile <<

<<

());

stderr_redirector.Redirect(new_fd);

success_flag =

;

(2,

<< e <<

);

(::chdir(

) ) {

};

CErrnoKeeper x_errno;

(exception& e) {

CErrnoKeeper x_errno;

);

: m_Process(process),

hProcess = ::OpenProcess(desired_access,

,

());

*errcode = ::GetLastError();

::CloseHandle(handle);

current =

;

kill(

(), 0) == 0 || errno == EPERM;

status == ERROR_ACCESS_DENIED;

::GetExitCodeProcess(hProcess, &status);

status == STILL_ACTIVE;

(kill(pid, SIGTERM) < 0 && errno == EPERM) {

x_timeout = timeout;

reap = waitpid(pid, 0, WNOHANG);

(reap != (

)(-1)) {

(errno != ECHILD) {

(kill(pid, 0) < 0)

(x_sleep > x_timeout) {

x_timeout -= x_sleep;

res = kill(pid, SIGKILL);

waitpid(pid, 0, WNOHANG);

kill(pid, 0) < 0;

safe = (timeout > 0);

allow_wait =

;

hProcess =

(PROCESS_CREATE_THREAD | PROCESS_TERMINATE | SYNCHRONIZE);

(err != ERROR_ACCESS_DENIED) {

(!::OpenThreadToken(::GetCurrentThread(),

TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,

, &hToken)) {

err = ::GetLastError();

(err != ERROR_NO_TOKEN) {

(!::OpenProcessToken(::GetCurrentProcess(),

TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, &hToken)) {

TOKEN_PRIVILEGES tp, tp_prev;

tp_prev_size =

(tp_prev);

tp.PrivilegeCount = 1;

tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

::LookupPrivilegeValue(

, SE_DEBUG_NAME, &tp.Privileges[0].Luid);

(!::AdjustTokenPrivileges(hToken,

, &tp,

(tp), &tp_prev, &tp_prev_size)) {

::CloseHandle(hToken);

err = ::GetLastError();

(err == ERROR_NOT_ALL_ASSIGNED) {

::CloseHandle(hToken);

hProcess = ::OpenProcess(PROCESS_TERMINATE,

,

());

::AdjustTokenPrivileges(hToken,

, &tp_prev,

(tp_prev),

,

);

::CloseHandle(hToken);

terminated =

;

( safe && allow_wait ) {

FARPROC exitproc = ::GetProcAddress(::GetModuleHandleA(

),

);

hThread = ::CreateRemoteThread(hProcess,

, 0, (LPTHREAD_START_ROUTINE)exitproc, 0, 0, 0);

(::WaitForSingleObject(hProcess, timeout) == WAIT_OBJECT_0)){

( ::TerminateProcess(hProcess, -1) != 0 ) {

err = ::GetLastError();

(err == ERROR_INVALID_HANDLE) {

(safe && terminated) {

linger_timeout = (elapsed < timeout) ?

(

)((double)timeout - elapsed) : 0;

(x_sleep > linger_timeout) {

x_sleep = linger_timeout;

linger_timeout -= x_sleep;

::CloseHandle(hThread);

snapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

PROCESSENTRY32 entry;

entry.dwSize =

(PROCESSENTRY32);

(!::Process32First(snapshot, &entry)) {

::CloseHandle(snapshot);

(entry.th32ParentProcessID == pid) {

timeout = (elapsed < timeout) ? (

)((double)timeout - elapsed) : 0;

::CloseHandle(snapshot);

::CloseHandle(snapshot);

(::Process32Next(snapshot, &entry));

timeout = (elapsed < timeout) ? (

)((double)timeout - elapsed) : 0;

::CloseHandle(snapshot);

::CloseHandle(snapshot);

(pgid == (

)(-1)) {

errno == ESRCH;

x_timeout = timeout;

(kill(-pgid, SIGTERM) < 0 && errno == EPERM) {

x_timeout = timeout;

reap = waitpid(pgid, 0, WNOHANG);

(reap != (

)(-1)) {

(errno != ECHILD) {

(kill(-pgid, 0) < 0) {

(x_sleep > x_timeout) {

x_sleep = x_timeout;

x_timeout -= x_sleep;

res = kill(-pgid, SIGKILL);

waitpid(pgid, 0, WNOHANG);

kill(-pgid, 0) < 0;

ws = waitpid(pid, &status, options);

->status = status;

WIFEXITED(status) ? WEXITSTATUS(status) : -1;

}

(ws == 0) {

(x_sleep > timeout) {

}

(errno != EINTR) {

allow_wait =

;

allow_wait =

;

(::GetExitCodeProcess(hProcess, &x_status)) {

(x_status == STILL_ACTIVE) {

(allow_wait && timeout) {

? INFINITE : (

) timeout);

ws = ::WaitForSingleObject(hProcess, tv);

(x_status == STILL_ACTIVE);

(::GetExitCodeProcess(hProcess, &x_status)) {

(x_status != STILL_ACTIVE) {

(

&& x_status == STILL_ACTIVE) {

->status = x_status;

FILETIME ft_creation, ft_exit, ft_kernel, ft_user;

res = ::GetProcessTimes(handle, &ft_creation, &ft_exit, &ft_kernel, &ft_user);

res = ::GetThreadTimes(handle, &ft_creation, &ft_exit, &ft_kernel, &ft_user);

::GetSystemTimeAsFileTime(&ft_sys);

.LowPart = ft_creation.dwLowDateTime;

.HighPart = ft_creation.dwHighDateTime;

.LowPart = ft_sys.dwLowDateTime;

.HighPart = ft_sys.dwHighDateTime;

.QuadPart = v_diff;

*real = (

.LowPart + ((

)

.HighPart << 32)) * 1.0e-7;

*sys = (ft_kernel.dwLowDateTime + ((

) ft_kernel.dwHighDateTime << 32)) * 1e-7;

*user = (ft_user.dwLowDateTime + ((

) ft_user.dwHighDateTime << 32)) * 1e-7;

s_Linux_GetTimes_ProcStat(

pid,

* real,

* user,

* sys,

what)

CLinuxFeature::CProcStat ps(pid);

fu = 14, fs = 15;

(start > 0 && uptime > 0) {

*real = uptime - (double)start / (

)tick;

s_Linux_GetTimes_ProcStat(

(), real, user, sys, what);

( s_Linux_GetTimes_ProcStat(0

, real, user, sys, what) ) {

who = RUSAGE_SELF;

who = RUSAGE_CHILDREN;

who = RUSAGE_THREAD;

memset(&ru,

,

(ru));

(getrusage(who, &ru) != 0) {

*user = double(ru.ru_utime.tv_sec) + double(ru.ru_utime.tv_usec) / 1e6;

*sys = double(ru.ru_stime.tv_sec) + double(ru.ru_stime.tv_usec) / 1e6;

clock_t

= times(&

);

(

== (clock_t)(-1) ) {

*user = (double)

.tms_utime / (

)tick;

*sys = (double)

.tms_stime / (

)tick;

(STDMETHODCALLTYPE

* dllGetProcessMemoryInfo)

dllGetProcessMemoryInfo = psapi_dll.

(

, &dllGetProcessMemoryInfo);

(dllGetProcessMemoryInfo) {

( !dllGetProcessMemoryInfo(handle, memcounters,

(memcounters)) ) {

memset(&ru,

,

(ru));

(getrusage(RUSAGE_SELF, &ru) == 0) {

.total_peak = ru.ru_maxrss;

.resident_peak = ru.ru_maxrss;

.resident_peak = ru.ru_maxrss * 1024;

.total_peak = ru.ru_maxrss * 1024;

.total = KBT(ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss);

(

.total > 0) {

.total_peak = KBT(ru.ru_ixrss + ru.ru_isrss) + maxrss;

.resident = KBT(ru.ru_idrss);

.resident_peak = maxrss;

.shared = KBT(ru.ru_ixrss);

.data = KBT(ru.ru_idrss);

.stack = KBT(ru.ru_isrss);

.total_peak = maxrss;

.resident_peak = maxrss;

(

.total > 0) {

task_flavor_t flavor = MACH_TASK_BASIC_INFO;

mach_task_basic_info t_info;

mach_msg_type_number_t t_info_count = MACH_TASK_BASIC_INFO_COUNT;

task_flavor_t flavor = TASK_BASIC_INFO;

task_basic_info t_info;

mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

(task_info(mach_task_self(), flavor, (task_info_t)&t_info, &t_info_count) == KERN_SUCCESS) {

.total = t_info.resident_size;

.resident = t_info.resident_size;

(

.resident_peak <

.resident) {

PROCESSENTRY32 entry;

entry.cntThreads;

CLinuxFeature::GetThreadCount(

());

PROCESSENTRY32 entry;

entry.cntThreads;

CLinuxFeature::GetThreadCount();

CLinuxFeature::GetFileDescriptorsCount(

());

rlim_t cur_limit = -1;

rlim_t max_limit = -1;

(getrlimit(RLIMIT_NOFILE, &rlim) == 0) {

cur_limit = rlim.rlim_cur;

max_limit = rlim.rlim_max;

cur_limit =

rlim_t

(sysconf(_SC_OPEN_MAX));

*soft_limit = (cur_limit > INT_MAX) ? INT_MAX :

(cur_limit);

*hard_limit = (max_limit > INT_MAX) ? INT_MAX :

(max_limit);

= CLinuxFeature::GetFileDescriptorsCount(

());

(n < 0 && cur_limit > 0) {

max_fd = (cur_limit > INT_MAX) ? INT_MAX :

(cur_limit);

(

fd = 0; fd < max_fd; ++fd) {

(fcntl(fd, F_GETFD, 0) == -1) {

(errno == EBADF) {

( soft_limit ) { *soft_limit = -1; }

( hard_limit ) { *hard_limit = -1; }

(real_dir.empty()) {

ref = 0;

(

!= pid ) {

(

.good() ) {

<< pid << endl << ref << endl;

( !

.good() ) {

+

+

valid_file =

;

ref = 1;

>> old_pid >> ref;

( old_pid == pid ) {

, old_pid);

(

.good() ) {

<< pid << endl << ref << endl;

( !

.good() ) {

+

+

(GetErrCode()) {

:

;

void Release()

Manually force the resource to be released.

Extended exit information for waited process.

static clock_t GetClockTicksPerSecond(void)

Get number of (statistics) clock ticks per second.

static double GetUptime(void)

Get system uptime in seconds.

static bool FindProcessEntry(DWORD id, PROCESSENTRY32 &entry)

Find process entry information by process identifier (pid).

std::ofstream out("events_result.xml")

main entry point for tests

@ eTriState_False

The value is equivalent to false/no.

@ eTriState_True

The value is equivalent to true/yes.

@ eTriState_Unknown

The value is indeterminate.

CDiagContext & GetDiagContext(void)

Get diag context instance.

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

static void UpdateOnFork(TOnForkFlags flags)

Update diagnostics after fork().

void PrintStop(void)

Print exit message.

@ fOnFork_ResetTimer

Reset execution timer.

@ fOnFork_AsyncSafe

After a fork() in a multithreaded program, the child can safely call only async-signal-safe functions...

@ fOnFork_PrintStart

Log app-start.

TFunc GetEntryPoint_Func(const string &name, TFunc *func)

Get DLLs entry point (function).

static void SetFromWindowsError(void)

Set last error on MS Windows using GetLastError()

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

static void SetFromErrno(void)

Set last error using current "errno" code.

void Warning(CExceptionArgs_Base &args)

static void Set(ECode code)

Set last error using native error code enum.

#define NCBI_THROW2(exception_class, err_code, message, extra)

Throw exception with extra parameter.

#define NCBI_THROW_FMT(exception_class, err_code, message)

The same as NCBI_THROW but with message processed as output to ostream.

static void SetWindowsError(int native_err_code)

Set last error using Windows-specific error code.

virtual const char * GetErrCodeString(void) const

Get error code interpreted as text.

virtual const char * what(void) const noexcept

Standard report (includes full backlog).

@ eUnknown

Unknown error.

static string GetTmpDir(void)

Get temporary directory.

Int8 GetLength(void) const

Get size of file.

virtual bool Remove(TRemoveFlags flags=eRecursive) const

Remove a directory entry.

static string MakePath(const string &dir=kEmptyStr, const string &base=kEmptyStr, const string &ext=kEmptyStr)

Assemble a path from basic components.

static void SplitPath(const string &path, string *dir=0, string *base=0, string *ext=0)

Split a path string into its basic components.

int64_t Int8

8-byte (64-bit) signed integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

virtual const char * GetErrCodeString(void) const override

bool GetTimes(double *real, double *user, double *sys, EWhat what=eProcess)

Get process execution times.

static int GetThreadCount(void)

Get the number of threads in the current process.

TPid x_GetPid(void) const

~CPIDGuard(void)

Destructor.

CPIDGuard(const string &filename)

Create/check PID file.

TProcessHandle x_GetHandle(DWORD desired_access, DWORD *errcode=0) const

static TPid GetParentPid(void)

Get process identifier (pid) for the parent of the current process.

bool IsPresent(void) const

TRUE if the object contains information about the process state.

EType

How to interpret the used process identifier.

TProcessHandle GetHandle(void) const

Get stored process handle.

static bool KillGroupById(TPid pgid, unsigned long timeout=kDefaultKillTimeout)

Terminate a group of processes with specified ID.

bool KillGroup(unsigned long timeout=kDefaultKillTimeout) const

Terminate a group of processes.

static TPid GetPid(void)

Get process identifier (pid) for the current process.

int status

Process status information.

unsigned int TDaemonFlags

Bit-wise OR of FDaemonFlags.

static int GetFileDescriptorsCount(int *soft_limit=NULL, int *hard_limit=NULL)

Get the number of file descriptors consumed by the current process, and optional system wide file des...

EType m_Type

Type of process identifier.

EWhat

Process information "target".

unique_ptr< CInterProcessLock > m_MTGuard

bool IsExited(void) const

TRUE if the process terminated normally.

bool GetMemoryUsage(SMemoryUsage &usage)

Get process memory usage.

int GetSignal(void) const

Get the signal number that has caused the process to terminate (UNIX only).

bool Kill(unsigned long timeout=kDefaultKillTimeout)

Terminate process.

static bool GetMemoryUsage(SMemoryUsage &usage)

Get current process memory usage.

ETriState m_IsCurrent

Status that m_Process represent the current process.

static TPid Daemonize(const char *logfile=0, TDaemonFlags flags=0)

Go daemon.

static TPid Fork(TForkFlags flags=fFF_UpdateDiag)

Fork the process.

unique_ptr< CInterProcessLock > m_PIDGuard

static const unsigned long kInfiniteTimeoutMs

Infinite timeout (milliseconds).

CExitInfo(void)

Constructor.

intptr_t m_Process

Process identifier.

bool IsCurrent(void)

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

int Wait(unsigned long timeout=kInfiniteTimeoutMs, CExitInfo *info=0) const

Wait until process terminates.

void x_CloseHandle(TProcessHandle handle) const

int GetThreadCount(void)

Get the number of threads in the process.

static const unsigned long kDefaultKillTimeout

Default wait time (milliseconds) between "soft" and "hard" attempts to terminate a process.

unsigned TForkFlags

Bit-wise OR of FForkFlags.

pid_t TPid

Process identifier (PID) and process handle.

bool IsAlive(void) const

TRUE if the process is still alive.

void Release(void)

Release PID.

bool IsSignaled(void) const

TRUE if the process terminated by a signal (UNIX only).

CProcess(void)

Default constructor. Uses the current process pid.

TPid GetPid(void) const

Get stored process identifier (pid).

static bool GetTimes(double *real, double *user, double *sys, EWhat what=eProcess)

Get current process execution times.

bool IsAlive(void) const

Check for process existence.

static TProcessHandle GetHandle(void)

Get process handle for the current process (esp.

int GetFileDescriptorsCount(void)

Get the number of file descriptors consumed by the current process.

EType GetType(void) const

Get type of stored process identifier.

void UpdatePID(TPid pid=0)

Update PID in the file.

void Remove(void)

Remove the file.

int GetExitCode(void) const

Get process exit code.

@ ePid

A real process identifier (pid).

@ eHandle

A process handle (MS Windows).

@ eWrite

Unable to write into the PID file.

@ eStillRunning

The process listed in the file is still around.

@ eChildren

All children of the calling process.

@ eThread

Current thread.

@ eProcess

Current process.

@ fFF_UpdateDiag

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

@ fFF_AllowExceptions

Throw an exception on error.

@ fDF_KeepCWD

Don't change CWD to "/".

@ fDF_KeepParent

Do not exit the parent process but return.

@ fDF_KeepStdout

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

@ fDF_AllowExceptions

Throw an exception in case of an error.

@ fDF_KeepStdin

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

@ fDF_AllowThreads

Do not fail if pre-existing threads are detected.

@ fDF_ImmuneTTY

Make daemon immune to re-acquiring a controlling terminal.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

IO_PREFIX::ofstream CNcbiOfstream

Portable alias for ofstream.

IO_PREFIX::ifstream CNcbiIfstream

Portable alias for ifstream.

static Uint8 StringToUInt8(const CTempString str, TStringToNumFlags flags=0, int base=10)

Convert string to Uint8.

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

@ fConvErr_NoThrow

Do not throw an exception on error.

static unsigned int GetThreadsCount()

Get total amount of threads This amount does not contain main thread.

double Elapsed(void) const

Return time elapsed since first Start() or last Restart() call (in seconds).

const long kMilliSecondsPerSecond

Number milliseconds in one second.

void Start(void)

Start the timer.

#define INVALID_HANDLE_VALUE

A value for an invalid file handle.

#define HANDLE

An abstraction for a file handle.

Definition of all error codes used in corelib (xncbi.lib).

const struct ncbi::grid::netcache::search::fields::SIZE size

Defines MS Windows specific private functions and classes.

Private UNIX specific features.

bool s_Win_GetMemoryUsage(HANDLE handle, CProcess::SMemoryUsage &usage)

TPid s_Daemonize(const char *logfile, CCurrentProcess::TDaemonFlags flags)

bool s_Win_GetHandleTimes(HANDLE handle, double *real, double *user, double *sys, CProcess::EWhat what)

static bool s_Win_KillGroup(DWORD pid, CStopWatch *timer, unsigned long &timeout)

bool s_Win_GetMemoryCounters(HANDLE handle, SProcessMemoryCounters &memcounters)

const unsigned long kWaitPrecisionMs

DEFINE_STATIC_FAST_MUTEX(s_CorelibDaemonizeMutex)

static string s_ErrnoToString()

Defines process management classes.

Static variables safety - create on demand, destroy on application termination.

#define FALSE

bool replacment for C indicating false.

void SleepMilliSec(unsigned long ml_sec, EInterruptOnSignal onsignal=eRestartOnSignal)

bool GetMemoryUsage(size_t *total, size_t *resident, size_t *shared)

Defines NCBI C++ diagnostic APIs, classes, and macros.

Define class Dll and for Portable DLL handling.

Defines NCBI C++ Toolkit portable error codes.

Defines classes: CDirEntry, CFile, CDir, CSymLink, CMemoryFile, CFileUtil, CFileLock,...

Multi-threading – classes, functions, and features.

Defines: CTimeFormat - storage class for time format.

std::istream & in(std::istream &in_, double &x_)

static const TModelUnit kUndefined

Process memory usage information, in bytes.

SIZE_T QuotaPagedPoolUsage

SIZE_T QuotaNonPagedPoolUsage

SIZE_T QuotaPeakNonPagedPoolUsage

SIZE_T PeakWorkingSetSize

SIZE_T QuotaPeakPagedPoolUsage

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