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._start_exec_time = None
  52       self._end_exec_time = None
  53       self._start_input_time = None
  54       self._end_input_time = None
  55       self._start_output_time = None
  56       self._end_output_time = None
  57       self._input_mem = 0
  58       self._input_hdd_mem = None
  59       self._output_mem = 0
  60       self._output_hdd_mem = None
  61
  62     @property
  63     def inputMem(self):
  64       return self._input_mem
  65
  66     @inputMem.setter
  67     def inputMem(self,value):
  68       self._input_mem = value
  69
  70     @property
  71     def inputMemStr(self):
  72       return ScriptExecInfo.MemRepr( self.inputMem )
  73
  74     @property
  75     def outputMem(self):
  76       return self._output_mem
  77
  78     @outputMem.setter
  79     def outputMem(self,value):
  80       self._output_mem = value
  81
  82     @property
  83     def outputMemStr(self):
  84       return ScriptExecInfo.MemRepr( self.outputMem )
  85
  86     @property
  87     def inputHDDMem(self):
  88       return self._input_hdd_mem
  89
  90     @inputHDDMem.setter
  91     def inputHDDMem(self,value):
  92       self._input_hdd_mem = value
  93
  94     @property
  95     def inputHDDMemStr(self):
  96       if self._input_hdd_mem is None:
  97          return "not computed"
  98       return " ".join( [ ScriptExecInfo.MemRepr( elt.getSizeOfFileRead() ) for elt in self._input_hdd_mem] )
  99
 100     @property
 101     def outputHDDMem(self):
 102       return self._output_hdd_mem
 103
 104     @outputHDDMem.setter
 105     def outputHDDMem(self,value):
 106       self._output_hdd_mem = value
 107
 108     @property
 109     def outputHDDMemStr(self):
 110       if self._output_hdd_mem is None:
 111          return "not computed"
 112       return " ".join( [ ScriptExecInfo.MemRepr( elt.getSizeOfFileRead() ) for elt in self._output_hdd_mem] )
 113
 114     @property
 115     def startInputTime(self):
 116       return self._start_input_time
 117
 118     @startInputTime.setter
 119     def startInputTime(self,value):
 120       self._start_input_time = value
 121
 122     @property
 123     def endInputTime(self):
 124       return self._end_input_time
 125
 126     @endInputTime.setter
 127     def endInputTime(self,value):
 128       self._end_input_time = value
 129
 130     @property
 131     def startExecTime(self):
 132       return self._start_exec_time
 133
 134     @startExecTime.setter
 135     def startExecTime(self,value):
 136       self._start_exec_time = value
 137
 138     @property
 139     def endExecTime(self):
 140       return self._end_exec_time
 141
 142     @endExecTime.setter
 143     def endExecTime(self,value):
 144       self._end_exec_time = value
 145
 146     @property
 147     def startOutputTime(self):
 148       return self._start_output_time
 149
 150     @startOutputTime.setter
 151     def startOutputTime(self,value):
 152       self._start_output_time = value
 153
 154     @property
 155     def endOutputTime(self):
 156       return self._end_output_time
 157
 158     @endOutputTime.setter
 159     def endOutputTime(self,value):
 160       self._end_output_time = value
 161
 162     @property
 163     def execTimeStr(self):
 164        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endExecTime,self.startExecTime)
 165
 166     @property
 167     def inputTimeStr(self):
 168        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endInputTime,self.startInputTime)
 169
 170     @property
 171     def outputTimeStr(self):
 172        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endOutputTime,self.startOutputTime)
 173
 174     def __str__(self):
 175       return """start exec time = {self.startExecTime}
 176 end exec time = {self.endExecTime}
 177 exec_time = {self.execTimeStr}
 178 input unpickling and ev load from disk time = {self.inputTimeStr}
 179 output serialization and ev write to disk time = {self.outputTimeStr}
 180 input memory size before exec (MemoryPeak 2x) = {self.inputMemStr}
 181 input memory size from HDD = {self.inputHDDMemStr}
 182 output memory size after exec (MemoryPeak 2x) = {self.outputMemStr}
 183 output memory size from HDD = {self.outputHDDMemStr}""".format(**locals())
 184
 185 class ScriptInfo:
 186   def __init__(self, nodeName):
 187       self._node_name = nodeName
 188       self._code = ""
 189       self._exec = defaultdict(ScriptExecInfo)
 190
 191   @property
 192   def execs(self):
 193       return self._exec
 194
 195   @property
 196   def nodeName(self):
 197       return self._node_name
 198
 199   @property
 200   def code(self):
 201       return self._code
 202
 203   @code.setter
 204   def code(self,value):
 205       self._code = value
 206
 207   def __str__(self):
 208       return """code = {self.code}\nexecs = {self.execs}""".format(**locals())
 209
 210   def __repr__(self):
 211       return """ScriptInfo \"{self.nodeName}\"""".format(**locals())
 212
 213 from abc import ABC, abstractmethod
 214
 215 class InOutputObjVisitorAbstract(ABC):
 216   def __init__(self):
 217       self._cur_obj = None
 218       self._data = []
 219
 220   def enter(self):
 221       self._cur_obj = ObjMemModel()
 222       return self._cur_obj
 223
 224   def leave(self):
 225       self._data.append( self._cur_obj )
 226       self._cur_obj = None
 227
 228   def getSizeOfFileRead(self):
 229       return sum( [elt.getSizeOfFileRead() for elt in self._data] )
 230
 231   def visitor(self):
 232       return self
 233
 234   def setHDDMem(self, v):
 235       pass
 236
 237   def setFileName(self, fileName):
 238       pass
 239
 240   @abstractmethod
 241   def getRepr(self):
 242       pass
 243
 244 class InOutputObjVisitorIter:
 245   def __init__(self, visitor):
 246       self._visitor = visitor
 247       self._current = 0
 248
 249   def __next__(self):
 250       if self._current >= len(self._visitor._data):
 251             raise StopIteration
 252       else:
 253         ret = self._visitor._data[ self._current ]
 254         self._current += 1
 255         return ret
 256
 257 class InOutputObjVisitor(InOutputObjVisitorAbstract):
 258   def __init__(self):
 259       super().__init__()
 260
 261   def getRepr(self):
 262       return self.getSizeOfFileRead()
 263
 264   def __iter__(self):
 265      return InOutputObjVisitorIter(self)
 266
 267 class ObjMemModel(InOutputObjVisitorAbstract):
 268   def __init__(self):
 269       super().__init__()
 270       self._hdd_mem = 0
 271       self._file_name = None
 272
 273   def setHDDMem(self, v):
 274       self._hdd_mem = v
 275       del self._data
 276
 277   def setFileName(self, fileName):
 278       self._file_name = fileName
 279       pass
 280
 281   def getSizeOfFileRead(self):
 282       if hasattr(self,"_data"):
 283         return super().getSizeOfFileRead()
 284       else:
 285         return self._hdd_mem
 286
 287   def getRepr(self):
 288       return self.getSizeOfFileRead()
 289
 290 class FakeObjVisitor:
 291   def setHDDMem(self, v):
 292       pass
 293
 294   def visitor(self):
 295       return None
 296
 297 class InOutputObjVisitorCM:
 298   def __init__(self, visitor):
 299      self._visitor = visitor
 300   def __enter__(self):
 301       if self._visitor:
 302         r = self._visitor.enter()
 303         return r
 304       else:
 305         return FakeObjVisitor()
 306   def __exit__(self,exctype, exc, tb):
 307       if self._visitor:
 308         self._visitor.leave()
 309       pass