]> SALOME platform Git repositories - modules/kernel.git/blob - src/Container/SALOME_ContainerHelper.py
Salome HOME
add options-help get from launcher
[modules/kernel.git] / src / Container / SALOME_ContainerHelper.py
1 #  -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2023-2024  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 import pickle
24
25 class ScriptExecInfo:
26     @classmethod
27     def GetRepresentationOfTimeDelta(cls,endTime, startTime):
28        if endTime is None and startTime is None:
29           return "not measured"
30        td = endTime - startTime
31        import time
32        ts_of_td = time.gmtime(td.total_seconds())
33        return "{}.{:06d}".format(time.strftime("%H:%M:%S",ts_of_td),td.microseconds)
34     
35     @classmethod
36     def MemRepr(cls,memInByte):
37       m = int( memInByte )
38       UNITS=["B","kB","MB","GB"]
39       remain = 0
40       oss = ""
41       for i in range( len(UNITS) ):
42           if m<1024:
43               oss = "{:03d}".format( int( (remain/1024)*1000 ) )
44               oss = "{}.{} {}".format(m,oss,UNITS[i])
45               return oss
46           else:
47               if i!=3:
48                   remain = m%1024
49                   m//=1024
50       return "{} {}".format(m,UNITS[3])
51     
52     @classmethod
53     def SpeedRepr(cls,memInBytePerS):
54        return "{}/s".format( cls.MemRepr(memInBytePerS) )
55
56     def __init__(self):
57       self._measure_time_resolution_ms = None
58       self._cpu_mem_during_exec = None
59       self._start_exec_time = None
60       self._end_exec_time = None
61       self._start_input_time = None
62       self._end_input_time = None
63       self._start_output_time = None
64       self._end_output_time = None
65       self._input_mem = 0
66       self._input_hdd_mem = None
67       self._output_mem = 0
68       self._output_hdd_mem = None
69       self._start_pos_log = None
70       self._stop_pos_log = None
71       self._freestyle_log = []
72
73     @property
74     def freestyle(self):
75        return self._freestyle_log
76     
77     @freestyle.setter
78     def freestyle(self, value):
79        self._freestyle_log.append( value )
80
81     @property
82     def measureTimeResolution(self):
83       return self._measure_time_resolution_ms
84     
85     @measureTimeResolution.setter
86     def measureTimeResolution(self, value):
87       self._measure_time_resolution_ms = value
88
89     @property
90     def tracePosStart(self):
91       return self._start_pos_log
92     
93     @tracePosStart.setter
94     def tracePosStart(self,value):
95       self._start_pos_log = value
96
97     @property
98     def tracePosStop(self):
99       return self._stop_pos_log
100     
101     @tracePosStop.setter
102     def tracePosStop(self,value):
103       self._stop_pos_log = value
104       
105     @property
106     def CPUMemDuringExec(self):
107       return self._cpu_mem_during_exec
108     
109     @CPUMemDuringExec.setter
110     def CPUMemDuringExec(self,value):
111       self._cpu_mem_during_exec = value
112
113     @property
114     def CPUMemDuringExecStr(self):
115       return [(a,ScriptExecInfo.MemRepr(b)) for a,b in self._cpu_mem_during_exec.data]
116
117     @property
118     def inputMem(self):
119       return self._input_mem
120     
121     @inputMem.setter
122     def inputMem(self,value):
123       self._input_mem = value
124        
125     @property
126     def inputMemStr(self):
127       return ScriptExecInfo.MemRepr( self.inputMem )
128     
129     @property
130     def outputMem(self):
131       return self._output_mem
132     
133     @outputMem.setter
134     def outputMem(self,value):
135       self._output_mem = value
136        
137     @property
138     def outputMemStr(self):
139       return ScriptExecInfo.MemRepr( self.outputMem )
140     
141     def inputReadHDDSize(self):
142        return self.inputHDDMem.getSizeOfFileRead()
143     
144     def inputReadHDDSizeRepr(self):
145        return ScriptExecInfo.MemRepr( self.inputReadHDDSize() )
146     
147     def inputReadHDDSpeed(self):
148        return self.inputReadHDDSize() / ( self.endInputTime - self.startInputTime ).total_seconds()
149     
150     def inputReadHDDSpeedRepr(self):
151        return ScriptExecInfo.SpeedRepr( self.inputReadHDDSpeed() )
152     
153     def outputWriteHDDSize(self):
154        return self.outputHDDMem.getSizeOfFileRead()
155     
156     def outputWriteHDDSizeRepr(self):
157        return ScriptExecInfo.MemRepr( self.outputWriteHDDSize() )
158
159     def outputWriteHDDSpeed(self):
160       return self.outputWriteHDDSize() / ( self.endOutputTime - self.startOutputTime ).total_seconds()
161     
162     def outputWriteHDDSpeedRepr(self):
163       return ScriptExecInfo.SpeedRepr( self.outputWriteHDDSpeed() )
164     
165     @property
166     def inputHDDMem(self):
167       return self._input_hdd_mem
168     
169     @inputHDDMem.setter
170     def inputHDDMem(self,value):
171       self._input_hdd_mem = value
172
173     @property
174     def inputHDDMemStr(self):
175       if self._input_hdd_mem is None:
176          return "not computed"
177       return " ".join( [ ScriptExecInfo.MemRepr( elt.getSizeOfFileRead() ) for elt in self._input_hdd_mem] )
178     
179     @property
180     def outputHDDMem(self):
181       return self._output_hdd_mem
182     
183     @outputHDDMem.setter
184     def outputHDDMem(self,value):
185       self._output_hdd_mem = value
186
187     @property
188     def outputHDDMemStr(self):
189       if self._output_hdd_mem is None:
190          return "not computed"
191       return " ".join( [ ScriptExecInfo.MemRepr( elt.getSizeOfFileRead() ) for elt in self._output_hdd_mem] )
192
193     @property
194     def startInputTime(self):
195       return self._start_input_time
196     
197     @startInputTime.setter
198     def startInputTime(self,value):
199       self._start_input_time = value
200
201     @property
202     def endInputTime(self):
203       return self._end_input_time
204     
205     @endInputTime.setter
206     def endInputTime(self,value):
207       self._end_input_time = value
208
209     @property
210     def startExecTime(self):
211       return self._start_exec_time
212     
213     @startExecTime.setter
214     def startExecTime(self,value):
215       self._start_exec_time = value
216
217     @property
218     def endExecTime(self):
219       return self._end_exec_time
220     
221     @endExecTime.setter
222     def endExecTime(self,value):
223       self._end_exec_time = value
224
225     @property
226     def execTime(self):
227       if ( self.endExecTime is not None ) and (self.startExecTime is not None):
228         return self.endExecTime - self.startExecTime
229       return None
230     
231     @property
232     def fullExecTime(self):
233       return self.endOutputTime - self.startInputTime
234
235     @property
236     def startOutputTime(self):
237       return self._start_output_time
238     
239     @startOutputTime.setter
240     def startOutputTime(self,value):
241       self._start_output_time = value
242
243     @property
244     def endOutputTime(self):
245       return self._end_output_time
246     
247     @endOutputTime.setter
248     def endOutputTime(self,value):
249       self._end_output_time = value
250
251     @property
252     def execTimeStr(self):
253        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endExecTime,self.startExecTime)
254     
255     @property
256     def inputTimeStr(self):
257        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endInputTime,self.startInputTime)
258     
259     @property
260     def outputTimeStr(self):
261        return ScriptExecInfo.GetRepresentationOfTimeDelta(self.endOutputTime,self.startOutputTime)
262
263     def __str__(self):
264       CPUMemDuringExecForStr = self.CPUMemDuringExecStr
265       if len( CPUMemDuringExecForStr ) > 30:
266          CPUMemDuringExecForStr = "{} ...".format( str(CPUMemDuringExecForStr[:30]) )
267       else:
268          CPUMemDuringExecForStr = str( CPUMemDuringExecForStr )
269       return """start exec time = {self.startExecTime}
270 end exec time = {self.endExecTime}
271 exec_time = {self.execTimeStr}
272 Measure time resolution = {self.measureTimeResolution} ms
273 CPU and mem monitoring = {CPUMemDuringExecForStr}
274 input unpickling and ev load from disk time = {self.inputTimeStr}
275 output serialization and ev write to disk time = {self.outputTimeStr}
276 input memory size before exec (MemoryPeak 2x) = {self.inputMemStr}
277 input memory size from HDD = {self.inputHDDMemStr}
278 output memory size after exec (MemoryPeak 2x) = {self.outputMemStr}
279 output memory size from HDD = {self.outputHDDMemStr}
280 Start position in log = {self.tracePosStart}
281 End position in log = {self.tracePosStop}""".format(**locals())
282
283 class ScriptExecInfoDeco:
284   def __init__(self, eff, father):
285     self._eff = eff
286     self._father = father
287   @property
288   def father(self):
289     return self._father
290   def get(self):
291     return self._eff
292   def __getitem__(self,i):
293     return self._eff[i]
294   def __str__(self):
295     return self._eff.__str__()
296   def __repr__(self):
297     return self._eff.__repr__()
298   def log(self):
299     with open(self.father.father.logfile,"rb") as f:
300        cont = f.read()
301     return cont[self._eff.tracePosStart:self._eff.tracePosStop].decode()
302   @property
303   def nodeName(self):
304     return self.father.get().nodeName
305   @property
306   def code(self):
307     return self.father.code
308   @property
309   def ns_entry(self):
310     return self.father.father.ns_entry
311   @property
312   def computingNode(self):
313     return self.father.computingNode
314   
315   @property
316   def freestyle(self):
317       return self.get().freestyle
318   
319   @property
320   def measureTimeResolution(self):
321     return self.get().measureTimeResolution
322     
323   @property
324   def CPUMemDuringExec(self):
325     return self.get().CPUMemDuringExec
326
327   @property
328   def inputMem(self):
329     return self.get().inputMem
330   
331   @property
332   def outputMem(self):
333     return self.get().outputMem
334   
335   @property
336   def inputHDDMem(self):
337     return self.get().inputHDDMem
338   
339   @property
340   def outputHDDMem(self):
341     return self.get().outputHDDMem
342   
343   def inputReadHDDSize(self):
344     return self.get().inputReadHDDSize()
345   
346   def inputReadHDDSizeRepr(self):
347     return self.get().inputReadHDDSizeRepr()
348   
349   def inputReadHDDSpeed(self):
350     return self.get().inputReadHDDSpeed()
351   
352   def inputReadHDDSpeedRepr(self):
353     return self.get().inputReadHDDSpeedRepr()
354   
355   def outputWriteHDDSize(self):
356     return self.get().outputWriteHDDSize()
357   
358   def outputWriteHDDSizeRepr(self):
359     return self.get().outputWriteHDDSizeRepr()
360   
361   def outputWriteHDDSpeed(self):
362     return self.get().outputWriteHDDSpeed()
363   
364   def outputWriteHDDSpeedRepr(self):
365     return self.get().outputWriteHDDSpeedRepr()
366
367   @property
368   def startInputTime(self):
369     return self.get().startInputTime
370
371   @property
372   def endInputTime(self):
373     return self.get().endInputTime
374
375   @property
376   def startExecTime(self):
377     return self.get().startExecTime
378
379   @property
380   def endExecTime(self):
381     return self.get().endExecTime
382
383   @property
384   def execTime(self):
385     return self.get().execTime
386   
387   @property
388   def fullExecTime(self):
389      return self.get().fullExecTime
390
391   @property
392   def startOutputTime(self):
393     return self.get().startOutputTime
394
395   @property
396   def endOutputTime(self):
397     return self.get().endOutputTime
398
399 class ScriptInfoAbstract:
400   def __init__(self, scriptPtr):
401       self._node_name = scriptPtr.getName()
402       self._code = scriptPtr.getCode()
403       self._exec = [pickle.loads(elt.getObj()) for elt in scriptPtr.listOfExecs()]
404
405   @property
406   def execs(self):
407       return self._exec
408
409   @property
410   def nodeName(self):
411       return self._node_name
412
413   @property
414   def code(self):
415       return self._code
416   
417   @code.setter
418   def code(self,value):
419       self._code = value
420
421   def __len__(self):
422       return len( self._exec )
423   
424   def __getitem__(self,i):
425       return self._exec[i]
426
427   def __str__(self):
428       return """name = {self.nodeName}\ncode = {self.code}\nexecs = {self.execs}""".format(**locals())
429   
430   def __repr__(self):
431       return """ScriptInfo \"{self.nodeName}\"""".format(**locals())
432   
433 class ScriptInfoClt(ScriptInfoAbstract):
434   def __init__(self, scriptPtr):
435       def unPickledSafe( dataPickled ):
436         if len(dataPickled) > 0:
437           return pickle.loads(dataPickled)
438         else:
439            return None  
440       self._node_name = scriptPtr.getName()
441       self._code = scriptPtr.getCode()
442       self._exec = [unPickledSafe(elt.getObj()) for elt in scriptPtr.listOfExecs()]
443
444 class ScriptInfo(ScriptInfoAbstract):
445   def __init__(self, nodeName, code, execs):
446       self._node_name = nodeName
447       self._code = code
448       self._exec = execs
449
450 class ScriptInfoDeco:
451   def __init__(self, eff, father):
452     self._eff = eff
453     self._father = father
454   @property
455   def father(self):
456     return self._father
457   def get(self):
458     return self._eff
459   @property
460   def nodeName(self):
461     return self.get().nodeName
462   @property
463   def code(self):
464     return self.get().code
465   @property
466   def ns_entry(self):
467     return self.father.ns_entry
468   @property
469   def computingNode(self):
470     return self.father.computingNode
471   def __getitem__(self,i):
472     return ScriptExecInfoDeco( self._eff[i], self )
473   def __len__(self):
474     return self._eff.__len__()
475   def __str__(self):
476     return self._eff.__str__()
477   def __repr__(self):
478     return self._eff.__repr__()
479
480 class ContainerLogInfoAbstract:
481   
482   @property
483   def log(self):
484     with open(self.logfile,"rb") as f:
485        cont = f.read()
486     return cont.decode()
487
488   @property
489   def ns_entry(self):
490     return self._ns_entry
491   
492   @property
493   def logfile(self):
494     return self._log_file
495   
496   @property
497   def computingNode(self):
498     return ContainerLogInfoAbstract.ComputingNodeFromNSEntry( self.ns_entry )
499   
500   def __len__(self):
501     return len( self._scripts )
502   
503   def __getitem__(self,i):
504     return ScriptInfoDeco( self._scripts[i], self)
505   
506   def __str__(self):
507     return """NS entry = {self.ns_entry} LogFile = {self.logfile}""".format(**locals())
508   
509   @classmethod
510   def ComputingNodeFromNSEntry(cls, nsEntry):
511     return nsEntry.split("/")[2]
512   
513 class ContainerLogInfoClt(ContainerLogInfoAbstract):
514   def __init__(self,contLogPtr):
515     self._log_file = contLogPtr.getLogFile()
516     self._ns_entry = contLogPtr.getContainerEntryInNS()
517     self._scripts = [ScriptInfoClt(elt) for elt in contLogPtr.listOfScripts()]
518     
519 class ContainerLogInfo(ContainerLogInfoAbstract):
520   def __init__(self, nsEntry, logFile, scripts):
521      self._log_file = logFile
522      self._ns_entry = nsEntry
523      self._scripts = scripts
524
525 from abc import ABC, abstractmethod
526
527 class InOutputObjVisitorAbstract(ABC):
528   def __init__(self):
529       self._cur_obj = None
530       self._data = []
531
532   def enter(self):
533       self._cur_obj = ObjMemModel()
534       return self._cur_obj
535   
536   def leave(self):
537       self._data.append( self._cur_obj )
538       self._cur_obj = None
539
540   def getSizeOfFileRead(self):
541       return sum( [elt.getSizeOfFileRead() for elt in self._data] )
542       
543   def visitor(self):
544       return self
545
546   def setHDDMem(self, v):
547       pass
548   
549   def setFileName(self, fileName):
550       pass
551
552   @abstractmethod
553   def getRepr(self):
554       pass
555
556 class InOutputObjVisitorIter:
557   def __init__(self, visitor):
558       self._visitor = visitor
559       self._current = 0
560
561   def __next__(self):
562       if self._current >= len(self._visitor._data):
563             raise StopIteration
564       else:
565         ret = self._visitor._data[ self._current ]
566         self._current += 1
567         return ret
568
569 class InOutputObjVisitor(InOutputObjVisitorAbstract):
570   def __init__(self):
571       super().__init__()
572       
573   def getRepr(self):
574       return self.getSizeOfFileRead()
575   
576   def __iter__(self):
577      return InOutputObjVisitorIter(self)
578
579 class ObjMemModel(InOutputObjVisitorAbstract):
580   def __init__(self):
581       super().__init__()
582       self._hdd_mem = 0
583       self._file_name = None
584       
585   def setHDDMem(self, v):
586       self._hdd_mem = v
587       del self._data
588
589   def setFileName(self, fileName):
590       self._file_name = fileName
591       pass
592       
593   def getSizeOfFileRead(self):
594       if hasattr(self,"_data"):
595         return super().getSizeOfFileRead()
596       else:
597         return self._hdd_mem
598   
599   def getRepr(self):
600       return self.getSizeOfFileRead()
601
602 class FakeObjVisitor:
603   def setHDDMem(self, v):
604       pass
605   
606   def setFileName(self, fileName):
607       pass
608     
609   def visitor(self):
610       return None
611
612 class InOutputObjVisitorCM:
613   def __init__(self, visitor):
614      self._visitor = visitor
615   def __enter__(self):
616       if self._visitor:
617         r = self._visitor.enter()
618         return r
619       else:
620         return FakeObjVisitor()
621   def __exit__(self,exctype, exc, tb):
622       if self._visitor:
623         self._visitor.leave()
624       pass
625   
626 class OffsetType:
627   def __init__(self,i):
628     self._i = i
629   def __int__(self):
630     return self._i
631   def __iadd__(self,delta):
632     self._i += delta
633     return self
634
635 def unserializeInt(structData, offset):
636     from ctypes import c_int
637     sz_of_cint = 4
638     sz = c_int.from_buffer_copy( structData[int(offset):int(offset)+sz_of_cint] ).value
639     offset += sz_of_cint
640     return sz
641
642 def unserializeString(structData,offset):
643     sz = unserializeInt(structData,offset)
644     ret = structData[int(offset):int(offset)+sz].decode()
645     offset += sz
646     return ret
647
648 def unserializeContainerScriptExecPerfLog(structData, offset):
649     import pickle
650     sz = unserializeInt(structData,offset)
651     inst = None
652     if sz > 0:
653         inst = pickle.loads( structData[int(offset):int(offset)+sz] )
654     offset += sz
655     return inst
656
657 def unserializeContainerScriptPerfLog(structData, offset):
658     name = unserializeString(structData,offset)
659     code = unserializeString(structData,offset)
660     numberOfSessions = unserializeInt(structData,offset)
661     sessions = []
662     for _ in range(numberOfSessions):
663         session = unserializeContainerScriptExecPerfLog(structData,offset)
664         sessions.append( session )
665     return ScriptInfo(name,code,sessions)
666
667 def unserializeContainerPerfLog(structData, offset):
668     nsEntry = unserializeString(structData,offset)
669     logFile = unserializeString(structData,offset)
670     scripts = []
671     nbScripts = unserializeInt(structData,offset)
672     for _ in range(nbScripts):
673         script = unserializeContainerScriptPerfLog(structData,offset)
674         scripts.append( script )
675     return ContainerLogInfo(nsEntry,logFile,scripts)
676
677 def unserializeLogManager(structData):
678     offset = OffsetType(0)
679     numberOfScripts = unserializeInt(structData,offset)
680     logManagerInst = []
681     for _ in range(numberOfScripts):
682         containerPerfLogInst = unserializeContainerPerfLog(structData,offset)
683         logManagerInst.append( containerPerfLogInst )
684     if int(offset) != len(structData):
685         raise RuntimeError("Something went wrong during unserialization phase.")
686     return logManagerInst
687
688 def ListAllExecContainIn( listOfContainerLogInfo ):
689     """
690     For all ContainerLogInfo contained in listOfContainerLogInfo extract all ScriptExecInfo contained recursively
691     in it. This method filters all "side" executions like those positionning environment for exemple.
692
693     See also : ListAllExecFinishedContainIn
694
695     Args:
696     -----
697
698     listOfContainerLogInfo (list<ContainerLogInfo>) : instance typically returned by salome.LogManagerLoadFromFile
699
700     Returns
701     -------
702
703     list<ScriptExecInfoDeco> : all ScriptExecInfoDeco instance contained recursively in all input ContainerLogInfo instances
704
705     """
706     allexecs = sum( [sum( [[myexec for myexec in ps] for ps in cont],[] ) for cont in listOfContainerLogInfo], [] )
707     return [elt for elt in allexecs if elt.get() is not None]
708
709 def ListAllExecFinishedContainIn( listOfContainerLogInfo ):
710     """
711     For all ContainerLogInfo contained in listOfContainerLogInfo extract all ScriptExecInfo contained recursively
712     in it. This method filters all "side" executions like those positionning environment for exemple and those not finished.
713
714     See also : ListAllExecContainIn
715
716     Args:
717     -----
718
719     listOfContainerLogInfo (list<ContainerLogInfo>) : instance typically returned by salome.LogManagerLoadFromFile
720
721     Returns
722     -------
723
724     list<ScriptExecInfoDeco> : all ScriptExecInfoDeco instance contained recursively in all input ContainerLogInfo instances
725
726     """
727     beforeFiltering = ListAllExecContainIn( listOfContainerLogInfo )
728     return [elt for elt in beforeFiltering if elt.get().execTime is not None]
729
730 def IsExecTimeHigherThan( execInstDeco, limitDuration ):
731     """
732     Example of Usage :
733
734     [elt for elt in allexecs if IsExecTimeHigherThan(elt,datetime.timedelta(hours=1))]
735     
736     Args:
737     -----
738
739     execInstDeco (ScriptExecInfoDeco)
740     limitDuration (datetime.timedelta)  Ex (datetime.timedelta(hours=1))
741
742     """
743     if execInstDeco.get() is not None:
744         return execInstDeco.get().execTime > limitDuration
745     else:
746         return False
747     
748 def GetMaxTimeExec( listOfFinishedExecs ):
749     """
750     Returns the instance among listOfFinishedExecs that spends the max time to be executed
751
752     Args:
753     -----
754
755     listOfFinishedExecs ( list<ScriptExecInfoDeco> ) : instance of ScriptExecInfoDeco that have finished to be executed
756     Typically returned by ListAllExecFinishedContainIn
757     
758     Returns
759     -------
760
761     ScriptExecInfoDeco :
762     """
763     return listOfFinishedExecs[ max([(i,elt.execTime) for i,elt in enumerate( listOfFinishedExecs) ],key = lambda x : x[1])[0] ]
764
765 def GetMinTimeExec( listOfFinishedExecs ):
766     """
767     Returns the instance among listOfFinishedExecs that spends the min time to be executed
768
769     Args:
770     -----
771
772     listOfFinishedExecs ( list<ScriptExecInfoDeco> ) : instance of ScriptExecInfoDeco that have finished to be executed
773     Typically returned by ListAllExecFinishedContainIn
774     
775     Returns
776     -------
777
778     ScriptExecInfoDeco :
779     """
780     return listOfFinishedExecs[ min([(i,elt.execTime) for i,elt in enumerate( listOfFinishedExecs) ],key = lambda x : x[1])[0] ]
781
782 class DistriutionClass:
783     def __init__(self, begin, end, listOfExecs):
784         self._begin = begin
785         self._end = end
786         self._list_of_execs = sorted( listOfExecs, key = lambda x : x.execTime)
787     def __getitem__(self, *args):
788         return self._list_of_execs.__getitem__( *args )
789     @property
790     def begin(self):
791         return self._begin
792     @property
793     def end(self):
794         return self._end
795     @property
796     def listOfExecs(self):
797         return self._list_of_execs
798     @property
799     def size(self):
800         return len( self.listOfExecs )
801     @property
802     def reprGlobal(self):
803         return f"[{self.begin}->{self.end}] : {self.size} execs"
804
805 class DistributionOfExecs:
806     """
807     Class in charge to distribute execution log instance into equi-classes
808     """
809     def __init__(self, listOfFinishedExecs, nbOfClasses):
810         self._list_of_finished_execs = listOfFinishedExecs
811         self._nb_of_classes = nbOfClasses
812         self._classes = DistributionOfExecs.ComputeDistributionOfExecTime(self._list_of_finished_execs,self._nb_of_classes)
813     
814     def __getitem__(self, *args):
815         return self._classes.__getitem__( *args )
816     def reprOfExecs(self):
817         import numpy as np
818         cs = np.cumsum( [elt.size for elt in self._classes] )
819         ret = []
820         for i,(elt,cum_nb) in enumerate( zip(self._classes,cs) ):
821             ratio = (cum_nb / cs[-1])*100.0
822             ret.append( f"- For class {i} - {elt.reprGlobal} ( {ratio:.1f}% )" )
823         return "\n".join( ret )
824     @classmethod
825     def ComputeDistributionOfExecTime( cls, listOfFinishedExecs, nbOfClasses ):
826         maxt = GetMaxTimeExec( listOfFinishedExecs )
827         mint = GetMinTimeExec( listOfFinishedExecs )
828         deltaTime = ( maxt.execTime - mint.execTime ) / nbOfClasses
829         res = []
830         for i in range( nbOfClasses ):
831             begin = mint.execTime + i * deltaTime
832             end = mint.execTime + (i+1) * deltaTime
833             res.append( DistriutionClass(begin,end,[elt for elt in listOfFinishedExecs if elt.execTime >=begin and elt.execTime <= end]) )
834         return res