triton-model-analyzer 1.48.0__py3-none-any.whl → 1.49.0__py3-none-any.whl

model_analyzer/config/generate/brute_plus_binary_parameter_search_run_config_generator.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import logging
 from copy import deepcopy
@@ -132,9 +120,11 @@ class BrutePlusBinaryParameterSearchRunConfigGenerator(ConfigGeneratorInterface)
             for result in top_results:
                 run_config = deepcopy(result.run_config())
                 model_parameters = self._get_model_parameters(model_name)
+                perf_analyzer_flags = self._get_model_perf_analyzer_flags(model_name)
                 parameter_search = ParameterSearch(
                     config=self._config,
                     model_parameters=model_parameters,
+                    perf_analyzer_flags=perf_analyzer_flags,
                     skip_parameter_sweep=True,
                 )
                 for parameter in parameter_search.search_parameters():
@@ -151,6 +141,12 @@ class BrutePlusBinaryParameterSearchRunConfigGenerator(ConfigGeneratorInterface)
 
         return {}
 
+    def _get_model_perf_analyzer_flags(self, model_name: str) -> Dict:
+        for model in self._models:
+            if model_name == model.model_name():
+                return model.perf_analyzer_flags()
+        return {}
+
     def _set_parameter(
         self, run_config: RunConfig, model_parameters: Dict, parameter: int
     ) -> RunConfig:

model_analyzer/config/generate/model_profile_spec.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 from copy import deepcopy
 from typing import List
@@ -22,6 +10,7 @@ from model_analyzer.config.input.objects.config_model_profile_spec import (
     ConfigModelProfileSpec,
 )
 from model_analyzer.device.gpu_device import GPUDevice
+from model_analyzer.perf_analyzer.perf_config import PerfAnalyzerConfig
 from model_analyzer.triton.client.client import TritonClient
 from model_analyzer.triton.model.model_config import ModelConfig
 
@@ -72,3 +61,14 @@ class ModelProfileSpec(ConfigModelProfileSpec):
     def is_ensemble(self) -> bool:
         """Returns true if the model is an ensemble"""
         return "ensemble_scheduling" in self._default_model_config
+
+    def is_load_specified(self) -> bool:
+        """
+        Returns true if the model's PA config has specified any of the
+        inference load args (such as concurrency). Else returns false
+        """
+        load_args = PerfAnalyzerConfig.get_inference_load_args()
+        pa_flags = self.perf_analyzer_flags()
+        if pa_flags is None:
+            return False
+        return any(e in pa_flags for e in load_args)

model_analyzer/config/generate/perf_analyzer_config_generator.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import logging
 from typing import Generator, List, Optional
@@ -169,10 +157,12 @@ class PerfAnalyzerConfigGenerator(ConfigGeneratorInterface):
             self._parameter_results.extend(measurement)
 
     def _create_parameter_list(self) -> List[int]:
-        # The two possible parameters are request rate or concurrency
-        # Concurrency is the default and will be used unless the user specifies
-        # request rate, either as a model parameter or a config option
-        if self._cli_config.is_request_rate_specified(self._model_parameters):
+        # Determines the inference load (concurrency or request-rate or request-intervals)
+        # and creates the list of values to use. If nothing is specified by the user, then
+        # concurrency will be used.
+        if "request-intervals" in self._perf_analyzer_flags:
+            return [self._perf_analyzer_flags["request-intervals"]]
+        elif self._cli_config.is_request_rate_specified(self._model_parameters):
             return self._create_request_rate_list()
         else:
             return self._create_concurrency_list()
@@ -207,7 +197,7 @@ class PerfAnalyzerConfigGenerator(ConfigGeneratorInterface):
         for params in utils.generate_parameter_combinations(
             perf_config_non_parameter_values
         ):
-            configs_with_concurrency = []
+            configs_with_inference_load = []
             for parameter in self._parameters:
                 new_perf_config = PerfAnalyzerConfig()
 
@@ -217,7 +207,9 @@ class PerfAnalyzerConfigGenerator(ConfigGeneratorInterface):
 
                 new_perf_config.update_config(params)
 
-                if self._cli_config.is_request_rate_specified(self._model_parameters):
+                if "request-intervals" in self._perf_analyzer_flags:
+                    pass
+                elif self._cli_config.is_request_rate_specified(self._model_parameters):
                     new_perf_config.update_config({"request-rate-range": parameter})
                 else:
                     new_perf_config.update_config({"concurrency-range": parameter})
@@ -225,8 +217,8 @@ class PerfAnalyzerConfigGenerator(ConfigGeneratorInterface):
                 # User provided flags can override the search parameters
                 new_perf_config.update_config(self._perf_analyzer_flags)
 
-                configs_with_concurrency.append(new_perf_config)
-            self._configs.append(configs_with_concurrency)
+                configs_with_inference_load.append(new_perf_config)
+            self._configs.append(configs_with_inference_load)
 
     def _create_non_parameter_perf_config_values(self) -> dict:
         perf_config_values = {

model_analyzer/config/generate/quick_plus_concurrency_sweep_run_config_generator.py

@@ -1,21 +1,8 @@
 #!/usr/bin/env python3
-
-# Copyright 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import logging
-from copy import deepcopy
 from typing import Generator, List, Optional
 
 from model_analyzer.config.generate.concurrency_sweeper import ConcurrencySweeper
@@ -30,7 +17,6 @@ from model_analyzer.config.generate.search_config import SearchConfig
 from model_analyzer.config.input.config_command_profile import ConfigCommandProfile
 from model_analyzer.config.run.run_config import RunConfig
 from model_analyzer.constants import LOGGER_NAME
-from model_analyzer.result.parameter_search import ParameterSearch
 from model_analyzer.result.result_manager import ResultManager
 from model_analyzer.result.run_config_measurement import RunConfigMeasurement
 

model_analyzer/config/generate/quick_run_config_generator.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import logging
 from sys import maxsize
@@ -507,13 +495,13 @@ class QuickRunConfigGenerator(ConfigGeneratorInterface):
 
         perf_analyzer_config.update_config_from_profile_config(model_name, self._config)
 
-        concurrency = self._calculate_concurrency(dimension_values)
-
-        perf_config_params = {
-            "batch-size": DEFAULT_BATCH_SIZES,
-            "concurrency-range": concurrency,
-        }
-        perf_analyzer_config.update_config(perf_config_params)
+        if not model.is_load_specified():
+            concurrency = self._calculate_concurrency(dimension_values)
+            perf_config_params = {
+                "batch-size": DEFAULT_BATCH_SIZES,
+                "concurrency-range": concurrency,
+            }
+            perf_analyzer_config.update_config(perf_config_params)
 
         perf_analyzer_config.update_config(model.perf_analyzer_flags())
         return perf_analyzer_config
@@ -703,13 +691,13 @@ class QuickRunConfigGenerator(ConfigGeneratorInterface):
             model_config.get_field("name"), self._config
         )
 
-        default_concurrency = self._calculate_default_concurrency(model_config)
-
-        perf_config_params = {
-            "batch-size": DEFAULT_BATCH_SIZES,
-            "concurrency-range": default_concurrency,
-        }
-        default_perf_analyzer_config.update_config(perf_config_params)
+        if not model.is_load_specified():
+            default_concurrency = self._calculate_default_concurrency(model_config)
+            perf_config_params = {
+                "batch-size": DEFAULT_BATCH_SIZES,
+                "concurrency-range": default_concurrency,
+            }
+            default_perf_analyzer_config.update_config(perf_config_params)
 
         default_perf_analyzer_config.update_config(model.perf_analyzer_flags())
 

model_analyzer/config/input/config_defaults.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import os
 
@@ -64,7 +52,7 @@ DEFAULT_REQUEST_RATE_SEARCH_ENABLE = False
 DEFAULT_CONCURRENCY_SWEEP_DISABLE = False
 DEFAULT_DCGM_DISABLE = False
 DEFAULT_TRITON_LAUNCH_MODE = "local"
-DEFAULT_TRITON_DOCKER_IMAGE = "nvcr.io/nvidia/tritonserver:25.11-py3"
+DEFAULT_TRITON_DOCKER_IMAGE = "nvcr.io/nvidia/tritonserver:25.12-py3"
 DEFAULT_TRITON_HTTP_ENDPOINT = "localhost:8000"
 DEFAULT_TRITON_GRPC_ENDPOINT = "localhost:8001"
 DEFAULT_TRITON_METRICS_URL = "http://localhost:8002/metrics"

model_analyzer/perf_analyzer/perf_analyzer.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2020-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import csv
 import glob
@@ -432,8 +420,8 @@ class PerfAnalyzer:
         return cmd
 
     def _get_single_model_cmd(self, index):
-        if self._model_type == "LLM":
-            cmd = ["genai-perf", "-m", self._config.models_name()]
+        if self._model_type.lower() == "llm":
+            cmd = ["genai-perf", "profile", "-m", self._config.models_name()]
             cmd += self._get_genai_perf_cli_command(index).replace("=", " ").split()
             cmd += ["--"]
             cmd += (

model_analyzer/perf_analyzer/perf_config.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2020-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 from typing import List
 
@@ -98,6 +86,13 @@ class PerfAnalyzerConfig:
         "collect-metrics",
     ]
 
+    # Only one of these args can be sent to PA, as each one controls the inference load in a different way
+    inference_load_args = [
+        "concurrency-range",
+        "request-rate-range",
+        "request-intervals",
+    ]
+
     def __init__(self):
         """
         Construct a PerfAnalyzerConfig
@@ -108,7 +103,9 @@ class PerfAnalyzerConfig:
         self._options = {
             "-m": None,
             "-x": None,
-            "-b": None,
+            # Default to batch size of 1. This would be handled by PA if unspecified,
+            # but we want to be explicit so we can properly print/track values
+            "-b": 1,
             "-u": None,
             "-i": None,
             "-f": None,
@@ -160,6 +157,16 @@ class PerfAnalyzerConfig:
 
         return cls.additive_args[:]
 
+    @classmethod
+    def get_inference_load_args(cls):
+        """
+        Returns
+        -------
+        list of str
+            The Perf Analyzer args that control the inference load
+        """
+        return cls.inference_load_args
+
     def update_config(self, params=None):
         """
         Allows setting values from a params dict
@@ -275,6 +282,7 @@ class PerfAnalyzerConfig:
             "batch-size": self._options["-b"],
             "concurrency-range": self._args["concurrency-range"],
             "request-rate-range": self._args["request-rate-range"],
+            "request-intervals": self._args["request-intervals"],
         }
 
     @classmethod

model_analyzer/plots/detailed_plot.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import logging
 import os
@@ -22,6 +10,7 @@ import matplotlib.pyplot as plt
 from matplotlib import patches as mpatches
 
 from model_analyzer.constants import LOGGER_NAME
+from model_analyzer.perf_analyzer.perf_config import PerfAnalyzerConfig
 from model_analyzer.record.metrics_manager import MetricsManager
 
 logging.getLogger("matplotlib").setLevel(logging.ERROR)
@@ -89,7 +78,6 @@ class DetailedPlot:
         self._fig.set_figheight(8)
         self._fig.set_figwidth(12)
 
-        self._ax_latency.set_xlabel("Concurrent Client Requests")
         self._ax_latency.set_ylabel(latency_axis_label)
         self._ax_throughput.set_ylabel(throughput_axis_label)
 
@@ -120,29 +108,15 @@ class DetailedPlot:
         """
 
         # TODO-TMA-568: This needs to be updated because there will be multiple model configs
-        if (
-            "concurrency-range" in run_config_measurement.model_specific_pa_params()[0]
-            and run_config_measurement.model_specific_pa_params()[0][
-                "concurrency-range"
-            ]
-        ):
-            self._data["concurrency"].append(
-                run_config_measurement.model_specific_pa_params()[0][
-                    "concurrency-range"
-                ]
-            )
-
-        if (
-            "request-rate-range" in run_config_measurement.model_specific_pa_params()[0]
-            and run_config_measurement.model_specific_pa_params()[0][
-                "request-rate-range"
-            ]
-        ):
-            self._data["request_rate"].append(
-                run_config_measurement.model_specific_pa_params()[0][
-                    "request-rate-range"
-                ]
-            )
+        for load_arg in PerfAnalyzerConfig.get_inference_load_args():
+            if (
+                load_arg in run_config_measurement.model_specific_pa_params()[0]
+                and run_config_measurement.model_specific_pa_params()[0][load_arg]
+            ):
+                data_key = self._get_data_key_from_load_arg(load_arg)
+                self._data[data_key].append(
+                    run_config_measurement.model_specific_pa_params()[0][load_arg]
+                )
 
         self._data["perf_throughput"].append(
             run_config_measurement.get_non_gpu_metric_value(tag="perf_throughput")
@@ -164,25 +138,28 @@ class DetailedPlot:
         on this plot's Axes object
         """
 
-        # Need to change the default x-axis plot title for request rates
-        if "request_rate" in self._data and self._data["request_rate"][0]:
+        # Update the x-axis plot title
+        if "request_intervals" in self._data and self._data["request_intervals"][0]:
+            self._ax_latency.set_xlabel("Request Intervals File")
+            sort_indices_key = "request_intervals"
+        elif "request_rate" in self._data and self._data["request_rate"][0]:
             self._ax_latency.set_xlabel("Client Request Rate")
-
-        # Sort the data by request rate or concurrency
-        if "request_rate" in self._data and self._data["request_rate"][0]:
-            sort_indices = list(
-                zip(*sorted(enumerate(self._data["request_rate"]), key=lambda x: x[1]))
-            )[0]
+            sort_indices_key = "request_rate"
         else:
-            sort_indices = list(
-                zip(*sorted(enumerate(self._data["concurrency"]), key=lambda x: x[1]))
-            )[0]
+            self._ax_latency.set_xlabel("Concurrent Client Requests")
+            sort_indices_key = "concurrency"
+
+        sort_indices = list(
+            zip(*sorted(enumerate(self._data[sort_indices_key]), key=lambda x: x[1]))
+        )[0]
 
         sorted_data = {
             key: [data_list[i] for i in sort_indices]
             for key, data_list in self._data.items()
         }
 
+        sorted_data["indices"] = list(map(str, sorted_data[sort_indices_key]))
+
         # Plot latency breakdown bars
         labels = dict(
             zip(
@@ -197,11 +174,6 @@ class DetailedPlot:
         )
         bottoms = None
 
-        if "request_rate" in self._data:
-            sorted_data["indices"] = list(map(str, sorted_data["request_rate"]))
-        else:
-            sorted_data["indices"] = list(map(str, sorted_data["concurrency"]))
-
         # Plot latency breakdown with concurrency casted as string to make uniform x
         for metric, label in labels.items():
             self._ax_latency.bar(
@@ -264,3 +236,18 @@ class DetailedPlot:
         """
 
         self._fig.savefig(os.path.join(filepath, self._name))
+
+    def _get_data_key_from_load_arg(self, load_arg):
+        """
+        Gets the key into _data corresponding with the input load arg
+
+        For example, the load arg "request-rate-range" has the key "request_rate"
+        """
+        # Check if '-range' exists at the end of the input string and remove it
+        if load_arg.endswith("-range"):
+            load_arg = load_arg[:-6]
+
+        # Replace any '-' with '_' in the remaining string
+        data_key = load_arg.replace("-", "_")
+
+        return data_key

model_analyzer/record/metrics_manager.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import logging
 import os
@@ -782,7 +770,11 @@ class MetricsManager:
     def _print_run_config_info(self, run_config):
         for model_run_config in run_config.model_run_configs():
             perf_config = model_run_config.perf_config()
-            if perf_config["request-rate-range"]:
+            if perf_config["request-intervals"]:
+                logger.info(
+                    f"Profiling {model_run_config.model_variant_name()}: client batch size={perf_config['batch-size']}"
+                )
+            elif perf_config["request-rate-range"]:
                 if perf_config["batch-size"] != 1:
                     logger.info(
                         f"Profiling {model_run_config.model_variant_name()}: client batch size={perf_config['batch-size']}, request-rate-range={perf_config['request-rate-range']}"

model_analyzer/record/types/gpu_free_memory.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2020-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 from functools import total_ordering
 
@@ -27,6 +15,17 @@ class GPUFreeMemory(IncreasingGPURecord):
 
     tag = "gpu_free_memory"
 
+    @staticmethod
+    def value_function():
+        """
+        Returns the total value from a list
+
+        Returns
+        -------
+        Total value of the list
+        """
+        return sum
+
     def __init__(self, value, device_uuid=None, timestamp=0):
         """
         Parameters

model_analyzer/record/types/gpu_total_memory.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2020-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 from functools import total_ordering
 
@@ -27,6 +15,17 @@ class GPUTotalMemory(IncreasingGPURecord):
 
     tag = "gpu_total_memory"
 
+    @staticmethod
+    def value_function():
+        """
+        Returns the total value from a list
+
+        Returns
+        -------
+        Total value of the list
+        """
+        return sum
+
     def __init__(self, value, device_uuid=None, timestamp=0):
         """
         Parameters

model_analyzer/record/types/gpu_used_memory.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2020-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 from functools import total_ordering
 
@@ -27,6 +15,17 @@ class GPUUsedMemory(DecreasingGPURecord):
 
     tag = "gpu_used_memory"
 
+    @staticmethod
+    def value_function():
+        """
+        Returns the total value from a list
+
+        Returns
+        -------
+        Total value of the list
+        """
+        return sum
+
     def __init__(self, value, device_uuid=None, timestamp=0):
         """
         Parameters

model_analyzer/result/parameter_search.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import logging
 from math import log2
@@ -37,6 +25,8 @@ class ParameterSearch:
       - Will sweep from by powers of two from min to max parameter
       - If the user specifies a constraint, the algorithm will perform a binary search
         around the boundary if the constraint is violated
+      - Will not sweep at all if custom stimulus is provided by the user (via the
+        "request-intervals" perf analyzer flag)
 
     Invariant: It is necessary for the user to add new measurements as they are taken
     """
@@ -45,6 +35,7 @@ class ParameterSearch:
         self,
         config: ConfigCommandProfile,
         model_parameters: dict = {},
+        perf_analyzer_flags: dict = {},
         skip_parameter_sweep: bool = False,
     ) -> None:
         """
@@ -59,6 +50,7 @@ class ParameterSearch:
         self._parameter_is_request_rate = config.is_request_rate_specified(
             model_parameters
         )
+        self._inference_load_is_custom = "request-intervals" in perf_analyzer_flags
 
         if self._parameter_is_request_rate:
             self._min_parameter_index = int(
@@ -98,10 +90,11 @@ class ParameterSearch:
         a binary parameter search around the point where the constraint
         violated
         """
-        yield from self._perform_parameter_sweep()
+        if not self._inference_load_is_custom:
+            yield from self._perform_parameter_sweep()
 
-        if self._was_constraint_violated():
-            yield from self._perform_binary_parameter_search()
+            if self._was_constraint_violated():
+                yield from self._perform_binary_parameter_search()
 
     def _perform_parameter_sweep(self) -> Generator[int, None, None]:
         for parameter in (

model_analyzer/result/run_config_measurement.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import logging
 from copy import deepcopy
@@ -48,6 +36,9 @@ class RunConfigMeasurement:
         self._model_variants_name = model_variants_name
 
         self._gpu_data = gpu_data
+        # Note: "_avg_gpu_data" is a historical name. This actually contains
+        # aggregated GPU metrics: memory metrics are SUMMED, while utilization
+        # and power metrics are AVERAGED across GPUs.
         self._avg_gpu_data = self._average_list(list(self._gpu_data.values()))
         self._avg_gpu_data_from_tag = self._get_avg_gpu_data_from_tag()
 
@@ -213,7 +204,9 @@ class RunConfigMeasurement:
 
     def get_gpu_metric(self, tag: str) -> Optional[Record]:
         """
-        Returns the average of Records associated with this GPU metric
+        Returns the aggregated Record associated with this GPU metric
+        across all GPUs. GPU memory metrics are summed; other metrics
+        like utilization are averaged.
 
         Parameters
         ----------
@@ -224,7 +217,7 @@ class RunConfigMeasurement:
         Returns
         -------
         Record:
-            of average GPU metric Records corresponding to this tag,
+            of aggregated GPU metric Records corresponding to this tag,
             or None if tag not found
         """
         if tag in self._avg_gpu_data_from_tag:
@@ -320,8 +313,10 @@ class RunConfigMeasurement:
         Returns
         -------
         float :
-            Average of the values of the GPU metric Records
+            Aggregated value of the GPU metric Records across all GPUs
             corresponding to the tag, default_value if tag not found.
+            GPU memory metrics are summed; other metrics like utilization
+            are averaged.
         """
         metric = self.get_gpu_metric(tag)
         if metric is None:
@@ -615,7 +610,9 @@ class RunConfigMeasurement:
 
     def _average_list(self, row_list):
         """
-        Average a 2d list
+        Aggregate a 2d list of GPU records across GPUs.
+        Uses each record type's value_function() to determine
+        whether to sum or average the metric.
         """
 
         if not row_list:
@@ -623,13 +620,21 @@ class RunConfigMeasurement:
         else:
             N = len(row_list)
             d = len(row_list[0])
-            avg = [0 for _ in range(d)]
+            agg = [0 for _ in range(d)]
             for i in range(d):
-                avg[i] = (
-                    sum([row_list[j][i] for j in range(1, N)], start=row_list[0][i])
-                    * 1.0
-                ) / N
-            return avg
+                # Sum the records across all GPUs
+                summed_record = sum(
+                    [row_list[j][i] for j in range(1, N)], start=row_list[0][i]
+                )
+                # Get the aggregation function for this record type
+                value_func = row_list[0][i].value_function()
+                # If the value function is sum, use the sum directly
+                # If the value function is mean/average, divide by N
+                if value_func == sum:
+                    agg[i] = summed_record
+                else:
+                    agg[i] = summed_record / N
+            return agg
 
     def _deserialize_gpu_data(
         self, serialized_gpu_data: Dict

{triton_model_analyzer-1.48.0.dist-info → triton_model_analyzer-1.49.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: triton-model-analyzer
-Version: 1.48.0
+Version: 1.49.0
 Summary: Triton Model Analyzer is a tool to profile and analyze the runtime performance of one or more models on the Triton Inference Server
 Author-email: "NVIDIA Inc." <sw-dl-triton@nvidia.com>
 License-Expression: Apache-2.0

{triton_model_analyzer-1.48.0.dist-info → triton_model_analyzer-1.49.0.dist-info}/RECORD

@@ -11,7 +11,7 @@ model_analyzer/config/__init__.py,sha256=1vqDBvdG5Wrb-tDrHGyS9LC_cQst-QqLt5wOa3T
 model_analyzer/config/generate/__init__.py,sha256=4XgtPRt-6E1qrP6lxcqPIaEQb3V0yYu6EMtnVwAKdIY,647
 model_analyzer/config/generate/automatic_model_config_generator.py,sha256=EhpeYZlkAoSiKq1_QunXUBzbB7jPXSU2kyi3UpnzuOs,5797
 model_analyzer/config/generate/base_model_config_generator.py,sha256=sT8wghsLRgVT7-AWMTkrvdX-CeahFYdXzGEW0QgnQaI,12817
-model_analyzer/config/generate/brute_plus_binary_parameter_search_run_config_generator.py,sha256=qFmo7O3XarsUqPvkjDxWJTGwm7BIZpACVmcG6bmKrUk,6285
+model_analyzer/config/generate/brute_plus_binary_parameter_search_run_config_generator.py,sha256=fQ4NGO-1nUpX1wHbw6DPqnlXPGNCBLE_MrfWwYMpInk,6175
 model_analyzer/config/generate/brute_run_config_generator.py,sha256=bKYV3jFNpeE4cCIvBG8a3VYItjPzA0Lu_hyFukaQsUw,5484
 model_analyzer/config/generate/concurrency_sweeper.py,sha256=_VRCRw6iNgF3fJBdP46mywsy9Jz0QTBNSXyIHM4X0gk,2907
 model_analyzer/config/generate/config_generator_interface.py,sha256=4r2u5t7yrAqEeDTsfiPWEgqU0pesG3N5DChfweFPLm8,1681
@@ -20,15 +20,15 @@ model_analyzer/config/generate/coordinate_data.py,sha256=deqoRIvO0aN5D5sNDZcjmT0
 model_analyzer/config/generate/generator_utils.py,sha256=5hj7qGzVs-oHk6UK_ggBzKJiTDVdX6MSLrXyEfU-kFE,4157
 model_analyzer/config/generate/manual_model_config_generator.py,sha256=_Y78ORijg5E6c2a2zESwJzK55S8fbhoy2rqFTQq-seA,7088
 model_analyzer/config/generate/model_config_generator_factory.py,sha256=5BjSJxRmrEVy3LyjIPnMT-QCz8GABa62oY1VvJfmhbE,3334
-model_analyzer/config/generate/model_profile_spec.py,sha256=_OU1h_VTRbO7hdN7uKm_Emp-yZlpzRVk6_rQ5Kxx8Sc,2724
+model_analyzer/config/generate/model_profile_spec.py,sha256=fOCTNSK_GOOQ1FaRuCo_rDeVEf8H_67hUVERFlRndtM,2739
 model_analyzer/config/generate/model_run_config_generator.py,sha256=Ip1djtZ3wlwG_Zs3YivIlJxmwS1TsNa_7aMCU9bCQP0,5484
 model_analyzer/config/generate/model_variant_name_manager.py,sha256=qPAcvDQhkbArkW-A1A1mdRyqALUgfLlyV3dhNV6jKgs,5362
 model_analyzer/config/generate/neighborhood.py,sha256=s9g9igetHvF6Xm9FhuzjbhPBVWO65SngABrX3RGOUBQ,19481
 model_analyzer/config/generate/optuna_plus_concurrency_sweep_run_config_generator.py,sha256=iYCzT2gH-DH5mNbRMGM_UNyPNfRkObvjcrvy0TSKPD8,5861
 model_analyzer/config/generate/optuna_run_config_generator.py,sha256=Z09p5tZP8wl0hp9NpHXpGovv1dZZkZzH11FnuXe8HhU,33099
-model_analyzer/config/generate/perf_analyzer_config_generator.py,sha256=DVn5efgGWun8KwCnee1VdD9yCq0rtkB_8IvlkSaoqRk,11361
-model_analyzer/config/generate/quick_plus_concurrency_sweep_run_config_generator.py,sha256=QOd2qfQYgXbLmqxYZVQKllEvhfsyfAKGks-J5z42FLU,5091
-model_analyzer/config/generate/quick_run_config_generator.py,sha256=PEgmZuWL1R8VLgc15g0KJtsSrx-UIiTWy5XaIxxz-uw,28071
+model_analyzer/config/generate/perf_analyzer_config_generator.py,sha256=cCLQTV5V65QelGFMP3B4JaYvejNZj4tHJUQSZ3nTZSY,11112
+model_analyzer/config/generate/quick_plus_concurrency_sweep_run_config_generator.py,sha256=hAL6YD6hqLDL7ttOgJuDIUvEe6BpHNlYv82cQdHUo5o,4516
+model_analyzer/config/generate/quick_run_config_generator.py,sha256=ccs8W7Bh20pmxel5iQF92pF7pirpaBQeveQNhUwWPq0,27719
 model_analyzer/config/generate/run_config_generator_factory.py,sha256=KPjZGz0R-upqf7pwrtWrVRroNC-aDPeGZd63XR92zDU,13008
 model_analyzer/config/generate/search_config.py,sha256=mvQaoQ9wIeNEHWJtIwXh0JujPQZqXLLXmWpI7uBHDGA,3655
 model_analyzer/config/generate/search_dimension.py,sha256=iUoh4IhhMy9zhMhaY-q9DoBEku4--4o4j8RYQfXUVVk,2375
@@ -39,7 +39,7 @@ model_analyzer/config/input/__init__.py,sha256=1vqDBvdG5Wrb-tDrHGyS9LC_cQst-QqLt
 model_analyzer/config/input/config_command.py,sha256=63Y6aJrGBA-tR5eljlZSNwgFbHc4hZYd8mEOpmdrJxc,18776
 model_analyzer/config/input/config_command_profile.py,sha256=P5V0y_J3p6BCDCu_QBsl5AXaz_Y73y7CpiessWbuCy4,70509
 model_analyzer/config/input/config_command_report.py,sha256=Igiid6XK5OB23jvXZKPI4Pg5ZsSDkXgHU-QAGOo6_-E,9535
-model_analyzer/config/input/config_defaults.py,sha256=CnaT5JjCq0ne3977y5Yvcpi9fjsUdNXc45NbUU6DWe4,6684
+model_analyzer/config/input/config_defaults.py,sha256=DYmjHUPQxqhlhRmE2VtzLBHhdwhk-zXkMrlTJuYQGTg,6202
 model_analyzer/config/input/config_enum.py,sha256=lu9cUz_MY52EcLEXxcLYWqB5If6FhsM1K8w1srzhDt4,2386
 model_analyzer/config/input/config_field.py,sha256=XlqlouNuPENEYCBLYtHxsfMACrFlcYZGkbh6yE1psNo,5156
 model_analyzer/config/input/config_list_generic.py,sha256=-4vhDxIEMPOwYcUIkMIFzxJ61mOmX6GEgGCpTfbCFsc,3355
@@ -103,24 +103,24 @@ model_analyzer/output/file_writer.py,sha256=NbAbjLFBcHZMYOJF-3Af9dqGVjS8WRGsQDid
 model_analyzer/output/output_writer.py,sha256=JZ-e0uzrpNybKaAup0hLmvIuGn9v1Z5OsB8yMHX074A,1200
 model_analyzer/perf_analyzer/__init__.py,sha256=oA0IPbS32uHtDFDRhaVyzOCU717OJAgXZkq9db1uGaA,647
 model_analyzer/perf_analyzer/genai_perf_config.py,sha256=9g4081ttiAqV1H3vft3Brqx3nArslyAFspJODboj72g,5673
-model_analyzer/perf_analyzer/perf_analyzer.py,sha256=b9DZH6tyDP4yH2c2aHckKsWjoZG_07NBf-EuQigwqPU,31530
-model_analyzer/perf_analyzer/perf_config.py,sha256=jAtf10JIQCEwzeOzoQy6o66uIabP0ikmfEQKyy0XfrQ,14504
+model_analyzer/perf_analyzer/perf_analyzer.py,sha256=wcE6CIL_OKHFnJkipXb_mP8koBLXHOZb51OT4kR-JMQ,31067
+model_analyzer/perf_analyzer/perf_config.py,sha256=nQHxZaIGp--JoCeTp2c5spA_o5o6H4dAgnLyrmvlGvM,14718
 model_analyzer/plots/__init__.py,sha256=1vqDBvdG5Wrb-tDrHGyS9LC_cQst-QqLt5wOa3TD9rI,647
-model_analyzer/plots/detailed_plot.py,sha256=wEBl4mrE9k-JNKheY78b8pnziRoXiXd7xvDLivGPJsE,8567
+model_analyzer/plots/detailed_plot.py,sha256=nRxPM3MmsUsvmKpzJYST991pcmYCEXQWj2EhA11gTXg,8164
 model_analyzer/plots/plot_manager.py,sha256=CFDUSF8Xm-1Uesg8dQSC5z8JSXa40mKtDNN2kVKP0ek,8962
 model_analyzer/plots/simple_plot.py,sha256=udtWBXy_Y2UPWFEP4xhb-FWfjCjB4OWJwWN5lyJALhc,7163
 model_analyzer/record/__init__.py,sha256=oA0IPbS32uHtDFDRhaVyzOCU717OJAgXZkq9db1uGaA,647
 model_analyzer/record/gpu_record.py,sha256=7X9g6Y1efqiA9a9i80iIxLLWnk6121pYtk36WD8d62c,1872
-model_analyzer/record/metrics_manager.py,sha256=yy_rfXEM2xNsOlMTd_wy__aPQovZE23o4Oc4GsPleBs,32437
+model_analyzer/record/metrics_manager.py,sha256=D3gBuL73maQbWNq_gNMUVXisfZnwVwhiMHFgJ2ZB_3c,32173
 model_analyzer/record/record.py,sha256=asjFF8E3t6abXYd9RZCOG-w1AVVZRb5u9PHgxvMqgGA,7284
 model_analyzer/record/record_aggregator.py,sha256=YFA1Av6m3oB_0kTGgvtUZEt4TZz8vL85uqnDCVRdvJI,8051
 model_analyzer/record/types/__init__.py,sha256=oA0IPbS32uHtDFDRhaVyzOCU717OJAgXZkq9db1uGaA,647
 model_analyzer/record/types/cpu_available_ram.py,sha256=DHhg_pePj8A0gSCPLIAHJnxZpdwoaWcaRMiBHyC5nTU,2431
 model_analyzer/record/types/cpu_used_ram.py,sha256=h26jXoyGBHEeiE2Mvmwo6hpVaGBBYvZNQ8Fo0EMIBL4,2412
-model_analyzer/record/types/gpu_free_memory.py,sha256=aIttS0ZgBIlBB_u_OU4ZeaNZNnv0jyI-TV0mfVYJTQQ,2626
+model_analyzer/record/types/gpu_free_memory.py,sha256=_pksqjMi3guIMBIGVEpBamY86nT1V8o2phvEfvhsHBM,2341
 model_analyzer/record/types/gpu_power_usage.py,sha256=eIlggXrIJ3E9qveprOiVNrMsITom4WiWKsLaDJMD8Lg,2903
-model_analyzer/record/types/gpu_total_memory.py,sha256=zIou4DWtx0XJ1isBYZQDGjaYkl0bgZKGFlZxxgRw-I0,2631
-model_analyzer/record/types/gpu_used_memory.py,sha256=MH8MfPbXJFXGVNdeQDg5QMDvmdq0BOmKjydMauLIdnU,2622
+model_analyzer/record/types/gpu_total_memory.py,sha256=QI_MFIP2G38mmpsml6Qmyz3bvG5tgKCpa8RziWIfM4k,2346
+model_analyzer/record/types/gpu_used_memory.py,sha256=3tdjaSffCVLcfG7kLiNs3muwm-mBZld-n2VEKwJ450w,2337
 model_analyzer/record/types/gpu_utilization.py,sha256=h9wqr1NtBDpYzHKTmZyXUhRriEz1_DAJRfYITmSQdsE,2880
 model_analyzer/record/types/inter_token_latency_avg.py,sha256=i7jqWwdBcRyMblzdv-s8d1ET2-BdQq39WPt5WFaO7nE,1744
 model_analyzer/record/types/inter_token_latency_base.py,sha256=fUf-0aT_TbbIH7iKbQDEu2sAser6G24--MAn8Vac4bA,2062
@@ -167,14 +167,14 @@ model_analyzer/result/__init__.py,sha256=1vqDBvdG5Wrb-tDrHGyS9LC_cQst-QqLt5wOa3T
 model_analyzer/result/constraint_manager.py,sha256=nfHsBbX-66QN19uMH8ZBn68_mAaL0M30HMIG9N8KcBg,5005
 model_analyzer/result/model_config_measurement.py,sha256=qwsPF-ea17Gl5EyFu9OWNWJrvl5hWzeqAkQo5bPgwfE,10657
 model_analyzer/result/model_constraints.py,sha256=HXtbGK8mswXpCwWwrAantXb4sxhGo1bCWurwf9vW9KA,2687
-model_analyzer/result/parameter_search.py,sha256=vvlt8A-vTU7FOTsJwCv8P6-4QmxNgnIwC-o1ts72LTo,9069
+model_analyzer/result/parameter_search.py,sha256=kw-kkxV7FlHKYThcdZoybaIxH-dILP5lAmdNc1OW_RI,8901
 model_analyzer/result/result_manager.py,sha256=e_PWQV_33IM4SiLI7BGcmVtEMAe6IE_dZWbaf-DkXBo,15477
 model_analyzer/result/result_statistics.py,sha256=wvqs64W8rZftN59rcQiH7Bmd0dfSAD7a9BGK_K1LYTI,4343
 model_analyzer/result/result_table.py,sha256=NYwiPtkD_uSBn61omvkMvuLi-FBdMq0wHDlgcz9Gk7w,5843
 model_analyzer/result/result_table_manager.py,sha256=UKAMSbS8o3CtM_4uSNaDNWxX6ZlGRqohgVcrZeihtgY,23643
 model_analyzer/result/result_utils.py,sha256=EJXMo7csgqwonROb8_-hFeysnu-JDfj2Gf8naWHsw2s,1379
 model_analyzer/result/results.py,sha256=YZlz5oJPPYNM4Nub4r_UNKMphKDT44_30iVjp5S4lds,8675
-model_analyzer/result/run_config_measurement.py,sha256=E1pN6ozY2EMjLbycF2crpUDlJew3b3j2uDgHOJvnC40,21047
+model_analyzer/result/run_config_measurement.py,sha256=CKlz8l1dvcFaThZpeKrEr9eLw3drlT3gVBSrsFZf6ZU,21577
 model_analyzer/result/run_config_result.py,sha256=cs2fE-ISeInBErfJYG_L_3BuJjXNPDzIASYmwgU1JYE,6422
 model_analyzer/result/run_config_result_comparator.py,sha256=xLRYEdF2TLRSbCl0Qj3OTfNiYa5RPtOkv_BtQibfwfc,3759
 model_analyzer/result/sorted_results.py,sha256=ScWaT44X4-kplFv4lo9AClXEpA22DtwA6t8GPS2BTiw,4694
@@ -196,9 +196,9 @@ model_analyzer/triton/server/server_config.py,sha256=3pNQAnUmSXVAO7pKLNWak7AFGm1
 model_analyzer/triton/server/server_docker.py,sha256=38e_tMniv2PBiEIh2KMxgqsMZlttL0yCrpD0lKd0r5g,8248
 model_analyzer/triton/server/server_factory.py,sha256=WMZfXFQfO9aeFxCWewQhRk9ygMcne0ershGZ75XQ5IE,11152
 model_analyzer/triton/server/server_local.py,sha256=i5t5MaDwfvWqBA3zG15GPkGiUm6I4Bb4i0d-wBP0WNs,5406
-triton_model_analyzer-1.48.0.dist-info/licenses/LICENSE,sha256=vs3gOjyLmy49WMe2XKf_2eGOmBYjlsw3QFKYPB-qpHw,9144
-triton_model_analyzer-1.48.0.dist-info/METADATA,sha256=EndFgBdQhc5lMdwR8MGlxmOV8R8tehbxFX6MONLSXbM,2512
-triton_model_analyzer-1.48.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-triton_model_analyzer-1.48.0.dist-info/entry_points.txt,sha256=k6Q0D76sL3qUNxe80hUThftycJAT7Sj5dBk8IjHXJoI,66
-triton_model_analyzer-1.48.0.dist-info/top_level.txt,sha256=mTebknhUDSE7cCVyUtpzNVQ-tEUi8zZKFvp15xpIP2c,15
-triton_model_analyzer-1.48.0.dist-info/RECORD,,
+triton_model_analyzer-1.49.0.dist-info/licenses/LICENSE,sha256=vs3gOjyLmy49WMe2XKf_2eGOmBYjlsw3QFKYPB-qpHw,9144
+triton_model_analyzer-1.49.0.dist-info/METADATA,sha256=ebuhiEKjcPklcz1N1BXDHRZRM2B_a1OyAHCGBeirh_I,2512
+triton_model_analyzer-1.49.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+triton_model_analyzer-1.49.0.dist-info/entry_points.txt,sha256=k6Q0D76sL3qUNxe80hUThftycJAT7Sj5dBk8IjHXJoI,66
+triton_model_analyzer-1.49.0.dist-info/top_level.txt,sha256=mTebknhUDSE7cCVyUtpzNVQ-tEUi8zZKFvp15xpIP2c,15
+triton_model_analyzer-1.49.0.dist-info/RECORD,,