src/daComposant/daCore/PlatformInfo.py

   1 #-*-coding:iso-8859-1-*-
   2 #
   3 #  Copyright (C) 2008-2009  EDF R&D
   4 #
   5 #  This library is free software; you can redistribute it and/or
   6 #  modify it under the terms of the GNU Lesser General Public
   7 #  License as published by the Free Software Foundation; either
   8 #  version 2.1 of the License.
   9 #
  10 #  This library is distributed in the hope that it will be useful,
  11 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 #  Lesser General Public License for more details.
  14 #
  15 #  You should have received a copy of the GNU Lesser General Public
  16 #  License along with this library; if not, write to the Free Software
  17 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 #
  19 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 #
  21 __doc__ = """
  22     Informations sur le code et la plateforme, et mise à jour des chemins
  23
  24     La classe "PlatformInfo" permet de récupérer les informations générales sur
  25     le code et la plateforme sous forme de strings, ou d'afficher directement
  26     les informations disponibles par les méthodes. L'impression directe d'un
  27     objet de cette classe affiche les informations minimales. Par exemple :
  28         print PlatformInfo()
  29         print PlatformInfo().getVersion()
  30         created = PlatformInfo().getDate()
  31
  32     La classe "PathManagement" permet de mettre à jour les chemins système pour
  33     ajouter les outils numériques, matrices... On l'utilise en instanciant
  34     simplement cette classe, sans meme récupérer d'objet :
  35         PathManagement()
  36 """
  37 __author__ = "Jean-Philippe ARGAUD - Mars 2008"
  38
  39 import os
  40
  41 # ==============================================================================
  42 class PlatformInfo:
  43     """
  44     Rassemblement des informations sur le code et la plateforme
  45     """
  46     def getName(self):
  47         "Retourne le nom de l'application"
  48         import version
  49         return version.name
  50
  51     def getVersion(self):
  52         "Retourne le numéro de la version"
  53         import version
  54         return version.version
  55
  56     def getDate(self):
  57         "Retourne la date de création de la version"
  58         import version
  59         return version.date
  60
  61     def getPythonVersion(self):
  62         "Retourne la version de python utilisée"
  63         import sys
  64         return ".".join(map(str,sys.version_info[0:3]))
  65
  66     def getNumpyVersion(self):
  67         "Retourne la version de numpy utilisée"
  68         import numpy.version
  69         return numpy.version.version
  70
  71     def getScipyVersion(self):
  72         "Retourne la version de scipy utilisée"
  73         import scipy.version
  74         return scipy.version.version
  75
  76     def getCurrentMemorySize(self):
  77         "Retourne la taille mémoire courante utilisée"
  78         return 1
  79
  80     def __str__(self):
  81         import version
  82         return "%s %s (%s)"%(version.name,version.version,version.date)
  83
  84 # ==============================================================================
  85 class PathManagement:
  86     """
  87     Mise à jour du path système pour les répertoires d'outils
  88     """
  89     def __init__(self):
  90         import os, sys
  91         parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
  92         self.__paths = {}
  93         self.__paths["daExternals"] = os.path.join(parent,"daExternals")
  94         self.__paths["daMatrices"]  = os.path.join(parent,"daMatrices")
  95         self.__paths["daNumerics"]  = os.path.join(parent,"daNumerics")
  96         #
  97         for v in self.__paths.values():
  98             sys.path.insert(0, v )
  99         #
 100         # Conserve en unique exemplaire chaque chemin
 101         sys.path = list(set(sys.path))
 102         del parent
 103
 104     def getpaths(self):
 105         """
 106         Renvoie le dictionnaire des chemins ajoutés
 107         """
 108         return self.__paths
 109
 110 # ==============================================================================
 111 class SystemUsage:
 112     """
 113     Permet de récupérer les différentes tailles mémoires du process courant
 114     """
 115     #
 116     # Le module resource renvoie 0 pour les tailles mémoire. On utilise donc
 117     # plutôt : http://code.activestate.com/recipes/286222/ et les infos de
 118     # http://www.redhat.com/docs/manuals/enterprise/RHEL-4-Manual/en-US/Reference_Guide/s2-proc-meminfo.html
 119     #
 120     _proc_status = '/proc/%d/status' % os.getpid()
 121     _memo_status = '/proc/meminfo'
 122     _scale = {
 123         'o': 1.0,
 124         'ko': 1024.0, 'mo': 1024.0*1024.0,
 125         'Ko': 1024.0, 'Mo': 1024.0*1024.0,
 126         'B':     1.0,
 127         'kB': 1024.0, 'mB': 1024.0*1024.0,
 128         'KB': 1024.0, 'MB': 1024.0*1024.0,
 129              }
 130     _max_mem = 0
 131     _max_rss = 0
 132     _max_sta = 0
 133     #
 134     def _VmA(self, VmKey, unit):
 135         try:
 136             t = open(self._memo_status)
 137             v = t.read()
 138             t.close()
 139         except:
 140             return 0.0           # non-Linux?
 141         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 142         v = v[i:].split(None, 3) # whitespace
 143         if len(v) < 3:
 144             return 0.0           # invalid format?
 145         # convert Vm value to bytes
 146         mem = float(v[1]) * self._scale[v[2]]
 147         return mem / self._scale[unit]
 148     #
 149     def getAvailablePhysicalMemory(self, unit="o"):
 150         "Renvoie la mémoire physique utilisable en octets"
 151         return self._VmA('MemTotal:', unit)
 152     #
 153     def getAvailableSwapMemory(self, unit="o"):
 154         "Renvoie la mémoire swap utilisable en octets"
 155         return self._VmA('SwapTotal:', unit)
 156     #
 157     def getAvailableMemory(self, unit="o"):
 158         "Renvoie la mémoire totale (physique+swap) utilisable en octets"
 159         return self._VmA('MemTotal:', unit) + self._VmA('SwapTotal:', unit)
 160     #
 161     def getUsableMemory(self, unit="o"):
 162         """Renvoie la mémoire utilisable en octets
 163         Rq : il n'est pas sûr que ce décompte soit juste...
 164         """
 165         return self._VmA('MemFree:', unit) + self._VmA('SwapFree:', unit) + \
 166                self._VmA('Cached:', unit) + self._VmA('SwapCached:', unit)
 167     #
 168     def _VmB(self, VmKey, unit):
 169         try:
 170             t = open(self._proc_status)
 171             v = t.read()
 172             t.close()
 173         except:
 174             return 0.0           # non-Linux?
 175         i = v.index(VmKey)       # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
 176         v = v[i:].split(None, 3) # whitespace
 177         if len(v) < 3:
 178             return 0.0           # invalid format?
 179         # convert Vm value to bytes
 180         mem = float(v[1]) * self._scale[v[2]]
 181         return mem / self._scale[unit]
 182     #
 183     def getUsedMemory(self, unit="o"):
 184         "Renvoie la mémoire totale utilisée en octets"
 185         mem = self._VmB('VmSize:', unit)
 186         self._max_mem = max(self._max_mem, mem)
 187         return mem
 188     #
 189     def getUsedResident(self, unit="o"):
 190         "Renvoie la mémoire résidente utilisée en octets"
 191         mem = self._VmB('VmRSS:', unit)
 192         self._max_rss = max(self._max_rss, mem)
 193         return mem
 194     #
 195     def getUsedStacksize(self, unit="o"):
 196         "Renvoie la taille du stack utilisé en octets"
 197         mem = self._VmB('VmStk:', unit)
 198         self._max_sta = max(self._max_sta, mem)
 199         return mem
 200     #
 201     def getMaxUsedMemory(self):
 202         "Renvoie la mémoire totale maximale mesurée"
 203         return self._max_mem
 204     #
 205     def getMaxUsedResident(self):
 206         "Renvoie la mémoire résidente maximale mesurée"
 207         return self._max_rss
 208     #
 209     def getMaxUsedStacksize(self):
 210         "Renvoie la mémoire du stack maximale mesurée"
 211         return self._max_sta
 212
 213 # ==============================================================================
 214 if __name__ == "__main__":
 215     print '\n AUTODIAGNOSTIC \n'
 216
 217     print PlatformInfo()
 218     print
 219     p = PlatformInfo()
 220     print "Les caractéristiques détaillées des applications et outils sont :"
 221     print "  - Application.......:",p.getName()
 222     print "  - Version...........:",p.getVersion()
 223     print "  - Date Application..:",p.getDate()
 224     print "  - Python............:",p.getPythonVersion()
 225     print "  - Numpy.............:",p.getNumpyVersion()
 226     print "  - Scipy.............:",p.getScipyVersion()
 227     print
 228
 229     p = PathManagement()
 230     print "Les chemins ajoutés au système pour des outils :"
 231     for k,v in p.getpaths().items():
 232         print "  %12s : %s"%(k,os.path.basename(v))
 233     print
 234
 235     m = SystemUsage()
 236     print "La mémoire disponible est la suivante :"
 237     print "  - mémoire totale....: %4.1f Mo"%m.getAvailableMemory("Mo")
 238     print "  - mémoire physique..: %4.1f Mo"%m.getAvailablePhysicalMemory("Mo")
 239     print "  - mémoire swap......: %4.1f Mo"%m.getAvailableSwapMemory("Mo")
 240     print "  - utilisable........: %4.1f Mo"%m.getUsableMemory("Mo")
 241     print "L'usage mémoire de cette exécution est le suivant :"
 242     print "  - mémoire totale....: %4.1f Mo"%m.getUsedMemory("Mo")
 243     print "  - mémoire résidente.: %4.1f Mo"%m.getUsedResident("Mo")
 244     print "  - taille de stack...: %4.1f Mo"%m.getUsedStacksize("Mo")
 245     print "Création d'un objet range(1000000) et mesure mémoire"
 246     x = range(1000000)
 247     print "  - mémoire totale....: %4.1f Mo"%m.getUsedMemory("Mo")
 248     print "Destruction de l'objet et mesure mémoire"
 249     del x
 250     print "  - mémoire totale....: %4.1f Mo"%m.getUsedMemory("Mo")
 251     print "L'usage mémoire maximal de cette exécution est le suivant :"
 252     print "  - mémoire totale....: %4.1f Mo"%m.getMaxUsedMemory()
 253     print "  - mémoire résidente.: %4.1f Mo"%m.getMaxUsedResident()
 254     print "  - taille de stack...: %4.1f Mo"%m.getMaxUsedStacksize()
 255     print