mindspore 2.4.10__cp310-none-any.whl → 2.5.0__cp310-none-any.whl

mindspore/profiler/dynamic_profiler.py

@@ -16,6 +16,7 @@
 import os
 import sys
 import time
+import stat
 import json
 import atexit
 import struct
@@ -24,11 +25,13 @@ import multiprocessing
 
 from mindspore import log as logger
 from mindspore.train import Callback
-from mindspore.profiler import Profiler
-from mindspore.profiler import ProfilerLevel
+from mindspore.profiler import Profiler, tensor_board_trace_handler, schedule
 from mindspore.communication import get_rank
 from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
 from mindspore.profiler.parser.ascend_analysis.path_manager import PathManager
+from mindspore.profiler.profiler_interface import ProfilerInterface
+from mindspore.profiler.common.constant import ProfilerActivity, ProfilerLevel, AicoreMetrics
+from mindspore.profiler.common.util import no_exception_func
 
 
 def get_real_rank():
@@ -48,17 +51,16 @@ class DynamicProfilerArgs:
     """
     Data class for dynamic profile config.
     """
-    FMT = "iiiiii?????"
+    FMT = "iiiiii????"
     SIZE = struct.calcsize(FMT)
 
     def __init__(self,
                  start_step: int = -1,
                  stop_step: int = -1,
                  aicore_metrics: int = -1,
-                 profiler_level: int = -1,
-                 profile_framework: int = -1,
+                 profiler_level: int = 0,
                  analyse_mode: int = -1,
-                 profile_communication: bool = False,
+                 activities: int = 0,
                  parallel_strategy: bool = False,
                  with_stack: bool = False,
                  data_simplification: bool = True,
@@ -68,9 +70,8 @@ class DynamicProfilerArgs:
         self._stop_step = stop_step
         self._aicore_metrics = aicore_metrics
         self._profiler_level = profiler_level
-        self._profile_framework = profile_framework
         self._analyse_mode = analyse_mode
-        self._profile_communication = profile_communication
+        self._activities = activities
         self._parallel_strategy = parallel_strategy
         self._with_stack = with_stack
         self._data_simplification = data_simplification
@@ -92,24 +93,16 @@ class DynamicProfilerArgs:
             self._aicore_metrics = -1
 
         if not isinstance(self._profiler_level, int):
-            logger.warning("profiler_level should be int type, profiler_level will be reset to -1.")
-            self._profiler_level = -1
-
-        if not isinstance(self._profile_framework, int):
-            logger.warning("profile_framework should be int type, profile_framework will be reset to -1.")
-            self._profile_framework = -1
+            logger.warning("profiler_level should be int type, profiler_level will be reset to 0.")
+            self._profiler_level = 0
 
         if not isinstance(self._analyse_mode, int):
             logger.warning("analyse_mode should be int type, analyse_mode will be reset to -1.")
             self._analyse_mode = -1
 
-        if not isinstance(self._profile_communication, bool):
-            logger.warning("profile_communication should be bool type, profile_communication will be reset to False.")
-            self._profile_communication = False
-
-        if not isinstance(self._parallel_strategy, bool):
-            logger.warning("parallel_strategy should be bool type, parallel_strategy will be reset to False.")
-            self._parallel_strategy = False
+        if not isinstance(self._activities, int):
+            logger.warning("activities should be int type, activities will be reset to 0.")
+            self._activities = 0
 
         if not isinstance(self._with_stack, bool):
             logger.warning("with_stack should be bool type, with_stack will be reset to False.")
@@ -162,7 +155,8 @@ class DynamicProfilerArgs:
     def args(self):
         """ get all args in DynamicProfilerArgs."""
         self._profiler_level = self._convert_profiler_level(self._profiler_level)
-        self._profile_framework = self._convert_profile_framework(self._profile_framework)
+        self._activities = self._convert_activities(self._activities)
+        self._aicore_metrics = self._convert_aicore_metrics(self._aicore_metrics)
         not_supported_args = ['_start_step', '_stop_step', '_analyse_mode', '_is_valid']
         res = {}
         for key, value in self.__dict__.items():
@@ -199,16 +193,37 @@ class DynamicProfilerArgs:
             return ProfilerLevel.Level1
         if profiler_level == 2:
             return ProfilerLevel.Level2
-        return None
-
-    def _convert_profile_framework(self, profile_framework: int) -> str:
-        """ convert profile_framework to real args in Profiler."""
-        if profile_framework == 0:
-            return "time"
-        if profile_framework == 1:
-            return "all"
-        return None
-
+        return ProfilerLevel.Level0
+
+    def _convert_activities(self, activities: int) -> ProfilerLevel:
+        """ convert activities to real args in Profiler."""
+        if activities == 0:
+            return [ProfilerActivity.CPU, ProfilerActivity.NPU]
+        if activities == 1:
+            return [ProfilerActivity.CPU]
+        if activities == 2:
+            return [ProfilerActivity.NPU]
+        return [ProfilerActivity.CPU, ProfilerActivity.NPU]
+
+    def _convert_aicore_metrics(self, aicore_metrics: int) -> AicoreMetrics:
+        """ convert aicore_metrics to real args in Profiler."""
+        if aicore_metrics == -1:
+            return AicoreMetrics.AiCoreNone
+        if aicore_metrics == 0:
+            return AicoreMetrics.PipeUtilization
+        if aicore_metrics == 1:
+            return AicoreMetrics.ArithmeticUtilization
+        if aicore_metrics == 2:
+            return AicoreMetrics.Memory
+        if aicore_metrics == 3:
+            return AicoreMetrics.MemoryL0
+        if aicore_metrics == 4:
+            return AicoreMetrics.MemoryUB
+        if aicore_metrics == 5:
+            return AicoreMetrics.ResourceConflictRatio
+        if aicore_metrics == 6:
+            return AicoreMetrics.L2Cache
+        return AicoreMetrics.AiCoreNone
 
 class DynamicProfilerMonitorBase(Callback):
     """
@@ -240,12 +255,17 @@ class DynamicProfilerMonitorBase(Callback):
         self._last_stop_step = None
         self._is_create_process = None
         self._is_started = False
+        self._start_step = -1
+        self._stop_step = -1
+        self._step_num = 0
 
+        self._check_shm_for_killed()
         self._init_cfg_json()
         self._create_shm()
         self._create_process()
         atexit.register(self._clean_resource)
 
+    @no_exception_func()
     def step_begin(self, run_context):
         """
         Start profile at the begin of step.
@@ -287,6 +307,7 @@ class DynamicProfilerMonitorBase(Callback):
             print_msg(f"Rank {self._rank_id} Dynamic profiler start at step {start_step}, "
                       f"will stop at step {stop_step}")
 
+    @no_exception_func()
     def step_end(self, run_context):
         """
         Stop profile at the end of step.
@@ -312,11 +333,138 @@ class DynamicProfilerMonitorBase(Callback):
                 if prof_args.analyse_mode:
                     self._profiler.analyse(mode=prof_args.analyse_mode)
                 else:
-                    self._profiler._ascend_profiler.finalize()
+                    ProfilerInterface.finalize()
+                    ProfilerInterface.clear()
                 self._profiler = None
                 self._is_started = False
                 print_msg(f"Rank {self._rank_id} Dynamic profiler stop at step {step_num}")
 
+    @no_exception_func()
+    def step(self):
+        """
+        Used for Ascend, distinguish step collection and parsing performance data by dynamic profiler.
+
+        Raises:
+            RuntimeError: If the 'start_step' parameter setting is greater than the 'stop_step' parameter setting.
+
+        Examples:
+            >>> import json
+            >>> import os
+            >>> import numpy as np
+            >>>
+            >>> import mindspore
+            >>> import mindspore.dataset as ds
+            >>> from mindspore import context, nn
+            >>> from mindspore.profiler import DynamicProfilerMonitor
+            >>>
+            >>>
+            >>> class Net(nn.Cell):
+            ...     def __init__(self):
+            ...         super(Net, self).__init__()
+            ...         self.fc = nn.Dense(2, 2)
+            ...
+            ...     def construct(self, x):
+            ...         return self.fc(x)
+            >>>
+            >>> def generator_net():
+            ...     for _ in range(2):
+            ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
+            >>>
+            >>> def train(test_net):
+            ...     optimizer = nn.Momentum(test_net.trainable_params(), 1, 0.9)
+            ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+            ...     data = ds.GeneratorDataset(generator_net(), ["data", "label"])
+            ...     model = mindspore.train.Model(test_net, loss, optimizer)
+            ...     model.train(1, data)
+            >>>
+            >>> def change_cfg_json(json_path):
+            ...     with open(json_path, 'r', encoding='utf-8') as file:
+            ...          data = json.load(file)
+            ...
+            ...     data['start_step'] = 6
+            ...     data['stop_step'] = 7
+            ...
+            ...     with open(json_path, 'w', encoding='utf-8') as file:
+            ...          json.dump(data, file, ensure_ascii=False, indent=4)
+            >>>
+            >>> if __name__ == '__main__':
+            ...      # set json configuration file
+            ...      cfg_json = {
+            ...          "start_step": 2,
+            ...          "stop_step": 5,
+            ...          "aicore_metrics": -1,
+            ...          "profiler_level": 0,
+            ...          "activities": 0,
+            ...          "analyse_mode": -1,
+            ...          "parallel_strategy": False,
+            ...          "with_stack": False,
+            ...          "data_simplification": True,
+            ...          }
+            ...      context.set_context(mode=mindspore.PYNATIVE_MODE)
+            ...      mindspore.set_device("Ascend")
+            ...      cfg_path = os.path.join("./cfg_path", "profiler_config.json")
+            ...      # set cfg file
+            ...      with open(cfg_path, 'w') as f:
+            ...           json.dump(cfg_json, f, indent=4)
+            ...      # Assume the user has correctly configured the environment variable (RANK_ID is not a non-numeric type)
+            ...      rank_id = int(os.getenv('RANK_ID')) if os.getenv('RANK_ID') else 0
+            ...      # cfg_path contains the json configuration file path, and output_path is the output path
+            ...      dp = DynamicProfilerMonitor(cfg_path=cfg_path, output_path=cfg_path)
+            ...      STEP_NUM = 15
+            ...      # Define a network of training models
+            ...      net = Net()
+            ...      for i in range(STEP_NUM):
+            ...          print(f"step {i}")
+            ...          train(net)
+            ...          # Modify the configuration file after step 7. For example, change start_step to 8 and stop_step to 10
+            ...          if i == 7:
+            ...             # Modify parameters in the JSON file
+            ...             change_cfg_json(os.path.join(cfg_path, "profiler_config.json"))
+            ...             # Call step collection
+            ...             dp.step()
+        """
+
+        self._step_num += 1
+        prof_args = self._get_prof_args()
+
+        if not prof_args.is_valid:
+            logger.error("Dynamic profile json is not valid, please check the json file.")
+            return
+
+        if prof_args.start_step == -1 or prof_args.stop_step == -1:
+            return
+
+        # Skips the number of steps less than start_step
+        if self._step_num < prof_args.start_step:
+            return
+
+        if self._start_step != prof_args.start_step or self._stop_step != prof_args.stop_step:
+            # Update new start_step and stop_step
+            self._start_step = prof_args.start_step
+            self._stop_step = prof_args.stop_step
+            if self._start_step >= 0 and 0 <= self._start_step <= self._stop_step:
+                prof_path = os.path.join(self._output_path,
+                                         f"rank{self._rank_id}_start{self._start_step}_stop{self._stop_step}")
+                print_msg(f"Rank {self._rank_id} create output path {prof_path}")
+                print_msg(f"Rank {self._rank_id} Dynamic profile start at step {self._start_step}, "
+                          f"will stop at step {self._stop_step}")
+                self._profiler = Profiler(output_path=prof_path,
+                                          schedule=schedule(wait=0, warmup=0,
+                                                            active=self._stop_step - self._start_step + 1,
+                                                            repeat=1,
+                                                            skip_first=1),
+                                          on_trace_ready=tensor_board_trace_handler,
+                                          **prof_args.args)
+            else:
+                self._profiler = None
+                logger.error("Rank %d Dynamic profile start at step %d and stop at step %d in config_json must be "
+                             "greater than or equal to 0, and stop step should not be less than start step",
+                             self._rank_id, self._start_step, self._stop_step)
+
+        if self._profiler:
+            self._profiler.step()
+
+    @no_exception_func()
     def on_train_end(self, run_context):
         """
         Callback on trian end
@@ -357,6 +505,7 @@ class DynamicProfilerMonitorBase(Callback):
 
         return start_step, stop_step
 
+    @no_exception_func()
     def _init_cfg_json(self):
         """Init config json file"""
         if self._rank_id == 0:
@@ -372,6 +521,7 @@ class DynamicProfilerMonitorBase(Callback):
         """Create a json monitor process based on whether the SharedMemory is successfully created"""
         logger.error("Dynamic profiler _create_shm is not implemented")
 
+    @no_exception_func()
     def _create_process(self):
         """Create json monitor process, one process will be created at one worker"""
         if self._is_create_process:
@@ -385,18 +535,57 @@ class DynamicProfilerMonitorBase(Callback):
             self._process = None
             logger.info("Rank %d no need to create process.", self._rank_id)
 
+    @no_exception_func()
+    def _check_shm_for_killed(self):
+        """
+        User killed process shm can not clean normally, so check this when create shm.
+        """
+        if sys.version_info >= (3, 8):
+            shm_path = os.path.join("/dev/shm", self._shm_name)
+        else:
+            shm_path = self._shm_path
+
+        if not os.path.exists(shm_path):
+            return
+
+        MAX_TIME_DIFF = 30 # seconds
+        time_shm = os.stat(shm_path).st_ctime
+        cur_proc_time = self._get_pid_st_ctime(os.getpid())
+
+        if cur_proc_time and abs(cur_proc_time - time_shm) > MAX_TIME_DIFF:
+            raise RuntimeError("There maybe exist share memory before this task, if you kill last task, "
+                               "dynamic profiler will not valid, please remove %s, and retry." % shm_path)
+
+    def _get_pid_st_ctime(self, pid):
+        """Get pid st_ctime"""
+        try:
+            fd = os.open("/proc/" + str(pid), os.O_RDONLY, stat.S_IRUSR | stat.S_IRGRP)
+            stat_ino = os.fstat(fd)
+            os.close(fd)
+            create_time = stat_ino.st_ctime
+            return create_time
+        except FileNotFoundError:
+            logger.error("Process with PID %d does not exist.", pid)
+        except PermissionError:
+            logger.error("Permission denied when accessing PID %d.", pid)
+        except Exception as ex: # pylint: disable=W0703
+            logger.error("An error occurred while getting creation time for PID %d: %s", pid, str(ex))
+
 
 if sys.version_info >= (3, 8):
+    @no_exception_func()
     def write_bytes(shm, byte_data):
         """Write bytes to shared memory"""
         shm.buf[:DynamicProfilerArgs.SIZE] = byte_data
 else:
+    @no_exception_func()
     def write_bytes(shm, byte_data):
         """Write bytes to shared memory"""
         shm.seek(0)
         shm.write(byte_data)
 
 
+@no_exception_func()
 def worker_func(loop_flag, poll_interval, shm, cfg_path):
     """ Json monitor process worker function python version >= 3.8"""
     last_file_t = None
@@ -430,13 +619,45 @@ if sys.version_info >= (3, 8):
     from multiprocessing import shared_memory
     from unittest.mock import patch
 
+
     class DynamicProfilerMonitor(DynamicProfilerMonitorBase):
         r"""
         This class to enable the dynamic profile monitoring of MindSpore neural networks.
 
         Args:
             cfg_path (str): Dynamic profile json config file directory. The requirement is a shared path
-                that can be accessed by all nodes.
+                that can be accessed by all nodes. The parameters of the json configuration file are as follows:
+
+                - start_step (int, required) - Sets the step number at which the Profiler starts collecting data.
+                  It is a relative value, with the first step of training being 1. The default value is -1, indicating
+                  that data collection will not start during the entire training process.
+                - stop_step (int, required) - Sets the step number at which the Profiler stops collecting data. It is
+                  a relative value, with the first step of training being 1. The stop_step must be greater than or
+                  equal to start_step. The default value is -1, indicating that data collection will not start during
+                  the entire training process.
+                - aicore_metrics (int, optional) - The range of values corresponds to the Profiler. The default value -1
+                  indicates that AI Core utilization is not collected, and 0 indicates PipeUtilization, 1 indicates
+                  ArithmeticUtilization, 2 stands for Memory, 3 stands for MemoryL0, 4 stands for MemoryUB, 5 indicates
+                  ResourceConflictRatio, 6 indicates L2Cache.
+                - profiler_level (int, optional) - Sets the level of performance data collection, where 0 represents
+                  ProfilerLevel.Level0, 1 represents ProfilerLevel.Level1, and 2 represents ProfilerLevel.Level2. The
+                  default value is 0, indicating the ProfilerLevel.Level0 collection level.
+                - activities (int, optional) - Sets the devices for performance data collection, where 0 represents
+                  CPU+NPU, 1 represents CPU, and 2 represents NPU. The default value is 0, indicating the collection
+                  of CPU+NPU performance data.
+                - analyse_mode (int, optional) - Sets the mode for online analysis, corresponding to the analyse_mode
+                  parameter of the mindspore.Profiler.analyse interface, where 0 represents "sync" and 1 represents
+                  "async". The default value is -1, indicating that online analysis is not used.
+                - parallel_strategy (bool, optional) - Sets whether to collect parallel strategy performance data,
+                  where true means to collect and false means not to collect. The default value is false, indicating
+                  that parallel strategy performance data is not collected.
+                - with_stack (bool, optional) - Sets whether to collect call stack information, where true means to
+                  collect and false means not to collect. The default value is false, indicating that call stack
+                  information is not collected.
+                - data_simplification (bool, optional) - Sets whether to enable data simplification, where true means
+                  to enable and false means not to enable. The default value is true, indicating that data
+                  simplification is enabled.
+
             output_path (str, optional): Output data path. Default: ``"./dyn_profile_data"`` .
             poll_interval (int, optional): The polling period of the monitoring process, in seconds.
                 Default value: ``2``.
@@ -488,12 +709,14 @@ if sys.version_info >= (3, 8):
             """ Get prof_args py38"""
             return DynamicProfilerArgs.from_bytes(self._shm.buf[:DynamicProfilerArgs.SIZE])
 
+        @no_exception_func()
         def _clean_resource(self):
             """Clean resource py38"""
             # stop profiler when stop_step over all train step
             if self._profiler:
                 self._profiler.stop()
-                self._profiler._ascend_profiler.finalize()
+                ProfilerInterface.finalize()
+                ProfilerInterface.clear()
                 self._profiler = None
                 logger.warning("Rank %d Dynamic profiler stop at end of training", self._rank_id)
 
@@ -514,6 +737,7 @@ if sys.version_info >= (3, 8):
                     logger.warning("Rank %s unlink shm failed, may be removed", self._rank_id)
                 self._shm = None
 
+        @no_exception_func()
         def _create_shm(self):
             """Create a json monitor process based on whether the SharedMemory is successfully created py38"""
             try_times = 10
@@ -542,13 +766,19 @@ if sys.version_info >= (3, 8):
                         logger.warning("Rank %d shared memory create failed, "
                                        "retry times = %d.", self._rank_id, try_times)
                         time.sleep(random.uniform(0, 0.02))  # sleep 0 ~ 20 ms
+                except Exception as e: # pylint: disable=W0703
+                    # shm open failed because of other process create shm not finished
+                    try_times -= 1
+                    logger.warning("Rank %d shared memory open failed, error: %s, retry times = %d",
+                                   self._rank_id, str(e), try_times)
+                    time.sleep(random.uniform(0, 0.02))  # sleep 0 ~ 20 ms
 
             if try_times <= 0:
                 raise RuntimeError(f"Rank {self._rank_id} failed to create shared memory.")
 
 else:
     import mmap
-    import stat
+
 
     class DynamicProfilerMonitor(DynamicProfilerMonitorBase):
         r"""
@@ -617,12 +847,14 @@ else:
             self._shm.seek(0)
             return DynamicProfilerArgs.from_bytes(self._shm.read(DynamicProfilerArgs.SIZE))
 
+        @no_exception_func()
         def _clean_resource(self):
             """Clean resource py37"""
             # stop profiler when stop_step over all train step
             if self._profiler:
                 self._profiler.stop()
-                self._profiler._ascend_profiler.finalize()
+                ProfilerInterface.finalize()
+                ProfilerInterface.clear()
                 self._profiler = None
                 logger.warning("Rank %d Dynamic profiler stop at end of training", self._rank_id)
 
@@ -647,6 +879,7 @@ else:
                     logger.warning("Rank %s unlink shm failed, may be removed", self._rank_id)
                 self._shm = None
 
+        @no_exception_func()
         def _create_shm(self):
             """Create a json monitor process based on whether the SharedMemory is successfully created py37"""
 

mindspore/profiler/envprofiler.py

@@ -0,0 +1,138 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""EnvProfiler"""
+import os
+import json
+from mindspore import log as logger
+from mindspore.profiler.profiler import Profiler
+from mindspore.profiler.common.constant import (
+    ProfilerLevel,
+    AicoreMetrics,
+    ProfilerActivity,
+)
+from mindspore.profiler.common.profiler_parameters import ProfilerParameters
+
+
+class EnvProfiler:
+    """Collect and analyze training performance data, support calls during and after training."""
+
+    NOT_SUPPORTED_PARAMS = ["schedule", "on_trace_ready"]
+    profiler = None
+
+    @classmethod
+    def init_profiler(cls):
+        """
+        Initialize the profiler.
+        """
+        if not os.getenv("MS_PROFILER_OPTIONS"):
+            return
+        options = cls._load_options()
+        if not options:
+            logger.error("Failed to load MS_PROFILER_OPTIONS, json decode error.")
+            return
+
+        params = cls._convert_options_to_profiler_params(options)
+        logger.info(f"params: {params}")
+        if params["start_profile"]:
+            cls.profiler = Profiler(**params)
+            logger.info("Profiler init success.")
+
+    def analyse(self):
+        """
+        Analyze the collected data.
+        """
+        logger.info("analyse start")
+        if not self.profiler:
+            logger.info("Profiler is not initialized, skip analyse.")
+            return
+        self.profiler.analyse()
+        logger.info("analyse end")
+
+    @classmethod
+    def _load_options(cls):
+        """
+        Load the options from the environment variable.
+        """
+        try:
+            options = json.loads(os.environ.get("MS_PROFILER_OPTIONS", "{}"))
+        except json.JSONDecodeError:
+            return {}
+        return options
+
+    @classmethod
+    def _convert_option_to_enum_value(cls, enum_class, option_value, default_value):
+        """
+        Convert the option value to the enum value.
+        """
+        try:
+            return enum_class(option_value)
+        except ValueError:
+            logger.warning(
+                f"The value '{option_value}' of parameter '{enum_class.__name__}' is invalid, "
+                f"use default value '{default_value}' instead."
+            )
+            return default_value
+
+    @classmethod
+    def _convert_options_to_profiler_params(cls, options):
+        """
+        Convert the options to the profiler parameters.
+        """
+        params = {}
+        if not options:
+            logger.warning("MS_PROFILER_OPTIONS is empty, use default values.")
+            return params
+
+        if "output_path" in options:
+            params["output_path"] = options["output_path"]
+
+        # if start is not set, default is False
+        params["start_profile"] = options.get("start", False)
+
+        for param, (_, default_value) in ProfilerParameters.PARAMS.items():
+            if param in options and param not in cls.NOT_SUPPORTED_PARAMS:
+                if param == "activities" and isinstance(options[param], list):
+                    params[param] = cls._convert_activities_to_list(
+                        options[param], default_value
+                    )
+                elif param == "aicore_metrics":
+                    params[param] = cls._convert_option_to_enum_value(
+                        AicoreMetrics, options[param], default_value
+                    )
+                elif param == "profiler_level":
+                    params[param] = cls._convert_option_to_enum_value(
+                        ProfilerLevel, options[param], default_value
+                    )
+                else:
+                    params[param] = options[param]
+        return params
+
+    @classmethod
+    def _convert_activities_to_list(cls, activities, default_value):
+        """
+        Convert the activities to the list.
+        """
+        res = []
+        for activity in activities:
+            res.append(
+                cls._convert_option_to_enum_value(
+                    ProfilerActivity, activity, default_value
+                )
+            )
+        # remove duplicate
+        return list(set(default_value if default_value in res else res))
+
+
+EnvProfiler.init_profiler()