src/Container/SALOME_ContainerHelper.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2023  CEA, EDF
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 from collections import defaultdict
  22
  23 class ScriptExecInfo:
  24     @classmethod
  25     def GetRepresentationOfTimeDelta(cls,endTime, startTime):
  26        if endTime is None and startTime is None:
  27           return "not measured"
  28        td = endTime - startTime
  29        import time
  30        ts_of_td = time.gmtime(td.total_seconds())
  31        return "{}.{:06d}".format(time.strftime("%H:%M:%S",ts_of_td),td.microseconds)
  32
  33     @classmethod
  34     def MemRepr(cls,memInByte):
  35       m = memInByte
  36       UNITS=["B","kB","MB","GB"]
  37       remain = 0
  38       oss = ""
  39       for i in range( len(UNITS) ):
  40           if m<1024:
  41               oss = "{:03d}".format( int( (remain/1024)*1000 ) )
  42               oss = "{}.{} {}".format(m,oss,UNITS[i])
  43               return oss
  44           else:
  45               if i!=3:
  46                   remain = m%1024
  47                   m//=1024
  48       return "{} {}".format(m,UNITS[3])
  49
  50     def __init__(self):
  51       self._cpu_mem_during_exec = None
  52       self._start_exec_time = None
  53       self._end_exec_time = None
  54       self._start_input_time = None
  55       self._end_input_time = None
  56       self._start_output_time = None
  57       self._end_output_time = None
  58       self._input_mem = 0
  59       self._input_hdd_mem = None
  60       self._output_mem = 0
  61       self._output_hdd_mem = None
  62
  63     @property
  64     def CPUMemDuringExec(self):
  65       return self._cpu_mem_during_exec
  66
  67     @CPUMemDuringExec.setter
  68     def CPUMemDuringExec(self,value):
  69       self._cpu_mem_during_exec = value
  70
  71     @property
  72     def CPUMemDuringExecStr(self):
  73       cpu = self._cpu_mem_during_exec[::2]
  74       mem_rss = self._cpu_mem_during_exec[1::2]
  75       return [(a,ScriptExecInfo.MemRepr(b)) for a,b in self._cpu_mem_during_exec]
  76
  77     @property
  78     def inputMem(self):
  79       return self._input_mem
  80
  81     @inputMem.setter
  82     def inputMem(self,value):
  83       self._input_mem = value
  84
  85     @property
  86     def inputMemStr(self):
  87       return ScriptExecInfo.MemRepr( self.inputMem )
  88
  89     @property
  90     def outputMem(self):
  91       return self._output_mem
  92
  93     @outputMem.setter
  94     def outputMem(self,value):
  95       self._output_mem = value
  96
  97     @property
  98     def outputMemStr(self):
  99       return ScriptExecInfo.MemRepr( self.outputMem )
 100
 101     @property
 102     def inputHDDMem(self):
 103       return self._input_hdd_mem
 104
 105     @inputHDDMem.setter
 106     def inputHDDMem(self,value):
 107       self._input_hdd_mem = value
 108
 109     @property
 110     def inputHDDMemStr(self):
 111       if self._input_hdd_mem is None:
 112          return "not computed"
 113       return " ".join( [ ScriptExecInfo.MemRepr( elt.getSizeOfFileRead() ) for elt in self._input_hdd_mem] )
 114
 115     @property
 116     def outputHDDMem(self):
 117       return self._output_hdd_mem
 118
 119     @outputHDDMem.setter
 120     def outputHDDMem(self,value):
 121       self._output_hdd_mem = value
 122
 123     @property
 124     def outputHDDMemStr(self):
 125       if self._output_hdd_mem is None:
 126          return "not computed"
 127       return " ".join( [ ScriptExecInfo.MemRepr( elt.getSizeOfFileRead() ) for elt in self._output_hdd_mem] )
 128
 129     @property
 130     def startInputTime(self):
 131       return self._start_input_time
 132
 133     @startInputTime.setter
 134     def startInputTime(self,value):
 135       self._start_input_time = value
 136
 137     @property
 138     def endInputTime(self):
 139       return self._end_input_time
 140
 141     @endInputTime.setter
 142     def endInputTime(self,value):
 143       self._end_input_time = value
 144
 145     @property
 146     def startExecTime(self):
 147       return self._start_exec_time
 148
 149     @startExecTime.setter
 150     def startExecTime(self,value):
 151       self._start_exec_time = value
 152
 153     @property
 154     def endExecTime(self):
 155       return self._end_exec_time
 156
 157     @endExecTime.setter
 158     def endExecTime(self,value):
 159       self._end_exec_time = value
 160
 161     @property
 162     def startOutputTime(self):
 163       return self._start_output_time
 164
 165     @startOutputTime.setter
 166     def startOutputTime(self,value):
 167       self._start_output_time = value
 168
 169     @property
 170     def endOutputTime(self):
 171       return self._end_output_time
 172
 173     @endOutputTime.setter
 174     def endOutputTime(self,value):
 175       self._end_output_time = value
 176
 177     @property
 178     def execTimeStr(self):
 179        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endExecTime,self.startExecTime)
 180
 181     @property
 182     def inputTimeStr(self):
 183        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endInputTime,self.startInputTime)
 184
 185     @property
 186     def outputTimeStr(self):
 187        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endOutputTime,self.startOutputTime)
 188
 189     def __str__(self):
 190       return """start exec time = {self.startExecTime}
 191 end exec time = {self.endExecTime}
 192 exec_time = {self.execTimeStr}
 193 CPU and mem monitoring = {self.CPUMemDuringExecStr}
 194 input unpickling and ev load from disk time = {self.inputTimeStr}
 195 output serialization and ev write to disk time = {self.outputTimeStr}
 196 input memory size before exec (MemoryPeak 2x) = {self.inputMemStr}
 197 input memory size from HDD = {self.inputHDDMemStr}
 198 output memory size after exec (MemoryPeak 2x) = {self.outputMemStr}
 199 output memory size from HDD = {self.outputHDDMemStr}""".format(**locals())
 200
 201 class ScriptInfo:
 202   def __init__(self, nodeName):
 203       self._node_name = nodeName
 204       self._code = ""
 205       self._exec = defaultdict(ScriptExecInfo)
 206
 207   @property
 208   def execs(self):
 209       return self._exec
 210
 211   @property
 212   def nodeName(self):
 213       return self._node_name
 214
 215   @property
 216   def code(self):
 217       return self._code
 218
 219   @code.setter
 220   def code(self,value):
 221       self._code = value
 222
 223   def __str__(self):
 224       return """code = {self.code}\nexecs = {self.execs}""".format(**locals())
 225
 226   def __repr__(self):
 227       return """ScriptInfo \"{self.nodeName}\"""".format(**locals())
 228
 229 from abc import ABC, abstractmethod
 230
 231 class InOutputObjVisitorAbstract(ABC):
 232   def __init__(self):
 233       self._cur_obj = None
 234       self._data = []
 235
 236   def enter(self):
 237       self._cur_obj = ObjMemModel()
 238       return self._cur_obj
 239
 240   def leave(self):
 241       self._data.append( self._cur_obj )
 242       self._cur_obj = None
 243
 244   def getSizeOfFileRead(self):
 245       return sum( [elt.getSizeOfFileRead() for elt in self._data] )
 246
 247   def visitor(self):
 248       return self
 249
 250   def setHDDMem(self, v):
 251       pass
 252
 253   def setFileName(self, fileName):
 254       pass
 255
 256   @abstractmethod
 257   def getRepr(self):
 258       pass
 259
 260 class InOutputObjVisitorIter:
 261   def __init__(self, visitor):
 262       self._visitor = visitor
 263       self._current = 0
 264
 265   def __next__(self):
 266       if self._current >= len(self._visitor._data):
 267             raise StopIteration
 268       else:
 269         ret = self._visitor._data[ self._current ]
 270         self._current += 1
 271         return ret
 272
 273 class InOutputObjVisitor(InOutputObjVisitorAbstract):
 274   def __init__(self):
 275       super().__init__()
 276
 277   def getRepr(self):
 278       return self.getSizeOfFileRead()
 279
 280   def __iter__(self):
 281      return InOutputObjVisitorIter(self)
 282
 283 class ObjMemModel(InOutputObjVisitorAbstract):
 284   def __init__(self):
 285       super().__init__()
 286       self._hdd_mem = 0
 287       self._file_name = None
 288
 289   def setHDDMem(self, v):
 290       self._hdd_mem = v
 291       del self._data
 292
 293   def setFileName(self, fileName):
 294       self._file_name = fileName
 295       pass
 296
 297   def getSizeOfFileRead(self):
 298       if hasattr(self,"_data"):
 299         return super().getSizeOfFileRead()
 300       else:
 301         return self._hdd_mem
 302
 303   def getRepr(self):
 304       return self.getSizeOfFileRead()
 305
 306 class FakeObjVisitor:
 307   def setHDDMem(self, v):
 308       pass
 309
 310   def visitor(self):
 311       return None
 312
 313 class InOutputObjVisitorCM:
 314   def __init__(self, visitor):
 315      self._visitor = visitor
 316   def __enter__(self):
 317       if self._visitor:
 318         r = self._visitor.enter()
 319         return r
 320       else:
 321         return FakeObjVisitor()
 322   def __exit__(self,exctype, exc, tb):
 323       if self._visitor:
 324         self._visitor.leave()
 325       pass