src/daComposant/daCore/PlatformInfo.py

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