├── .clang-format ├── .devcontainer └── devcontainer.json ├── .github └── workflows │ ├── codeql.yml │ ├── mirror_repo.sh │ ├── pre-commit.yml │ ├── python-package-genai.yml │ └── trigger_ci.yml ├── .gitignore ├── .pre-commit-config.yaml ├── CMakeLists.txt ├── LICENSE ├── README.md ├── SECURITY.md ├── docs ├── README.md ├── benchmarking.md ├── cli.md ├── inference_load_modes.md ├── input_data.md ├── install.md ├── measurements_metrics.md └── quick_start.md ├── genai-perf ├── .gitignore ├── LICENSE ├── README.md ├── docs │ ├── analyze.md │ ├── assets │ │ ├── custom_gpu_metrics.csv │ │ ├── distribution_of_input_sequence_lengths_to_output_sequence_lengths.jpeg │ │ ├── request_latency.jpeg │ │ ├── time_to_first_token.jpeg │ │ ├── time_to_first_token_vs_input_sequence_lengths.jpeg │ │ └── token-to-token_latency_vs_output_token_position.jpeg │ ├── customizable_frontends.md │ ├── customizable_payloads.md │ ├── dynamo.md │ ├── embeddings.md │ ├── example_plots.md │ ├── files.md │ ├── goodput.md │ ├── gpu_telemetry.md │ ├── huggingface_tgi.md │ ├── lora.md │ ├── multi_modal.md │ ├── multi_turn.md │ ├── process_export_files.md │ ├── rankings.md │ └── tutorial.md ├── genai_perf │ ├── .gitignore │ ├── __init__.py │ ├── checkpoint │ │ └── checkpoint.py │ ├── config │ │ ├── endpoint_config.py │ │ ├── generate │ │ │ ├── genai_perf_config.py │ │ │ ├── objective_parameter.py │ │ │ ├── perf_analyzer_config.py │ │ │ ├── search_parameter.py │ │ │ ├── search_parameters.py │ │ │ └── sweep_objective_generator.py │ │ ├── input │ │ │ ├── base_config.py │ │ │ ├── config_analyze.py │ │ │ ├── config_command.py │ │ │ ├── config_defaults.py │ │ │ ├── config_endpoint.py │ │ │ ├── config_field.py │ │ │ ├── config_input.py │ │ │ ├── config_output.py │ │ │ ├── config_perf_analyzer.py │ │ │ ├── config_process.py │ │ │ ├── config_tokenizer.py │ │ │ └── create_config.py │ │ ├── model_spec.py │ │ └── run │ │ │ ├── results.py │ │ │ └── run_config.py │ ├── constants.py │ ├── exceptions.py │ ├── export_data │ │ ├── console_exporter.py │ │ ├── csv_exporter.py │ │ ├── data_exporter_factory.py │ │ ├── data_exporter_interface.py │ │ ├── exporter_config.py │ │ ├── exporter_utils.py │ │ ├── json_exporter.py │ │ ├── output_reporter.py │ │ └── telemetry_data_exporter_util.py │ ├── goodput_calculator │ │ ├── __init__.py │ │ ├── goodput_calculator.py │ │ └── llm_goodput_calculator.py │ ├── inputs │ │ ├── __init__.py │ │ ├── converters │ │ │ ├── __init__.py │ │ │ ├── base_converter.py │ │ │ ├── dynamic_grpc_converter.py │ │ │ ├── huggingface_generate_converter.py │ │ │ ├── image_retrieval_converter.py │ │ │ ├── nvclip_converter.py │ │ │ ├── openai_chat_completions_converter.py │ │ │ ├── openai_completions_converter.py │ │ │ ├── openai_embeddings_converter.py │ │ │ ├── output_format_converter_factory.py │ │ │ ├── rankings_converter.py │ │ │ ├── template_converter.py │ │ │ ├── tensorrtllm_converter.py │ │ │ ├── tensorrtllm_engine_converter.py │ │ │ ├── triton_generate_converter.py │ │ │ └── vllm_converter.py │ │ ├── input_constants.py │ │ ├── inputs.py │ │ ├── inputs_config.py │ │ └── retrievers │ │ │ ├── __init__.py │ │ │ ├── base_file_input_retriever.py │ │ │ ├── base_input_retriever.py │ │ │ ├── file_input_retriever.py │ │ │ ├── generic_dataset.py │ │ │ ├── input_retriever_factory.py │ │ │ ├── payload_input_retriever.py │ │ │ ├── shakespeare.txt │ │ │ ├── source_images │ │ │ ├── dlss.png │ │ │ ├── h100.jpeg │ │ │ ├── h200.jpeg │ │ │ └── jensen.jpeg │ │ │ ├── synthetic_audio_generator.py │ │ │ ├── synthetic_data_retriever.py │ │ │ ├── synthetic_image_generator.py │ │ │ └── synthetic_prompt_generator.py │ ├── logging.py │ ├── main.py │ ├── measurements │ │ ├── model_config_measurement.py │ │ ├── model_constraints.py │ │ ├── run_config_measurement.py │ │ └── run_constraints.py │ ├── metrics │ │ ├── __init__.py │ │ ├── image_retrieval_metrics.py │ │ ├── llm_metrics.py │ │ ├── metrics.py │ │ ├── statistics.py │ │ ├── telemetry_metrics.py │ │ ├── telemetry_statistics.py │ │ └── telemetry_stats_aggregator.py │ ├── parser.py │ ├── plots │ │ ├── __init__.py │ │ ├── base_plot.py │ │ ├── box_plot.py │ │ ├── heat_map.py │ │ ├── plot_config.py │ │ ├── plot_config_parser.py │ │ ├── plot_manager.py │ │ └── scatter_plot.py │ ├── profile_data_parser │ │ ├── __init__.py │ │ ├── image_retrieval_profile_data_parser.py │ │ ├── llm_profile_data_parser.py │ │ ├── merged_profile_parser.py │ │ └── profile_data_parser.py │ ├── record │ │ ├── gpu_record.py │ │ ├── record.py │ │ └── types │ │ │ ├── __init__.py │ │ │ ├── energy_consumption_avg.py │ │ │ ├── energy_consumption_base.py │ │ │ ├── energy_consumption_max.py │ │ │ ├── energy_consumption_min.py │ │ │ ├── energy_consumption_p1.py │ │ │ ├── energy_consumption_p10.py │ │ │ ├── energy_consumption_p25.py │ │ │ ├── energy_consumption_p5.py │ │ │ ├── energy_consumption_p50.py │ │ │ ├── energy_consumption_p75.py │ │ │ ├── energy_consumption_p90.py │ │ │ ├── energy_consumption_p95.py │ │ │ ├── energy_consumption_p99.py │ │ │ ├── energy_consumption_std.py │ │ │ ├── gpu_clock_memory_avg.py │ │ │ ├── gpu_clock_memory_base.py │ │ │ ├── gpu_clock_memory_max.py │ │ │ ├── gpu_clock_memory_min.py │ │ │ ├── gpu_clock_memory_p1.py │ │ │ ├── gpu_clock_memory_p10.py │ │ │ ├── gpu_clock_memory_p25.py │ │ │ ├── gpu_clock_memory_p5.py │ │ │ ├── gpu_clock_memory_p50.py │ │ │ ├── gpu_clock_memory_p75.py │ │ │ ├── gpu_clock_memory_p90.py │ │ │ ├── gpu_clock_memory_p95.py │ │ │ ├── gpu_clock_memory_p99.py │ │ │ ├── gpu_clock_memory_std.py │ │ │ ├── gpu_clock_sm_avg.py │ │ │ ├── gpu_clock_sm_base.py │ │ │ ├── gpu_clock_sm_max.py │ │ │ ├── gpu_clock_sm_min.py │ │ │ ├── gpu_clock_sm_p1.py │ │ │ ├── gpu_clock_sm_p10.py │ │ │ ├── gpu_clock_sm_p25.py │ │ │ ├── gpu_clock_sm_p5.py │ │ │ ├── gpu_clock_sm_p50.py │ │ │ ├── gpu_clock_sm_p75.py │ │ │ ├── gpu_clock_sm_p90.py │ │ │ ├── gpu_clock_sm_p95.py │ │ │ ├── gpu_clock_sm_p99.py │ │ │ ├── gpu_clock_sm_std.py │ │ │ ├── gpu_energy_consumption_avg.py │ │ │ ├── gpu_memory_free_avg.py │ │ │ ├── gpu_memory_free_base.py │ │ │ ├── gpu_memory_free_max.py │ │ │ ├── gpu_memory_free_min.py │ │ │ ├── gpu_memory_free_p1.py │ │ │ ├── gpu_memory_free_p10.py │ │ │ ├── gpu_memory_free_p25.py │ │ │ ├── gpu_memory_free_p5.py │ │ │ ├── gpu_memory_free_p50.py │ │ │ ├── gpu_memory_free_p75.py │ │ │ ├── gpu_memory_free_p90.py │ │ │ ├── gpu_memory_free_p95.py │ │ │ ├── gpu_memory_free_p99.py │ │ │ ├── gpu_memory_free_std.py │ │ │ ├── gpu_memory_temperature_avg.py │ │ │ ├── gpu_memory_temperature_base.py │ │ │ ├── gpu_memory_temperature_max.py │ │ │ ├── gpu_memory_temperature_min.py │ │ │ ├── gpu_memory_temperature_p1.py │ │ │ ├── gpu_memory_temperature_p10.py │ │ │ ├── gpu_memory_temperature_p25.py │ │ │ ├── gpu_memory_temperature_p5.py │ │ │ ├── gpu_memory_temperature_p50.py │ │ │ ├── gpu_memory_temperature_p75.py │ │ │ ├── gpu_memory_temperature_p90.py │ │ │ ├── gpu_memory_temperature_p95.py │ │ │ ├── gpu_memory_temperature_p99.py │ │ │ ├── gpu_memory_temperature_std.py │ │ │ ├── gpu_memory_used_avg.py │ │ │ ├── gpu_memory_used_base.py │ │ │ ├── gpu_memory_used_max.py │ │ │ ├── gpu_memory_used_min.py │ │ │ ├── gpu_memory_used_p1.py │ │ │ ├── gpu_memory_used_p10.py │ │ │ ├── gpu_memory_used_p25.py │ │ │ ├── gpu_memory_used_p5.py │ │ │ ├── gpu_memory_used_p50.py │ │ │ ├── gpu_memory_used_p75.py │ │ │ ├── gpu_memory_used_p90.py │ │ │ ├── gpu_memory_used_p95.py │ │ │ ├── gpu_memory_used_p99.py │ │ │ ├── gpu_memory_used_std.py │ │ │ ├── gpu_power_limit_avg.py │ │ │ ├── gpu_power_limit_base.py │ │ │ ├── gpu_power_usage_avg.py │ │ │ ├── gpu_power_usage_base.py │ │ │ ├── gpu_power_usage_max.py │ │ │ ├── gpu_power_usage_min.py │ │ │ ├── gpu_power_usage_p1.py │ │ │ ├── gpu_power_usage_p10.py │ │ │ ├── gpu_power_usage_p25.py │ │ │ ├── gpu_power_usage_p5.py │ │ │ ├── gpu_power_usage_p50.py │ │ │ ├── gpu_power_usage_p75.py │ │ │ ├── gpu_power_usage_p90.py │ │ │ ├── gpu_power_usage_p95.py │ │ │ ├── gpu_power_usage_p99.py │ │ │ ├── gpu_power_usage_std.py │ │ │ ├── gpu_temperature_avg.py │ │ │ ├── gpu_temperature_base.py │ │ │ ├── gpu_temperature_max.py │ │ │ ├── gpu_temperature_min.py │ │ │ ├── gpu_temperature_p1.py │ │ │ ├── gpu_temperature_p10.py │ │ │ ├── gpu_temperature_p25.py │ │ │ ├── gpu_temperature_p5.py │ │ │ ├── gpu_temperature_p50.py │ │ │ ├── gpu_temperature_p75.py │ │ │ ├── gpu_temperature_p90.py │ │ │ ├── gpu_temperature_p95.py │ │ │ ├── gpu_temperature_p99.py │ │ │ ├── gpu_temperature_std.py │ │ │ ├── gpu_utilization_avg.py │ │ │ ├── gpu_utilization_base.py │ │ │ ├── gpu_utilization_max.py │ │ │ ├── gpu_utilization_min.py │ │ │ ├── gpu_utilization_p1.py │ │ │ ├── gpu_utilization_p10.py │ │ │ ├── gpu_utilization_p25.py │ │ │ ├── gpu_utilization_p5.py │ │ │ ├── gpu_utilization_p50.py │ │ │ ├── gpu_utilization_p75.py │ │ │ ├── gpu_utilization_p90.py │ │ │ ├── gpu_utilization_p95.py │ │ │ ├── gpu_utilization_p99.py │ │ │ ├── gpu_utilization_std.py │ │ │ ├── input_sequence_length_avg.py │ │ │ ├── input_sequence_length_base.py │ │ │ ├── input_sequence_length_max.py │ │ │ ├── input_sequence_length_min.py │ │ │ ├── input_sequence_length_p1.py │ │ │ ├── input_sequence_length_p10.py │ │ │ ├── input_sequence_length_p25.py │ │ │ ├── input_sequence_length_p5.py │ │ │ ├── input_sequence_length_p50.py │ │ │ ├── input_sequence_length_p75.py │ │ │ ├── input_sequence_length_p90.py │ │ │ ├── input_sequence_length_p95.py │ │ │ ├── input_sequence_length_p99.py │ │ │ ├── input_sequence_length_std.py │ │ │ ├── inter_token_latency_avg.py │ │ │ ├── inter_token_latency_base.py │ │ │ ├── inter_token_latency_max.py │ │ │ ├── inter_token_latency_min.py │ │ │ ├── inter_token_latency_p1.py │ │ │ ├── inter_token_latency_p10.py │ │ │ ├── inter_token_latency_p25.py │ │ │ ├── inter_token_latency_p5.py │ │ │ ├── inter_token_latency_p50.py │ │ │ ├── inter_token_latency_p75.py │ │ │ ├── inter_token_latency_p90.py │ │ │ ├── inter_token_latency_p95.py │ │ │ ├── inter_token_latency_p99.py │ │ │ ├── inter_token_latency_std.py │ │ │ ├── memory_copy_utilization_avg.py │ │ │ ├── memory_copy_utilization_base.py │ │ │ ├── memory_copy_utilization_max.py │ │ │ ├── memory_copy_utilization_min.py │ │ │ ├── memory_copy_utilization_p1.py │ │ │ ├── memory_copy_utilization_p10.py │ │ │ ├── memory_copy_utilization_p25.py │ │ │ ├── memory_copy_utilization_p5.py │ │ │ ├── memory_copy_utilization_p50.py │ │ │ ├── memory_copy_utilization_p75.py │ │ │ ├── memory_copy_utilization_p90.py │ │ │ ├── memory_copy_utilization_p95.py │ │ │ ├── memory_copy_utilization_p99.py │ │ │ ├── memory_copy_utilization_std.py │ │ │ ├── output_sequence_length_avg.py │ │ │ ├── output_sequence_length_base.py │ │ │ ├── output_sequence_length_max.py │ │ │ ├── output_sequence_length_min.py │ │ │ ├── output_sequence_length_p1.py │ │ │ ├── output_sequence_length_p10.py │ │ │ ├── output_sequence_length_p25.py │ │ │ ├── output_sequence_length_p5.py │ │ │ ├── output_sequence_length_p50.py │ │ │ ├── output_sequence_length_p75.py │ │ │ ├── output_sequence_length_p90.py │ │ │ ├── output_sequence_length_p95.py │ │ │ ├── output_sequence_length_p99.py │ │ │ ├── output_sequence_length_std.py │ │ │ ├── output_token_throughput_avg.py │ │ │ ├── output_token_throughput_per_user_avg.py │ │ │ ├── output_token_throughput_per_user_base.py │ │ │ ├── output_token_throughput_per_user_max.py │ │ │ ├── output_token_throughput_per_user_min.py │ │ │ ├── output_token_throughput_per_user_p1.py │ │ │ ├── output_token_throughput_per_user_p10.py │ │ │ ├── output_token_throughput_per_user_p25.py │ │ │ ├── output_token_throughput_per_user_p5.py │ │ │ ├── output_token_throughput_per_user_p50.py │ │ │ ├── output_token_throughput_per_user_p75.py │ │ │ ├── output_token_throughput_per_user_p90.py │ │ │ ├── output_token_throughput_per_user_p95.py │ │ │ ├── output_token_throughput_per_user_p99.py │ │ │ ├── output_token_throughput_per_user_std.py │ │ │ ├── pcie_receive_throughput_avg.py │ │ │ ├── pcie_receive_throughput_base.py │ │ │ ├── pcie_receive_throughput_max.py │ │ │ ├── pcie_receive_throughput_min.py │ │ │ ├── pcie_receive_throughput_p1.py │ │ │ ├── pcie_receive_throughput_p10.py │ │ │ ├── pcie_receive_throughput_p25.py │ │ │ ├── pcie_receive_throughput_p5.py │ │ │ ├── pcie_receive_throughput_p50.py │ │ │ ├── pcie_receive_throughput_p75.py │ │ │ ├── pcie_receive_throughput_p90.py │ │ │ ├── pcie_receive_throughput_p95.py │ │ │ ├── pcie_receive_throughput_p99.py │ │ │ ├── pcie_receive_throughput_std.py │ │ │ ├── pcie_replay_counter_avg.py │ │ │ ├── pcie_replay_counter_base.py │ │ │ ├── pcie_replay_counter_max.py │ │ │ ├── pcie_replay_counter_min.py │ │ │ ├── pcie_replay_counter_p1.py │ │ │ ├── pcie_replay_counter_p10.py │ │ │ ├── pcie_replay_counter_p25.py │ │ │ ├── pcie_replay_counter_p5.py │ │ │ ├── pcie_replay_counter_p50.py │ │ │ ├── pcie_replay_counter_p75.py │ │ │ ├── pcie_replay_counter_p90.py │ │ │ ├── pcie_replay_counter_p95.py │ │ │ ├── pcie_replay_counter_p99.py │ │ │ ├── pcie_replay_counter_std.py │ │ │ ├── pcie_transmit_throughput_avg.py │ │ │ ├── pcie_transmit_throughput_base.py │ │ │ ├── pcie_transmit_throughput_max.py │ │ │ ├── pcie_transmit_throughput_min.py │ │ │ ├── pcie_transmit_throughput_p1.py │ │ │ ├── pcie_transmit_throughput_p10.py │ │ │ ├── pcie_transmit_throughput_p25.py │ │ │ ├── pcie_transmit_throughput_p5.py │ │ │ ├── pcie_transmit_throughput_p50.py │ │ │ ├── pcie_transmit_throughput_p75.py │ │ │ ├── pcie_transmit_throughput_p90.py │ │ │ ├── pcie_transmit_throughput_p95.py │ │ │ ├── pcie_transmit_throughput_p99.py │ │ │ ├── pcie_transmit_throughput_std.py │ │ │ ├── power_throttle_duration_avg.py │ │ │ ├── power_throttle_duration_base.py │ │ │ ├── power_throttle_duration_max.py │ │ │ ├── power_throttle_duration_min.py │ │ │ ├── power_throttle_duration_p1.py │ │ │ ├── power_throttle_duration_p10.py │ │ │ ├── power_throttle_duration_p25.py │ │ │ ├── power_throttle_duration_p5.py │ │ │ ├── power_throttle_duration_p50.py │ │ │ ├── power_throttle_duration_p75.py │ │ │ ├── power_throttle_duration_p90.py │ │ │ ├── power_throttle_duration_p95.py │ │ │ ├── power_throttle_duration_p99.py │ │ │ ├── power_throttle_duration_std.py │ │ │ ├── request_count_avg.py │ │ │ ├── request_goodput_avg.py │ │ │ ├── request_latency_avg.py │ │ │ ├── request_latency_base.py │ │ │ ├── request_latency_max.py │ │ │ ├── request_latency_min.py │ │ │ ├── request_latency_p1.py │ │ │ ├── request_latency_p10.py │ │ │ ├── request_latency_p25.py │ │ │ ├── request_latency_p5.py │ │ │ ├── request_latency_p50.py │ │ │ ├── request_latency_p75.py │ │ │ ├── request_latency_p90.py │ │ │ ├── request_latency_p95.py │ │ │ ├── request_latency_p99.py │ │ │ ├── request_latency_std.py │ │ │ ├── request_throughput_avg.py │ │ │ ├── retired_pages_dbe_avg.py │ │ │ ├── retired_pages_dbe_base.py │ │ │ ├── retired_pages_dbe_max.py │ │ │ ├── retired_pages_dbe_min.py │ │ │ ├── retired_pages_dbe_p1.py │ │ │ ├── retired_pages_dbe_p10.py │ │ │ ├── retired_pages_dbe_p25.py │ │ │ ├── retired_pages_dbe_p5.py │ │ │ ├── retired_pages_dbe_p50.py │ │ │ ├── retired_pages_dbe_p75.py │ │ │ ├── retired_pages_dbe_p90.py │ │ │ ├── retired_pages_dbe_p95.py │ │ │ ├── retired_pages_dbe_p99.py │ │ │ ├── retired_pages_dbe_std.py │ │ │ ├── retired_pages_sbe_avg.py │ │ │ ├── retired_pages_sbe_base.py │ │ │ ├── retired_pages_sbe_max.py │ │ │ ├── retired_pages_sbe_min.py │ │ │ ├── retired_pages_sbe_p1.py │ │ │ ├── retired_pages_sbe_p10.py │ │ │ ├── retired_pages_sbe_p25.py │ │ │ ├── retired_pages_sbe_p5.py │ │ │ ├── retired_pages_sbe_p50.py │ │ │ ├── retired_pages_sbe_p75.py │ │ │ ├── retired_pages_sbe_p90.py │ │ │ ├── retired_pages_sbe_p95.py │ │ │ ├── retired_pages_sbe_p99.py │ │ │ ├── retired_pages_sbe_std.py │ │ │ ├── sm_utilization_avg.py │ │ │ ├── sm_utilization_base.py │ │ │ ├── sm_utilization_max.py │ │ │ ├── sm_utilization_min.py │ │ │ ├── sm_utilization_p1.py │ │ │ ├── sm_utilization_p10.py │ │ │ ├── sm_utilization_p25.py │ │ │ ├── sm_utilization_p5.py │ │ │ ├── sm_utilization_p50.py │ │ │ ├── sm_utilization_p75.py │ │ │ ├── sm_utilization_p90.py │ │ │ ├── sm_utilization_p95.py │ │ │ ├── sm_utilization_p99.py │ │ │ ├── sm_utilization_std.py │ │ │ ├── thermal_throttle_duration_avg.py │ │ │ ├── thermal_throttle_duration_base.py │ │ │ ├── thermal_throttle_duration_max.py │ │ │ ├── thermal_throttle_duration_min.py │ │ │ ├── thermal_throttle_duration_p1.py │ │ │ ├── thermal_throttle_duration_p10.py │ │ │ ├── thermal_throttle_duration_p25.py │ │ │ ├── thermal_throttle_duration_p5.py │ │ │ ├── thermal_throttle_duration_p50.py │ │ │ ├── thermal_throttle_duration_p75.py │ │ │ ├── thermal_throttle_duration_p90.py │ │ │ ├── thermal_throttle_duration_p95.py │ │ │ ├── thermal_throttle_duration_p99.py │ │ │ ├── thermal_throttle_duration_std.py │ │ │ ├── time_to_first_token_avg.py │ │ │ ├── time_to_first_token_base.py │ │ │ ├── time_to_first_token_max.py │ │ │ ├── time_to_first_token_min.py │ │ │ ├── time_to_first_token_p1.py │ │ │ ├── time_to_first_token_p10.py │ │ │ ├── time_to_first_token_p25.py │ │ │ ├── time_to_first_token_p5.py │ │ │ ├── time_to_first_token_p50.py │ │ │ ├── time_to_first_token_p75.py │ │ │ ├── time_to_first_token_p90.py │ │ │ ├── time_to_first_token_p95.py │ │ │ ├── time_to_first_token_p99.py │ │ │ ├── time_to_first_token_std.py │ │ │ ├── time_to_second_token_avg.py │ │ │ ├── time_to_second_token_base.py │ │ │ ├── time_to_second_token_max.py │ │ │ ├── time_to_second_token_min.py │ │ │ ├── time_to_second_token_p1.py │ │ │ ├── time_to_second_token_p10.py │ │ │ ├── time_to_second_token_p25.py │ │ │ ├── time_to_second_token_p5.py │ │ │ ├── time_to_second_token_p50.py │ │ │ ├── time_to_second_token_p75.py │ │ │ ├── time_to_second_token_p90.py │ │ │ ├── time_to_second_token_p95.py │ │ │ ├── time_to_second_token_p99.py │ │ │ ├── time_to_second_token_std.py │ │ │ ├── total_ecc_dbe_aggregate_avg.py │ │ │ ├── total_ecc_dbe_aggregate_base.py │ │ │ ├── total_ecc_dbe_aggregate_max.py │ │ │ ├── total_ecc_dbe_aggregate_min.py │ │ │ ├── total_ecc_dbe_aggregate_p1.py │ │ │ ├── total_ecc_dbe_aggregate_p10.py │ │ │ ├── total_ecc_dbe_aggregate_p25.py │ │ │ ├── total_ecc_dbe_aggregate_p5.py │ │ │ ├── total_ecc_dbe_aggregate_p50.py │ │ │ ├── total_ecc_dbe_aggregate_p75.py │ │ │ ├── total_ecc_dbe_aggregate_p90.py │ │ │ ├── total_ecc_dbe_aggregate_p95.py │ │ │ ├── total_ecc_dbe_aggregate_p99.py │ │ │ ├── total_ecc_dbe_aggregate_std.py │ │ │ ├── total_ecc_dbe_volatile_avg.py │ │ │ ├── total_ecc_dbe_volatile_base.py │ │ │ ├── total_ecc_dbe_volatile_max.py │ │ │ ├── total_ecc_dbe_volatile_min.py │ │ │ ├── total_ecc_dbe_volatile_p1.py │ │ │ ├── total_ecc_dbe_volatile_p10.py │ │ │ ├── total_ecc_dbe_volatile_p25.py │ │ │ ├── total_ecc_dbe_volatile_p5.py │ │ │ ├── total_ecc_dbe_volatile_p50.py │ │ │ ├── total_ecc_dbe_volatile_p75.py │ │ │ ├── total_ecc_dbe_volatile_p90.py │ │ │ ├── total_ecc_dbe_volatile_p95.py │ │ │ ├── total_ecc_dbe_volatile_p99.py │ │ │ ├── total_ecc_dbe_volatile_std.py │ │ │ ├── total_ecc_sbe_aggregate_avg.py │ │ │ ├── total_ecc_sbe_aggregate_base.py │ │ │ ├── total_ecc_sbe_aggregate_max.py │ │ │ ├── total_ecc_sbe_aggregate_min.py │ │ │ ├── total_ecc_sbe_aggregate_p1.py │ │ │ ├── total_ecc_sbe_aggregate_p10.py │ │ │ ├── total_ecc_sbe_aggregate_p25.py │ │ │ ├── total_ecc_sbe_aggregate_p5.py │ │ │ ├── total_ecc_sbe_aggregate_p50.py │ │ │ ├── total_ecc_sbe_aggregate_p75.py │ │ │ ├── total_ecc_sbe_aggregate_p90.py │ │ │ ├── total_ecc_sbe_aggregate_p95.py │ │ │ ├── total_ecc_sbe_aggregate_p99.py │ │ │ ├── total_ecc_sbe_aggregate_std.py │ │ │ ├── total_ecc_sbe_volatile_avg.py │ │ │ ├── total_ecc_sbe_volatile_base.py │ │ │ ├── total_ecc_sbe_volatile_max.py │ │ │ ├── total_ecc_sbe_volatile_min.py │ │ │ ├── total_ecc_sbe_volatile_p1.py │ │ │ ├── total_ecc_sbe_volatile_p10.py │ │ │ ├── total_ecc_sbe_volatile_p25.py │ │ │ ├── total_ecc_sbe_volatile_p5.py │ │ │ ├── total_ecc_sbe_volatile_p50.py │ │ │ ├── total_ecc_sbe_volatile_p75.py │ │ │ ├── total_ecc_sbe_volatile_p90.py │ │ │ ├── total_ecc_sbe_volatile_p95.py │ │ │ ├── total_ecc_sbe_volatile_p99.py │ │ │ ├── total_ecc_sbe_volatile_std.py │ │ │ ├── total_gpu_memory_avg.py │ │ │ ├── total_gpu_memory_base.py │ │ │ ├── total_nvlink_crc_data_errors_avg.py │ │ │ ├── total_nvlink_crc_data_errors_base.py │ │ │ ├── total_nvlink_crc_data_errors_max.py │ │ │ ├── total_nvlink_crc_data_errors_min.py │ │ │ ├── total_nvlink_crc_data_errors_p1.py │ │ │ ├── total_nvlink_crc_data_errors_p10.py │ │ │ ├── total_nvlink_crc_data_errors_p25.py │ │ │ ├── total_nvlink_crc_data_errors_p5.py │ │ │ ├── total_nvlink_crc_data_errors_p50.py │ │ │ ├── total_nvlink_crc_data_errors_p75.py │ │ │ ├── total_nvlink_crc_data_errors_p90.py │ │ │ ├── total_nvlink_crc_data_errors_p95.py │ │ │ ├── total_nvlink_crc_data_errors_p99.py │ │ │ ├── total_nvlink_crc_data_errors_std.py │ │ │ ├── total_nvlink_crc_flit_errors_avg.py │ │ │ ├── total_nvlink_crc_flit_errors_base.py │ │ │ ├── total_nvlink_crc_flit_errors_max.py │ │ │ ├── total_nvlink_crc_flit_errors_min.py │ │ │ ├── total_nvlink_crc_flit_errors_p1.py │ │ │ ├── total_nvlink_crc_flit_errors_p10.py │ │ │ ├── total_nvlink_crc_flit_errors_p25.py │ │ │ ├── total_nvlink_crc_flit_errors_p5.py │ │ │ ├── total_nvlink_crc_flit_errors_p50.py │ │ │ ├── total_nvlink_crc_flit_errors_p75.py │ │ │ ├── total_nvlink_crc_flit_errors_p90.py │ │ │ ├── total_nvlink_crc_flit_errors_p95.py │ │ │ ├── total_nvlink_crc_flit_errors_p99.py │ │ │ ├── total_nvlink_crc_flit_errors_std.py │ │ │ ├── video_decoder_utilization_avg.py │ │ │ ├── video_decoder_utilization_base.py │ │ │ ├── video_decoder_utilization_max.py │ │ │ ├── video_decoder_utilization_min.py │ │ │ ├── video_decoder_utilization_p1.py │ │ │ ├── video_decoder_utilization_p10.py │ │ │ ├── video_decoder_utilization_p25.py │ │ │ ├── video_decoder_utilization_p5.py │ │ │ ├── video_decoder_utilization_p50.py │ │ │ ├── video_decoder_utilization_p75.py │ │ │ ├── video_decoder_utilization_p90.py │ │ │ ├── video_decoder_utilization_p95.py │ │ │ ├── video_decoder_utilization_p99.py │ │ │ ├── video_decoder_utilization_std.py │ │ │ ├── video_encoder_utilization_avg.py │ │ │ ├── video_encoder_utilization_base.py │ │ │ ├── video_encoder_utilization_max.py │ │ │ ├── video_encoder_utilization_min.py │ │ │ ├── video_encoder_utilization_p1.py │ │ │ ├── video_encoder_utilization_p10.py │ │ │ ├── video_encoder_utilization_p25.py │ │ │ ├── video_encoder_utilization_p5.py │ │ │ ├── video_encoder_utilization_p50.py │ │ │ ├── video_encoder_utilization_p75.py │ │ │ ├── video_encoder_utilization_p90.py │ │ │ ├── video_encoder_utilization_p95.py │ │ │ ├── video_encoder_utilization_p99.py │ │ │ ├── video_encoder_utilization_std.py │ │ │ ├── xid_last_error_avg.py │ │ │ ├── xid_last_error_base.py │ │ │ ├── xid_last_error_max.py │ │ │ ├── xid_last_error_min.py │ │ │ ├── xid_last_error_p1.py │ │ │ ├── xid_last_error_p10.py │ │ │ ├── xid_last_error_p25.py │ │ │ ├── xid_last_error_p5.py │ │ │ ├── xid_last_error_p50.py │ │ │ ├── xid_last_error_p75.py │ │ │ ├── xid_last_error_p90.py │ │ │ ├── xid_last_error_p95.py │ │ │ ├── xid_last_error_p99.py │ │ │ └── xid_last_error_std.py │ ├── subcommand │ │ ├── analyze.py │ │ ├── common.py │ │ ├── config.py │ │ ├── process_export_files.py │ │ ├── profile.py │ │ ├── subcommand.py │ │ └── template.py │ ├── telemetry_data │ │ ├── __init__.py │ │ ├── dcgm_telemetry_data_collector.py │ │ ├── telemetry_data_collector.py │ │ └── triton_telemetry_data_collector.py │ ├── tokenizer.py │ ├── types.py │ └── utils.py ├── pyproject.toml ├── pytest.ini └── tests │ ├── __init__.py │ ├── integration_tests │ ├── test_multiturn.py │ └── test_telemetry.py │ ├── test_artifacts.py │ ├── test_base_config.py │ ├── test_checkpoint.py │ ├── test_cli.py │ ├── test_collectors │ ├── test_create_telemetry_data_collectors.py │ ├── test_dcgm_telemetry_data_collector.py │ ├── test_telemetry_data_collector.py │ └── test_triton_telemetry_data_collector.py │ ├── test_config_command.py │ ├── test_config_field.py │ ├── test_converters │ ├── test_dynamic_grpc_converter.py │ ├── test_embeddings_converter.py │ ├── test_huggingface_generate_converter.py │ ├── test_image_retrieval_converter.py │ ├── test_nvclip_converter.py │ ├── test_openai_chat_converter.py │ ├── test_openai_completions_converter.py │ ├── test_output_format_converter.py │ ├── test_rankings_converter.py │ ├── test_template_converter.py │ ├── test_tensorrtllm_engine_converter.py │ ├── test_triton_generate_converter.py │ ├── test_triton_tensorrtllm_converter.py │ └── test_triton_vllm_converter.py │ ├── test_data_parser │ ├── test_image_retrieval_profile_data_parser.py │ ├── test_llm_profile_data_parser.py │ ├── test_merged_profile_data_parser.py │ └── test_profile_data_parser.py │ ├── test_exporters │ ├── test_console_exporter.py │ ├── test_csv_exporter.py │ ├── test_data_exporter_factory.py │ ├── test_json_exporter.py │ └── test_telemetry_data_exporter_util.py │ ├── test_genai_perf_config.py │ ├── test_inputs.py │ ├── test_library.py │ ├── test_llm_goodput_calculator.py │ ├── test_metrics │ ├── test_llm_metrics.py │ ├── test_metrics.py │ ├── test_telemetry_metrics.py │ └── test_telemetry_stats_aggregator.py │ ├── test_model_config_measurement.py │ ├── test_perf_analyzer_config.py │ ├── test_plot_configs.py │ ├── test_process_export_files.py │ ├── test_record.py │ ├── test_results.py │ ├── test_retrievers │ ├── test_file_input_retriever.py │ ├── test_input_retriever_factory.py │ ├── test_payload_input_retriever.py │ ├── test_synthetic_audio_generator.py │ ├── test_synthetic_data_retriever.py │ ├── test_synthetic_image_generator.py │ └── test_synthetic_prompt_generator.py │ ├── test_run_config.py │ ├── test_run_config_measurement.py │ ├── test_search_parameters.py │ ├── test_statistics │ ├── test_statistics.py │ └── test_telemetry_statistics.py │ ├── test_subcommand.py │ ├── test_sweep_objective_generator.py │ ├── test_tokenizer.py │ └── test_utils.py ├── pyproject.toml ├── src ├── CMakeLists.txt ├── base_queue_ctx_id_tracker.h ├── client_backend │ ├── CMakeLists.txt │ ├── client_backend.cc │ ├── client_backend.h │ ├── dynamic_grpc │ │ ├── CMakeLists.txt │ │ ├── dynamic_grpc_client.cc │ │ ├── dynamic_grpc_client.h │ │ ├── dynamic_grpc_client_backend.cc │ │ ├── dynamic_grpc_client_backend.h │ │ ├── dynamic_grpc_infer_input.cc │ │ └── dynamic_grpc_infer_input.h │ ├── mock_client_backend.h │ ├── openai │ │ ├── CMakeLists.txt │ │ ├── http_client.cc │ │ ├── http_client.h │ │ ├── openai_client.cc │ │ ├── openai_client.h │ │ ├── openai_client_backend.cc │ │ ├── openai_client_backend.h │ │ ├── openai_infer_input.cc │ │ └── openai_infer_input.h │ ├── tensorflow_serving │ │ ├── CMakeLists.txt │ │ ├── CompileProto.cmake │ │ ├── tfserve_client_backend.cc │ │ ├── tfserve_client_backend.h │ │ ├── tfserve_grpc_client.cc │ │ ├── tfserve_grpc_client.h │ │ ├── tfserve_infer_input.cc │ │ └── tfserve_infer_input.h │ ├── torchserve │ │ ├── CMakeLists.txt │ │ ├── torchserve_client_backend.cc │ │ ├── torchserve_client_backend.h │ │ ├── torchserve_http_client.cc │ │ ├── torchserve_http_client.h │ │ ├── torchserve_infer_input.cc │ │ └── torchserve_infer_input.h │ ├── triton │ │ ├── CMakeLists.txt │ │ ├── test_triton_client_backend.cc │ │ ├── triton_client_backend.cc │ │ └── triton_client_backend.h │ └── triton_c_api │ │ ├── CMakeLists.txt │ │ ├── alloc_payload.h │ │ ├── c_api_infer_results.h │ │ ├── response_output.h │ │ ├── scoped_defer.cc │ │ ├── scoped_defer.h │ │ ├── shared_library.cc │ │ ├── shared_library.h │ │ ├── shared_memory_manager.cc │ │ ├── shared_memory_manager.h │ │ ├── triton_c_api_backend.cc │ │ ├── triton_c_api_backend.h │ │ ├── triton_loader.cc │ │ └── triton_loader.h ├── command_line_parser.cc ├── command_line_parser.h ├── concurrency_ctx_id_tracker.h ├── concurrency_manager.cc ├── concurrency_manager.h ├── concurrency_worker.cc ├── concurrency_worker.h ├── constants.h ├── ctx_id_tracker_factory.h ├── cuda_runtime_library_manager.cc ├── cuda_runtime_library_manager.h ├── custom_load_manager.cc ├── custom_load_manager.h ├── custom_request_schedule_manager.cc ├── custom_request_schedule_manager.h ├── data_loader.cc ├── data_loader.h ├── doctest.h ├── fifo_ctx_id_tracker.h ├── ictx_id_tracker.h ├── idle_timer.h ├── iinfer_data_manager.h ├── infer_context.cc ├── infer_context.h ├── infer_data.h ├── infer_data_manager.cc ├── infer_data_manager.h ├── infer_data_manager_base.cc ├── infer_data_manager_base.h ├── infer_data_manager_factory.h ├── infer_data_manager_shm.cc ├── infer_data_manager_shm.h ├── inference_load_mode.h ├── inference_profiler.cc ├── inference_profiler.h ├── ischeduler.h ├── iworker.h ├── load_manager.cc ├── load_manager.h ├── load_worker.cc ├── load_worker.h ├── main.cc ├── metrics.h ├── metrics_manager.cc ├── metrics_manager.h ├── mock_concurrency_worker.h ├── mock_data_loader.h ├── mock_infer_context.h ├── mock_infer_data_manager.h ├── mock_inference_profiler.h ├── mock_load_manager.h ├── mock_model_parser.h ├── mock_profile_data_collector.h ├── mock_profile_data_exporter.h ├── mock_request_rate_worker.h ├── mock_sequence_manager.h ├── model_parser.cc ├── model_parser.h ├── mpi_utils.cc ├── mpi_utils.h ├── perf_analyzer.cc ├── perf_analyzer.h ├── perf_analyzer │ ├── __init__.py │ └── cli.py ├── perf_analyzer_exception.h ├── perf_analyzer_unit_tests.cc ├── perf_utils.cc ├── perf_utils.h ├── periodic_concurrency_manager.cc ├── periodic_concurrency_manager.h ├── periodic_concurrency_worker.cc ├── periodic_concurrency_worker.h ├── profile_data_collector.cc ├── profile_data_collector.h ├── profile_data_exporter.cc ├── profile_data_exporter.h ├── rand_ctx_id_tracker.h ├── rapidjson_utils.h ├── rate_schedule.h ├── report_writer.cc ├── report_writer.h ├── request_rate_manager.cc ├── request_rate_manager.h ├── request_rate_worker.cc ├── request_rate_worker.h ├── request_record.h ├── sequence_manager.cc ├── sequence_manager.h ├── sequence_status.h ├── session_concurrency │ ├── payload_dataset_manager.cc │ ├── payload_dataset_manager.h │ ├── payload_json_utils.cc │ ├── payload_json_utils.h │ ├── request_handler.cc │ ├── request_handler.h │ ├── response_json_utils.cc │ ├── response_json_utils.h │ ├── session_concurrency_manager.cc │ └── session_concurrency_manager.h ├── tensor_data.h ├── test_command_line_parser.cc ├── test_concurrency_manager.cc ├── test_ctx_id_tracker.cc ├── test_custom_load_manager.cc ├── test_custom_request_schedule_manager.cc ├── test_dataloader.cc ├── test_http_client.cc ├── test_idle_timer.cc ├── test_infer_context.cc ├── test_inference_profiler.cc ├── test_load_manager.cc ├── test_load_manager_base.h ├── test_metrics_manager.cc ├── test_model_parser.cc ├── test_payload_dataset_manager.cc ├── test_payload_json_utils.cc ├── test_perf_utils.cc ├── test_profile_data_collector.cc ├── test_profile_data_exporter.cc ├── test_report_writer.cc ├── test_request_rate_manager.cc ├── test_response_json_utils.cc ├── test_sequence_manager.cc ├── test_utils.h ├── thread_config.h └── thread_stat.h ├── templates ├── genai-perf-templates │ ├── README_template │ ├── customizable_frontends_template │ ├── embeddings_template │ ├── example_plots_template │ ├── files_template │ ├── lora_template │ ├── multi_modal_template │ ├── rankings_template │ ├── tutorial_template │ └── version_template ├── generate_docs.py └── template_vars.yaml └── tools ├── add_copyright.py └── sharegpt_dataset_converter.py /.devcontainer/devcontainer.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "perf_analyzer Dev Container", 3 | "image": "gitlab-master.nvidia.com:5005/dl/dgx/tritonserver:master-py3-base", 4 | "postCreateCommand": "apt update && apt install -y --no-install-recommends clang-format-16 cmake gdb rapidjson-dev libssl-dev && update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-16 100", 5 | "runArgs": ["--gpus=all", "--net=host", "--pull=always"], 6 | "customizations": { 7 | "vscode": { 8 | "extensions": ["ms-vscode.cpptools", "ms-vscode.cmake-tools", "xaver.clang-format", "ms-python.python"] 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # C++ 2 | /build 3 | 4 | # GenAI-Perf Artifacts 5 | artifacts/ 6 | 7 | # Avoid squashing local people's file for now 8 | /.vscode 9 | 10 | # Python setuptools artifacts 11 | *.egg-info/ 12 | dist/ 13 | bin/ 14 | -------------------------------------------------------------------------------- /genai-perf/.gitignore: -------------------------------------------------------------------------------- 1 | artifacts/ 2 | __pycache__/ 3 | *.pyc 4 | -------------------------------------------------------------------------------- /genai-perf/docs/assets/distribution_of_input_sequence_lengths_to_output_sequence_lengths.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/docs/assets/distribution_of_input_sequence_lengths_to_output_sequence_lengths.jpeg -------------------------------------------------------------------------------- /genai-perf/docs/assets/request_latency.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/docs/assets/request_latency.jpeg -------------------------------------------------------------------------------- /genai-perf/docs/assets/time_to_first_token.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/docs/assets/time_to_first_token.jpeg -------------------------------------------------------------------------------- /genai-perf/docs/assets/time_to_first_token_vs_input_sequence_lengths.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/docs/assets/time_to_first_token_vs_input_sequence_lengths.jpeg -------------------------------------------------------------------------------- /genai-perf/docs/assets/token-to-token_latency_vs_output_token_position.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/docs/assets/token-to-token_latency_vs_output_token_position.jpeg -------------------------------------------------------------------------------- /genai-perf/genai_perf/.gitignore: -------------------------------------------------------------------------------- 1 | *.json 2 | *.cache 3 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/exceptions.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | 16 | class GenAIPerfException(Exception): 17 | """ 18 | A custom exception specific to the genai-perf 19 | """ 20 | 21 | pass 22 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/inputs/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/inputs/retrievers/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from .synthetic_audio_generator import SyntheticAudioGenerator 16 | from .synthetic_image_generator import SyntheticImageGenerator 17 | from .synthetic_prompt_generator import SyntheticPromptGenerator 18 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/inputs/retrievers/source_images/dlss.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/genai_perf/inputs/retrievers/source_images/dlss.png -------------------------------------------------------------------------------- /genai-perf/genai_perf/inputs/retrievers/source_images/h100.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/genai_perf/inputs/retrievers/source_images/h100.jpeg -------------------------------------------------------------------------------- /genai-perf/genai_perf/inputs/retrievers/source_images/h200.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/genai_perf/inputs/retrievers/source_images/h200.jpeg -------------------------------------------------------------------------------- /genai-perf/genai_perf/inputs/retrievers/source_images/jensen.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/genai_perf/inputs/retrievers/source_images/jensen.jpeg -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_memory_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_memory_base import GPUClockMemoryBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockMemoryAvg(GPUClockMemoryBase): 22 | """ 23 | A record for avg GPU Clock Memory metric 24 | """ 25 | 26 | tag = GPUClockMemoryBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. GPU Clock Memory (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_memory_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_memory_base import GPUClockMemoryBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockMemoryMax(GPUClockMemoryBase): 22 | """ 23 | A record for max GPU Clock Memory metric 24 | """ 25 | 26 | tag = GPUClockMemoryBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max GPU Clock Memory (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_memory_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_memory_base import GPUClockMemoryBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockMemoryMin(GPUClockMemoryBase): 22 | """ 23 | A record for min GPU Clock Memory metric 24 | """ 25 | 26 | tag = GPUClockMemoryBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min GPU Clock Memory (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_memory_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_memory_base import GPUClockMemoryBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockMemory1(GPUClockMemoryBase): 22 | """ 23 | A record for p1 GPU Clock Memory metric 24 | """ 25 | 26 | tag = GPUClockMemoryBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 GPU Clock Memory (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_memory_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_memory_base import GPUClockMemoryBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockMemoryP10(GPUClockMemoryBase): 22 | """ 23 | A record for p10 GPU Clock Memory metric 24 | """ 25 | 26 | tag = GPUClockMemoryBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 GPU Clock Memory (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_memory_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_memory_base import GPUClockMemoryBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockMemoryP25(GPUClockMemoryBase): 22 | """ 23 | A record for p25 GPU Clock Memory metric 24 | """ 25 | 26 | tag = GPUClockMemoryBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 GPU Clock Memory (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_memory_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_memory_base import GPUClockMemoryBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockMemoryP5(GPUClockMemoryBase): 22 | """ 23 | A record for p5 GPU Clock Memory metric 24 | """ 25 | 26 | tag = GPUClockMemoryBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 GPU Clock Memory (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMAvg(GPUClockSMBase): 22 | """ 23 | A record for avg GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMMax(GPUClockSMBase): 22 | """ 23 | A record for max GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMMin(GPUClockSMBase): 22 | """ 23 | A record for min GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP1(GPUClockSMBase): 22 | """ 23 | A record for p1 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP10(GPUClockSMBase): 22 | """ 23 | A record for p10 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP25(GPUClockSMBase): 22 | """ 23 | A record for p25 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP5(GPUClockSMBase): 22 | """ 23 | A record for p5 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP50(GPUClockSMBase): 22 | """ 23 | A record for p50 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP75(GPUClockSMBase): 22 | """ 23 | A record for p75 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP90(GPUClockSMBase): 22 | """ 23 | A record for p90 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP95(GPUClockSMBase): 22 | """ 23 | A record for p95 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMP99(GPUClockSMBase): 22 | """ 23 | A record for p99 GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_clock_sm_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_clock_sm_base import GPUClockSMBase 18 | 19 | 20 | @total_ordering 21 | class GpuClockSMStd(GPUClockSMBase): 22 | """ 23 | A record for std GPU Clock SM metric 24 | """ 25 | 26 | tag = GPUClockSMBase.base_tag + "_std" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std. GPU Clock SM (MHz)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeAvg(GPUMemoryFreeBase): 22 | """ 23 | A record for avg GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeMax(GPUMemoryFreeBase): 22 | """ 23 | A record for max GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeMin(GPUMemoryFreeBase): 22 | """ 23 | A record for min GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP1(GPUMemoryFreeBase): 22 | """ 23 | A record for p1 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP10(GPUMemoryFreeBase): 22 | """ 23 | A record for p10 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP25(GPUMemoryFreeBase): 22 | """ 23 | A record for p25 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP5(GPUMemoryFreeBase): 22 | """ 23 | A record for p5 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP50(GPUMemoryFreeBase): 22 | """ 23 | A record for p50 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP75(GPUMemoryFreeBase): 22 | """ 23 | A record for p75 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP90(GPUMemoryFreeBase): 22 | """ 23 | A record for p90 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP95(GPUMemoryFreeBase): 22 | """ 23 | A record for p95 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeP99(GPUMemoryFreeBase): 22 | """ 23 | A record for p99 GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_free_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_free_base import GPUMemoryFreeBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryFreeStd(GPUMemoryFreeBase): 22 | """ 23 | A record for std GPU memory free metric 24 | """ 25 | 26 | tag = GPUMemoryFreeBase.base_tag + "_std" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std. GPU Memory Free (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedAvg(GPUMemoryUsedBase): 22 | """ 23 | A record for avg GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedMax(GPUMemoryUsedBase): 22 | """ 23 | A record for max GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedMin(GPUMemoryUsedBase): 22 | """ 23 | A record for min GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP1(GPUMemoryUsedBase): 22 | """ 23 | A record for p1 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP10(GPUMemoryUsedBase): 22 | """ 23 | A record for p10 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP25(GPUMemoryUsedBase): 22 | """ 23 | A record for p25 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP5(GPUMemoryUsedBase): 22 | """ 23 | A record for p5 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP50(GPUMemoryUsedBase): 22 | """ 23 | A record for p50 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP75(GPUMemoryUsedBase): 22 | """ 23 | A record for p75 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP90(GPUMemoryUsedBase): 22 | """ 23 | A record for p90 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP95(GPUMemoryUsedBase): 22 | """ 23 | A record for p95 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedP99(GPUMemoryUsedBase): 22 | """ 23 | A record for p99 GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_memory_used_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_memory_used_base import GPUMemoryUsedBase 18 | 19 | 20 | @total_ordering 21 | class GpuMemoryUsedStd(GPUMemoryUsedBase): 22 | """ 23 | A record for std GPU memory used metric 24 | """ 25 | 26 | tag = GPUMemoryUsedBase.base_tag + "_std" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std. GPU Memory Used (GB)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_limit_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_limit_base import GPUPowerLimitBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerLimitAvg(GPUPowerLimitBase): 22 | """ 23 | A record for avg GPU Power Limit metric 24 | """ 25 | 26 | tag = GPUPowerLimitBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. GPU Power Limit (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageAvg(GPUPowerUsageBase): 22 | """ 23 | A record for avg GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageMax(GPUPowerUsageBase): 22 | """ 23 | A record for max GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageMin(GPUPowerUsageBase): 22 | """ 23 | A record for min GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GpuPowerUsageP1(GPUPowerUsageBase): 22 | """ 23 | A record for p1 GPU power usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GpuPowerUsageP10(GPUPowerUsageBase): 22 | """ 23 | A record for p10 GPU power usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageP25(GPUPowerUsageBase): 22 | """ 23 | A record for p25 GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GpuPowerUsageP5(GPUPowerUsageBase): 22 | """ 23 | A record for p5 GPU power usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageP50(GPUPowerUsageBase): 22 | """ 23 | A record for p50 GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageP75(GPUPowerUsageBase): 22 | """ 23 | A record for p75 GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageP90(GPUPowerUsageBase): 22 | """ 23 | A record for p90 GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageP95(GPUPowerUsageBase): 22 | """ 23 | A record for p95 GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageP99(GPUPowerUsageBase): 22 | """ 23 | A record for p99 GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_power_usage_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_power_usage_base import GPUPowerUsageBase 18 | 19 | 20 | @total_ordering 21 | class GPUPowerUsageStd(GPUPowerUsageBase): 22 | """ 23 | A record for std GPU Power Usage metric 24 | """ 25 | 26 | tag = GPUPowerUsageBase.base_tag + "_std" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std. GPU Power Usage (W)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureAvg(GPUTemperatureBase): 22 | """ 23 | A record for avg GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureMax(GPUTemperatureBase): 22 | """ 23 | A record for max GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureMin(GPUTemperatureBase): 22 | """ 23 | A record for min GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP1(GPUTemperatureBase): 22 | """ 23 | A record for p1 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP10(GPUTemperatureBase): 22 | """ 23 | A record for p10 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP25(GPUTemperatureBase): 22 | """ 23 | A record for p25 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP5(GPUTemperatureBase): 22 | """ 23 | A record for p5 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP50(GPUTemperatureBase): 22 | """ 23 | A record for p50 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP75(GPUTemperatureBase): 22 | """ 23 | A record for p75 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP90(GPUTemperatureBase): 22 | """ 23 | A record for p90 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP95(GPUTemperatureBase): 22 | """ 23 | A record for p95 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureP99(GPUTemperatureBase): 22 | """ 23 | A record for p99 GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_temperature_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_temperature_base import GPUTemperatureBase 18 | 19 | 20 | @total_ordering 21 | class GpuTemperatureStd(GPUTemperatureBase): 22 | """ 23 | A record for std GPU Temperature metric 24 | """ 25 | 26 | tag = GPUTemperatureBase.base_tag + "_std" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std. GPU Temperature (°C)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationAvg(GPUUtilizationBase): 22 | """ 23 | A record for avg GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationMax(GPUUtilizationBase): 22 | """ 23 | A record for max GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationMin(GPUUtilizationBase): 22 | """ 23 | A record for min GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GpuUtilizationP1(GPUUtilizationBase): 22 | """ 23 | A record for p1 GPU utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GpuUtilizationP10(GPUUtilizationBase): 22 | """ 23 | A record for p10 GPU utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationP25(GPUUtilizationBase): 22 | """ 23 | A record for p25 GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GpuUtilizationP5(GPUUtilizationBase): 22 | """ 23 | A record for p5 GPU utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationP50(GPUUtilizationBase): 22 | """ 23 | A record for p50 GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationP75(GPUUtilizationBase): 22 | """ 23 | A record for p75 GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationP90(GPUUtilizationBase): 22 | """ 23 | A record for p90 GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationP95(GPUUtilizationBase): 22 | """ 23 | A record for p95 GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/gpu_utilization_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.gpu_utilization_base import GPUUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class GPUUtilizationP99(GPUUtilizationBase): 22 | """ 23 | A record for p99 GPU Utilization metric 24 | """ 25 | 26 | tag = GPUUtilizationBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 GPU Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyAvg(InterTokenLatencyBase): 22 | """ 23 | A record for avg Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyMax(InterTokenLatencyBase): 22 | """ 23 | A record for max Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_max" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyMin(InterTokenLatencyBase): 22 | """ 23 | A record for min Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_min" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyP1(InterTokenLatencyBase): 22 | """ 23 | A record for p1 Inter-token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyP25(InterTokenLatencyBase): 22 | """ 23 | A record for p25 Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyP5(InterTokenLatencyBase): 22 | """ 23 | A record for p5 Inter-token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyP50(InterTokenLatencyBase): 22 | """ 23 | A record for p50 Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyP75(InterTokenLatencyBase): 22 | """ 23 | A record for p75 Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyP90(InterTokenLatencyBase): 22 | """ 23 | A record for p90 Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyP95(InterTokenLatencyBase): 22 | """ 23 | A record for p95 Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyP99(InterTokenLatencyBase): 22 | """ 23 | A record for p99 Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/inter_token_latency_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.inter_token_latency_base import InterTokenLatencyBase 18 | 19 | 20 | @total_ordering 21 | class InterTokenLatencyStd(InterTokenLatencyBase): 22 | """ 23 | A record for std Inter token latency metric 24 | """ 25 | 26 | tag = InterTokenLatencyBase.base_tag + "_std" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std Inter Token Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyAvg(RequestLatencyBase): 22 | """ 23 | A record for avg request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyMaX(RequestLatencyBase): 22 | """ 23 | A record for max request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_max" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyMin(RequestLatencyBase): 22 | """ 23 | A record for min request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_min" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP1(RequestLatencyBase): 22 | """ 23 | A record for p1 Request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP10(RequestLatencyBase): 22 | """ 23 | A record for p10 Request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP25(RequestLatencyBase): 22 | """ 23 | A record for p25 request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP5(RequestLatencyBase): 22 | """ 23 | A record for p5 Request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP50(RequestLatencyBase): 22 | """ 23 | A record for p50 request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP75(RequestLatencyBase): 22 | """ 23 | A record for p75 request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP90(RequestLatencyBase): 22 | """ 23 | A record for p90 request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP95(RequestLatencyBase): 22 | """ 23 | A record for p95 request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyP99(RequestLatencyBase): 22 | """ 23 | A record for p99 request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/request_latency_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.request_latency_base import RequestLatencyBase 18 | 19 | 20 | @total_ordering 21 | class RequestLatencyStd(RequestLatencyBase): 22 | """ 23 | A record for std request latency metric 24 | """ 25 | 26 | tag = RequestLatencyBase.base_tag + "_std" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std. Request Latency (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationAvg(SMUtilizationBase): 22 | """ 23 | A record for avg SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationMax(SMUtilizationBase): 22 | """ 23 | A record for max SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationMin(SMUtilizationBase): 22 | """ 23 | A record for min SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationP50(SMUtilizationBase): 22 | """ 23 | A record for p50 SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "P50 SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationP75(SMUtilizationBase): 22 | """ 23 | A record for p75 SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "P75 SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationP90(SMUtilizationBase): 22 | """ 23 | A record for p90 SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "P90 SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationP95(SMUtilizationBase): 22 | """ 23 | A record for p95 SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "P95 SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationP99(SMUtilizationBase): 22 | """ 23 | A record for p99 SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "P99 SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/sm_utilization_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.sm_utilization_base import SMUtilizationBase 18 | 19 | 20 | @total_ordering 21 | class SMUtilizationStd(SMUtilizationBase): 22 | """ 23 | A record for std SM Utilization metric 24 | """ 25 | 26 | tag = SMUtilizationBase.base_tag + "_std" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std. SM Utilization (%)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenAvg(TimeToFirstTokenBase): 22 | """ 23 | A record for avg Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenMax(TimeToFirstTokenBase): 22 | """ 23 | A record for max Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_max" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenMin(TimeToFirstTokenBase): 22 | """ 23 | A record for min Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_min" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP1(TimeToFirstTokenBase): 22 | """ 23 | A record for p1 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP10(TimeToFirstTokenBase): 22 | """ 23 | A record for p10 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP25(TimeToFirstTokenBase): 22 | """ 23 | A record for p25 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP5(TimeToFirstTokenBase): 22 | """ 23 | A record for p5 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP50(TimeToFirstTokenBase): 22 | """ 23 | A record for p50 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP75(TimeToFirstTokenBase): 22 | """ 23 | A record for p75 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP90(TimeToFirstTokenBase): 22 | """ 23 | A record for p90 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP95(TimeToFirstTokenBase): 22 | """ 23 | A record for p95 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenP99(TimeToFirstTokenBase): 22 | """ 23 | A record for p99 Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_first_token_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_first_token_base import TimeToFirstTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToFirstTokenMin(TimeToFirstTokenBase): 22 | """ 23 | A record for std Time to first token metric 24 | """ 25 | 26 | tag = TimeToFirstTokenBase.base_tag + "_std" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std Time To First Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenAvg(TimeToSecondTokenBase): 22 | """ 23 | A record for avg Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenMax(TimeToSecondTokenBase): 22 | """ 23 | A record for max Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_max" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenMin(TimeToSecondTokenBase): 22 | """ 23 | A record for min Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_min" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenP1(TimeToSecondTokenBase): 22 | """ 23 | A record for p1 Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenP25(TimeToSecondTokenBase): 22 | """ 23 | A record for p25 Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenP5(TimeToSecondTokenBase): 22 | """ 23 | A record for p5 Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenP50(TimeToSecondTokenBase): 22 | """ 23 | A record for p50 Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenP75(TimeToSecondTokenBase): 22 | """ 23 | A record for p75 Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenP90(TimeToSecondTokenBase): 22 | """ 23 | A record for p90 Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenP95(TimeToSecondTokenBase): 22 | """ 23 | A record for p95 Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenP99(TimeToSecondTokenBase): 22 | """ 23 | A record for p99 Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/time_to_second_token_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.time_to_second_token_base import TimeToSecondTokenBase 18 | 19 | 20 | @total_ordering 21 | class TimeToSecondTokenMin(TimeToSecondTokenBase): 22 | """ 23 | A record for std Time to second token metric 24 | """ 25 | 26 | tag = TimeToSecondTokenBase.base_tag + "_std" 27 | 28 | def __init__(self, value, timestamp=0): 29 | super().__init__(value, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std Time To Second Token (ms)" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_avg.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorAvg(XidLastErrorBase): 22 | """ 23 | A record for avg Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_avg" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Avg. Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_max.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorMax(XidLastErrorBase): 22 | """ 23 | A record for max Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_max" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Max Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_min.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorMin(XidLastErrorBase): 22 | """ 23 | A record for min Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_min" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Min Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p1.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP1(XidLastErrorBase): 22 | """ 23 | A record for p1 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p1" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p1 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p10.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP10(XidLastErrorBase): 22 | """ 23 | A record for p10 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p10" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p10 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p25.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP25(XidLastErrorBase): 22 | """ 23 | A record for p25 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p25" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p25 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p5.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP5(XidLastErrorBase): 22 | """ 23 | A record for p5 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p5" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p5 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p50.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP50(XidLastErrorBase): 22 | """ 23 | A record for p50 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p50" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p50 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p75.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP75(XidLastErrorBase): 22 | """ 23 | A record for p75 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p75" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p75 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p90.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP90(XidLastErrorBase): 22 | """ 23 | A record for p90 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p90" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p90 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p95.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP95(XidLastErrorBase): 22 | """ 23 | A record for p95 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p95" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p95 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_p99.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorP99(XidLastErrorBase): 22 | """ 23 | A record for p99 Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_p99" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "p99 Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/genai_perf/record/types/xid_last_error_std.py: -------------------------------------------------------------------------------- 1 | # Copyright 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | 15 | from functools import total_ordering 16 | 17 | from genai_perf.record.types.xid_last_error_base import XidLastErrorBase 18 | 19 | 20 | @total_ordering 21 | class XidLastErrorStd(XidLastErrorBase): 22 | """ 23 | A record for std Xid Last Error 24 | """ 25 | 26 | tag = XidLastErrorBase.base_tag + "_std" 27 | 28 | def __init__(self, value, device_uuid=None, timestamp=0): 29 | super().__init__(value, device_uuid, timestamp) 30 | 31 | @classmethod 32 | def header(cls, aggregation_tag=False) -> str: 33 | return "Std. Xid Last Error" 34 | -------------------------------------------------------------------------------- /genai-perf/tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/triton-inference-server/perf_analyzer/fee5b71118b61c7e88299fe19148253933dde3cf/genai-perf/tests/__init__.py --------------------------------------------------------------------------------