Python psutil 模块，virtual_memory() 实例源码

def tell_system_status(self):
        import psutil
        import platform
        import datetime

        os, name, version, _, _, _ = platform.uname()
        version = version.split('-')[0]
        cores = psutil.cpu_count()
        cpu_percent = psutil.cpu_percent()
        memory_percent = psutil.virtual_memory()[2]
        disk_percent = psutil.disk_usage('/')[3]
        boot_time = datetime.datetime.fromtimestamp(psutil.boot_time())
        running_since = boot_time.strftime("%A %d. %B %Y")
        response = "I am currently running on %s version %s.  " % (os, version)
        response += "This system is named %s and has %s CPU cores.  " % (name, cores)
        response += "Current disk_percent is %s percent.  " % disk_percent
        response += "Current CPU utilization is %s percent.  " % cpu_percent
        response += "Current memory utilization is %s percent. " % memory_percent
        response += "it's running since %s." % running_since
        return response

def test_procfs_path(self):
        tdir = tempfile.mkdtemp()
        try:
            psutil.PROCFS_PATH = tdir
            self.assertRaises(IOError, psutil.virtual_memory)
            self.assertRaises(IOError, psutil.cpu_times)
            self.assertRaises(IOError, psutil.cpu_times, percpu=True)
            self.assertRaises(IOError, psutil.boot_time)
            # self.assertRaises(IOError, psutil.pids)
            self.assertRaises(IOError, psutil.net_connections)
            self.assertRaises(IOError, psutil.net_io_counters)
            self.assertRaises(IOError, psutil.net_if_stats)
            self.assertRaises(IOError, psutil.disk_io_counters)
            self.assertRaises(IOError, psutil.disk_partitions)
            self.assertRaises(psutil.NoSuchProcess, psutil.Process)
        finally:
            psutil.PROCFS_PATH = "/proc"
            os.rmdir(tdir)

def check(request):
    return {
            'hostname': socket.gethostname(),
            'ips': ips,
            'cpus': psutil.cpu_count(),
            'uptime': timesince(datetime.fromtimestamp(psutil.boot_time())),
            'memory': {
                'total': filesizeformat(psutil.virtual_memory().total),
                'available': filesizeformat(psutil.virtual_memory().available),
                'used': filesizeformat(psutil.virtual_memory().used),
                'free': filesizeformat(psutil.virtual_memory().free),
                'percent': psutil.virtual_memory().percent
            },
            'swap': {
                'total': filesizeformat(psutil.swap_memory().total),
                'used': filesizeformat(psutil.swap_memory().used),
                'free': filesizeformat(psutil.swap_memory().free),
                'percent': psutil.swap_memory().percent
            }
        }

def stream_host_stats():
    while True:
        net = psutil.net_io_counters(pernic=True)
        time.sleep(1)
        net1 = psutil.net_io_counters(pernic=True)
        net_stat_download = {}
        net_stat_upload = {}
        for k, v in net.items():
            for k1, v1 in net1.items():
                if k1 == k:
                    net_stat_download[k] = (v1.bytes_recv - v.bytes_recv) / 1000.
                    net_stat_upload[k] = (v1.bytes_sent - v.bytes_sent) / 1000.
        ds = statvfs('/')
        disk_str = {"Used": ((ds.f_blocks - ds.f_bfree) * ds.f_frsize) / 10 ** 9, "Unused": (ds.f_bavail * ds.f_frsize) / 10 ** 9}
        yield '[{"cpu":"%s","memory":"%s","memTotal":"%s","net_stats_down":"%s","net_stats_up":"%s","disk":"%s"}],' \
              % (psutil.cpu_percent(interval=1), psutil.virtual_memory().used, psutil.virtual_memory().free, \
                 net_stat_download, net_stat_upload, disk_str)

def doit(channel):

    cpu_pc = psutil.cpu_percent()
    mem_avail = psutil.virtual_memory().percent

    try:
        response = channel.update({1:cpu_pc, 2:mem_avail})
        print cpu_pc
        print mem_avail_mb
        print strftime("%a, %d %b %Y %H:%M:%S", localtime())
        print response
    except:
        print "connection failed"


#sleep for 16 seconds (api limit of 15 secs)

def remove_oldest_entries(storage, percentage=90):
    # compute current memory usage (%)
    old_mem = psutil.virtual_memory().percent
    # if we have data in storage and utilization exceeds 90%
    while storage and old_mem > percentage:
        # removed oldest entry
        storage.popitem(last=False)
        # garbage collect
        gc.collect(1)
        # comute used memory again
        new_mem = psutil.virtual_memory().percent
        # if the used memory did not decrease stop
        if new_mem >= old_mem:
            break
        # net new measurement for memory usage and loop
        old_mem = new_mem

def get_hugepage_number():
    # TODO: defaults to 2M - this should probably be configurable
    #       and support multiple pool sizes - e.g. 2M and 1G.
    # NOTE(jamespage): 2M in bytes
    hugepage_size = 2048 * 1024
    hugepage_config = config('hugepages')
    hugepages = None
    if hugepage_config:
        if hugepage_config.endswith('%'):
            # NOTE(jamespage): return units of virtual_memory is
            #                  bytes
            import psutil
            mem = psutil.virtual_memory()
            hugepage_config_pct = hugepage_config.strip('%')
            hugepage_multiplier = float(hugepage_config_pct) / 100
            hugepages = int((mem.total * hugepage_multiplier) / hugepage_size)
        else:
            hugepages = int(hugepage_config)
    return hugepages

def __init__(self):
        super().__init__()
        # From the psutil documentation https://pythonhosted.org/psutil/#psutil.cpu_percent:
        #
        #    Warning the first time this function is called
        #    with interval = 0.0 or None it will return a
        #    meaningless 0.0 value which you are supposed
        #    to ignore.
        psutil.cpu_percent()
        # '...is recommended for accuracy that this function be called with at least 0.1 seconds between calls.'
        time.sleep(0.1)
        # a sliding window of 60 contiguous 5 sec utilization (up to five minutes)
        self.cpuutils = collections.deque([psutil.cpu_percent()], maxlen=60)
        self.system_virtual_memory = psutil.virtual_memory()

        logger.debug('System Utilization handler initialized.')

def get_stats():
    root.authorized()
    params = {}

    # number of jobs in queued, running, and completed states
    params['nq'] = db(jobs.state=='Q').count()
    params['nr'] = db(jobs.state=='R').count()
    params['nc'] = db(jobs.state=='C').count()

    params['cpu'] = psutil.cpu_percent()
    params['vm'] = psutil.virtual_memory().percent
    params['disk'] = psutil.disk_usage('/').percent
    params['cid'] = request.query.cid
    params['app'] = request.query.app

    return template("stats", params)

def psutil_phymem_usage():
    """
    Return physical memory usage (float)
    Requires the cross-platform psutil (>=v0.3) library
    (http://code.google.com/p/psutil/)
    """
    # This is needed to avoid a deprecation warning error with
    # newer psutil versions

    if settings.__PSUTIL__ == False:
        return 0.0

    try:
        percent = psutil.virtual_memory().percent
    except:
        percent = psutil.phymem_usage().percent
    return percent

def collect_system_information(self):
        import psutil

        mem = psutil.virtual_memory()

        with self.git.batch_commit('JOB_SYSTEM_INFORMATION'):
            self.set_system_info('memory_total', mem.total)

            import aetros.cuda_gpu
            try:
                self.set_system_info('cuda_version', aetros.cuda_gpu.get_version())
            except Exception: pass

            import cpuinfo
            cpu = cpuinfo.get_cpu_info()
            self.set_system_info('cpu_name', cpu['brand'])
            self.set_system_info('cpu', [cpu['hz_actual_raw'][0], cpu['count']])

def sysInfoRaw():
    import time
    import psutil

    cpuPercent = psutil.cpu_percent(interval=1)
    memPercent = psutil.virtual_memory().percent
    sda2Percent = psutil.disk_usage('/').percent
    sda3Percent = psutil.disk_usage('/home').percent

    seconds = int(time.time()) - int(psutil.boot_time())
    m, s = divmod(seconds, 60)
    h, m = divmod(m, 60)
    d, h = divmod(h, 24)

    uptime =  [d, h, m, s]

    return [cpuPercent, memPercent, sda2Percent, sda3Percent, uptime]

def test_serialization(self):
        def check(ret):
            if json is not None:
                json.loads(json.dumps(ret))
            a = pickle.dumps(ret)
            b = pickle.loads(a)
            self.assertEqual(ret, b)

        check(psutil.Process().as_dict())
        check(psutil.virtual_memory())
        check(psutil.swap_memory())
        check(psutil.cpu_times())
        check(psutil.cpu_times_percent(interval=0))
        check(psutil.net_io_counters())
        if LINUX and not os.path.exists('/proc/diskstats'):
            pass
        else:
            if not APPVEYOR:
                check(psutil.disk_io_counters())
        check(psutil.disk_partitions())
        check(psutil.disk_usage(os.getcwd()))
        check(psutil.users())

def test_total_phymem(self):
        w = wmi.WMI().Win32_ComputerSystem()[0]
        self.assertEqual(int(w.TotalPhysicalMemory),
                         psutil.virtual_memory().total)

    # @unittest.skipIf(wmi is None, "wmi module is not installed")
    # def test__UPTIME(self):
    #     # _UPTIME constant is not public but it is used internally
    #     # as value to return for pid 0 creation time.
    #     # WMI behaves the same.
    #     w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
    #     p = psutil.Process(0)
    #     wmic_create = str(w.CreationDate.split('.')[0])
    #     psutil_create = time.strftime("%Y%m%d%H%M%S",
    #                                   time.localtime(p.create_time()))

    # Note: this test is not very reliable

def test_virtual_memory(self):
        mem = psutil.virtual_memory()
        assert mem.total > 0, mem
        assert mem.available > 0, mem
        assert 0 <= mem.percent <= 100, mem
        assert mem.used > 0, mem
        assert mem.free >= 0, mem
        for name in mem._fields:
            value = getattr(mem, name)
            if name != 'percent':
                self.assertIsInstance(value, (int, long))
            if name != 'total':
                if not value >= 0:
                    self.fail("%r < 0 (%s)" % (name, value))
                if value > mem.total:
                    self.fail("%r > total (total=%s, %s=%s)"
                              % (name, mem.total, name, value))

def test_proc_cpu_times(self):
        tested = []
        out = sh('procstat -r %s' % self.pid)
        p = psutil.Process(self.pid)
        for line in out.split('\n'):
            line = line.lower().strip()
            if 'user time' in line:
                pstat_value = float('0.' + line.split()[-1].split('.')[-1])
                psutil_value = p.cpu_times().user
                self.assertEqual(pstat_value, psutil_value)
                tested.append(None)
            elif 'system time' in line:
                pstat_value = float('0.' + line.split()[-1].split('.')[-1])
                psutil_value = p.cpu_times().system
                self.assertEqual(pstat_value, psutil_value)
                tested.append(None)
        if len(tested) != 2:
            raise RuntimeError("couldn't find lines match in procstat out")

    # --- virtual_memory(); tests against sysctl

def remove_oldest_entries(storage, percentage=90):
    # compute current memory usage (%)
    old_mem = psutil.virtual_memory().percent
    # if we have data in storage and utilization exceeds 90%
    while storage and old_mem > percentage:
        # removed oldest entry
        storage.popitem(last=False)
        # garbage collect
        gc.collect(1)
        # comute used memory again
        new_mem = psutil.virtual_memory().percent
        # if the used memory did not decrease stop
        if new_mem >= old_mem:
            break
        # net new measurement for memory usage and loop
        old_mem = new_mem

def __init__(self):
        self.conn = None
        self.dirty_scene = False
        self.guest = None
        self.guest_mapping_by_uuid = dict()
        self.hostname = ji.Common.get_hostname()
        self.node_id = uuid.getnode()
        self.cpu = psutil.cpu_count()
        self.memory = psutil.virtual_memory().total
        self.interfaces = dict()
        self.disks = dict()
        self.guest_callbacks = list()
        self.interval = 60
        # self.last_host_cpu_time = dict()
        self.last_host_traffic = dict()
        self.last_host_disk_io = dict()
        self.last_guest_cpu_time = dict()
        self.last_guest_traffic = dict()
        self.last_guest_disk_io = dict()
        self.ts = ji.Common.ts()
        self.ssh_client = None

def remove_oldest_entries(storage, percentage=90):
    # compute current memory usage (%)
    old_mem = psutil.virtual_memory().percent
    # if we have data in storage and utilization exceeds 90%
    while storage and old_mem > percentage:
        # removed oldest entry
        storage.popitem(last=False)
        # garbage collect
        gc.collect(1)
        # comute used memory again
        new_mem = psutil.virtual_memory().percent
        # if the used memory did not decrease stop
        if new_mem >= old_mem:
            break
        # net new measurement for memory usage and loop
        old_mem = new_mem

def get_memory():
    memory = dict()
    virtual = psutil.virtual_memory()
    swap = psutil.swap_memory()
    memory['virtual_total'] = '%.2fMB' % (virtual.total/1024/1024)
    memory['virtual_available'] = '%.2fMB' % (virtual.available/1024/1024)
    memory['virtual_percent'] = str(virtual.percent)+'%'
    memory['virtual_used'] = '%.2fMB' % (virtual.used/1024/1024)
    memory['virtual_free'] = '%.2fMB' % (virtual.free/1024/1024)
    memory['virtual_active'] = '%.2fMB' % (virtual.active/1024/1024)
    memory['virtual_inactive'] = '%.2fMB' % (virtual.inactive/1024/1024)
    memory['virtual_buffers'] = '%.2fMB' % (virtual.buffers/1024/1024)
    memory['virtual_cached'] = '%.2fMB' % (virtual.cached/1024/1024)
    memory['virtual_shared'] = '%.2fMB' % (virtual.shared/1024/1024)
    memory['swap_total'] = '%.2fMB' % (swap.total/1024/1024)
    memory['swap_used'] = '%.2fMB' % (swap.used/1024/1024)
    memory['swap_free'] = '%.2fMB' % (swap.free/1024/1024)
    memory['swap_percent'] = str(swap.percent)+'%'
    memory['swap_sin'] = '%.2fMB' % (swap.sin/1024/1024)
    memory['swap_sout'] = '%.2fMB' % (swap.sout/1024/1024)
    return memory

def _get_memory_stats(self):
        mem_info = {'virtual': {}, 'swap': {}}
        v_mem = ps.virtual_memory()
        s_mem = ps.swap_memory()

        _c = mem_info['virtual']
        _c['total'] = v_mem.total
        _c['used'] = v_mem.used
        _c['free'] = v_mem.free
        _c['used_percent'] = v_mem.percent

        _c = mem_info['swap']
        _c['total'] = s_mem.total
        _c['used'] = s_mem.used
        _c['free'] = s_mem.free
        _c['used_percent'] = s_mem.percent

        return mem_info

def _init_in_memory_chunks(self, size):
        available_mem = psutil.virtual_memory().available
        required_mem = self._calculate_required_memory(size)
        if required_mem <= available_mem:
            self._in_memory_chunks = np.empty(shape=(size, self.data_producer.dimension()),
                                              order='C', dtype=np.float32)
        else:
            if self.oom_strategy == 'raise':
                self.logger.warning('K-means failed to load all the data (%s required, %s available) into memory. '
                                    'Consider using a larger stride or set the oom_strategy to \'memmap\' which works '
                                    'with a memmapped temporary file.'
                                    % (bytes_to_string(required_mem), bytes_to_string(available_mem)))
                raise MemoryError()
            else:
                self.logger.warning('K-means failed to load all the data (%s required, %s available) into memory '
                                    'and now uses a memmapped temporary file which is comparably slow. '
                                    'Consider using a larger stride.'
                                    % (bytes_to_string(required_mem), bytes_to_string(available_mem)))
                self._in_memory_chunks = np.memmap(tempfile.mkstemp()[1], mode="w+",
                                                   shape=(size, self.data_producer.dimension()), order='C',
                                                   dtype=np.float32)

def memory():
    c = statsd.StatsClient(STATSD_HOST, 8125, prefix=PREFIX + 'system.memory')
    while True:
        swap = psutil.swap_memory()
        c.gauge('swap.total', swap.total)
        c.gauge('swap.used', swap.used)
        c.gauge('swap.free', swap.free)
        c.gauge('swap.percent', swap.percent)

        virtual = psutil.virtual_memory()
        c.gauge('virtual.total', virtual.total)
        c.gauge('virtual.available', virtual.available)
        c.gauge('virtual.used', virtual.used)
        c.gauge('virtual.free', virtual.free)
        c.gauge('virtual.percent', virtual.percent)
        c.gauge('virtual.active', virtual.active)
        c.gauge('virtual.inactive', virtual.inactive)
        c.gauge('virtual.buffers', virtual.buffers)
        c.gauge('virtual.cached', virtual.cached)
        time.sleep(GRANULARITY)

def POST(self):
        cpuused = psutil.cpu_percent(interval=None, percpu=False)
        memused = psutil.virtual_memory()[2]
        diskused = psutil.disk_usage('/')[3]
        pidcount = len(psutil.pids())

        uptimeshell = subprocess.Popen(['uptime'], stderr=subprocess.PIPE,stdout=subprocess.PIPE)
        uptimeshell.wait()
        uptime = uptimeshell.communicate()

        return json.dumps(
            {
                "code": 0,
                "current": {
                    "cpuused": cpuused,
                    "memused": memused,
                    "diskused": diskused,
                    "pidcount": pidcount,
                    "uptime": uptime
                }
            }
        )

def cpuinfo():
    men=psutil.virtual_memory()
    menab=(men.available)/(1024*1024)
    menta=(men.total)/(1024*1024)
    menus=(men.used)/(1024*1024)
    disk=psutil.disk_usage('/')
    diskta=(disk.total)/(1024*1024*1024)
    diskus=(disk.used)/(1024*1024*1024)
    diskfr=(disk.free)/(1024*1024*1024)
    time = datetime.datetime.now()
    with open('eggs.csv', 'a') as csvfile:
        spamwriter = csv.writer(csvfile, delimiter=' ',
                                quotechar='|', quoting=csv.QUOTE_MINIMAL)
        spamwriter.writerow({"??????%s"%time})
        spamwriter.writerow({"cpu?????%d%s"%(psutil.cpu_percent(interval=1),"%")})
        spamwriter.writerow({"???????%sMB" % int(menta)})
        spamwriter.writerow({"?????????%sMB" % int(menus)})
        spamwriter.writerow({"????????%sMB" % int(menab)})
        spamwriter.writerow({"???????%sG" % int(diskta)})
        spamwriter.writerow({"???????%sG" % int(diskus)})
        spamwriter.writerow({"???????%sG" % int(diskfr)})
    with open('eggs.csv', 'r') as csvfile:
          spamreader = csv.reader(csvfile, delimiter=' ', quotechar='|')
          for row in spamreader:
             print(row)

def _get_docker_node_info(info):
    """Gets the node info specific to docker.
    """
    cpucapacity = int(cpu_count() * 100)
    memcapacity = (psutil.virtual_memory().total * 0.9) // _BYTES_IN_MB

    # TODO: manage disk space a little better
    if os.name == 'nt':
        path = 'C:\\ProgramData\\docker'
    else:
        path = '/var/lib/docker'

    diskfree = disk_usage(path).free // _BYTES_IN_MB

    info.update({
        'memory': '%dM' % memcapacity,
        'disk':  '%dM' % diskfree,
        'cpu': '%d%%' % cpucapacity,
        'up_since': up_since(),
    })

    return info

def monitor(arglar):
    logger.info("Starting main loop")
    while True:
        if arglar.mode in "ca":
            cpu_reading = max(psutil.cpu_percent(arglar.resolution, percpu=True))
            logger.debug("Cpu percents {}".format(cpu_reading))
            if cpu_reading > arglar.cpu_crit:
                logger.debug("Cpu percentage is higher than critical level")
                print("CPU usage is high", file=arglar.crit_out)
            elif arglar.cpu_warn is not None and cpu_reading > arglar.cpu_warn:
                logger.debug("Cpu percentage is higher than warning level")
                print("CPU usage is critical", file=arglar.warn_out)

        if arglar.mode in "ra":
            ram_reading = psutil.virtual_memory().percent
            logger.debug("Ram percents {}".format(ram_reading))
            if ram_reading > arglar.ram_crit:
                logger.debug("Ram percentage is higher than critical level")
                print("RAM usage is high", file=arglar.crit_out)
            elif arglar.ram_warn is not None and ram_reading > arglar.ram_warn:
                logger.debug("Ram percentage is higher than warning level")
                print("RAM usage is critical", file=arglar.warn_out)

        logger.debug("Sleeping")
        time.sleep(arglar.resolution)

def get_memory_usage(output_dict):
    my_dict = {}
    memory_usage = psutil.virtual_memory()
    memory_total_gb = float(memory_usage.total)/(1024*1024*1024)
    memory_used_gb = float(memory_usage.used)/(1024*1024*1024)
    memory_available_gb = float(memory_usage.available)/(1024*1024*1024)
    memory_buffers_gb = float(memory_usage.buffers)/(1024*1024*1024)
    my_dict["ram_total_gb"] = "{:.2f}".format(memory_total_gb)
    my_dict["ram_used_gb"] = "{:.2f}".format(memory_used_gb)
    my_dict["ram_available_gb"] = "{:.2f}".format(memory_available_gb)
    my_dict["ram_buffers_gb"] = "{:.2f}".format(memory_buffers_gb)
    percent_ratio = float(my_dict["ram_used_gb"])*100/float(my_dict["ram_total_gb"])
    my_dict["used_percentage"] = "%s(%sgb/%sgb)" % \
                                 ("{:.2f}".format(percent_ratio) + "%", \
                                  my_dict["ram_used_gb"], my_dict["ram_total_gb"])

    output_dict["ram"] = my_dict

# https://stackoverflow.com/questions/276052/how-to-get-current-cpu-and-ram-usage-in-python

def updateGui(screen, boxes, data):
    maxy, maxx = screen.getmaxyx()

    date = str(time.strftime("%c"))
    screen.addstr(1, maxx - len(date) - 2, date)

    screen.addstr(3, 15, '%3d' % (psutil.cpu_percent()))
    # svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, active=4748992512, inactive=2758115328, buffers=790724608, cached=3500347392, shared=787554304)
    screen.addstr(4, 15, str(psutil.virtual_memory()[4] / (1024 * 1024)))

    screen.refresh()
    n = 0
    for box in boxes:
        testspersecond = '%8d' % data[n]["testspersecond"]
        testcount = '%8d' % data[n]["testcount"]
        crashcount = '%8d' % data[n]["crashcount"]
        box.addstr(1, 1, testspersecond)
        box.addstr(2, 1, testcount)
        box.addstr(3, 1, crashcount)
        box.refresh()
        n += 1

def status(cmd, message, args):
    os_icon, os_color = get_os_icon()
    general_text = f'Latency: **{int(cmd.bot.latency * 1000)}ms**'
    general_text += f'\nPlatform: **{sys.platform.upper()}**'
    general_text += f'\nStarted: **{arrow.get(psutil.boot_time()).humanize()}**'
    cpu_clock = psutil.cpu_freq()
    if cpu_clock:
        cpu_clock = cpu_clock.current
    else:
        cpu_clock = 'Unknown'
    cpu_text = f'Count: **{psutil.cpu_count()} ({psutil.cpu_count(logical=False)})**'
    cpu_text += f'\nUsage: **{psutil.cpu_percent()}%**'
    cpu_text += f'\nClock: **{cpu_clock} MHz**'
    used_mem = humanfriendly.format_size(psutil.virtual_memory().available, binary=True)
    total_mem = humanfriendly.format_size(psutil.virtual_memory().total, binary=True)
    mem_text = f'Used: **{used_mem}**'
    mem_text += f'\nTotal: **{total_mem}**'
    mem_text += f'\nPercent: **{int(100 - psutil.virtual_memory().percent)}%**'
    response = discord.Embed(color=os_color)
    response.set_author(name=socket.gethostname(), icon_url=os_icon)
    response.add_field(name='General', value=general_text)
    response.add_field(name='CPU', value=cpu_text)
    response.add_field(name='Memory', value=mem_text)
    await message.channel.send(embed=response)

def isMemEnoughEigen(D, extraVarsRatio=5):
    mem = virtual_memory()
    installedMemGB = round( mem.total * 1.0 / (1<<30) )
    # 15 is an empirical estimation. when D=30K, it takes around 50GB mem
    requiredMemGB = D * D * 4.0 * ( extraVarsRatio + 8 ) / 1000000000

    # installed mem is enough
    if requiredMemGB <= installedMemGB:
        isEnough = 2

    # give a warning, will use some paging file and make the computer very slow
    elif requiredMemGB <= installedMemGB * 1.2:
        isEnough = 1
    # not enough
    else:
        isEnough = 0

    return isEnough, installedMemGB, requiredMemGB

def monitor(frist_invoke=1):

    mem = psutil.virtual_memory()

    value_dic = {
        'memory': {
            'mem.total': int(mem.total/(1024*1024)),
            'mem.free': int(mem.free/(1024*1024)),
            'mem.buffers': int(mem.buffers/(1024*1024)),
            'mem.cache': int(mem.cached/(1024*1024)),
            'mem.used': int(mem.used/(1024*1024)),
            'mem.percent': mem.percent
        }
    }

    return value_dic

def poll():
    global lastChecksum, voltage
    if socketio != None:

        mempercent = psutil.virtual_memory().percent
        cpupercent = psutil.cpu_percent(interval=None)
        cputemp = get_cpu_temperature()

        secs = int(round(time.time()))
        # every 10 seconds update voltage (or if it is zero)
        if(secs % 10 == 0 or voltage == 0):
            v = robot.getVoltage()
            # sometimes getVoltage fails and returns 0...don't show it..wait for next read
            if(v != 0):
                voltage = v

        data = {'mp': mempercent, 'cp': cpupercent, 'ct': cputemp, 'v': voltage}
        checksum = hashlib.sha224(json.dumps(data)).hexdigest()
        if lastChecksum != checksum:
            socketio.emit('sysinfo', data)
            lastChecksum = checksum
    time.sleep(0.5)

def update(self):
        """Function to update the entire class information."""
        self.cpu["percentage"] = psutil.cpu_percent(interval=0.7)
        self.boot = datetime.datetime.fromtimestamp(psutil.boot_time()).strftime(
            "%Y-%m-%d %H:%M:%S")
        virtual_memory = psutil.virtual_memory()
        self.memory["used"] = virtual_memory.used
        self.memory["free"] = virtual_memory.free
        self.memory["cached"] = virtual_memory.cached
        net_io_counters = psutil.net_io_counters()
        self.network["packet_sent"] = net_io_counters.packets_sent
        self.network["packet_recv"] = net_io_counters.packets_recv
        disk_usage = psutil.disk_usage('/')
        self.disk["total"] = int(disk_usage.total/1024)
        self.disk["used"] = int(disk_usage.used/1024)
        self.disk["free"] = int(disk_usage.free/1024)
        self.timestamp = time.time()

def show_platform():
    ''' Show information on platform'''
    swrite('\n=== SYSTEM ===\n\n')
    try:
        linux_distribution = platform.linux_distribution()
    except:
        linux_distribution = "N/A"
    swrite("""
    dist: %s
    linux_distribution: %s
    system: %s
    machine: %s
    platform: %s
    uname: %s
    version: %s
    mac_ver: %s
    memory: %s
    number of CPU: %s
    """ % (
    str(platform.dist()),
    linux_distribution,
    platform.system(),
    platform.machine(),
    platform.platform(),
    platform.uname(),
    platform.version(),
    platform.mac_ver(),
    psutil.virtual_memory(),
    str(psutil.cpu_count())
    ))

def collect_meminfo(self):
        meminfo = psutil.virtual_memory()
        memdict = {}
        memdict['total'] = meminfo.total/1024
        memdict['used'] = meminfo.used/1024
        memdict['free'] = meminfo.free/1024
        memdict['buffers'] = meminfo.buffers/1024
        memdict['cached'] = meminfo.cached/1024
        memdict['percent'] = meminfo.percent
        #print(output)
        #print(memparts)
        return memdict

    # collect cpu used information and processors information

def printMemUsage():
    psutil = getPSUtil()
    if psutil:
        u = mem_usage()
        M = psutil.virtual_memory()
        print( "Process Mem: %0.1fMb     System: %0.1fMb / %0.1fMb"%(u, M.used/1048576., M.total/1048576.) )

def print_mem_time(tag):
    print(tag," time %.2f seconds"%(time.time()-_start), end='')
    try:
        summ = psutil.virtual_memory()
        print(" Used: %.2f GB %.2f%%"%((summ.used)/(1024.0*1024*1024),summ.percent))
    except:
        print()

def __get_mem_usage(self):
        return psutil.virtual_memory().percent / 100.0

def __init__(self, cfgParams, memory_factor):
        """
        Constructor
        :param cfgParams: initialized NetTrainerParams
        :param memory_factor: fraction of memory used for single shared variable
        """

        self.cfgParams = cfgParams

        if not isinstance(cfgParams, NetTrainerParams):
            raise ValueError("cfgParams must be an instance of NetTrainerParams")

        if 'gpu' in theano.config.device:
            # get GPU memory info
            mem_info = theano.sandbox.cuda.cuda_ndarray.cuda_ndarray.mem_info()
            self.memory = (mem_info[0] / 1024 ** 2) / float(memory_factor)  # MB, use third of free memory
        elif 'cpu' in theano.config.device:
            # get CPU memory info
            self.memory = (psutil.virtual_memory().available / 1024 ** 2) / float(memory_factor)  # MB, use third of free memory
        else:
            raise EnvironmentError("Neither GPU nor CPU device in theano.config found!")

        self.currentMacroBatch = -1  # current batch on GPU, load on first run
        self.trainSize = 0
        self.sampleSize = 0
        self.numTrainSamples = 0
        self.numValSamples = 0
        self.managedVar = []

def get_system_load(self):
        return {
            MEM_AVAILABLE: psutil.virtual_memory().available,
            CPU_IDLE_PERCENT: psutil.cpu_times_percent(
                self.cpu_sample_interval).idle,
            CLIENT_NUMBER: len(self.protocol.server.clients),
        }

def get_memo_usage_available():
    psy_mem = psutil.virtual_memory()
    vrt_mem = psutil.swap_memory()
    return psy_mem.available, vrt_mem.free + psy_mem.available

def get_init_resource():
    cpu = cpu_count() * 100
    psy_mem = psutil.virtual_memory()
    vrt_mem = psutil.swap_memory()
    disk = list(psutil.disk_usage(get_config("env", "workspace")))[0]
    return cpu, psy_mem.total, disk, vrt_mem.total + psy_mem.total

def init_with_context(self, context):
        ram = psutil.virtual_memory().percent
        cpu = psutil.cpu_percent()
        green, orange, red, grey = '#00FF38', '#FFB400', '#FF3B00', '#EBEBEB'

        ram_color = green
        if ram >= 75:
            ram_color = red
        elif ram >= 50:
            ram_color = orange

        cpu_color = green
        if cpu >= 75:
            cpu_color = red
        elif cpu >= 50:
            cpu_color = orange

        self.cpu_idel = 100 - cpu
        self.cpu_color = cpu_color
        self.cpu = cpu
        self.ram = 100 - ram
        self.ram_used = ram
        self.ram_color = ram_color

def memory(self, type):
        mem = psutil.virtual_memory()
        if type == 'total':
            return format(mem.total / 1024 / 1024, '.0f')
        elif type == 'available':
            return format(mem.available / 1024 / 1024, '.0f')
        elif type == 'used':
            return format(mem.used / 1024 / 1024, '.0f')
        elif type == 'free':
            return format(mem.free / 1024 / 1024, '.0f')
        elif type == 'cached':
            return format(mem.cached / 1024 / 1024, '.0f')

def get_total_mem():
    total_mem = virtual_memory().total
    return jsonify(status=0, total_mem=total_mem)

def show_platform():
    ''' Show information on platform'''
    swrite('\n=== SYSTEM ===\n\n')
    try:
        linux_distribution = platform.linux_distribution()
    except:
        linux_distribution = "N/A"
    swrite("""
    dist: %s
    linux_distribution: %s
    system: %s
    machine: %s
    platform: %s
    uname: %s
    version: %s
    mac_ver: %s
    memory: %s
    number of CPU: %s
    """ % (
    str(platform.dist()),
    linux_distribution,
    platform.system(),
    platform.machine(),
    platform.platform(),
    platform.uname(),
    platform.version(),
    platform.mac_ver(),
    psutil.virtual_memory(),
    str(psutil.cpu_count())
    ))

def get_memory(self):
        return int(psutil.virtual_memory()[2])

def get_total_memory(self):
        return psutil.virtual_memory()[0]

def get(self, request, show=False):
        if show == 'all':
            show = True

        cpu_count = get_cpu_count()
        return ('processes.html', {
                                    'panel_pid': prism.settings.PANEL_PID,
                                    'cpu_count': cpu_count[0],
                                    'cpu_count_logical': cpu_count[1],
                                    'ram': psutil.virtual_memory()[0],
                                    'processes': self.get_processes(show,
                                                lambda x: x['memory_percent'] + x['cpu_percent'])
                                })