Diff Coverage

Diff: origin/master...HEAD, staged and unstaged changes

Source File Diff Coverage (%) Missing Lines
hyper_parallel/auto_parallel/sapp_nd/memory_estimation/_func_tracer.py 100%  
hyper_parallel/auto_parallel/sapp_nd/memory_estimation/_hook_manager.py 100%  
hyper_parallel/auto_parallel/sapp_nd/nd/common/cost_model_preprocess.py 75.0% 136,140,373
hyper_parallel/auto_parallel/sapp_nd/nd/parallelize.py 59.4% 251,404,409,416-420,433-436,439
hyper_parallel/auto_parallel/sapp_ppb/utils/compute_memory.py 0.0% 150-154,156-157
hyper_parallel/auto_parallel/sapp_ppb/utils/logger.py 100%  
hyper_parallel/auto_parallel/sapp_nd/nd/common/cost_model_preprocess.py
132
133
134
135
136
137
138
139
140
141
142
143
144
        return res

    def __getstate__(self) -> dict:
        """Return instance state for multiprocessing serialization."""
        return self.__dict__.copy()

    def __setstate__(self, state: dict) -> None:
        """Restore instance state after multiprocessing deserialization."""
        self.__dict__.update(state)

    def fp_bytes(self, precision):
        """Return bytes size for datatype"""
        if precision and isinstance(precision, str):

369
370
371
372
373
374
375
376
377
                hook(e)
                if isinstance(e, CostModelConfig):
                    config = config_ref()
                    if config is None:
                        raise ReferenceError(
                            "CostModelConfig has already been released"
                        )
                    fun(config)
                else:
hyper_parallel/auto_parallel/sapp_nd/nd/parallelize.py
247
248
249
250
251
252
253
254
255
                    logger.debug("result = %s", str(result))
                    logger.debug(
                        "before get: is ready ? %s", str(result.ready())
                    )
                    peak_mem = result.get()
                    logger.debug(
                        "after get: is ready ? %s", str(result.ready())
                    )
                    logger.debug(

400
401
402
403
404
405
406
407
408
409
410
411
412
413
                        ),
                    )
                else:
                    if self.enable_debug:
                        debugger = Debug.Debug(
                            config,
                            info_type=Debug.PerfParts,
                            enable=self.enable_debug,
                        )
                        score = estimate_performance(
                            self.config.ccfg,
                            debugger=debugger,
                            device_type=self.machine.device,
                            memory=mem,

412
413
414
415
416
417
418
419
420
421
422
423
424
                            device_type=self.machine.device,
                            memory=mem,
                            cache_file=cache_file,
                        )
                        debugger.write()
                        debug_parts = list(debugger.info.keys())
                        values = list(debugger.info.values())
                        del values[-2:]
                        del debug_parts[-2:]
                    else:
                        score = estimate_performance(
                            self.config.ccfg,
                            device_type=self.machine.device,

429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
                if not multiproc:
                    logger.info("config %s has score %f", str(config), score)

            if multiproc:
                new_scored_space = []
                for config, mem, score, values in scored_space:
                    score_value = score.get()
                    logger.info(
                        "config %s has score %f", str(config), score_value
                    )
                    new_scored_space.append(
                        (config, mem, score_value, values)
                    )
            else:
                new_scored_space = scored_space
hyper_parallel/auto_parallel/sapp_ppb/utils/compute_memory.py
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
        """
        if multi_run or (len(self.stages_a) < 5 and len(self.stages_b) < 5):
            memory_parameter_list = []
            for stage1 in self.stages_a:
                if stage1.id_ in [0, (self.number_of_stage_ - 1)]:
                    continue
                for stage2 in self.stages_a:
                    if stage2.id_ in [0, (self.number_of_stage_ - 1), stage1.id_]:
                        continue
                    mem_param = self._compute_memory_parameter_local_(stage1, stage2)
                    if mem_param != 0:
                        memory_parameter_list.append(mem_param)
            for stage1 in self.stages_b:
                if stage1.id_ not in [0, (self.number_of_stage_ - 1)]:
                    for stage2 in self.stages_b:
                        mem_param = self._compute_memory_parameter_local_(stage1, stage2)