dev

DATA_100

+# (COMPLEXITY 100) SUBJECTS CORES_1 CORES_2
+500 0.24411559104919434 0.9702152252197266
+100 0.04988713264465332 0.1922530174255371

DATA_2000

+# (COMPLEXITY 2000) SUBJECTS CORES_1 CORES_2
+500 0.9194584846496582 1.1027130842208863
+100 0.1884233236312866 0.21506776809692382

perf.py

 
 import time
 from collections import OrderedDict
+from random import randint
 
 from sandbox.perf.simulation import ComputeSubject
 from synergine2.config import Config
 
 
 def simulate(complexity, subject_count, cycle_count, cores):
-    config = Config(dict(complexity=complexity, use_x_cores=cores))
+    config = Config(dict(complexity=complexity, core=dict(use_x_cores=cores)))
     simulation = Simulation(config)
 
     subjects = Subjects(simulation=simulation)
         subjects.append(ComputeSubject(
             config=config,
             simulation=simulation,
+            data=[randint(0, 1000) for i in range(1000)]
         ))
 
     simulation.subjects = subjects
 
     host_cores = multiprocessing.cpu_count()
     retry = 3
-    cycles = 200
-    subject_counts = [1, 10, 100, 1000, 5000]
+    cycles = 10
+    subject_counts = [100, 500]
     complexities = [100, 2000]
     max_cores = args.max_cores or host_cores
 

sandbox/perf/simulation.py

 import random
 
+from synergine2.config import Config
 from synergine2.simulation import SubjectMechanism, SubjectBehaviour, Event, Subject
 
 
 
 class ComputeSubject(Subject):
     behaviours_classes = [ComputeBehaviour]
+
+    def __init__(
+        self,
+        config: Config,
+        simulation: 'Simulation',
+        data,
+    ):
+        super().__init__(config, simulation)
+        self.data = data

sandbox/tile/config.yaml

+core:
+    cycle_duration: 0.125
+    use_x_cores: 1
+terminals:
+    sync: True

sandbox/tile/run.py

 import logging
 from random import seed
 
-from sandbox.tile.simulation.subject import Man
-
 synergine2_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
 sys.path.append(synergine2_path)
 
+from sandbox.tile.simulation.subject import Man
 from sandbox.tile.simulation.base import TileStrategySimulation
 from sandbox.tile.simulation.base import TileStrategySubjects
 from synergine2.log import get_default_logger
     seed(seed_value)
 
     config = Config()
-    config.load_files(['sandbox/engulf/config.yaml'])  # TODO: heu ... engulf ??
-    logger = get_default_logger(level=logging.ERROR)
+    config.load_files(['sandbox/tile/config.yaml'])
+    logger = get_default_logger(level=logging.DEBUG)
 
     map_file_path = 'sandbox/tile/{}.tmx'.format(os.path.join(map_dir_path, os.path.basename(map_dir_path)))
 

synergine2/core.py

 from synergine2.simulation import Simulation
 from synergine2.terminals import TerminalManager
 from synergine2.terminals import TerminalPackage
+from synergine2.utils import time_it
 
 
 class Core(BaseObject):
                         subject_actions=package.subject_actions,
                     ))
 
-                events.extend(self.cycle_manager.next())
+                with time_it() as elapsed_time:
+                    events.extend(self.cycle_manager.next())
+                # TODO: There is a problem with logger: when "pickled" we remove it's handler
+                self.logger.info('Cycle duration: {}s'.format(elapsed_time.get_final_time()))
+                print('Cycle duration: {}s'.format(elapsed_time.get_final_time()))
+
                 cycle_package = TerminalPackage(
                     events=events,
                     add_subjects=self.simulation.subjects.adds,

synergine2/cycle.py

 from synergine2.simulation import SubjectBehaviour
 from synergine2.simulation import SubjectMechanism
 from synergine2.simulation import Event
-from synergine2.utils import ChunkManager
+from synergine2.utils import ChunkManager, time_it
 
 
 class CycleManager(BaseObject):
     ):
         if process_manager is None:
             process_manager = ProcessManager(
-                process_count=config.get('use_x_cores', multiprocessing.cpu_count()),
+                # TODO: Changer de config de merde (core.use_x_cores)
+                process_count=config.get('core', {}).get('use_x_cores', multiprocessing.cpu_count()),
                 chunk_manager=ChunkManager(multiprocessing.cpu_count()),
             )
 
         events = []
         # TODO: gestion des behaviours non parallelisables
         # TODO: Proposer des ordres d'execution
-        events.extend(self._get_subjects_events())
-        events.extend(self._get_simulation_events())
+        with time_it() as elapsed_time:
+            events.extend(self._get_subjects_events())
+        print('Cycle subjects events duration: {}s'.format(elapsed_time.get_final_time()))
+
+        with time_it() as elapsed_time:
+            events.extend(self._get_simulation_events())
+        print('Cycle simulation events duration: {}s'.format(elapsed_time.get_final_time()))
 
         self.logger.info('Cycle {} generate {} events'.format(
             str(self.current_cycle),
             behaviours_data = {}
 
             for mechanism in mechanisms:
-                mechanism_data = mechanism.run()
+                with time_it() as elapsed_time:
+                    mechanism_data = mechanism.run()
                 if self.logger.is_debug:
-                    self.logger.info('Subject {}: {} mechanisms produce data: {}'.format(
+                    self.logger.debug('Subject {}: {} mechanisms produce data: {} in {}s'.format(
                         str(subject.id),
                         type(mechanism).__name__,
                         str(mechanism_data),
+                        elapsed_time.get_final_time(),
                     ))
 
                 mechanisms_data[type(mechanism)] = mechanism_data
                 ))
 
                 # We identify behaviour data with it's class to be able to intersect it after subprocess data collect
-                behaviour_data = behaviour.run(mechanisms_data)  # TODO: Behaviours dependencies
+                with time_it() as elapsed_time:
+                    behaviour_data = behaviour.run(mechanisms_data)  # TODO: Behaviours dependencies
 
                 if self.logger.is_debug:
-                    self.logger.debug('Subject {}: behaviour {} produce data: {}'.format(
+                    self.logger.debug('Subject {}: behaviour {} produce data: {} in {}s'.format(
                         str(type(behaviour)),
                         str(subject.id),
                         str(behaviour_data),
+                        elapsed_time.get_final_time(),
                     ))
 
                 if behaviour_data:

synergine2/processing.py

         chunks = self._chunk_manager.make_chunks(data)
 
         if self._process_count > 1:
+            print('USE POOL')
             results = self.pool.starmap(job_maker, [(chunk, i, self._process_count) for i, chunk in enumerate(chunks)])
         else:
+            print('USE MONO')
             results = [job_maker(data, 0, 1)]
 
         return results

synergine2/utils.py

+import typing
+from contextlib import contextmanager
+
+import time
+
 from synergine2.base import BaseObject
 
 
     for behaviour_class in mechanized.behaviours_classes:
         mechanisms_classes.extend(behaviour_class.use)
     return list(set(mechanisms_classes))  # Remove duplicates
+
+
+class ElapsedTime(object):
+    def __init__(self, start_time: float) -> None:
+        self.start_time = start_time
+        self.end_time = None
+
+    def get_final_time(self) -> float:
+        assert self.end_time
+        return self.end_time - self.start_time
+
+    def get_time(self) -> float:
+        return time.time() - self.start_time
+
+
+@contextmanager
+def time_it() -> typing.Generator[ElapsedTime, None, None]:
+    elapsed_time = ElapsedTime(time.time())
+    try:
+        yield elapsed_time
+    finally:
+        elapsed_time.end_time = time.time()

synergine2_xyz/move.py

         self.to_position = to_position
 
     def repr_debug(self) -> str:
-        return '{}: subject_id:{}, position:{}'.format(
+        return '{}: subject_id:{}, from_position:{} to_position: {}'.format(
             type(self).__name__,
             self.subject_id,
-            self.position,
+            self.from_position,
+            self.to_position,
         )