Wie der Prozess Startzeit (oder Uptime) in Python abrufen

StackOverflow https://stackoverflow.com/questions/2598145

  •  25-09-2019
  •  | 
  •  

Frage

Wie die Prozess Startzeit (oder Uptime) in Python in Linux zurückzuholen?

Ich weiß nur, kann ich „ps -p my_process_id -f“ und dann die Ausgabe analysieren. Aber es ist nicht cool.

War es hilfreich?

Lösung

Wenn Sie es aus dem Python-Programm tun Sie versuchen, messen Sie so etwas tun könnte: 

import time
# at the beginning of the script
startTime = time.time()
# ...
def getUptime():
    """
    Returns the number of seconds since the program started.
    """
    # do return startTime if you just want the process start time
    return time.time() - startTime

Ansonsten haben Sie keine andere Wahl, als ps zu analysieren oder in /proc/pid zu gehen. Ein schöner bashy Weg, um die verstrichene Zeit zu bekommen ist: 

ps -eo pid,etime | grep $YOUR_PID | awk '{print $2}'

Dies wird nur die verstrichene Zeit im folgende Format gedruckt werden, so dass es ganz einfach zu Parse sein sollte: 

days-HH:MM:SS

(wenn es für weniger als einen Tag läuft, es ist nur HH:MM:SS)

Die Startzeit ist wie folgt zur Verfügung: 

ps -eo pid,stime | grep $YOUR_PID | awk '{print $2}'

Leider, wenn Ihr Prozess nicht starten heute , dies Ihnen nur das Datum geben, dass sie begann, anstatt die Zeit.

Der beste Weg, dies zu tun, ist die verstrichene Zeit und die aktuelle Zeit zu bekommen und macht nur ein bisschen Mathematik. Im Folgenden ist ein Python-Skript, das eine PID als Argument übernimmt und tut das oben für Sie, das Startdatum und die Uhrzeit des Prozessdruck aus: 

import sys
import datetime
import time
import subprocess

# call like this: python startTime.py $PID

pid = sys.argv[1]
proc = subprocess.Popen(['ps','-eo','pid,etime'], stdout=subprocess.PIPE)
# get data from stdout
proc.wait()
results = proc.stdout.readlines()
# parse data (should only be one)
for result in results:
    try:
        result.strip()
        if result.split()[0] == pid:
            pidInfo = result.split()[1]
            # stop after the first one we find
            break
    except IndexError:
        pass # ignore it
else:
    # didn't find one
    print "Process PID", pid, "doesn't seem to exist!"
    sys.exit(0)
pidInfo = [result.split()[1] for result in results
           if result.split()[0] == pid][0]
pidInfo = pidInfo.partition("-")
if pidInfo[1] == '-':
    # there is a day
    days = int(pidInfo[0])
    rest = pidInfo[2].split(":")
    hours = int(rest[0])
    minutes = int(rest[1])
    seconds = int(rest[2])
else:
    days = 0
    rest = pidInfo[0].split(":")
    if len(rest) == 3:
        hours = int(rest[0])
        minutes = int(rest[1])
        seconds = int(rest[2])
    elif len(rest) == 2:
        hours = 0
        minutes = int(rest[0])
        seconds = int(rest[1])
    else:
        hours = 0
        minutes = 0
        seconds = int(rest[0])

# get the start time
secondsSinceStart = days*24*3600 + hours*3600 + minutes*60 + seconds
# unix time (in seconds) of start
startTime = time.time() - secondsSinceStart
# final result
print "Process started on",
print datetime.datetime.fromtimestamp(startTime).strftime("%a %b %d at %I:%M:%S %p")

Andere Tipps

Durch die Verwendung von psutil https://github.com/giampaolo/psutil : 

>>> import psutil, os, time
>>> p = psutil.Process(os.getpid())
>>> p.create_time()
1293678383.0799999
>>> time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(p.create_time()))
'2010-12-30 04:06:23'
>>>

... plus es ist Cross-Plattform, nicht nur Linux.

NB: Ich bin einer der Autoren dieses Projekts

.

man proc sagt, dass das 22. Element in /proc/my_process_id/stat ist:

  

starttime %lu

     

Die Zeit in jiffies den Prozess nach Systemstart gestartet.

Ihr Problem ist jetzt, wie die Länge eines Jiffy zu bestimmen, und wie zu bestimmen, wann das System gestartet.

Die Antwort für die letztere kommt nach wie vor aus man proc: es ist in /proc/stat, auf einer eigenen Zeile wie folgt aus: 

btime 1270710844

Das ist eine Messung in Sekunden seit der Epoche.

Die Antwort für das ehemalige ich bin nicht sicher. man 7 time sagt:

  

Die Software Clock, HZ und jiffies

     

Die Genauigkeit vieler Systemaufrufe und Zeitstempel durch die Auflösung der Software-Uhr begrenzt ist, beibehalten eine Uhr durch den Kernel, misst die Zeit in jiffies. Die Größe eines Jiffy wird durch den Wert des Kern konstant HZ bestimmt. Der Wert von HZ variiert je nach Kernel-Versionen und Hardware-Plattformen. Auf x86 ist die Situation folgt als: Kerne auf bis zu und einschließlich 2.4.x, HZ 100 wurde, wurde ein Wert von 0,01 Jiffy Sekunden ergibt; beginnend mit 2.6.0 HZ wurde auf 1000 erhöht, eine Jiffy von 0,001 Sekunden ergibt; da kernel 2.6.13, ist der Wert HZ ein Kernel-Konfigurationsparameter und kann 100, 250 (Standard) oder 1000, wodurch man einen jiffies Wert von jeweils 0,01, 0,004 oder 0,001 Sekunden sein.

Wir brauchen HZ zu finden, aber ich habe keine Ahnung, was ich davon aus Python gehen würde, bis auf den Wert der Hoffnung, 250 (wie Wikipedia Ansprüche ist die Standardeinstellung).

ps erhält es so aus: 

  /* sysinfo.c init_libproc() */
  if(linux_version_code > LINUX_VERSION(2, 4, 0)){ 
    Hertz = find_elf_note(AT_CLKTCK);
    //error handling
  }
  old_Hertz_hack(); //ugh

Das klingt wie ein Job gut durch eine sehr kleine C-Modul für Python getan:)

Hier ist Code basierend auf BADP Antwort: 

import os
from time import time

HZ = os.sysconf(os.sysconf_names['SC_CLK_TCK'])

def proc_age_secs():
    system_stats = open('/proc/stat').readlines()
    process_stats = open('/proc/self/stat').read().split()
    for line in system_stats:
        if line.startswith('btime'):
            boot_timestamp = int(line.split()[1])
    age_from_boot_jiffies = int(process_stats[21])
    age_from_boot_timestamp = age_from_boot_jiffies / HZ
    age_timestamp = boot_timestamp + age_from_boot_timestamp
    return time() - age_timestamp

Ich bin mir nicht sicher, ob es richtig ist, obwohl. Ich schrieb ein Testprogramm, dass Anrufe Schlaf (5) und dann läuft es und der Ausgang ist falsch und ein paar Sekunden von Lauf zu Lauf variiert. Dies ist in einer VMWare Workstation vm: 

if __name__ == '__main__':
    from time import sleep
    sleep(5)
    print proc_age_secs()

Die Ausgabe lautet: 

$ time python test.py
6.19169998169

real    0m5.063s
user    0m0.020s
sys     0m0.036s

def proc_starttime(pid=os.getpid()):
    # https://gist.github.com/westhood/1073585
    p = re.compile(r"^btime (\d+)$", re.MULTILINE)
    with open("/proc/stat") as f:
        m = p.search(f.read())
    btime = int(m.groups()[0])

    clk_tck = os.sysconf(os.sysconf_names["SC_CLK_TCK"])
    with open("/proc/%d/stat" % pid) as f:
        stime = int(f.read().split()[21]) / clk_tck

    return datetime.fromtimestamp(btime + stime)

Sie können /proc/uptime

analysieren 
>>> uptime, idletime = [float(f) for f in open("/proc/uptime").read().split()]
>>> print uptime
29708.1
>>> print idletime
26484.45

für Windows-Rechner, können Sie wahrscheinlich verwenden wmi 

import wmi
c = wmi.WMI()
secs_up = int([uptime.SystemUpTime for uptime in c.Win32_PerfFormattedData_PerfOS_System()][0])
hours_up = secs_up / 3600
print hours_up
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top