Example #1
0
File: core.py Project: OspreyX/dask
    def extend(self, seq):
        if isinstance(seq, Iterator):
            start_available_memory = psutil.avail_phymem()
            # Two bounds to avoid hysteresis
            target_low = 0.4 * start_available_memory
            target_high = 0.6 * start_available_memory
            # Pull chunksize from last run
            chunksize = global_chunksize[0]
            empty = False

            while not empty:
                chunk = tuple(take(chunksize, seq))
                self.extend_chunk(chunk)

                # tweak chunksize if necessary
                available_memory = psutil.avail_phymem()
                if len(chunk) == chunksize:
                    if available_memory > target_high:
                        chunksize = int(chunksize * 1.6)
                    elif available_memory < target_low:
                        chunksize = int(chunksize / 1.6)

                empty, seq = isempty(seq)

            global_chunksize[0] = chunksize
        else:
            self.extend_chunk(seq)
Example #2
0
    def extend(self, seq):
        if isinstance(seq, Iterator):
            start_available_memory = psutil.avail_phymem()
            # Two bounds to avoid hysteresis
            target_low = 0.4 * start_available_memory
            target_high = 0.6 * start_available_memory
            # Pull chunksize from last run
            chunksize = global_chunksize[0]
            empty = False

            while not empty:
                chunk = tuple(take(chunksize, seq))
                self.extend_chunk(chunk)

                # tweak chunksize if necessary
                available_memory = psutil.avail_phymem()
                if len(chunk) == chunksize:
                    if available_memory > target_high:
                        chunksize = int(chunksize * 1.6)
                    elif available_memory < target_low:
                        chunksize = int(chunksize / 1.6)

                empty, seq = isempty(seq)

            global_chunksize[0] = chunksize
        else:
            self.extend_chunk(seq)
Example #3
0
    def cpustat(self):
        tags = "node:%s %s" % (self.nodename, self.tags)

        val = int(psutil.cpu_percent())
        measurement = "cpu_perc"
        key = "%s.%s" % (self.nodename, measurement)
        self.measure(key, measurement, tags, val, aggrkey=measurement)

        val = int(psutil.avail_phymem() / 1024 / 1024)
        measurement = "mem_free_mb"
        key = "%s.%s" % (self.nodename, measurement)
        self.measure(key, measurement, tags, val, aggrkey=measurement)

        val = int(psutil.virtmem_usage()[3])
        measurement = "mem_virt_perc"
        key = "%s.%s" % (self.nodename, measurement)
        self.measure(key, measurement, tags, val, aggrkey=measurement)

        val = int(psutil.phymem_usage()[2])
        measurement = "mem_phy_perc"
        key = "%s.%s" % (self.nodename, measurement)
        self.measure(key, measurement, tags, val, aggrkey=measurement)

        res = psutil.cpu_times_percent()
        names = [
            "cputimeperc_user", "cputimeperc_nice", "cputimeperc_system",
            "cputimeperc_idle", "cputimeperc_iowait", "cputimeperc_irq",
            "cputimeperc_softirq", "steal", "guest", "guest_nice"
        ]
        for i in range(len(names)):
            if names[i].startswith("cputime"):
                val = int(res[i])
                measurement = names[i]
                key = "%s.%s" % (self.nodename, measurement)
                self.measure(key, measurement, tags, val, aggrkey=measurement)
Example #4
0
    def mem(self, widget, data=None) :
	print ' \n DETAILS OF PHYSICAL AND VIRTUAL MEMORY\n '
	print 'Total physical memory (in bytes) - '
	print psutil.TOTAL_PHYMEM
	print 'Available physical memory (in bytes) - '
	print psutil.avail_phymem()
	print 'Used physical memory (in bytes) - '
	print psutil.used_phymem()
	print 'Total virtual memory (in bytes) - '
	print psutil.total_virtmem()
	print 'Available virtual memory (in bytes) - '
	print psutil.avail_virtmem()
	print 'Used virtual memory (in bytes) - '
	print psutil.used_virtmem()
	print 'Total cached memory (in bytes) - '
	print psutil.cached_phymem()
def main():
    usedRAM = psutil.TOTAL_PHYMEM - psutil.avail_phymem()
    myRAM = usedRAM * 100 / psutil.TOTAL_PHYMEM
    myCPU = psutil.cpu_percent(interval = 2)

    print("CPU:", getStatusBar(myCPU))
    print("RAM:", getStatusBar(myRAM))
Example #6
0
def _computeMaximumBufferSize(nodes):
    """number of nodes.

    This actually depends on the system mcvine is running on.

    If we are running on one machine that has shared memory, we need
    to set here nodes to the number of mpi instances.

    If we are running on a cluster of nodes without shared memory,
    we should not need to divide the maximum buffer size by nodes.
    """
    import psutil
    memsize = min(psutil.TOTAL_PHYMEM / 2,
                  (psutil.avail_phymem() + psutil.avail_virtmem()) * 0.7)
    memsize = int(memsize)
    from mcni.neutron_storage.idfneutron import ndblsperneutron

    bytesperdble = 8
    minsize = MINIMUM_BUFFER_SIZE

    n = int(memsize/nodes/ndblsperneutron/bytesperdble/minsize) \
        *MINIMUM_BUFFER_SIZE

    if n < minsize:
        raise RuntimeError, "Not enough memory"

    return n
Example #7
0
  def update_memory(self, name, config):
    
    self.g[name] = ["memory_used","memory_available"]

    if("virtual_memory" in dir(psutil)): # new style function call
      data = psutil.virtual_memory() 
      self.d["memory_used"] = data.used
      self.d["memory_available"] = data.available
    else:
      self.d["memory_used"] = psutil.used_phymem()
      self.d["memory_available"] = psutil.avail_phymem()
        
    self.c[name] =[
      "graph_title Memory",
      "graph_order memory_used memory_available",
      "graph_category system",
      "graph_period second",
      "memory_used.label in use",
      "memory_used.min 0",
      "memory_used.type GAUGE",      
      "memory_used.draw AREA",      
      "memory_available.label available",
      "memory_available.type GAUGE",
      "memory_available.draw STACK",
      "."]
Example #8
0
def _computeMaximumBufferSize(nodes):
    """number of nodes.

    This actually depends on the system mcvine is running on.

    If we are running on one machine that has shared memory, we need
    to set here nodes to the number of mpi instances.

    If we are running on a cluster of nodes without shared memory,
    we should not need to divide the maximum buffer size by nodes.
    """
    import psutil
    memsize = min(psutil.TOTAL_PHYMEM/2, (psutil.avail_phymem() + psutil.avail_virtmem())*0.7)
    memsize = int(memsize)
    from mcni.neutron_storage.idfneutron import ndblsperneutron

    bytesperdble = 8
    minsize = MINIMUM_BUFFER_SIZE

    n = int(memsize/nodes/ndblsperneutron/bytesperdble/minsize) \
        *MINIMUM_BUFFER_SIZE

    if n<minsize:
        raise RuntimeError, "Not enough memory"

    return n
Example #9
0
def getPhyMem():
    """取本机的物理内存,可用物理内存,剩余可用物理内存,单位K
    """
    phymem = int(psutil.TOTAL_PHYMEM)/1024
    availphymem = int(psutil.avail_phymem())/1024
    usedphymem = int(psutil.used_phymem())/1024
    return phymem,availphymem,usedphymem
    def cpustat(self):
        tags="node:%s %s"%(self.nodename,self.tags)

        val=int(psutil.cpu_percent())
        measurement="cpu_perc"
        key="%s.%s"%(self.nodename,measurement)
        self.measure(key,measurement,tags,val,aggrkey=measurement)

        val=int(psutil.avail_phymem()/1024/1024)
        measurement="mem_free_mb"
        key="%s.%s"%(self.nodename,measurement)
        self.measure(key,measurement,tags,val,aggrkey=measurement)

        val=int(psutil.virtmem_usage()[3])
        measurement="mem_virt_perc"
        key="%s.%s"%(self.nodename,measurement)
        self.measure(key,measurement,tags,val,aggrkey=measurement)

        val=int(psutil.phymem_usage()[2])
        measurement="mem_phy_perc"
        key="%s.%s"%(self.nodename,measurement)
        self.measure(key,measurement,tags,val,aggrkey=measurement)

        res=psutil.cpu_times_percent()
        names=["cputimeperc_user","cputimeperc_nice","cputimeperc_system","cputimeperc_idle","cputimeperc_iowait","cputimeperc_irq","cputimeperc_softirq","steal","guest","guest_nice"]
        for i in range(len(names)):
            if names[i].startswith("cputime"):
                val=int(res[i])
                measurement=names[i]
                key="%s.%s"%(self.nodename,measurement)
                self.measure(key,measurement,tags,val,aggrkey=measurement)
def doit():
    cpu_pc = psutil.cpu_percent()
    mem_avail_mb = psutil.avail_phymem() / 1000000
    cpu_temp = round(
        int(open('/sys/class/thermal/thermal_zone0/temp').read()) / 1e3, 1)
    params = urllib.urlencode({
        'field1': cpu_pc,
        'field2': mem_avail_mb,
        'field3': cpu_temp,
        'key': '5KZO92TTCY5OEB8K'
    })
    headers = {
        "Content-type": "application/x-www-form-urlencoded",
        "Accept": "text/plain"
    }
    conn = httplib.HTTPConnection("api.thingspeak.com:80")

    try:
        conn.request("POST", "/update", params, headers)
        response = conn.getresponse()
        print cpu_pc
        print mem_avail_mb
        print cpu_temp
        print strftime("%a, %d %b %Y %H:%M:%S", localtime())
        print response.status, response.reason
        data = response.read()
        conn.close()
    except:
        print "connection failed"
def getMemoryInfo():
    """ return a tuple(total_phymen,avi_phymen.used_phymen) KB .get System Memory Inforation"""
    if psutilUsed==False: return None
    totalPhymen=psutil.TOTAL_PHYMEM
    aviPhymen=psutil.avail_phymem()
    usedPhymen=psutil.used_phymem()
    return (totalPhymen/1024,aviPhymen/1024,usedPhymen/1024)
Example #13
0
 def getStat(self):
     return {'memTotal': psutil.TOTAL_PHYMEM,
             'memFree': psutil.avail_phymem(),
             'swapTotal': psutil.total_virtmem(),
             'swapFree': psutil.avail_virtmem(),
             'buffers': psutil.phymem_buffers(),
             'cached': psutil.cached_phymem()}
def doit():
    cpu_pc = psutil.cpu_percent()
    mem_avail_mb = psutil.avail_phymem() / 1000000
    params = urllib.urlencode({
        'field1': cpu_pc,
        'field2': mem_avail_mb,
        'key': 'NJQGS40ZVNGNK36S'
    })
    headers = {
        "Content-type": "application/x-www-form-urlencoded",
        "Accept": "text/plain"
    }
    conn = httplib.HTTPConnection("api.thingspeak.com:80")

    try:
        conn.request("POST", "/update", params, headers)
        response = conn.getresponse()
        print cpu_pc
        print mem_avail_mb
        print strftime("%a, %d %b %Y %H:%M:%S", localtime())
        print response.status, response.reason
        data = response.read()
        conn.close()
    except:
        print "connection failed"
Example #15
0
def getPhyMem():
    """取本机的物理内存,可用物理内存,剩余可用物理内存,单位K
    """
    phymem = int(psutil.TOTAL_PHYMEM) / 1024
    availphymem = int(psutil.avail_phymem()) / 1024
    usedphymem = int(psutil.used_phymem()) / 1024
    return phymem, availphymem, usedphymem
def getData():
    temp =  round(int(open('/sys/class/thermal/thermal_zone0/temp').read()) / 1e3,1)
    perc = psutil.cpu_percent()
    memAvail = round(psutil.avail_phymem()/1000000,1)
    diskUsage =  psutil.disk_usage('/').percent
    j = {'cpu_temp': temp, 'cpu_perc': perc, 'mem_avail': memAvail, 'disk_usage': diskUsage}
    return json.dumps(j,indent=4, separators=(',', ': '))
Example #17
0
def memInfo():
    logging.debug("Mem info")

    logging.debug(psutil.virtual_memory())
    logging.debug(psutil.swap_memory())
    logging.debug(psutil.phymem_usage())
    logging.debug(psutil.avail_virtmem())
    logging.debug(psutil.avail_phymem())
Example #18
0
def main(expr):
    vars = {'free': psutil.avail_virtmem(),
            'available': psutil.avail_virtmem(),
            'pfree': psutil.avail_phymem(),
            'buffers': psutil.phymem_buffers(),
            'total': psutil.total_virtmem(),
            'cached': psutil.cached_phymem(),
    }
    return eval(expr, {}, vars)
Example #19
0
    def generate(self, **kwargs):
        result = {'mem_phys_total': psutil.TOTAL_PHYMEM,
                  'mem_phys_avail': psutil.avail_phymem(),
                  'mem_phys_used': psutil.used_phymem(),
                  'mem_virt_total': psutil.total_virtmem(),
                  'mem_virt_avail': psutil.used_virtmem(),
                  'cpu_cores': self._get_total_core(),
                }

        return result
 def generate(self, **kwargs):
     result = {
         'mem_phys_total': psutil.TOTAL_PHYMEM,
         'mem_phys_avail': psutil.avail_phymem(),
         'mem_phys_used': psutil.used_phymem(),
         'mem_virt_total': psutil.total_virtmem(),
         'mem_virt_avail': psutil.avail_virtmem(),
         'mem_virt_used': psutil.used_virtmem(),
         'cpu_cores': self._get_total_cores(),
     }
     return result
Example #21
0
    def memorypercent(self):

        import psutil
        from distutils.version import StrictVersion

        if StrictVersion(psutil.__version__) < '0.4':  # deprecated
            total_mem = psutil.avail_phymem() + \
                psutil.cached_phymem() + psutil.phymem_buffers()
            return psutil.used_phymem() * 100 / total_mem
        else:
            return int(psutil.phymem_usage().percent)
Example #22
0
def info():
    ps = get_ps()
    print "PID,\tPPID,\tCPU,\tRSS - \tVMS"
    total = 0
    for p in ps:
        rss, vms = p.get_memory_info()
        total += rss 
        print "%s\t%s\t%0.2f%%\t%s - \t%s" % (p.pid, p.ppid, p.get_cpu_percent(), mb(rss), mb(vms)) 
    print 'total watched RSS: %d' % mb(total)
    used, all, avail = mb(psutil.used_phymem()), mb(psutil.TOTAL_PHYMEM), mb(psutil.avail_phymem())
    print 'Used memory %dMB out of %dMB' %  (used, all)
    print 'Available memory %dMB' % avail
Example #23
0
 def xOnTimer(self, event):
 #   ------------------------------------------------------------------------
     if self.posTick:
         self.SetStatusText(
             datetime.now().strftime("%H:%M:%S"), self.posTick)
     if self.posCpu and 0 == self.counter % 1:
         self.SetStatusText(
             "CPU: %s%%" % psutil.cpu_percent(0), self.posCpu)
     if self.posMem and 0 == self.counter % 1:
         self.SetStatusText(
             "Free: %.1fMB" % (psutil.avail_phymem()*1e-6,), self.posMem)
     self.counter += 1
	def foo(self):
		perc = psutil.cpu_percent(interval = None, percpu = False)
		mem = psutil.avail_phymem()
		self.gaz_arr, self.gaz = self.usred(self.gaz_arr, perc)
		d = 4;	aa = int(round(self.gaz, 0)) / d;	aa *= d
		self.gaz = aa
		self.tacho_arr, self.tacho = self.usred(self.tacho_arr, self.gaz)
		
		self.tacho_angle = (MAX_ANGLE / 100.0) * self.tacho
		self.gaz_angle = (MAX_ANGLE / 100.0) * self.gaz
		self.mem_angle = MAX_ANGLE * (1.0 * mem / self.MEM)
		self.update()
		pass
Example #25
0
def doit():
    cpu_pc = psutil.cpu_percent()
    mem_avail_mb = psutil.avail_phymem()/1000000
    print cpu_pc
    print mem_avail_mb
    params = urllib.urlencode({'field1': cpu_pc, 'field2': mem_avail_mb,'key':'662EQ8O35OEBQ547'})
    headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
    conn = httplib.HTTPConnection("api.thingspeak.com:80")
    conn.request("POST", "/update", params, headers)
    response = conn.getresponse()
    print response.status, response.reason
    data = response.read()
    conn.close()
Example #26
0
def doit(channel):
    cpu_pc = psutil.cpu_percent()
    mem_avail_mb = psutil.avail_phymem()/1000000

    try:
        response = channel.update([cpu_pc, mem_avail_mb])
        print cpu_pc
        print mem_avail_mb
        print strftime("%a, %d %b %Y %H:%M:%S", localtime())
        print response.status, response.reason
        data = response.read()
    except:
        print "connection failed"
Example #27
0
def doit(channel):
    cpu_pc = psutil.cpu_percent()
    mem_avail_mb = psutil.avail_phymem() / 1000000

    try:
        response = channel.update([cpu_pc, mem_avail_mb])
        print cpu_pc
        print mem_avail_mb
        print strftime("%a, %d %b %Y %H:%M:%S", localtime())
        print response.status, response.reason
        data = response.read()
    except:
        print "connection failed"
Example #28
0
 def processReportSystemResourcesRequest(self, packet):
     def getDiskFree():
         import ctypes, platform, os   
         
         if platform.system() == 'Windows':
             free_bytes = ctypes.c_ulonglong(0)
             ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p('C:\\'), None, None, ctypes.pointer(free_bytes))
             return free_bytes.value
         else:
             return os.statvfs('/').f_bfree
         
     response = ReportSystemResourcesResponse()
     
     import platform
     
     if packet.reportNode:
         response.clientVersion = CLIENT_VERSION
         response.system, response.node, response.release, response.version, response.machine, response.processor = platform.uname()
         response.python_version = platform.python_version()
         
         
     if packet.reportResources:
         import psutil
           
         response.memoryFree = psutil.avail_phymem()
         response.totalMemory = psutil.TOTAL_PHYMEM
         response.cpuUsage = psutil.cpu_percent()
         response.diskFree = getDiskFree()
         
         from time import time
         
         response.actualTime = int(time());
                 
     
     if packet.reportProcessList:
         import psutil
         
         for process in psutil.process_iter():
             proc = response.processList.add()
             
             proc.pid = process.pid
             proc.name = process.name
             try:
                 proc.exe = process.exe
             except:
                 pass
             proc.userName = process.username
             #proc.cpuPercent = process.cpu_percent()
             proc.memoryPercent = process.get_memory_percent()
             
     self.sendResponse(response)
Example #29
0
 def __init__(self):
     self.memfree = int(psutil.avail_phymem()) / (1024 * 1024)
     self.memused = int(psutil.used_phymem()) / (1024 * 1024)
     self.memcached = int(psutil.cached_phymem()) / (1024 * 1024)
     self.memtotal = self.memfree + self.memused
     self.memload = psutil.phymem_usage()[3]
     self.load = os.getloadavg()
     self.uptime = ProcParser().getuptime()
     self.coresload = psutil.cpu_percent(0.7, True)
     self.time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
     statvfs = os.statvfs('/')
     self.hddtotal = statvfs.f_frsize * statvfs.f_blocks / 1024 / 1024  # Size of filesystem in bytes
     self.hddfree = statvfs.f_frsize * statvfs.f_bfree / 1024 / 1024  # Actual number of free bytes
     self.hddused = self.hddtotal - self.hddfree
Example #30
0
 def on_global(self, msg=None):
     global_cpu = psutil.get_system_cpu_times()
     global_cpu['percent'] = psutil.cpu_percent()
     global_mem = {
         'used_physical': psutil.used_phymem(),
         'used_virtual': psutil.used_virtmem(),
         'available_physical': psutil.avail_phymem(),
         'available_virtual': psutil.avail_virtmem(),
     }
     result = {
         'hostnome': socket.gethostname(),
         'cpu': global_cpu,
         'mem': global_mem,
     }
     return {'global': result}
Example #31
0
    def foo(self):
        perc = psutil.cpu_percent(interval=None, percpu=False)
        mem = psutil.avail_phymem()
        self.gaz_arr, self.gaz = self.usred(self.gaz_arr, perc)
        d = 4
        aa = int(round(self.gaz, 0)) / d
        aa *= d
        self.gaz = aa
        self.tacho_arr, self.tacho = self.usred(self.tacho_arr, self.gaz)

        self.tacho_angle = (MAX_ANGLE / 100.0) * self.tacho
        self.gaz_angle = (MAX_ANGLE / 100.0) * self.gaz
        self.mem_angle = MAX_ANGLE * (1.0 * mem / self.MEM)
        self.update()
        pass
Example #32
0
 def getSystemStats(self):
     physMem = psutil.TOTAL_PHYMEM
     phyMemAvailable = psutil.avail_phymem()
     try:
         cpuPercent = psutil.cpu_percent(interval=1)
     except:
         cpuPercent = psutil.cpu_percent()
     server_is_running = self.minecraft.isRunning()
     data = {
         'total_physical_memory':physMem,
         'available_physical_memory':phyMemAvailable,
         'cpu_usage':cpuPercent,
         'server_is_running':server_is_running
     }
     #cherrypy.response.headers['Content-Type']= 'application/json'
     return json.dumps(data);
Example #33
0
 def convert_to_texture(self, imInfo):
     # Convert image to OpenGL texture
     glGenTextures(1, imInfo['i'])
     glBindTexture(GL_TEXTURE_2D, imInfo['i'])  # 2d texture (x and y size)
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
     glTexImage2D(GL_TEXTURE_2D, 0, 3, imInfo['size'][0], imInfo['size'][1],
                  0, GL_RGBA, GL_UNSIGNED_BYTE, imInfo['img'])
     print str(imInfo['i']) + ': ' + os.path.basename(
         imInfo['filepath']) + ' loaded: ' + self.convert_bytes(
             psutil.avail_phymem()) + ' free'
Example #34
0
def _main():
    global available_memory
    'Command line entry point.'
    allow_destructive = False
    try:
        if os.environ['DESTRUCTIVE_MODE']:
            allow_destructive = True
    except Exception:
        True

    hrdw = eval(open(sys.argv[1]).read(-1))

    try:
        available_memory = psutil.virtual_memory().total
    except Exception:
        available_memory = psutil.avail_phymem()

    sys.stderr.write("Available memory before run = %s\n" % available_memory)

    mode = 'cpu,memory,storage'
    try:
        mode = sys.argv[2]
    except Exception:
        True

    if 'cpu-burn' in mode:
        cpu_perf(hrdw, 60, True)
    elif 'cpu' in mode:
        cpu_perf(hrdw)

    if 'memory-burn' in mode:
        mem_perf_burn(hrdw, 60)
    elif 'memory' in mode:
        mem_perf(hrdw)

    if 'storage-burn' in mode:
        storage_perf_burn(hrdw, allow_destructive, 30)
    elif 'storage' in mode:
        storage_perf(hrdw, allow_destructive)

    # Saving result to stdout but also to a filename based on the hw properties
    output_filename = get_output_filename(hrdw)
    sys.stderr.write("Saving results in %s\n" % output_filename)
    with open(output_filename, 'w') as state_file:
        pprint.pprint(hrdw, stream=state_file)
    pprint.pprint(hrdw)
Example #35
0
 def test_avail_phymem(self):
     # This test is not particularly accurate and may fail if the OS is
     # consuming memory for other applications.
     # We just want to test that the difference between psutil result
     # and sysctl's is not too high.
     _sum = sum((sysctl("sysctl vm.stats.vm.v_inactive_count"),
                 sysctl("sysctl vm.stats.vm.v_cache_count"),
                 sysctl("sysctl vm.stats.vm.v_free_count")))
     _pagesize = sysctl("sysctl hw.pagesize")
     sysctl_avail_phymem = _sum * _pagesize
     psutil_avail_phymem = psutil.avail_phymem()
     difference = abs(psutil_avail_phymem - sysctl_avail_phymem)
     # On my system both sysctl and psutil report the same values.
     # Let's use a tollerance of 0.5 MB and consider the test as failed
     # if we go over it.
     if difference > (0.5 * 2**20):
         self.fail("sysctl=%s; psutil=%s; difference=%s;" %
                   (sysctl_avail_phymem, psutil_avail_phymem, difference))
def doit():
	cpu_pc = psutil.cpu_percent()
	mem_avail_mb = psutil.avail_phymem()/1000000	
	params = urllib.urlencode({'field1': cpu_pc, 'field2': mem_avail_mb,'key':'NJQGS40ZVNGNK36S'})
	headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
	conn = httplib.HTTPConnection("api.thingspeak.com:80")

	try:
		conn.request("POST", "/update", params, headers)
		response = conn.getresponse()
		print cpu_pc
		print mem_avail_mb
		print strftime("%a, %d %b %Y %H:%M:%S", localtime())
		print response.status, response.reason
		data = response.read()
		conn.close()
	except:
		print "connection failed"	
Example #37
0
    def usedmemory(self):

        import psutil
        from distutils.version import StrictVersion

        # print sizes in human readable (MB)
        MB = 1024 * 1024

        if StrictVersion(psutil.__version__) < '0.4':  # deprecated
            total_mem = psutil.avail_phymem() + \
                psutil.cached_phymem() + psutil.phymem_buffers()
            return "%d of %d" % (psutil.used_phymem() / MB, total_mem / MB)
        else:
            # I don't care about cached memory..
            return "%d of %d" % \
                ((psutil.phymem_usage().used -
                  psutil.cached_phymem() -
                  psutil.phymem_buffers()) / MB,
                 psutil.phymem_usage().total / MB)
Example #38
0
 def test_avail_phymem(self):
     # This test is not particularly accurate and may fail if the OS is
     # consuming memory for other applications.
     # We just want to test that the difference between psutil result
     # and sysctl's is not too high.
     _sum = sum((sysctl("sysctl vm.stats.vm.v_inactive_count"),
                 sysctl("sysctl vm.stats.vm.v_cache_count"),
                 sysctl("sysctl vm.stats.vm.v_free_count")
                ))
     _pagesize = sysctl("sysctl hw.pagesize")
     sysctl_avail_phymem = _sum * _pagesize
     psutil_avail_phymem =  psutil.avail_phymem()
     difference = abs(psutil_avail_phymem - sysctl_avail_phymem)
     # On my system both sysctl and psutil report the same values.
     # Let's use a tollerance of 0.5 MB and consider the test as failed
     # if we go over it.
     if difference > (0.5 * 2**20):
         self.fail("sysctl=%s; psutil=%s; difference=%s;" %(
                   sysctl_avail_phymem, psutil_avail_phymem, difference))
Example #39
0
 def collect(self):
     return dict(
         cpu_times=psutil.cpu_times()._asdict(),
         mem=dict(
             total_phymem=psutil.TOTAL_PHYMEM,
             avail_phymem=psutil.avail_phymem(),
             avail_virtmem=psutil.avail_virtmem(),
             cached_phymem=psutil.cached_phymem(),
             phymem_buffers=psutil.phymem_buffers(),
             total_virtmem=psutil.total_virtmem(),
             used_phymem=psutil.used_phymem(),
             used_virtmem=psutil.used_virtmem(),
         ),
         processes=list(self._processes()),
         net=dict(ifaces=self._net_dev(), proto=self._net_proto()),
         io=self._io_stats(),
         fs=dict(self._fs_usage()),
         fh=self._file_handles(),
     )
Example #40
0
    def refresh(self):
        logging.debug("Host.refresh(): Refreshing all host entries")
        self.refreshVirtServiceSpecs()
        self.__machine_type=platform.machine()
        self.__network_name=platform.node()
        self.__processor=platform.processor()
        self.__python_version=platform.python_version()
        self.__linuxKernel_version=platform.release()
        #self.__name=platform.system()
        dist_info=platform.linux_distribution(distname='', version='', id='', supported_dists=('SuSE', 'debian', 'redhat'), full_distribution_name=1)
        self.__distroName=dist_info[0]
        self.__distroVersion=dist_info[1]
        self.__distroCode=dist_info[2]
        self.__vm_manager_pid=os.getpid()
        self.__freePhyMem=psutil.avail_phymem()/1048576
        self.__freeVirtMem=psutil.avail_virtmem()/1048576
        self.__totalVirtMem=psutil.total_virtmem()/1048576
        self.__usedPhyMem=psutil.used_phymem()/1048576
        self.__manager_process=psutil.Process(self.__vm_manager_pid)
        self.__virt_process=psutil.Process(int(self.__virtProcessPid))
        self.__processUptime=datetime.datetime.fromtimestamp(self.__manager_process.create_time).strftime("%Y-%m-%d %H:%M")
        #self.__processOwner=self.__manager_process.username
        #self.__numOfProcessThreads=self.__manager_process.get_num_threads()
        #self.__numOfVirtProcessThreads=self.__virt_process.get_num_threads()
    
        #for thread in self.__virt_process.get_threads():
        #    self.__virtProcessThreadIDs.append(thread[0])
            
        #for thread in self.__manager_process.get_threads():
        #    self.__processThreadIDs.append(thread[0])

        self.__virtProcessCpuUsage=self.__virt_process.get_cpu_percent()
        self.__proccessCpuUsage=self.__manager_process.get_cpu_percent()
        mem=self.__virt_process.get_memory_info()
        self.__virtProcessMemUsage=mem[1]/1048576
        mem=self.__manager_process.get_memory_info()
        self.__processMemUsage=mem[1]/1048576
        #self.__processOpenedFilesSpecs=self.__manager_process.get_open_files()
        #self.__virtProcessOpenedFilesSpecs=self.__virt_process.get_open_files()
        #self.__processConnectionsSpecs=self.__manager_process.get_connections()
        #self.__virtProcessConnectionsSpecs=self.__virt_process.get_connections()
        self.__cpuUsage=psutil.cpu_percent()
    def test2(self):
        "Instrument: _getBufferSize"
        instrument = Instrument('t')

        # for lower values of ncount, buffer_size=ncount/mpisize/DEFAULT_NUMBER_SIM_LOOPS
        instrument.inventory.ncount = ncount = 1e3
        self.assertEqual(instrument._getBufferSize(),
                         ncount / DEFAULT_NUMBER_SIM_LOOPS)

        instrument.inventory.ncount = ncount = 2e3
        self.assertEqual(instrument._getBufferSize(),
                         ncount / DEFAULT_NUMBER_SIM_LOOPS)

        instrument.mpiSize = mpiSize = 10
        self.assertEqual(instrument._getBufferSize(),
                         int(ncount / mpiSize / DEFAULT_NUMBER_SIM_LOOPS))

        # for higher values, buffer_size is set by memory limit
        import psutil
        temp = min(psutil.TOTAL_PHYMEM / 2,
                   (psutil.avail_phymem() + psutil.avail_virtmem()) * 0.7)
        temp = int(temp)
        from mcni.neutron_storage.idfneutron import ndblsperneutron
        max = int(temp / ndblsperneutron / 8 / 100 / mpiSize) * 100

        instrument.inventory.ncount = ncount = 1e9
        self.assertEqual(instrument._getBufferSize(), max)

        instrument.inventory.ncount = ncount = 2e9
        self.assertEqual(instrument._getBufferSize(), max)

        # if user set a too high number for buffer size, it is ignored
        instrument.inventory.ncount = ncount = 2e9
        instrument.inventory.buffer_size = 2e9
        self.assertEqual(instrument._getBufferSize(), max)

        # if user set a too low value for buffer_size, a warning would be issued
        instrument.inventory.ncount = 1e8
        instrument.inventory.buffer_size = 100
        instrument._getBufferSize()

        return
Example #42
0
def _main():
    global available_memory
    'Command line entry point.'
    allow_destructive = False
    try:
        if os.environ['DESTRUCTIVE_MODE']:
            allow_destructive = True
    except:
        True

    hrdw = eval(open(sys.argv[1]).read(-1))

    available_memory = psutil.avail_phymem()
    sys.stderr.write("Available memory before run = %s\n" % available_memory)

    mode = 'cpu,memory,storage'
    try:
        mode = sys.argv[2]
    except:
        True

    if 'cpu-burn' in mode:
        cpu_perf(hrdw, 60, True)
    elif 'cpu' in mode:
        cpu_perf(hrdw)

    if 'memory-burn' in mode:
        mem_perf_burn(hrdw, 60)
    elif 'memory' in mode:
        mem_perf(hrdw)

    if 'storage-burn' in mode:
        storage_perf_burn(hrdw, allow_destructive, 30)
    elif 'storage' in mode:
        storage_perf(hrdw, allow_destructive)

    # Saving result to stdout but also to a filename based on the hw properties
    output_filename = get_output_filename(hrdw)
    sys.stderr.write("Saving results in %s\n" % output_filename)
    with open(output_filename, 'w') as state_file:
        pprint.pprint(hrdw, stream=state_file)
    pprint.pprint(hrdw)
Example #43
0
    def report_mem(prev_values=None,msg=None):
        """ Show status of phy/virt mem, and if given previous values, 
        report differences
        requires the psutil module - avail in apt-get, but I used pip
        """
        if msg is None: msg=''
        else: msg += ': '
        pm = psutil.avail_phymem()
        vm = psutil.avail_virtmem()
        tim = seconds()
        print('{msg}{pm:.2g} GB phys mem, {vm:.2g} GB virt mem avail'
              .format(msg=msg, pm=pm/1e9, vm=vm/1e9)),

        if prev_values is None:
            print
        else:
            print('- dt={dt:.2g}s, used {pm:.2g} GB phys, {vm:.2g} GB virt'
                  .format(pm=(prev_values[0] - pm)/1e9,
                          vm=(prev_values[1] - vm)/1e9, dt = tim-prev_values[2]))
        return((pm,vm,tim))
def doit():
	cpu_pc = psutil.cpu_percent()
	mem_avail_mb = psutil.avail_phymem()/1000000
	cpu_temp = round(int(open('/sys/class/thermal/thermal_zone0/temp').read()) / 1e3,1)
	params = urllib.urlencode({'field1': cpu_pc, 'field2': mem_avail_mb, 'field3': cpu_temp,'key':'YOUR_KEY_HERE'})
	headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
	conn = httplib.HTTPConnection("api.thingspeak.com:80")
	
	try:
		conn.request("POST", "/update", params, headers)
		response = conn.getresponse()
		print cpu_pc
		print mem_avail_mb
		print cpu_temp
		print strftime("%a, %d %b %Y %H:%M:%S", localtime())
		print response.status, response.reason
		data = response.read()
		conn.close()
	except:
		print "connection failed"	
Example #45
0
def get_maxmem():
    mem = psutil.avail_phymem()
    sl = []
    i = 0
    fill_size = 1024
    if sys.version.startswith('2.7'):
        fill_size = 1003
    if sys.version.startswith('3'):
        fill_size = 497

    fill_size *= 1024
    MiB = 0
    while True:
        max_mem = mem/1024/1024*0.8
        if MiB > max_mem: break
        s = str(i).zfill(fill_size)
        sl.append(s)
        i += 1
        # MiB += 1024
        MiB += 1
    return MiB*1024*1024
Example #46
0
    def report_mem(prev_values=None, msg=None):
        """ Show status of phy/virt mem, and if given previous values, 
        report differences
        requires the psutil module - avail in apt-get, but I used pip
        """
        if msg is None: msg = ''
        else: msg += ': '
        pm = psutil.avail_phymem()
        vm = psutil.avail_virtmem()
        tim = seconds()
        print('{msg}{pm:.2g} GB phys mem, {vm:.2g} GB virt mem avail'.format(
            msg=msg, pm=pm / 1e9, vm=vm / 1e9)),

        if prev_values is None:
            print
        else:
            print('- dt={dt:.2g}s, used {pm:.2g} GB phys, {vm:.2g} GB virt'.
                  format(pm=(prev_values[0] - pm) / 1e9,
                         vm=(prev_values[1] - vm) / 1e9,
                         dt=tim - prev_values[2]))
        return ((pm, vm, tim))
Example #47
0
 def collect(self):
     return dict(
         cpu_times=psutil.cpu_times()._asdict(),
         mem=dict(
             total_phymem=psutil.TOTAL_PHYMEM,
             avail_phymem=psutil.avail_phymem(),
             avail_virtmem=psutil.avail_virtmem(),
             cached_phymem=psutil.cached_phymem(),
             phymem_buffers=psutil.phymem_buffers(),
             total_virtmem=psutil.total_virtmem(),
             used_phymem=psutil.used_phymem(),
             used_virtmem=psutil.used_virtmem(),
         ),
         processes=list(self._processes()),
         net=dict(
             ifaces=self._net_dev(),
             proto=self._net_proto()
         ),
         io=self._io_stats(),
         fs=dict(self._fs_usage()),
         fh=self._file_handles(),
     )
Example #48
0
def doit():
    cpu_pc = list(psutil.process_iter())
    mem_avail_mb = psutil.avail_phymem() / 1000000
    params = urllib.urlencode({
        'field1': cpu_pc,
        'field2': mem_avail_mb,
        'key': 'YOURKEYHERE'
    })
    headers = {
        "Content-type": "application/x-www-form-urlencoded",
        "Accept": "text/plain"
    }
    conn = httplib.HTTPConnection("api.thingspeak.com:80")

    try:
        conn.request("POST", "/update", params, headers)
        response = conn.getresponse()

        data = response.read()
        conn.close()
    except:
        print("connection failed")
Example #49
0
def get_available_memory():
    try:
        return psutil.virtual_memory().total
    except Exception:
        return psutil.avail_phymem()
Example #50
0
import psutil, requests, time, json, subprocess
SERVER_ADDRESS = "http://11.0.0.100:9009/upload"
TYPE = "rpi"
ID = 60

while True:
    try:
        packet_loss = 100
        avg_ping = 0
        cpu_usage = psutil.cpu_percent()
        mem_free = psutil.avail_phymem() / 1000000
        disk_free = psutil.disk_usage('/')[3]
        proc = subprocess.Popen("ping -i 2 -c 5 -q google.com",
                                shell=True,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE)
        return_code = proc.wait()
        stdout_lines = list(proc.stdout)
        if "error" in stdout_lines:
            pass
        else:
            for line in stdout_lines:
                if "received" in line and "transmitted" in line:
                    split_comma = line.split(",")
                    packet_loss = int(split_comma[2].split("%")[0])

                if "rtt min/avg/max/mdev" in line:
                    avg_ping = int(float(line.split("=")[1].split("/")[1]))
        client_time = int(time.time())
    except Exception, e:
        print e
Example #51
0
def mem_available():
    mem = psutil.avail_phymem()
    return mem * 1024.** -2
Example #52
0
def sort(filename, key, outputFile, fields=None, watermark=1024 * 1024 * 100):
  """Sort a potentially big file

  filename - the input file (standard File format)
  key - a list of field names to sort by
  outputFile - the name of the output file
  fields - a list of fields that should be included (all fields if None)
  watermark - when available memory goes bellow the watermark create a new chunk

  sort() works by reading as records from the file into memory
  and calling _sortChunk() on each chunk. In the process it gets
  rid of unneeded fields if any. Once all the chunks have been sorted and
  written to chunk files it calls _merge() to merge all the chunks into a
  single sorted file.

  Note, that sort() gets a key that contains field names, which it converts
  into field indices for _sortChunk() becuase _sortChunk() doesn't need to know
  the field name.

  sort() figures out by itself how many chunk files to use by reading records
  from the file until the low watermark value of availabel memory is hit and
  then it sorts the current records, generates a chunk file, clears the sorted
  records and starts on a new chunk.

  The key field names are turned into indices
  """
  if fields is not None:
    assert set(key).issubset(set([f[0] for f in fields]))

  with FileRecordStream(filename) as f:


    # Find the indices of the requested fields
    if fields:
      fieldNames = [ff[0] for ff in fields]
      indices = [f.getFieldNames().index(name) for name in fieldNames]
      assert len(indices) == len(fields)
    else:
      fileds = f.getFields()
      fieldNames = f.getFieldNames()
      indices = None

    # turn key fields to key indices
    key = [fieldNames.index(name) for name in key]

    chunk = 0
    records = []
    for i, r in enumerate(f):
      # Select requested fields only
      if indices:
        temp = []
        for i in indices:
          temp.append(r[i])
        r = temp
      # Store processed record
      records.append(r)

      # Check memory
      available_memory = psutil.avail_phymem()

      # If bellow the watermark create a new chunk, reset and keep going
      if available_memory < watermark:
        _sortChunk(records, key, chunk, fields)
        records = []
        chunk += 1

    # Sort and write the remainder
    if len(records) > 0:
      _sortChunk(records, key, chunk, fields)
      chunk += 1

    # Marge all the files
    _mergeFiles(key, chunk, outputFile, fields)
Example #53
0
def test(long):
  import shutil
  from tempfile import gettempdir

  print 'Running sorter self-test...'

  # Switch to a temp dir in order to create files freely
  workDir = os.path.join(gettempdir(), 'sorter_test')
  if os.path.exists(workDir):
    shutil.rmtree(workDir)
  os.makedirs(workDir)
  os.chdir(workDir)
  print 'cwd:', os.getcwd()

  # The fields definition used by all tests
  fields = [
   ('f1', 'int', ''),
   ('f2', 'int', ''),
   ('f3', 'int', ''),
   ('payload', 'string', '')
  ]

  # Create a test file
  testFile = '1.csv'
  if not os.path.isfile(testFile):
    writeTestFile(testFile, fields, big=long)

  # Set watermark here to 300MB bellow current available memory. That ensures
  # multiple chunk files in the big testcase

  mem = psutil.avail_phymem()
  watermark = mem - 300 * 1024 * 1024

  print 'Test sorting by f1 and f2, watermak:', watermark
  results = []
  sort(testFile,
       key=['f1', 'f2'],
       fields=fields,
       outputFile='f1_f2.csv',
       watermark=watermark)
  with FileRecordStream('f1_f2.csv') as f:
    for r in f:
      results.append(r[:3])

  assert results == [
    [1, 3, 6],
    [1, 3, 5],
    [1, 4, 6],
    [1, 4, 5],
    [2, 3, 6],
    [2, 3, 5],
    [2, 4, 6],
    [2, 4, 5],
  ]

  mem = psutil.avail_phymem()
  watermark = mem - 300 * 1024 * 1024
  print 'Test sorting by f2 and f1, watermark:', watermark
  results = []
  sort(testFile,
       key=['f2', 'f1'],
       fields=fields,
       outputFile='f2_f1.csv',
       watermark=watermark)
  with FileRecordStream('f2_f1.csv') as f:
    for r in f:
      results.append(r[:3])
  assert results == [
    [1, 3, 6],
    [1, 3, 5],
    [2, 3, 6],
    [2, 3, 5],
    [1, 4, 6],
    [1, 4, 5],
    [2, 4, 6],
    [2, 4, 5],
  ]

  mem = psutil.avail_phymem()
  watermark = mem - 300 * 1024 * 1024
  print 'Test sorting by f3 and f2, watermark:', watermark
  results = []
  sort(testFile,
       key=['f3', 'f2'],
       fields=fields,
       outputFile='f3_f2.csv',
       watermark=watermark)
  with FileRecordStream('f3_f2.csv') as f:
    for r in f:
      results.append(r[:3])

  assert results == [
    [1, 3, 5],
    [2, 3, 5],
    [1, 4, 5],
    [2, 4, 5],
    [1, 3, 6],
    [2, 3, 6],
    [1, 4, 6],
    [2, 4, 6],
  ]

  # Cleanup the work dir
  os.chdir('..')
  shutil.rmtree(workDir)

  print 'done'
Example #54
0
 def update(self):
     """ Record information about the cpu and memory usage for this host into a buffer """
     self.cpu_load_log.append(psutil.cpu_percent(interval=0, percpu=True))
     self.phymem_used_log.append(psutil.used_phymem())
     self.phymem_avail_log.append(psutil.avail_phymem())
 def test_avail_phymem(self):
     x = psutil.avail_phymem()
     self.assertTrue(isinstance(x, (int, long)))
     self.assertTrue(x > 0)
Example #56
0
    for i in range(0, 1):
        humidity = sense.get_humidity()
        #print("Humidity: %s %%H" % humidity)
        sense_pressure = sense.get_pressure()
        #print("Pressure: %s Millibars" % sense_pressure)
        convert_pressure = sense_pressure * 100
        #print("Pressure: %s Pascal" % convert_pressure)
        temp1 = sense.get_temperature_from_humidity()
        #print("Temperature1: %sC" % temp1)
        temp2 = sense.get_temperature_from_pressure()
        #print("Temperature2: %sC" % temp2)
        temp3 = (((temp1 + temp2) / 2) - 11)
        #print("Temperature3: %sC" % temp3)
        cpu_pc = psutil.cpu_percent()
        #print cpu_pc
        mem_avail_mb = psutil.avail_phymem() / 1000000
        #print mem_avail_mb
        cpu_temp = round(
            int(open('/sys/class/thermal/thermal_zone0/temp').read()) / 1e3, 1)
        #print cpu_temp

        if temp3 < 10:
            #print "cas 1"
            color = white
        elif temp3 >= 10 and temp3 < 16:
            #print "cas 2"
            color = blue
        elif temp3 >= 16 and temp3 < 29:
            #print "cas 3"
            color = green
        elif temp3 >= 29 and temp3 < 35:
# Author:Wl
# -*- coding=utf-8 -*-

import psutil
import datetime

# 查看cpu的信息
print u"CPU 个数 %s" % psutil.cpu_count()
print u"物理CPU个数 {}".format(psutil.cpu_count(logical=False))
print u"CPU uptimes"
print psutil.cpu_times()
print ""

# 查看内存信息
print u"系统总内存 %s M" % (psutil.TOTAL_PHYMEM / 1024 / 1024)
print u"系统可用内存 %s M" % (psutil.avail_phymem() / 1024 / 1024)
mem_rate = int(psutil.avail_phymem()) / float(psutil.TOTAL_PHYMEM)
print u"系统内存使用率 %s %%" % int(mem_rate * 100)

# 系统启动时间
print u"系统启动时间 %s" % datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")

# 系统用户
users_count = len(psutil.users())
users_list = ",".join([u.name for u in psutil.users()])
print u"当前有%s个用户,分别是%s" % (users_count, users_list)

# 网卡,可以得到网卡属性,连接数,当前流量等信息
net = psutil.net_io_counters()
bytes_sent = '{0:.2f} kb'.format(net.bytes_rPcv / 1024)
bytes_rcvd = '{0:.2f} kb'.format(net.bytes_sent / 1024)