pmemstat 3.0.2__tar.gz → 3.0.4__tar.gz

{pmemstat-3.0.2 → pmemstat-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: pmemstat
-Version: 3.0.2
+Version: 3.0.4
 Summary: Report Proportional Memory on Linux
 Keywords: proportional memory,RAM,htop,top,monitor
 Author-email: Joe Defen <joedef@duck.com>
@@ -9,9 +9,8 @@ Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
-License-File: LICENSE.txt
 Requires-Dist: psutil > 5.9
-Requires-Dist: console-window >= 1.0.0
+Requires-Dist: console-window >= 1.0.5
 Project-URL: Bug Tracker, https://github.com/joedefen/pmemstat/issues
 Project-URL: Homepage, https://github.com/joedefen/pmemstat
 

{pmemstat-3.0.2 → pmemstat-3.0.4}/pmemstat/main.py

@@ -94,6 +94,92 @@ def human(number):
             return f'{number:.1f}{suffix}'
     return '' # impossible, but make pylint happy
 
+####################################################################################
+# PORTABLE FUNCTION - Copy-pasted from zram-advisor
+# When updating: copy entire function from zram_advisor/main.py (lines 86-166)
+####################################################################################
+def compute_zram_effective(meminfo_total, meminfo_used, meminfo_available,
+                          zram_orig_data_size, zram_mem_used_total,
+                          zram_disksize, zram_mem_limit=0, limit_pct=80):
+    """
+    Compute effective memory values accounting for zRAM compression.
+
+    This is a PORTABLE function that can be copy-pasted between projects.
+    NO class dependencies - all inputs passed as parameters.
+
+    Args:
+        meminfo_total: Total physical RAM in bytes
+        meminfo_used: Currently used RAM in bytes
+        meminfo_available: Available RAM in bytes
+        zram_orig_data_size: Uncompressed data size stored in zRAM (bytes)
+        zram_mem_used_total: Physical RAM consumed by zRAM including overhead (bytes)
+        zram_disksize: Max uncompressed data zRAM will accept (bytes)
+        zram_mem_limit: Max RAM zRAM can use (0=unlimited) (bytes)
+        limit_pct: Arbitrary limit on % of RAM zRAM should use (default 80%)
+
+    Returns:
+        SimpleNamespace with:
+            - e_used: Effective memory used (uncompressed equivalent)
+            - e_avail: Effective memory available
+            - e_max_used: Maximum effective memory at full zRAM capacity
+            - ratio_current: Current effective compression ratio
+            - ratio_projected: Projected ratio accounting for degradation
+            - projection_confidence: 'low', 'medium', or 'high'
+            - usage_fraction: Fraction of disksize currently used
+    """
+    # Calculate effective used memory (what it would be if uncompressed)
+    e_used = meminfo_used - zram_mem_used_total + zram_orig_data_size
+
+    # Determine compression ratio
+    ratio = None
+    if e_used <= meminfo_used:  # zRAM not helping yet
+        e_used = meminfo_used
+        ratio = 2.75  # Conservative guess for projection when no data yet
+
+    if ratio is None:  # Calculate actual ratio
+        ratio = zram_orig_data_size / zram_mem_used_total if zram_mem_used_total > 0 else 2.75
+
+    # Apply memory limit if configured
+    if zram_mem_limit > 0:
+        stats_limit_pct = (zram_mem_limit / meminfo_total) * 100
+        limit_pct = min(100.0, limit_pct, stats_limit_pct)
+
+    # Calculate usage fraction and apply degradation
+    usage_fraction = zram_orig_data_size / zram_disksize if zram_disksize > 0 else 0
+
+    # Degradation logic based on current usage
+    if usage_fraction < 0.10:
+        degradation_factor = 0.75  # Aggressive: little real data
+        confidence = "low"
+    elif usage_fraction < 0.50:
+        degradation_factor = 0.85  # Moderate: some real data
+        confidence = "medium"
+    else:
+        degradation_factor = 0.95  # Conservative: lots of real data
+        confidence = "high"
+
+    projected_ratio = ratio * degradation_factor
+
+    # Project maximum effective memory when zRAM fills to limit
+    e_max_used = projected_ratio * meminfo_total * limit_pct / 100
+    # Cap by disksize limit
+    e_max_used = min(e_max_used, zram_disksize)
+    # Add uncompressed memory not in zRAM
+    e_max_used += meminfo_total - e_max_used / projected_ratio
+
+    # Calculate effective available
+    e_avail = e_max_used - e_used
+
+    return SimpleNamespace(
+        e_used=e_used,
+        e_avail=e_avail,
+        e_max_used=e_max_used,
+        ratio_current=ratio,
+        ratio_projected=projected_ratio,
+        projection_confidence=confidence,
+        usage_fraction=usage_fraction
+    )
+
 ####################################################################################
 ###### ZramProjector class
 ####################################################################################
@@ -156,7 +242,7 @@ class ZramProjector:
         return infos
 
     def compute_effective(self, meminfoKB):
-        """ Compute the effective values """
+        """ Compute the effective values - now uses portable function """
         def seed(meminfoKB):
             nonlocal self
             meminfo = self.meminfo = SimpleNamespace()
@@ -175,6 +261,8 @@ class ZramProjector:
         devs = self._get_zram_stats()
         if not devs:
             return
+
+        # Aggregate stats from all zRAM devices
         stats = None
         for stat in devs.values():
             # NOTE: generalization for more than one weak unless all
@@ -187,29 +275,25 @@ class ZramProjector:
         stats = SimpleNamespace(**stats)
         self.meminfo.MemZram = stats.mem_used_total
 
-        e_used = meminfo.MemUsed - stats.mem_used_total + stats.orig_data_size
-        ratio, self.ratio = None, 0.0
-        if e_used <= self.e_used: # zram hurts. assume not enuf data to project
-            e_used = self.e_used
-            self.ratio = ratio = 3.5 # wild guess for projection
-            # if self.DB: dump_effective(ns, '(unchg)')
-            # return ns
-        self.e_used = e_used
-        limit_pct = self.limit_pct
-        if stats.mem_limit > 0:
-            stats_limit_pct = (stats.limit / meminfo.MemTotal)*100
-            limit_pct = min(1.0, limit_pct, stats_limit_pct)
-            # projected amount of orig used memory that fits in limit
-        if ratio is None: # hopefully about 4 ;-)
-            self.ratio = ratio = stats.orig_data_size / stats.mem_used_total
-        e_max_used = ratio * meminfo.MemTotal * limit_pct/100
-            # now limit by disksize
-        e_max_used = min(e_max_used, stats.disksize)
-            # now add uncompressed memory
-        e_max_used += meminfo.MemTotal - e_max_used/ratio
-        self.e_max_used = e_max_used
-        # self.e_max_used = max(e_max_total, e_max_used)
-        self.e_avail = e_max_used - e_used
+        # Call the portable computation function
+        result = compute_zram_effective(
+            meminfo_total=meminfo.MemTotal,
+            meminfo_used=meminfo.MemUsed,
+            meminfo_available=meminfo.MemAvailable,
+            zram_orig_data_size=stats.orig_data_size,
+            zram_mem_used_total=stats.mem_used_total,
+            zram_disksize=stats.disksize,
+            zram_mem_limit=stats.mem_limit,
+            limit_pct=self.limit_pct
+        )
+
+        # Update instance variables from result
+        self.e_used = result.e_used
+        self.e_avail = result.e_avail
+        self.e_max_used = result.e_max_used
+        self.ratio = result.ratio_current
+        self.ratio_projected = result.ratio_projected
+        self.projection_confidence = result.projection_confidence
 
 
 ####################################################################################
@@ -246,7 +330,7 @@ class ProcMem:
     # units = '' # determined by arguments
     # fwidth = 11
     pmemstat = None # the main program object
-    max_cmd_len = 32 # command line maximum length
+    max_cmd_len = 96 # command line maximum length
     chunk_dict = {
             'cat': None,
             'beg': 0,
@@ -286,58 +370,137 @@ class ProcMem:
             self.cpu = CpuSmooth(self.pid, avg_secs= ProcMem.opts.cpu_avg_secs)
         return self.cpu.refresh_cpu() # sets self.cpu.percent
 
+    def _get_exebasename(self, exepath, wds):
+        """
+        Final, definitive, robust executable base name resolver.
+        """
+        
+        # --- Phase 1: Determine the Initial Best Name Candidate ---
+        # ... (same initial logic as before, using os.readlink)
+        basename = os.path.basename(exepath)
+        is_bad_name = not basename or basename == 'exe' or len(basename) > 16 or not re.search(r'[a-zA-Z]', basename)
+
+        if is_bad_name:
+            try:
+                link_target = os.readlink(f'/proc/{self.pid}/exe')
+                if ' (deleted)' not in link_target and 'a.out' not in link_target:
+                    basename = os.path.basename(link_target)
+            except (FileNotFoundError, OSError):
+                pass
+
+        # --- Phase 2: Multi-Step Aggressive Cleanup (The FINAL Final Fix) ---
+
+        # 1. Remove VQ... style hashes and generic suffixes
+        hash_and_bin_pattern = r'(VQ[A-Z0-9]{10,}|-bin|\.bin)' 
+        basename = re.sub(hash_and_bin_pattern, '', basename).strip()
+
+        # 2. **CRITICAL FIX:** Remove all tab/PID/browser-related arguments from the tail.
+        # This addresses both 'browser 14 tab' AND any simple trailing numbers (like 'browser 4')
+        tab_and_num_pattern = r'(?:\s+\d+)?\s+(tab.*|socket.*|rdd.*|process.*|\d+)$'
+        basename = re.sub(tab_and_num_pattern, '', basename, flags=re.IGNORECASE).strip()
+        
+        # 3. Remove common internal browser-role suffixes (renderer, rdd, content, etc.)
+        roles_pattern = r'-(renderer|gpu|utility|plugin|content|chrm|bsp|extension)$'
+        basename = re.sub(roles_pattern, '', basename, flags=re.IGNORECASE).strip()
+
+        # Final safety cleanup for any leading/trailing punctuation/spaces leftover
+        basename = re.sub(r'^\W+|\W+$', '', basename).strip()
+
+        # --- Phase 3: Last Resort Fallback ---
+        
+        if not basename or basename in ('exe', 'a.out'):
+            try:
+                basename = os.path.basename(wds[0])
+            except IndexError:
+                basename = 'exe'
+        
+        # Special Case Protection: Restore I3 if it was reduced
+        if basename == 'i':
+            basename = 'i3'
+
+        return basename
+
     def get_cmdline(self):
         """Get the command line of the PID."""
-        try:
 
+        try:
             cmdline_file = f'/proc/{self.pid}/cmdline'
             try:
                 # pylint: disable=consider-using-with
                 line = open(cmdline_file, encoding='utf-8').read()[:-1]
             except FileNotFoundError as exc:
-                # this seems to be a race which ignore; either the process is just
-                # started or just quickly ended before even identified
                 if DebugLevel:
                     DB(1, f'skip pid={self.pid} no-rollup-lines exc={type(exc).__name__}')
                 return
+
             arguments = line.split('\0')
             if not arguments or not arguments[0]: # kernel process
                 self.wanted, self.kernel = False, True
-                # print(f'{self.pid}: kernel thread')
                 return
-            # DB(0, f'{self.pid}: {arguments}')
-            # sometimes the first word
-            wds = os.path.basename(arguments[0]).split() + arguments[1:]
-            basename = re.sub(r'^\W+', '', wds.pop(0))
-            basename = re.sub(r'\W+$', '', basename)
-            # DB(0, f'basename={basename} wds={wds}')
-            if basename in ('python', 'python2', 'python3', 'perl', 'bash', 'ruby',
+
+            exepath = arguments[0]
+            
+            # Prepare wds (words/arguments) for use in the helper and cmdline rebuild
+            base_name_list = os.path.basename(exepath).split()
+            if base_name_list:
+                initial_basename = base_name_list.pop(0) 
+                wds = base_name_list + arguments[1:]
+            else:
+                initial_basename = ''
+                wds = arguments[1:]
+                
+            # Use the robust helper to determine the final, clean basename
+            self.exebasename = self._get_exebasename(exepath, wds) 
+            
+            # --- START ELABORATION LOGIC ---
+
+            # 1. Elaboration: The Sudo Wrapper
+            if self.exebasename == 'sudo' and wds:
+                actual_cmd_name = os.path.basename(wds[0])
+                if actual_cmd_name:
+                    self.exebasename = actual_cmd_name
+                    del wds[0]
+
+            # 2. Elaboration: The Interpreter (Python, Perl, etc.)
+            if self.exebasename in ('python', 'python2', 'python3', 'perl', 'bash', 'ruby',
                     'sh', 'ksh', 'zsh') and wds:
-                script = os.path.basename(wds[0])
-                # DB(0, f'script={script} wds[0]={wds[0]}')
-                if script != wds[0]:
-                    basename = f'{basename}->{script}'
+
+                # 2.a. Catch the 'python -m <module>' pattern (The New Fix)
+                if len(wds) >= 2 and wds[0] == '-m':
+                    module_name = wds[1]
+                    self.exebasename = f'{self.exebasename}->{module_name}'
+                    # Remove '-m' and the module name from arguments
+                    del wds[0]
                     del wds[0]
-            self.exebasename = basename
-            self.cmdline = ' '.join([basename] + wds)
+                
+                # 2.b. Catch the standard '<script.py>' pattern (Original Logic)
+                elif wds[0] and os.path.exists(wds[0]) and os.path.isfile(wds[0]):
+                    script = os.path.basename(wds[0])
+                    if script != wds[0]:
+                        # Only elaborate if it's a clear script name, not a generic main
+                        if not re.search(r'^__main__\.', script):
+                            self.exebasename = f'{self.exebasename}->{script}'
+                            del wds[0] # Remove the script path from arguments
+
+            # --- END ELABORATION LOGIC ---
+
+            self.cmdline = ' '.join([self.exebasename] + wds)
             self.cmdline_trunc = self.cmdline[0:ProcMem.max_cmd_len]
-            # DB(0, f'basename={basename} cmdline_trunc={self.cmdline}')
+            
         except Exception as exc:
-            # not really expecting this ... probably a bug
+            # ... (rest of exception handling is the same)
             print(f'  WARNING: skip pid={self.pid} no-basename exc={exc}')
             print(traceback.format_exc())
             self.wanted = self.kernel = False
             self.why_not = 'CannotGetCmdline'
             return
 
-        ## print(f'DBDB: {self.pid} {ProcMem.opts.pids}')
         # filter unwanted before too much work
         if (ProcMem.opts.pids and str(self.pid) not in ProcMem.opts.pids
                 and self.exebasename not in ProcMem.opts.pids):
             self.wanted = False
             self.why_not = 'FilteredByArgs'
-            # print(f'    >>>> unwanted {pid}')
-        ## print(f'DBDB: {self.pid} wanted={self.wanted} why_not={self.why_not}')
+
         self.set_key()
 
     def set_key(self):
@@ -1235,7 +1398,12 @@ def rerun_module_as_root(module_name):
     """ rerun using the module name """
     if os.geteuid() != 0: # Re-run the script with sudo
         os.chdir(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-        vp = ['sudo', sys.executable, '-m', module_name] + sys.argv[1:]
+        # Preserve PYTHONPATH to allow sudo to find user-installed packages
+        pythonpath = os.pathsep.join(sys.path)
+        env_vars = os.environ.copy()
+        env_vars['PYTHONPATH'] = pythonpath
+        # Use env to pass PYTHONPATH through sudo
+        vp = ['sudo', 'env', f'PYTHONPATH={pythonpath}', sys.executable, '-m', module_name] + sys.argv[1:]
         os.execvp('sudo', vp)
 
 def main():

{pmemstat-3.0.2 → pmemstat-3.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "pmemstat"
-version = "3.0.2"
+version = "3.0.4"
 description = "Report Proportional Memory on Linux"
 authors = [
     {name = "Joe Defen", email = "joedef@duck.com"},
@@ -20,7 +20,7 @@ classifiers = [
 ]
 dependencies = [
     'psutil > 5.9',
-    'console-window >= 1.0.0',
+    'console-window >= 1.0.5',
 ]
 
 [project.urls]

pmemstat-3.0.4/runner

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# runner.py
+# Located in the top-level <svr pmemstat> directory
+
+import os
+import sys
+
+# Add the project directory to PYTHONPATH for editable install support
+project_dir = os.path.dirname(os.path.abspath(__file__))
+if project_dir not in sys.path:
+    sys.path.insert(0, project_dir)
+
+# Import and run the main module directly
+if __name__ == '__main__':
+    sys.argv[0] = 'pmemstat'
+    from pmemstat import main
+    main.run()

pmemstat-3.0.2/run.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-
-SRC="$(dirname "$0")/src"
-
-set -x
-##### choose one:
-
-PYTHONPATH="$SRC" python3 -m pmemstat.main "$@"
-# PYTHONPATH="$SRC" python3 src/pmemstat/main.py "$@"