Skip to main content

HAMi Enterprise 2.11.0-r0

Chart versionDeclared appVersionRelease date
2.11.0-r02.11.0-r02026-11-12

This release uses open-source HAMi v2.11.0 as its baseline. Enterprise upgrade changes are compared with v2.10.0-r5.

Software changes​

Release focus: Enterprise sharing controls for Ascend​

HAMi Enterprise extends the resource controls already available for NVIDIA to Ascend, providing similar runtime memory management, Turbo mode, and task-priority controls on NPUs. The scheduler owns allocation and approval; the Ascend device plugin and libvnpu apply controls while workloads run.

  • Runtime memory expansion: Application containers using hami-core soft slicing can request larger memory allowances with NPU_MEMORY_AUTO_ADJUST=true. The scheduler checks available device memory and namespace quotas before the plugin updates runtime allowances. This currently supports one vNPU per application container, expands without shrinking, and leaves the Pod's initial resource declaration unchanged. Rejection or timeout retains the previous allowance, and the original allocation can still return OOM.
  • Turbo mode: NPU_TURBO_MODE=true lets trusted, compute-exclusive workloads run without runtime AI Core throttling while retaining memory limits, accounting, and approved memory expansion. It is disabled by default. Workloads should request 100% AI cores and recreate the Pod to change modes. Turbo workloads do not participate in task-priority arbitration.
  • Task-priority control: With NPU_CORE_UTILIZATION_POLICY=force, NPU_TASK_PRIORITY controls the priority of workloads sharing an NPU. Lower unsigned integers mean higher priority; 0 outranks the default 1. Priority and compute share are configured separately. The runtime coordinates priorities cooperatively at work-submission boundaries; submitted work completes naturally, without a fixed preemption-latency guarantee.

This release pairs with Ascend Device Plugin v1.5.0 (Chart 0.4.0) and libvnpu v1.5.0. They are deployed independently: upgrading the main Chart does not update the Ascend plugin or runtime libraries in existing application containers. Memory expansion additionally requires explicit huawei.com/vnpu-mode: hami-core, Kubernetes 1.30 or later, and expansion approval and admission protection. See the Ascend Chart 0.4.0 release notes for companion upgrades and runtime-state migration. Changes from Enterprise r5 are identified in the capability comparison below.

Changes from Enterprise v2.10.0-r5​

Enterprise improvements and fixes​

  • Adds NVIDIA Downward runtime resource-bound validation. On Kubernetes 1.30 and later with admission enabled, it checks runtime device limits against container resource requests. Deployments with custom admission manifests must configure /downward/validate.
  • Fixes NVIDIA admission for ordinary init containers by omitting unsupported postStart hooks. Existing HTTP, TCP, or Sleep postStart actions no longer receive an incompatible Exec action.
  • Fixes how NVIDIA automatic memory expansion locates an application container's allocation when the Pod has init containers, preventing expansion feedback from updating the wrong container record. Expansion still requires explicit opt-in and excludes init containers.
  • Updates the companion NVIDIA runtime library with fixes for concurrent memory reservation and failure rollback, memory accounting for asynchronous allocation, CUDA Graph and virtual memory management (VMM), and CUDA/NVML API compatibility.

Changes synchronized from upstream​

  • Adds device resource accounting for native sidecar containers, counting their memory, compute, and device slots alongside application containers. Accounting follows container lifecycles during initialization, after initialization, and when restoring allocations after a scheduler restart.
  • Improves dynamic MIG placement, idle-instance reuse, and reclamation; adds MIG profile preferences and CDI injection for dynamic MIG devices. MIG memory and utilization collection requires devicePlugin.monitor.migInstanceAccess: true; CDI injection requires a CDI-capable container runtime.
  • Adds optional NVIDIA NUMA allocation refit. When kubelet topology constraints conflict with the original allocation, the device plugin asks the scheduler to recalculate the allocation and update accounting. It is disabled by default. Enabling it requires device topology, node preferred-allocation settings, a Pod NUMA policy, and the scheduler CA; see this page's Values reference.
  • Extends AMD scheduling with memory-percentage requests, namespace memory-quota checks during allocation, XGMI and NUMA topology selection, and a configurable RuntimeClass.
  • Adds Lupine-based remote GPU scheduling and server-pool selection by node label. It is disabled by default and requires the corresponding server and client runtime configuration.
  • Adds whole-card configuration for Ascend950DT 9582, using huawei.com/Ascend950DT, 98,304 MiB memory and 32 AI cores per card. A compatible device plugin must be deployed separately. This configuration does not establish support for other 950DT SKUs or slicing modes.
  • Adds optional preferred node-affinity scoring, scheduler leader and cache-sync metrics, and GPU hardware-health metrics. Metric deprecations and migration steps are listed below.
  • Improves quota memory-unit conversion, node-lock recovery, locking for init-container device requests, and accounting during Pod deletion and scheduler restarts.

Enterprise extensions over open-source HAMi v2.11.0​

CapabilityAddition over open-source v2.11.0Change from Enterprise v2.10.0-r5Components and conditions
Ascend hami-core runtime memory expansionExtends static soft slicing with runtime expansion requests, device-memory and namespace-quota checks, and allowance updates after approval.Retains the capability and adapts it to this release's device and init-container accounting.Main software plus separately delivered Ascend plugin and libvnpu; requires huawei.com/vnpu-mode: hami-core, NPU_MEMORY_AUTO_ADJUST=true, one vNPU per application container, and the admission requirements on Kubernetes 1.30 or later.
Ascend Turbo modeProvides unthrottled compute with memory controls retained for trusted, compute-exclusive workloads.Retains the companion runtime capability.Ascend plugin and libvnpu; explicitly set NPU_TURBO_MODE=true and request 100% AI cores. Disabled by default, outside task-priority arbitration, and requires Pod recreation to change modes.
Ascend task-priority controlCoordinates work submission by priority for workloads sharing an NPU, with compute shares and task priorities configured separately.Retains the companion runtime capability.libvnpu force policy and NPU_TASK_PRIORITY; lower values take precedence, default 1. Coordination is cooperative at submission boundaries, without a fixed preemption-latency guarantee.
Ascend hami-core compute policies and capacityProvides spatial, dynamic, fixed, and overdraft policies and a compute-capacity multiplier, controlling runtime compute usage and registered capacity separately.Retains the policies and configuration interfaces available in r5.The main Chart generates shared configuration; the independent Ascend plugin and libvnpu apply it. devices.ascend.hamiCorePolicy defaults to spatial, and devices.ascend.deviceCoreScaling to 1. Scaling does not change the 100% per-device compute-request ceiling for one workload; spatial does not provide exclusive hardware partitions.
NVIDIA container allocation interfaceProvides a Downward API allocation path that passes device, memory, and compute settings through container annotations for runtime and platform integration.Retains the allocation interface; adds /downward/validate runtime resource-bound validation.Main software; scheduler.useDownward: true is the default. The new validation requires Kubernetes 1.30 or later with admission enabled.
NVIDIA runtime memory oversubscriptionThe companion runtime provides memory oversubscription alongside scheduler memory-capacity settings. Increasing scheduler capacity alone does not enable runtime oversubscription.Retains the capability; fixes memory reservation, rollback, and accounting in the companion runtime.Enterprise NVIDIA runtime and device-allocation components; the CUDA allocation paths and workload must match the oversubscription configuration.
CUDA IPC compatibility under oversubscriptionProvides an optional CUDA IPC compatibility policy to reduce the impact of oversubscription on some IPC allocations.Retained capability, not introduced in this release.Enterprise NVIDIA runtime; the policy is disabled by default and used with oversubscription. It does not guarantee compatibility with every IPC workload.
NVIDIA runtime memory expansionIncreases application-container memory allowances from runtime feedback. The scheduler checks requests against allocatable memory and updates allocation records.Retains the capability; fixes application-container lookup when a Pod has init containers.Main software and Enterprise NVIDIA runtime; application containers explicitly set CUDA_MEMORY_AUTO_ADJUST=true. Targets round up to 1 GiB; init containers are excluded.
T-Head PPU sharing and schedulingAdds PPU memory and compute sharing, model, UUID and topology selection, quotas, and licensing integration.Retained capability, not a first-time PPU integration.PPU backend in the main software plus a separate PPU plugin. Resource names and slicing configuration must match; the main Chart does not install the PPU plugin.
Enterprise licensingSupports licensing by device instance or device-model quantity, with status, validity information, and abnormal-state events.Retains the multi-vendor licensing available in r5.Main software and companion runtime components; an Enterprise license must cover the target cluster, devices, and validity period.
Enterprise resource and memory observabilityAdds the memory oversubscription factor, compute-allocation mode, expansion enablement and completion state, and context, module, and buffer memory details.Retains Enterprise metrics; synchronized hardware-health and collection-status metrics are listed below.Scheduler, monitor, and companion runtime; extensions include hami_gpu_memory_oversell_factor, the compute_allocation_mode, vgpu_mode, oom_expand, oom_expanded allocation-metric labels, and hami_vgpu_memory_context_bytes, hami_vgpu_memory_module_bytes, hami_vgpu_memory_buffer_bytes.

Main synchronized upstream changes​

ChangeEffect on use or integrationUpstream PRs
Native sidecar and init-container accountingCounts persistent sidecars and locks devices for Pods whose device requests are confined to init containers.#2723, #2755
MIG placement and profile preferencesImproves multi-instance placement. nvidia.com/mig-profile-preference prefers allowlisted profiles without relaxing memory requirements or hardware constraints.#2855, #3014
Dynamic MIG lifecycle and CDIReuses matching idle instances, reclaims idle instances that block new placements, and maintains dynamic MIG CDI entries.#3128, #3070
MIG monitoringCollects MIG workload metrics through NVML/DCGM; requires monitor access to MIG devices.#3270
NUMA refitAdds optional allocation recalculation and reservation updates, authenticated with the device plugin's ServiceAccount identity.#2731, #2882
AMD memory and quotasSupports percentage-based memory requests and checks namespace quotas against the resolved allocation.#3179, #3180
AMD topology and RuntimeClassSelects devices using XGMI and NUMA relationships; applies the configured RuntimeClass only when the Pod leaves it unset.#3191, #3194
Remote GPUAdds Lupine discovery, allocation, and server-pool selection. Each allocation reserves the GPU resources of one server.#3004, #3013, #3195
Ascend950DT 9582Adds whole-card configuration for this SKU; the device plugin is deployed separately.#3316
Preferred node-affinity scoringAn optional weight includes Pod preferred node affinity in HAMi scoring; disabled by default.#3298
Scheduler state and GPU health metricsAdds leader, cache-sync, temperature, power, and ECC error metrics.#2758, #2732
Metric deprecationsRetains existing output while defining replacements for a memory metric and the quota-limit label.#3273, #3299
Unified vendor Helm configurationMoves vendor settings to devices.<vendor> and generates device defaults from Values.#3124, #3152

Monitoring metric changes​

Metric or labelStatus and action
hami_container_device_memory_bytesDeprecated but still emitted. Use hami_vgpu_memory_used_bytes in dashboards and alerts; labels are unchanged.
limit label on hami_resource_quota_usedDeprecated but retained. Read limits from hami_resource_quota_limit and match on namespace, quota_name. Use sum without (limit) to remove the old usage label before comparing values.
hami_scheduler_is_leader, hami_scheduler_cache_syncedNew state metrics: 1 means this instance is leader or its cache is synchronized; 0 means it is not.
hami_vgpumonitor_collect_successNew collection-status metric. 0 means collection encountered a failure; missing samples must not be treated as zero usage. Unsupported optional hardware metrics are skipped.
hami_host_gpu_temperature_celsius, hami_host_gpu_power_usage_watts, hami_host_gpu_ecc_errors_total, hami_host_gpu_memory_controller_utilization_ratioNew hardware metrics, collected where supported by the device and driver.

Chart changes​

  • Moves vendor settings to devices.<vendor>. Removed fields, including configurations that mix old and new keys, fail rendering. NVIDIA resource defaults, MIG profiles, and vendor model lists are configurable through their Values entries.
  • Updates the main components' default image tag to v2.11.0-r0. Image repositories, tags, and pull credentials can be configured separately; component tags take precedence over global.imageTag.
  • Adds global.imageSource, defaulting to upstream. cn selects supported mirrors for upstream images. It does not rewrite the Enterprise ghcr.io/dynamia-ai/hami-enterprise image; a nonempty global.imageRegistry takes precedence.
  • Uses a separate loopback extender endpoint, port 9444 by default, for the kube-scheduler in the same Pod. Adds node-lock retry and extender request-timeout settings.
  • Adds scheduler PodDisruptionBudget settings, creating the budget only when leader election is enabled and the replica count is greater than 1.
  • Adds monitor health probes, enabled by default. devicePlugin.monitor.migInstanceAccess controls access required for MIG instance monitoring and defaults to false.
  • Removes the HAMi-DRA subchart. dra and hami-dra settings are rejected; this release deploys HAMi scheduler and device plugins.

Upgrade notes​

Migrate an existing r5 deployment​

For vendor field mappings, old Values cleanup, and rendering checks, see the upstream v2.10 to v2.11.0 upgrade guide. Perform the upgrade with the Enterprise 2.11.0-r0 Chart and v2.11.0-r0 images. Image tags, the Enterprise defaults below, and companion components follow this release note and the delivery manifest.

  • Export r5 user Values and migrate every override that must be retained, then apply the new defaults with --reset-values. Do not use --reuse-values or --reset-then-reuse-values, which can restore removed fields.
  • Remove the entire dra and hami-dra sections, including an old dra.enabled: false. Enterprise no longer provides these installation options.
  • Keep valid settings already used by r5, including HCU resource names and devices.ascend.deviceSplitCount, and check resource names against the installed device plugin. Do not repeat resource renaming that the upstream guide describes for an original v2.10 installation. Deployments with historical fixed selectors must retain legacySelectorLabels: true.
  • Deployments using device-config.content must migrate that complete configuration separately and retain Enterprise settings such as nvidia.useDownward consistently with the existing allocation path; the default Downward path requires true. This content is not merged with devices.*; independently deployed Ascend plugins sharing the device ConfigMap must use matching configuration.
Enterprise settingDefault in this releaseUpgrade action
scheduler.useDownwardtrueRetain the existing allocation path; the new validation requirements are below.
devices.nvidia.limitDeliveryenvContinue passing NVIDIA limits through environment variables; do not import the upstream file default directly.
devicePlugin.monitor.disableHAMiCoreForWholeGPUfalseRetain the Enterprise whole-GPU runtime-library path; do not import the different upstream default directly.
devicePlugin.nvidiaDriverRoot""Retain the setting appropriate for the existing driver installation; do not change it solely because upstream defaults to auto.

Check Enterprise allocation and runtime integration​

On Kubernetes 1.30 and later with scheduler.admissionWebhook.enabled: true, the main Chart installs /downward/validate automatically. Custom admission manifests must add this validation endpoint and configure its CA. It checks NVIDIA Downward runtime limits against container resource requests. Earlier Kubernetes versions do not install this check. Where the same resource-bound validation is required, use the non-Downward allocation path, scheduler.useDownward: false, and recreate affected Pods through the normal workload-update process.

Deployments with an external kube-scheduler must also update extender connectivity: /filter and /bind default to 127.0.0.1:9444. Configure a reachable --extender-bind through scheduler.extender.extraArgs, and update client addresses and network access together. Changing the Service alone does not expose these endpoints.

Upgrading components does not replace environment variables in existing Pods or reload the runtime library in running processes. Workloads that need this release's runtime fixes or new injection behavior should be rolled out or recreated through the business maintenance process. Obtain installation packages and companion component manifests through the agreed delivery channel, or visit the software center.

Values reference​

The parameter table below comes from the README shipped with Chart 2.11.0-r0 and retains its original text. The default configuration is defined by this version's values.yaml.

展开参数表

Values are listed in the same order as in values.yaml.

KeyTypeDefaultDescription
global.imageSourcestring"upstream"Image source: upstream or cn. Set --set global.imageSource=cn to use Alibaba Cloud for kube-scheduler and the default pinned certgen image, and m.daocloud.io for the upstream HAMi, mock-device-plugin, and Lupine server/client repositories. Other registries/repositories, explicit remote-GPU libImage/sessionImage, and supplied device-config content are unchanged. A non-empty global.imageRegistry disables source selection. Custom certgen pins and explicitly pinned kube-scheduler images are used unchanged.
global.imageRegistrystring""Global Docker image registry that replaces the registry of every HAMi image, overriding the per-component *.image.registry settings. Leave empty to keep the per-component registries.
global.imagePullSecretslist[]Global Docker image pull secrets added to the scheduler, device plugin, webhook patch job, and remote-gpu Pods; the mock device plugin DaemonSet does not use them. Each entry is the name of an existing docker-registry Secret, e.g. myRegistryKeySecretName.
global.imageTagstring"v2.11.0-r0"Tag (optionally tag@sha256:...) used by the scheduler extender, device plugin and monitor images when their own *.image.tag is empty. An explicit tag replaces the complete value. A non-empty per-component tag takes precedence. The kube-scheduler, webhook patch, mock device plugin and remote-gpu images do not use it.
global.gpuHookPathstring"/usr/local"Directory prefix on the node where the NVIDIA vGPU hook files are installed (<gpuHookPath>/vgpu). Only used by the NVIDIA device plugin.
global.labelsobject{}Labels added to the scheduler Deployment and PodDisruptionBudget, the NVIDIA and remote-gpu DaemonSets, and the ServiceMonitors.
global.annotationsobject{}Annotations added to the scheduler Deployment and PodDisruptionBudget and to the NVIDIA and remote-gpu DaemonSets.
global.managedNodeSelectorEnableboolfalseWhen true, add global.managedNodeSelector to the scheduler pod as NODE_SELECTOR_* environment variables.
global.managedNodeSelectorobject{"usage":"gpu"}Node labels exposed to the scheduler pod when global.managedNodeSelectorEnable is true. Each key/value pair becomes a NODE_SELECTOR_<KEY> environment variable on the scheduler pod (key upper-cased, with -, / and . replaced by _), e.g. usage: gpu becomes NODE_SELECTOR_USAGE=gpu.
nameOverridestring""Replaces the chart name in resource names and in the app.kubernetes.io/name label. Resource names use the release name alone when it already contains this name, otherwise <release>-<name>. fullnameOverride takes precedence for resource names.
fullnameOverridestring""Fully overrides the names of the resources the chart creates, bypassing the <release>-<chart> naming. Truncated to 63 characters.
namespaceOverridestring""Namespace the chart's resources are rendered into instead of the release namespace. The chart does not create it, so it must already exist.
platform.openshiftboolfalseEnable when deploying HAMi on OpenShift. Applies restricted security contexts to the scheduler extender and webhook jobs, and omits scheduler.patch.runAsUser so OpenShift can assign job UIDs.
platform.openshiftVersionstring""
openshift.securityContextConstraints.createbooltrueCreate the named SecurityContextConstraints (SCC) and its use ClusterRole (system:openshift:scc:<name>) when platform.openshift=true and name is non-empty. The created SCC allows privileged containers, hostPath volumes, and the host PID namespace. Set to false to reuse an existing SCC and matching ClusterRole. Must be false for the built-in privileged SCC.
openshift.securityContextConstraints.namestring"hami-device-plugin"Name of the SCC that enabled NVIDIA and mock device-plugin service accounts are allowed to use when platform.openshift=true. Leave empty to skip SCC creation and binding, and manage SCC access separately.
selinux.enabledboolfalseAdd a privileged NVIDIA device-plugin init container to recursively relabel host directories devicePlugin.libPath, devicePlugin.monitor.ctrPath, and /tmp/vgpulock. Creates missing directories and sets permissions to 0777 on devicePlugin.monitor.ctrPath and 1777 on /tmp/vgpulock. Requires devicePlugin.enabled=true. Available on any SELinux-enabled Kubernetes distribution, independently of platform.openshift. Uninstalling does not restore host labels or permissions.
selinux.typestring"container_file_t"SELinux file type passed to chcon -t for the shared vGPU host directories when selinux.enabled=true. Must be a type supported by the node's SELinux policy.
selinux.levelstring"s0"SELinux security level or range passed to chcon -l for the shared vGPU host directories when selinux.enabled=true, for example s0 or s0:c123,c456.
schedulerNamestring"hami-scheduler"Name of the HAMi scheduler. The admission webhook sets it as schedulerName on Pods that request devices, the kube-scheduler container serves it, and the scheduler extender and kube-scheduler use it as their leader election lease name.
podSecurityPolicy.enabledboolfalseRender a policy/v1beta1 PodSecurityPolicy and its use RBAC rule for the webhook certificate creation and patch jobs. Only takes effect when scheduler.admissionWebhook.enabled=true, scheduler.patch.enabled=true, and scheduler.certManager.enabled=false. Keep disabled on Kubernetes 1.25 and later, where the PodSecurityPolicy API is removed.
scheduler.nodeNamestring""Node to run the scheduler Pod on, bypassing scheduling, for example when HAMi replaces the default scheduler. Empty lets Kubernetes place it; scheduler.nodeSelector can also be set.
scheduler.overwriteEnvstring"false"Default for whether the admission webhook hides devices from containers that request none: NVIDIA_VISIBLE_DEVICES=none for NVIDIA and an empty ASCEND_VISIBLE_DEVICES for Ascend. The Pod annotations hami.io/overwrite-env and hami.io/overwrite-env-containers override it.
scheduler.defaultSchedulerPolicy.nodeSchedulerPolicystring"binpack"Default node scoring policy: binpack fills busy nodes first, spread prefers idle ones. The hami.io/node-scheduler-policy Pod annotation overrides it.
scheduler.defaultSchedulerPolicy.gpuSchedulerPolicystring"spread"Default device scoring policy within a node: binpack, spread, or topology-aware. topology-aware also makes the NVIDIA device plugin report GPU topology scores. The hami.io/gpu-scheduler-policy Pod annotation overrides it.
scheduler.defaultSchedulerPolicy.nodeAffinityScoreWeightfloat0Bonus added to the node score for nodes matching a Pod's preferred nodeAffinity, scaled by the matched weight ratio (0..1). 0 disables it. HAMi returns a single node from Filter, so other kube-scheduler score plugins are still ignored. Values above 30 let the preference outweigh GPU usage.
scheduler.metricsBindAddressstring":9395"Address the scheduler serves Prometheus metrics on, as [host]:port. The chart also takes the port from it for the metrics container port.
scheduler.profilingBindAddressstring"127.0.0.1:6060"Address of the pprof server, used only when --profiling is added to scheduler.extender.extraArgs. Keep it on loopback and reach it with kubectl port-forward.
scheduler.kubeQPSstring""Queries per second the scheduler may send to kube-apiserver. Empty keeps the client default of 5. Raise it, with kubeBurst, on large clusters.
scheduler.kubeBurststring""Request burst the scheduler may send to kube-apiserver. Empty keeps the client default of 10.
scheduler.kubeTimeoutstring""Timeout in seconds for scheduler requests to kube-apiserver. Empty or 0 means no timeout.
scheduler.nodeLockRetryTimeoutstring""How long Bind retries locking a node held by another member of the same PodGroup, as a duration such as 28s. Empty keeps the default of 28s, and 0 disables the retry. Keep it below extenderHTTPTimeout.
scheduler.extenderHTTPTimeoutint30Timeout in seconds that kube-scheduler gives each call to the HAMi extender. Keep it above nodeLockRetryTimeout, or kube-scheduler cancels Bind while the extender is still retrying a node lock.
scheduler.extenderPortint9444Loopback port the extender serves /filter and /bind on, for the kube-scheduler container in the same Pod. It must differ from scheduler.service.httpTargetPort. If kube-scheduler runs outside the Pod, change --extender-bind through scheduler.extender.extraArgs.
scheduler.forceOverwriteDefaultSchedulerbooltrueLet the admission webhook replace default-scheduler with schedulerName on Pods that request devices. Kubernetes fills in default-scheduler for Pods that name no scheduler, so when false the webhook leaves every Pod that does not already name schedulerName unchanged.
scheduler.livenessProbeboolfalseAdd liveness probes to the scheduler containers.
scheduler.leaderElectbooltrueEnable leader election for the scheduler extender and kube-scheduler. Required for replicas above 1; it also adds a readiness probe, spreads replicas across nodes when possible, and allows the PodDisruptionBudget. Only the leader receives Service traffic.
scheduler.replicasint1Number of scheduler replicas. Used only when leaderElect is true; otherwise one replica runs.
scheduler.podDisruptionBudget.minAvailableint1Minimum available scheduler Pods for the PodDisruptionBudget, which is created only when leaderElect is true and replicas is above 1. Setting podDisruptionBudget.maxUnavailable uses that instead.
scheduler.kubeScheduler.enabledbooltrueRun a kube-scheduler container in the scheduler Pod, configured with schedulerName and the HAMi extender. When false, provide a scheduler named schedulerName that calls the extender yourself; the extender listens on loopback, so also change --extender-bind through scheduler.extender.extraArgs.
scheduler.kubeScheduler.image.registrystring"registry.k8s.io"Registry of the kube-scheduler image. global.imageRegistry overrides it. global.imageSource=cn selects registry.cn-hangzhou.aliyuncs.com/google_containers/kube-scheduler for tag-based upstream references.
scheduler.kubeScheduler.image.repositorystring"kube-scheduler"Repository of the kube-scheduler image.
scheduler.kubeScheduler.image.tagstring""Tag of the kube-scheduler image. Empty uses the cluster's Kubernetes version without distribution suffixes, such as v1.31.1 for v1.31.1+k3s1. It is not pinned by digest automatically. global.imageTag does not apply to it.
scheduler.kubeScheduler.image.pullPolicystring"IfNotPresent"Pull policy of the kube-scheduler image.
scheduler.kubeScheduler.image.pullSecretslist[]Names of existing image pull Secrets for the scheduler Pod, added after global.imagePullSecrets. Used only when enabled is true.
scheduler.kubeScheduler.resourcesobject{}Resource requests and limits for the kube-scheduler container.
scheduler.kubeScheduler.extraNewArgslist["--config=/config/config.yaml","-v=4"]Complete kube-scheduler arguments on Kubernetes 1.22 and later. Keep --config=/config/config.yaml, the chart-generated KubeSchedulerConfiguration that sets schedulerName, leader election, and the HAMi extender.
scheduler.kubeScheduler.extraArgslist["--policy-config-file=/config/config.json","-v=4"]Extra kube-scheduler arguments on Kubernetes versions before 1.22, after the chart's --scheduler-name flag and before its leader election flags. Keep --policy-config-file=/config/config.json, the chart-generated Policy that adds the HAMi extender.
scheduler.extender.image.registrystring"ghcr.io"Registry of the scheduler extender image. global.imageRegistry overrides it. For docker.io/projecthami/hami, set global.imageSource=cn and leave global.imageRegistry empty to use m.daocloud.io/docker.io/projecthami/hami with the same tag and digest.
scheduler.extender.image.repositorystring"dynamia-ai/hami-enterprise"Repository of the scheduler extender image.
scheduler.extender.image.tagstring""Tag of the scheduler extender image. Empty uses global.imageTag.
scheduler.extender.image.pullPolicystring"IfNotPresent"Pull policy of the scheduler extender image.
scheduler.extender.image.pullSecretslist[]Names of existing image pull Secrets for the scheduler Pod, added after global.imagePullSecrets.
scheduler.extender.resourcesobject{}Resource requests and limits for the scheduler extender container.
scheduler.extender.extraArgslist["--debug","-v=4"]Extra command-line flags for the scheduler extender, appended after the flags the chart generates, such as --profiling to serve pprof on scheduler.profilingBindAddress.
scheduler.nodeLockExpirestring"5m"Age after which a node lock is treated as expired, as a positive duration such as 5m. An unparsable or non-positive value is ignored and 5m is used. A --node-lock-timeout flag in scheduler.extender.extraArgs overrides it.
scheduler.podAnnotationsobject{}Annotations for the scheduler Pods.
scheduler.tolerationslist[]Tolerations for the scheduler Pods.
scheduler.admissionWebhook.enabledbooltrueInstall the mutating admission webhook. It rejects Pods that preset HAMi allocation annotations, and for Pods that request devices it applies each device backend's admission changes, sets schedulerName, checks ResourceQuota, and rejects privileged containers. When false, Pods that should use HAMi must set schedulerName and their device settings themselves, and the scheduler serves its HTTP port without TLS.
scheduler.admissionWebhook.customURL.enabledboolfalseHave kube-apiserver call the webhook at https://<host>:<port><path>, such as a node port, instead of through the scheduler Service.
scheduler.admissionWebhook.customURL.hoststring"127.0.0.1"Host name or IP address in the custom webhook URL. The certificate from the patch Jobs includes it; the cert-manager certificate does not.
scheduler.admissionWebhook.customURL.portint31998Port in the custom webhook URL. The default matches scheduler.service.schedulerPort.
scheduler.admissionWebhook.customURL.pathstring"/webhook"Path in the custom webhook URL. The scheduler serves the webhook on /webhook.
scheduler.admissionWebhook.whitelistNamespaceslistunsetNames of namespaces whose Pods the webhook skips, such as kube-system. Applies only when manageNamespaceSelector is true.
scheduler.admissionWebhook.manageNamespaceSelectorbooltrueRender the webhook's namespaceSelector. Set it to false on platforms that manage that field themselves, such as AKS, to avoid server-side apply conflicts. whitelistNamespaces and namespaceSelector then have no effect.
scheduler.admissionWebhook.namespaceSelector.matchLabelsobjectunsetLabels a namespace must have for the webhook to apply to its Pods. Applies only when manageNamespaceSelector is true.
scheduler.admissionWebhook.namespaceSelector.matchExpressionslist[]Extra namespace selector expressions, added after the built-in one that skips namespaces labeled hami.io/webhook: ignore. Applies only when manageNamespaceSelector is true.
scheduler.admissionWebhook.objectSelector.matchExpressionslist[]Extra Pod selector expressions, added after the built-in one that skips Pods labeled hami.io/webhook: ignore. Labels a Pod must have can also be set as objectSelector.matchLabels.
scheduler.admissionWebhook.reinvocationPolicystring"Never"Whether kube-apiserver calls the webhook again after a later mutating webhook changes the Pod: Never or IfNeeded.
scheduler.admissionWebhook.failurePolicystring"Ignore"What kube-apiserver does when it cannot reach the webhook. Ignore admits the Pod without HAMi's changes and without an error. Fail rejects the request; because the webhook handles every Pod create and update in the selected namespaces, an unavailable scheduler then blocks them all.
scheduler.certManager.enabledboolfalseUse cert-manager for the admission webhook certificate. The chart creates a self-signed Issuer and a Certificate for <scheduler Service>.<namespace>.svc stored in Secret <fullname>-scheduler-tls, and annotates the webhook so cert-manager injects its CA. Requires cert-manager in the cluster and admissionWebhook.enabled. Takes precedence over patch. With both certManager.enabled and patch.enabled false, create that Secret with tls.crt and tls.key and set the webhook CA yourself.
scheduler.patch.enabledbooltrueUse kube-webhook-certgen Jobs for the admission webhook certificate when certManager.enabled is false. A pre-install and pre-upgrade hook Job writes a self-signed certificate to Secret <fullname>-scheduler-tls, and a post-install and post-upgrade hook Job sets its CA on the webhook. Requires admissionWebhook.enabled.
scheduler.patch.imageNew.registrystring"registry.k8s.io"Registry of the certgen image. If registry.k8s.io is inaccessible, set global.imageSource=cn before installing or upgrading. For a manual mirror override, use registry.cn-hangzhou.aliyuncs.com with the matching repository and tag below. global.imageRegistry overrides this field; leave it empty to use this per-component setting.
scheduler.patch.imageNew.repositorystring"ingress-nginx/kube-webhook-certgen"Repository of the certgen image. For the China mirror, use google_containers/kube-webhook-certgen.
scheduler.patch.imageNew.tagstring"v1.6.9@sha256:01038e7de14b78d702d2849c3aad72fd25903c4765af63cf16aa3398f5d5f2dd"Certgen version and multi-architecture index digest, in tag@sha256:... format. For the China mirror, use v1.6.9@sha256:78bf4f774a27f29a5e6333c11708ac4645139e7bb2b74aa9e9c4574935f7a989. global.imageSource=cn switches the default pinned reference to the mirror automatically. Source and mirror index digests differ; for manual overrides, change registry, repository, and tag together.
scheduler.patch.imageNew.pullPolicystring"IfNotPresent"Pull policy of the certgen image.
scheduler.patch.imageNew.pullSecretslist[]Names of existing image pull Secrets for the certgen Jobs, added after global.imagePullSecrets.
scheduler.patch.priorityClassNamestring""PriorityClass for the certgen Job Pods. Empty sets none.
scheduler.patch.podAnnotationsobject{}Annotations for the certgen Job Pods.
scheduler.patch.nodeSelectorobject{}Node selector for the certgen Job Pods.
scheduler.patch.tolerationslist[]Tolerations for the certgen Job Pods.
scheduler.patch.runAsUserint2000User ID the certgen Job Pods run as. They always run as non-root. Not set when platform.openshift is true, so the OpenShift SCC can assign an allowed UID, or when this value is 0 or empty.
scheduler.service.typestring"NodePort"Type of the scheduler Service, which routes only to the scheduler Pod holding leadership. With NodePort, the chart also sets the node ports from schedulerPort and monitorPort. Empty uses ClusterIP.
scheduler.service.httpPortint443Service port for the scheduler's HTTP port. The admission webhook and the device plugin's default NUMA refit endpoint reach the scheduler through it.
scheduler.service.schedulerPortint31998Node port for the HTTP port when type is NodePort.
scheduler.service.monitorPortint31993Service port for scheduler metrics. When type is NodePort, it is also used as the node port, so it must be in the cluster's node port range.
scheduler.service.monitorTargetPortint9395Container port the metrics Service port targets, by number or name. The default metrics names the container port taken from scheduler.metricsBindAddress.
scheduler.service.httpTargetPortint9443Container port the scheduler serves the admission webhook, /refit, and probes on. It must differ from scheduler.extenderPort.
scheduler.service.labelsobject{}Extra labels for the scheduler Service.
scheduler.service.annotationsobject{}Annotations for the scheduler Service.
scheduler.networkPolicy.enabledboolfalseCreate a NetworkPolicy for the scheduler Pods. It admits traffic to the HTTP port (scheduler.service.httpTargetPort), which serves the admission webhook and the device plugin's /refit calls, only from this release's device plugin Pods and the kube-system namespace, leaves the metrics port open to all sources, and denies other ingress. Enable it only if your CNI matches kube-apiserver traffic against namespaceSelector: when kube-apiserver uses host networking, many CNIs do not, and with admissionWebhook.failurePolicy: Ignore Pods are then admitted without HAMi's changes and without an error.
scheduler.useDownwardbooltrue
devicePlugin.enabledbooltrueDeploy the NVIDIA device plugin DaemonSet, including the vGPU monitor container.
devicePlugin.gpuOperatorToolkitReady.enabledboolfalseWait for <hostPath>/toolkit-ready in an init container before starting the device plugin and monitor.
devicePlugin.gpuOperatorToolkitReady.hostPathstring"/run/nvidia/validations"Host directory containing toolkit-ready. Also supplies driver-ready when devicePlugin.nvidiaDriverRoot=auto.
devicePlugin.gpuOperatorToolkitReady.securityContextobject{"privileged":true,"runAsUser":0}Security context for the toolkit-validation init container.
devicePlugin.image.registrystring"ghcr.io"NVIDIA device plugin image registry. Overridden by a non-empty global.imageRegistry. For docker.io/projecthami/hami, set global.imageSource=cn and leave global.imageRegistry empty to use m.daocloud.io/docker.io/projecthami/hami with the same tag and digest.
devicePlugin.image.repositorystring"dynamia-ai/hami-enterprise"Image repository for the NVIDIA device plugin container and the selinux-relabel and toolkit-validation init containers when enabled.
devicePlugin.image.tagstring""NVIDIA device plugin image tag. Empty uses global.imageTag.
devicePlugin.image.pullPolicystring"IfNotPresent"Image pull policy for the NVIDIA device plugin and its enabled init containers: Always, IfNotPresent, or Never.
devicePlugin.image.pullSecretslist[]Image pull Secret names for the device plugin Pod, appended to global.imagePullSecrets, e.g. [myRegistryKeySecretName].
devicePlugin.vgpuCache.gracePeriodstring"5m"Minimum cache directory age, measured from its modification time, before garbage collection. Use Go duration syntax such as 30s, 5m, or 1h. Empty or invalid values use 5m; negative durations prevent startup. 0s removes the age grace period but still requires live Pod confirmation. Independent of monitor resync and the GC scan interval.
devicePlugin.monitor.image.registrystring"ghcr.io"Monitor image registry. Overridden by a non-empty global.imageRegistry. For docker.io/projecthami/hami, set global.imageSource=cn and leave global.imageRegistry empty to use m.daocloud.io/docker.io/projecthami/hami with the same tag and digest.
devicePlugin.monitor.image.repositorystring"dynamia-ai/hami-enterprise"Monitor image repository.
devicePlugin.monitor.image.tagstring""Monitor image tag. Empty uses global.imageTag.
devicePlugin.monitor.image.pullPolicystring"IfNotPresent"Monitor image pull policy: Always, IfNotPresent, or Never.
devicePlugin.monitor.image.pullSecretslist[]Monitor image pull Secret names. Currently unused by the DaemonSet; configure devicePlugin.image.pullSecrets or global.imagePullSecrets for the shared Pod.
devicePlugin.monitor.ctrPathstring"/usr/local/vgpu/containers"Shared per-container libvgpu cache path used by the device plugin and monitor.
devicePlugin.monitor.metricsBindAddressstring":9394"Address the monitor serves /metrics on. The container port, Service target port and probes follow it. Loopback addresses are rejected. Set it here, not in extraArgs.
devicePlugin.monitor.probes.enabledbooltrueRun the monitor liveness and readiness probes. Disable to debug inside the container.
devicePlugin.monitor.resyncIntervalstring"5m"Monitor Pod informer resync interval and grace period for releasing mappings of missing Pods. Does not control directory GC or Prometheus scrape frequency.
devicePlugin.monitor.disableHAMiCoreForWholeGPUboolfalseDisable the HAMi-core hook for whole-GPU containers when memory and core scaling are both 1; the monitor reads their metrics from NVML instead. Whole-GPU means a non-MIG device with full device memory allocated and cores unrequested or gpucores=100.
devicePlugin.monitor.extraArgslist["-v=4"]Additional monitor command-line arguments as a list of strings.
devicePlugin.monitor.extraEnvslist[]Extra Kubernetes env entries for the vGPU monitor, as a list of objects with name and value or valueFrom. @schema type: [array, object]
devicePlugin.monitor.securityContextobject{"allowPrivilegeEscalation":false,"capabilities":{"add":["SYS_ADMIN"],"drop":["ALL"]}}Security context for the monitor container.
devicePlugin.monitor.migInstanceAccessboolfalseMIG instance monitoring requires privileged access for the monitor container; if you don't use MIG, you can set this to false.
devicePlugin.monitor.resourcesobject{}Resource requests and limits for the monitor container.
devicePlugin.numaRefit.enabledboolfalseNUMA alignment refit (#2080): when enabled, the device plugin asks the scheduler to re-run its fit over the NUMA-restricted device set kubelet allows, keeping scheduler accounting authoritative. Requires devices.nvidia.enableNumaTopology plus the per-node enablegetpreferredallocation node configuration; pods opt in with the hami.io/numa-alignment annotation (best-effort or strict). Disabled by default: mismatches are only logged.
devicePlugin.numaRefit.schedulerEndpointstring""Scheduler base URL override. Defaults to the in-cluster scheduler service, https://<release>-scheduler.<namespace>.svc:<scheduler.service.httpPort>.
devicePlugin.numaRefit.tlsInsecureboolfalseMust remain false: refit sends a ServiceAccount token and requires TLS certificate verification. Enabling refit requires caFile or caSecret containing the CA that signed the scheduler serving certificate.
devicePlugin.numaRefit.caFilestring""Path to a CA bundle already present inside the device-plugin container.
devicePlugin.numaRefit.caSecretstring""Name of a Secret (key ca.crt) to mount as the CA bundle instead; used when caFile is empty.
devicePlugin.reportNodeCapacityboolfalseReport GPU memory and core resources in Node capacity and allocatable. The reportnodecapacity JSON field in nodeConfiguration.config overrides this setting for matching nodes.
devicePlugin.nodeConfiguration.configstringExample node configuration; see values.yaml.JSON content for the generated device plugin ConfigMap key config.json; ignored when externalConfigName is set. The nodeconfig list selects entries whose name matches the node. If none match, it selects matching nodelabelselector entries; if neither matches, it uses entries named *. For example, use {"nodelabelselector":{"matchLabels":{"gpu.example.com/pool":"mig"}},"operatingmode":"mig"}. Node labels are read at plugin startup; restart the plugin after changing them and use labels available when the node registers. Selected entries apply in list order; later overrides take precedence. For per-node resource settings, null, zero, or false does not replace an existing non-zero or true value. Empty operatingmode and filterdevices values are ignored. Entries with both or neither of name and nodelabelselector, or with an empty or invalid label selector, are skipped.
devicePlugin.nodeConfiguration.externalConfigNamestring""Existing ConfigMap containing a config.json key in the Pod namespace. When non-empty, the chart mounts it instead of creating a ConfigMap from nodeConfiguration.config.
devicePlugin.migStrategystring"none"Strategy for exposing NVIDIA MIG devices: none, single, or mixed. mixed exposes MIG profiles as separate resources. Passed as --mig-strategy.
devicePlugin.disablecorelimitstring"false"Set to "true" to disable HAMi-core utilization limits. This value is merged with nvidia.disableCoreLimit in device-config.yaml; either one being true disables limits, while "false" does not override a true file value.
devicePlugin.passDeviceSpecsEnabledbooltruePass device specifications to kubelet in Allocate responses. Ignored when deviceListStrategy contains only CDI strategies. Null leaves the plugin default unchanged (disabled).
devicePlugin.deviceListStrategystring"envvar"Comma-separated device list strategies passed to the container runtime: envvar, volume-mounts, cdi-annotations, or cdi-cri. CDI strategies require a CDI-capable runtime; cdi-cri also requires kubelet/CRI support for CDI devices.
devicePlugin.nvidiaHookPathstring""Path for NVIDIA CDI hooks in generated CDI specifications. Null omits NVIDIA_CDI_HOOK_PATH and keeps the plugin default /usr/bin/nvidia-ctk.
devicePlugin.nvidiaDriverRootstring""Root of the NVIDIA driver on the host. Set to "auto" to read the driver and device roots from GPU Operator's driver-ready contract. If the contract is absent, both roots default to / for a host-installed driver. In auto mode the device plugin uses the driver injected by the NVIDIA Container Toolkit, so it must run with the NVIDIA runtime; the host root is mounted read-only only when deviceListStrategy uses a cdi-* strategy.
devicePlugin.gdrcopyEnabledboolfalseEnable GDRCopy support for allocated GPU containers. A boolean sets GDRCOPY_ENABLED; null leaves the plugin default unchanged (disabled). Requires the corresponding host drivers and runtime support.
devicePlugin.gdsEnabledboolfalseEnable GPUDirect Storage support for allocated GPU containers. A boolean sets GDS_ENABLED; null leaves the plugin default unchanged (disabled). Requires the corresponding host drivers and runtime support.
devicePlugin.mofedEnabledboolfalseEnable MOFED support for allocated GPU containers. A boolean sets MOFED_ENABLED; null leaves the plugin default unchanged (disabled). Requires the corresponding host drivers and runtime support.
devicePlugin.extraArgslist["-v=4"]Additional NVIDIA device plugin command-line arguments as a list of strings.
devicePlugin.extraEnvslist[]Extra Kubernetes env entries for the device plugin, as a list of objects with name and value or valueFrom. @schema type: [array, object]
devicePlugin.service.typestring"NodePort"Service type for vGPU monitor metrics. Empty uses NodePort; ClusterIP exposes metrics only within the cluster.
devicePlugin.service.httpPortint31992Monitor Service port. Also used as the nodePort when service.type=NodePort. Empty or zero uses 31992; the target port follows monitor.metricsBindAddress.
devicePlugin.service.labelsobject{}Additional labels for the vGPU monitor Service, as a map of label names to string values.
devicePlugin.service.annotationsobject{}Annotations for the vGPU monitor Service, as a map of annotation names to string values.
devicePlugin.pluginPathstring"/var/lib/kubelet/device-plugins"Host kubelet device-plugin socket directory, mounted at /var/lib/kubelet/device-plugins inside the device plugin container.
devicePlugin.libPathstring"/usr/local/vgpu"Host directory for HAMi-core library files, mounted at <global.gpuHookPath>/vgpu inside the device plugin container.
devicePlugin.podAnnotationsobject{}Additional annotations for NVIDIA device plugin Pods, as a map of annotation names to string values.
devicePlugin.hostPIDbooltrueUse the host PID namespace for NVIDIA device plugin Pods. Must be true when hostPIDBroker.enabled is true.
devicePlugin.hostPIDBroker.enabledboolfalseEnable the host PID broker so HAMi-core can query the device plugin for its host PID. Requires hostPID=true; mounts the broker socket directory at /var/run/hami/hostpid. See Host PID broker.
devicePlugin.hostNetworkboolfalseUse the host network for NVIDIA device plugin Pods. When enabled, the chart sets dnsPolicy: ClusterFirstWithHostNet so the scheduler Service remains resolvable.
devicePlugin.securityContextobject{"allowPrivilegeEscalation":true,"capabilities":{"add":["SYS_ADMIN"],"drop":["ALL"]},"privileged":true}Kubernetes container security context for the NVIDIA device plugin.
devicePlugin.nvidiaNodeSelectorobject{"gpu":"on"}Node labels required for NVIDIA device plugin Pods, as a map of label names to string values.
devicePlugin.tolerationslist[{"effect":"NoSchedule","key":"nvidia.com/gpu","operator":"Exists"}]Kubernetes tolerations for NVIDIA device plugin Pods, as a list of objects with key, operator, value, effect, and optional tolerationSeconds.
devicePlugin.updateStrategyobject{"rollingUpdate":{"maxUnavailable":1},"type":"RollingUpdate"}Kubernetes DaemonSet update strategy: RollingUpdate or OnDelete. For RollingUpdate, configure rollingUpdate.maxUnavailable as a count or percentage.
devicePlugin.resourcesobject{}Kubernetes resource requests and limits for the NVIDIA device plugin container, for example {requests: {cpu: 100m, memory: 100Mi}, limits: {memory: 1Gi}}.
devicePlugin.cdiVendorstring""
mockDevicePlugin.enabledboolfalseDeploy the mock device plugin as a DaemonSet on all eligible nodes without node selectors.
mockDevicePlugin.image.registrystring"docker.io"Image registry, overridden by global.imageRegistry.
mockDevicePlugin.image.repositorystring"projecthami/mock-device-plugin"Image repository for the mock-device-plugin.
mockDevicePlugin.image.tagstring"1.0.1@sha256:61d08a5641251ed776e4701c0dcf05c2c2bed5a58b39b8a11ec85ca5e57e674a"Image tag (required), pinned by digest; does not inherit global.imageTag.
mockDevicePlugin.image.pullPolicystring"IfNotPresent"Image pull policy: Always, IfNotPresent, or Never.
devices.metax.resourceCountNamestring"metax-tech.com/gpu"Resource name for non-negative integer whole-GPU counts. Must match the vendor device plugin; 0 requests no device.
devices.metax.resourceVCountNamestring"metax-tech.com/sgpu"Resource name for non-negative integer sGPU counts in container limits. Required for sGPU memory or core requests; 0 requests no device. See MetaX workload examples.
devices.metax.resourceVCoreNamestring"metax-tech.com/vcore"Resource name for each sGPU's requested compute percentage (integer, 0-100; 40 means 40%). Omission requests 100; 0 reserves no compute. Pods annotated with metax-tech.com/sgpu-app-class: online do not reserve compute through this resource.
devices.metax.resourceVMemoryNamestring"metax-tech.com/vmemory"Resource name for the memory limit on each sGPU. Bare integers are in GiB; use a quantity such as 2048Mi to specify the unit explicitly. An omitted or zero limit requests the GPU's full memory.
devices.metax.sgpuTopologyAwareboolfalseEnable topology-aware node scoring for sGPU requests of 100% compute. Does not apply to online-class Pods or whole-GPU requests. The Pod annotation metax-tech.com/sgpu-topology-aware overrides this setting when it contains a valid boolean. @schema type: [boolean, string]
devices.hygon.memoryFactorint1Non-negative integer multiplier for explicit HCU memory requests in MiB and their ResourceQuota limits. For example, 1024 makes a memory request of 4 mean 4 GiB. 0 and 1 leave requests unscaled.
devices.hygon.resourceCountNamestring"hygon.com/hcunum"Resource name for non-negative integer vHCU counts. Required for HCU memory or core requests; 0 requests no device. Must match the vendor device plugin. See HCU workload examples.
devices.hygon.resourceMemoryNamestring"hygon.com/hcumem"Resource name for the memory requested on each vHCU, in integer MiB units, scaled by devices.hygon.memoryFactor when it is greater than 1. Omission or 0 requests the selected HCU's full memory.
devices.hygon.resourceCoreNamestring"hygon.com/hcucores"Resource name for each vHCU's requested compute percentage (integer, 0-100; 40 means 40%). Omission or 0 reserves no compute. An explicit 100 requests the card exclusively.
devices.cambricon.resourceCountNamestring"cambricon.com/vmlu"Resource name for the number of MLUs a container requests; it must match the Cambricon device plugin. A zero count requests no device; HAMi reads memory and core requests only for a positive count. Sharing needs one MLU and the plugin in dynamic-smlu mode; a count above 1 allocates whole MLUs and ignores the memory and core values. A non-empty device-config.content or a bundled files/device-config.yaml replaces the generated device configuration, so set the name there too.
devices.cambricon.resourceMemoryNamestring"cambricon.com/mlu.smlu.vmemory"Resource name for MLU memory, requested in integer units of 256 MiB (20 is 5120 MiB); run the plugin with min-dsmlu-unit=256. Omitted or 0 reserves the whole MLU memory. Set the name in device-config.content or files/device-config.yaml too when either replaces the generated configuration.
devices.cambricon.resourceCoreNamestring"cambricon.com/mlu.smlu.vcore"Resource name for MLU compute, requested as an integer percentage from 0 to 100; omitted requests 100. Set the name in device-config.content or files/device-config.yaml too when either replaces the generated configuration.
devices.amd.resourceCountNamestring"amd.com/gpu"Resource name for AMD GPU count requests. Must match the resource advertised by the AMD device plugin; 0 requests no device. An empty value skips the node GPU health check.
devices.amd.resourceMemoryNamestring"amd.com/gpumem"Resource name for per-GPU memory requests in MiB. defaultMemory applies when neither memory resource is specified.
devices.amd.resourceMemoryPercentageNamestring"amd.com/gpumem-percentage"Resource name for requesting GPU memory as a percentage (0-100). If both a positive fixed memory size and a percentage are set, the fixed size takes priority. If either value is explicitly set to 0 and the other is not positive, the full GPU memory is used. If neither is set, defaultMemory is used. An empty value disables percentage memory requests.
devices.amd.resourceCoreNamestring"amd.com/gpucores"Resource name for per-GPU core percentage requests (1-100). Omitted uses defaultCores, or all cores when that value is 0.
devices.amd.runtimeClassNamestring""RuntimeClass the admission webhook adds to AMD GPU Pods that do not already specify one. The chart does not create it; empty leaves the Pod unchanged.
devices.amd.defaultGPUNumint1Default GPU count added by the admission webhook when memory, memory percentage, or cores are requested without a GPU count. Values below 1 are treated as 1. A GPU count already specified in resource requests is preserved.
devices.amd.defaultMemoryint0Default memory per requested GPU in MiB. Used when neither memory resource is specified; 0 uses the full GPU memory.
devices.amd.defaultCoresint0Default core percentage per requested GPU. Used when no core request is specified; 0 uses all cores. Values are clamped to 0-100.
devices.amd.customresourceslist["amd.com/gpu","amd.com/gpumem","amd.com/gpucores"]Resource names managed by the scheduler extender. Include resourceCountName, resourceMemoryName, and resourceCoreName; they are not added automatically. resourceMemoryPercentageName is added automatically.
devices.awsneuron.resourceCountNamestring"aws.amazon.com/neuron"Resource name for positive integer counts of whole Neuron devices. Takes precedence over devices.awsneuron.resourceCoreName requests when both are present.
devices.awsneuron.resourceCoreNamestring"aws.amazon.com/neuroncore"Resource name for positive integer NeuronCore counts. Cores per device depend on the node; one core is not always half a device. See the NeuronCore workload example.
devices.awsneuron.customresourceslist["aws.amazon.com/neuron","aws.amazon.com/neuroncore"]List of resource-name strings managed by the scheduler extender. Include the names configured by devices.awsneuron.resourceCountName and devices.awsneuron.resourceCoreName; they are not added automatically.
devices.kunlun.resourceCountNamestring"kunlunxin.com/xpu"Resource name for non-negative integer physical XPU counts. Must match the device plugin and Pod resources. See Kunlunxin scheduling.
devices.kunlun.resourceVCountNamestring"kunlunxin.com/vxpu"Resource name for non-negative integer virtual XPU counts. Use with devices.kunlun.resourceVMemoryName for memory partitions. See VXPU usage.
devices.kunlun.resourceVMemoryNamestring"kunlunxin.com/vxpu-memory"Resource name for virtual XPU memory requests in integer MiB per XPU. Requires a virtual XPU count request. See memory partition sizes.
devices.kunlun.enabledbooltrueAdd Kunlun resource names to the bundled kube-scheduler's extender configuration. Setting false retains the device configuration. The vendor device plugin must be installed separately.
devices.kunlun.customresourceslist[]Additional resource-name strings managed by the scheduler extender when devices.kunlun.enabled is true. Standard names are added automatically from the resource fields.
devices.enflame.resourceNameGCUstring"enflame.com/gcu"Resource name for non-negative integer whole-GCU counts. Must match the device plugin and Pod resources.
devices.enflame.resourceNameDRSGCUstring"enflame.com/drs-gcu"Resource name for a positive integer DRS slice count on one GCU. Takes precedence over memory/core requests. See DRS workload examples.
devices.enflame.resourceNameGCUMemorystring"enflame.com/gcu-memory"Resource name for positive integer memory requests used to select a GCU partition, optionally combined with devices.enflame.resourceNameGCUCore. Documented requests use MiB (20480 = 20 GiB); small values may be interpreted as GiB depending on the available partitions. See Enflame DRS workload examples.
devices.enflame.resourceNameGCUCorestring"enflame.com/gcu-core"Resource name for a minimum core percentage (integer, 0-100; 40 means 40%), optionally combined with devices.enflame.resourceNameGCUMemory. Zero or omission sets no core minimum. See DRS workload examples.
devices.enflame.enabledbooltrueAdd Enflame resource names to the bundled kube-scheduler's extender configuration. Setting false retains the device configuration. The vendor device plugin must be installed separately.
devices.enflame.customresourceslist[]Additional resource-name strings managed by the scheduler extender when devices.enflame.enabled is true. Standard names are added automatically from the resource fields.
devices.enflame.resourceNameVGCUstring"enflame.com/vgcu"
devices.enflame.resourceNameVGCUPercentagestring"enflame.com/vgcu-percentage"
devices.mthreads.enabledbooltrueRegister customresources with the HAMi scheduler extender. The MThreads toolkit must be installed separately.
devices.mthreads.customresourceslist["mthreads.com/vgpu"]Resource names managed by the scheduler extender when enabled. Include resourceCountName; it is not added automatically.
devices.mthreads.resourceCountNamestring"mthreads.com/vgpu"Resource name for MThreads GPU count requests. Must match the vendor device plugin and the entry in customresources. Requesting only this resource allocates exclusive GPUs.
devices.mthreads.resourceMemoryNamestring"mthreads.com/sgpu-memory"Resource name for sGPU memory requests in integer units of 512 MiB (32 = 16 GiB). When memory is not requested, HAMi uses the selected node's per-card capacity.
devices.mthreads.resourceCoreNamestring"mthreads.com/sgpu-core"Resource name for integer sGPU time-sharing weight requests. HAMi accounts for 16 units per card: a single-card request of 8 consumes 8/16 of its allocatable compute units. Device sharing for multi-cards is not supported. For multi-card requests, HAMi overwrites the compute request with 16 units per card. Actual GPU time depends on the vendor scheduling policy and competing workloads.
devices.mthreads.memoryPerCardlist[96]Per-card capacities in 512 MiB units used to validate explicit single-device memory limits, not to set node capacity. 96 = MTT S4000 (48 GiB); 160 = MTT S5000 (80 GiB). Use [96, 160] for mixed fleets. Allowed limits are the union of powers of two starting at 2 and each full-card capacity. An empty list falls back to [96]; a legacy scalar is converted to a one-item list.
devices.vastai.resourceCountNamestring"vastaitech.com/va"Resource name for non-negative integer Vastai device counts (cards or dies, depending on the device plugin mode). Must match the device plugin and Pod resources. See Vastai usage.
devices.vastai.enabledbooltrueAdd Vastai resource names to the bundled kube-scheduler's extender configuration. Setting false retains the device configuration. The vendor device plugin must be installed separately.
devices.vastai.customresourceslist[]Additional resource-name strings managed by the scheduler extender when devices.vastai.enabled is true. Standard names are added automatically from the resource fields.
devices.biren.resourceCountNamestring"birentech.com/gpu"Resource name for non-negative integer Biren device counts. Must match the device plugin and Pod resources. See Biren usage.
devices.biren.enabledbooltrueAdd Biren resource names to the bundled kube-scheduler's extender configuration. Setting false retains the device configuration. The vendor device plugin must be installed separately.
devices.biren.customresourceslist[]Additional resource-name strings managed by the scheduler extender when devices.biren.enabled is true. Standard names are added automatically from the resource fields.
devices.nvidia.adoptExistingMIGInstancesboolfalseIn the mig operating mode, let the device plugin adopt, when it starts, MIG instances HAMi has no record of creating, so it can reuse or destroy them. When false, they are left untouched. Enable it only when HAMi alone manages the MIG layout of the node.
devices.nvidia.migProfileAllowlistlistProfiles for A30, A100, H100, H20, GH200, H200, B200, and RTX PRO 6000 Blackwell Server EditionMIG profiles HAMi may create on nodes whose device plugin runs in the mig operating mode. Each entry has models, a list of GPU model names matched as substrings of the name NVML reports, and profiles, a list of MIG profile names such as 1g.10gb, for example {models: ["A30"], profiles: ["1g.6gb", "2g.12gb"]}. The first entry that matches a GPU's model decides the profiles for that GPU; a GPU that no entry matches is not registered. The nvidia.com/mig-profile-preference Pod annotation accepts only listed profiles or their slice prefix, such as 4g. The scheduler and device plugin fail to start if an entry has empty models or profiles, or if a profile name has no . or its part before the first . is not at least two characters ending in g. The part after the . is not checked. A profile that passes this check but names a slice count the GPU does not support, such as 5g.20gb, is skipped on the node. Setting this value replaces the whole default list.
devices.nvidia.defaultMemoryint0GPU memory in MiB assigned to each requested GPU when a container sets neither the resourceMemoryName nor the resourceMemoryPercentageName resource, or sets them to 0. 0 assigns the whole memory of the GPU. memoryFactor does not apply to this value. Must not be negative.
devices.nvidia.defaultCoresint0Percentage of GPU cores, from 0 to 100, assigned to each requested GPU when a container does not set the resourceCoreName resource. 0 reserves no cores and sets no core limit. When the admission webhook is enabled, a container that requests GPUs without a memory amount, or with 100% of the memory, gets 100 instead, which requests each GPU exclusively when deviceCoreScaling is 1.
devices.nvidia.defaultGPUNumint1Number of GPUs the admission webhook adds to a container that sets a resourceMemoryName, resourceMemoryPercentageName, or resourceCoreName limit but no resourceCountName limit. 0 adds nothing, so such a container is not treated as an NVIDIA GPU request.
devices.nvidia.memoryFactorint1Multiplier applied to the resourceMemoryName value a container requests, which is otherwise in MiB. For example, 1024 makes nvidia.com/gpumem: 4 request 4 GiB. ResourceQuota limits for that resource are scaled the same way. 0 and 1 disable scaling. Must not be negative.
devices.nvidia.resourceCountNamestring"nvidia.com/gpu"Extended resource name for the number of NVIDIA GPUs a container requests. The device plugin registers it with kubelet, advertising each physical GPU deviceSplitCount times.
devices.nvidia.resourceMemoryNamestring"nvidia.com/gpumem"Extended resource name for the GPU memory a container requests on each GPU, in MiB multiplied by memoryFactor.
devices.nvidia.resourceMemoryPercentageNamestring"nvidia.com/gpumem-percentage"Extended resource name for the GPU memory a container requests on each GPU as a percentage of that GPU's memory, an integer from 0 to 100. 0 is treated as unset.
devices.nvidia.resourceCoreNamestring"nvidia.com/gpucores"Extended resource name for the GPU cores a container requests on each GPU, as an integer percentage from 0 to 100. 0 reserves no cores and sets no core limit. With deviceCoreScaling: 1, 100 requests each GPU exclusively.
devices.nvidia.resourcePriorityNamestring"nvidia.com/priority"Extended resource name for the task priority of a container. The admission webhook passes its limit to HAMi-core as CUDA_TASK_PRIORITY. A lower value is a higher priority, and HAMi-core uses 1 when it is unset. On a shared GPU, vGPUmonitor pauses kernel launches of lower-priority tasks while higher-priority tasks are active, but only for tasks with a resourceCoreName limit between 1 and 99 whose core limit is being enforced (see gpuCorePolicy).
devices.nvidia.deviceSplitCountint10Number of vGPUs each physical GPU is advertised as, which is the maximum number of containers that can share one GPU. In the mig operating mode, the number of MIG instances a GPU can hold limits sharing instead. A device-plugin nodeconfig entry can override it per node with devicesplitcount.
devices.nvidia.deviceMemoryScalingfloat1Factor applied to the memory each GPU reports to the scheduler. Accepts decimals, such as 1.5. A value above 1 lets the memory requests on one GPU add up to more than its physical memory, and the device plugin sets CUDA_OVERSUBSCRIBE=true in those containers. Not applied in the mig operating mode. A device-plugin nodeconfig entry can override it per node with devicememoryscaling. @schema type: number
devices.nvidia.deviceCoreScalingfloat1Factor applied to the cores each GPU reports to the scheduler, which is 100 times this value. Accepts decimals, such as 1.5. A value above 1 lets the resourceCoreName requests on one GPU add up to more than 100. Not applied in the mig operating mode. A device-plugin nodeconfig entry can override it per node with devicecorescaling. @schema type: number
devices.nvidia.preConfiguredDeviceMemoryint0Total memory in MiB registered for a GPU whose memory NVML cannot query, such as a unified-memory GPU like the NVIDIA GB10. GPUs that report their memory always use the reported value. 0 skips GPUs whose memory cannot be queried. A device-plugin nodeconfig entry can override it per node with preconfigureddevicememory.
devices.nvidia.enableNumaTopologyboolfalseAdvertise each GPU's NUMA node on its vGPUs so kubelet's Topology Manager can align CPUs and GPUs. Disabled by default because the single-numa-node Topology Manager policy then changes which Pods kubelet admits. A device-plugin nodeconfig entry can override it per node with enablenumatopology.
devices.nvidia.runtimeClassNamestring""RuntimeClass set on the device plugin Pods and, by the admission webhook, on GPU Pods that do not set runtimeClassName, commonly nvidia when the NVIDIA container runtime is not the default. The RuntimeClass must exist, either created by createRuntimeClass or already present in the cluster. Empty sets no RuntimeClass.
devices.nvidia.createRuntimeClassboolfalseCreate the RuntimeClass named by runtimeClassName, with the nvidia handler, when devicePlugin.enabled is true. Has no effect when runtimeClassName is empty. Leave it false if the RuntimeClass already exists, such as one created by the GPU Operator.
devices.nvidia.gpuCorePolicystring"default"How HAMi-core enforces the resourceCoreName limit. The admission webhook passes values other than default as GPU_CORE_UTILIZATION_POLICY. default lets vGPUmonitor turn enforcement on only while it sees other active tasks of the same or higher priority on the GPU. force always enforces it. disable never enforces it. HAMi-core treats any other value as default. Limits of 0 and 100 are never enforced.
devices.nvidia.libCudaLogLevelint1HAMi-core log level, passed to containers as LIBCUDA_LOG_LEVEL. Errors are always logged. 0 and 1 log errors only, 2 adds warnings and messages, 3 adds info, and 4 adds debug logs. HAMi-core itself defaults to 2 when the variable is unset. Not applied in the mig operating mode. A device-plugin nodeconfig entry can override it per node with libcudaloglevel.
devices.nvidia.limitDeliverystring"env"How the device plugin passes a container's GPU limits to HAMi-core. file sets the limit environment variables and also mounts the limits read-only at /overrideEnv, so HAMi-core can apply them to processes started without the container's environment, such as from SSH, su -, sudo or cron. env sets the environment variables only. A device-plugin nodeconfig entry can override it per node with limitdelivery, and a Pod with the hami.io/limit-delivery annotation. An unknown value is ignored, and file is used when no valid value is set. Not applied in the mig operating mode.
devices.remotegpu.enabledboolfalseSchedule Pods onto GPUs served over the network by a lupine server. Mark lupine nodes with operatingmode: remote in devicePlugin.nodeConfiguration (peer to hami-core / mig). The device plugin applies hami.io/lupine-server; set that label's value to a custom port only when the server is managed outside the chart (empty value uses defaultPort below). Keep resource names consistent with any device-config.content override.
devices.remotegpu.defaultPortint14833Port (1-65535) used by the scheduler and the server DaemonSet's container and host ports. A valid port in the hami.io/lupine-server node label overrides the scheduler's connection port. Must match the server's listen port; the chart does not configure the server process.
devices.remotegpu.resourceCountNamestring"nvidia.com/remote-gpu"Resource name for an integer GPU count in a container's requests or limits. A positive count reserves a whole server with at least that many GPUs, including any extra GPUs on that server. Zero requests no GPU allocation.
devices.remotegpu.resourceMemoryNamestring"nvidia.com/remote-gpu-memory"Resource name for optional per-GPU memory in a container's requests or limits, as integer MiB (1024 = 1 GiB). Used with a remote GPU count request. Missing or zero requests set no memory limit. Enforcement requires library injection through devices.remotegpu.libImage.
devices.remotegpu.libImagestringnilHAMi-core image for the client's library-copy init container, used to enforce positive memory requests. Must provide sh, cp, and /k8s-vgpu/lib/nvidia/libvgpu.so.*. Leave unset or null to use the device plugin image, including its registry and tag overrides. Set to "" to skip library injection and use memory requests only as placement filters. An explicit image reference is used unchanged.
devices.remotegpu.clientImagestring"ghcr.io/lupinemachines/lupine-client:cuda-13.3.1-ubuntu24.04@sha256:fe0e8c283fe29b0c8bfb4bbe2a81fac4fabd3a477fe694f31b5a97a996fb028e"Client image used to deliver Lupine libraries, libnghttp2, and nvidia-smi for the CUDA/vLLM examples; empty disables delivery. It must contain /opt/lupine/lib, sh, cp, libnghttp2.so.14, and nvidia-smi. Injection fails when nvidia-smi is missing. Match the server version and workload ABI; an empty string disables delivery. global.imageSource=cn prefixes the upstream Lupine client reference with m.daocloud.io/; other repositories are unchanged.
devices.remotegpu.sessionImagestring""Image for a relay Pod on each lupine server node, so users can port-forward to the relay. Requires sh and socat; global image overrides do not apply. Empty disables creation of relays without deleting existing ones.
devices.remotegpu.sessionImagePullSecretslist[]Names of existing image pull Secrets for the session relay Pods, added after global.imagePullSecrets. The Secrets must exist in the HAMi namespace.
devices.remotegpu.server.enabledbooltrueDeploy a lupine server DaemonSet when devices.remotegpu.enabled is true. Selects only nodes with an empty hami.io/lupine-server label value. A node whose label names its own port is left to a server managed outside the chart. False leaves server deployment to the operator without disabling remote GPU scheduling.
devices.remotegpu.server.image.registrystring"ghcr.io"Registry of the lupine server container image. global.imageRegistry overrides it.
devices.remotegpu.server.image.repositorystring"lupinemachines/lupine-server"Repository of the lupine server container image.
devices.remotegpu.server.image.tagstring"cuda-13.3.1-ubuntu24.04@sha256:79f023523ed0ea8704b6e3634c5831ed2d4210a0a8c7ed700a3bcdbbf7c9e1a3"Tag and digest of the lupine server container image; does not inherit global.imageTag.
devices.remotegpu.server.image.pullPolicystring"IfNotPresent"Pull policy of the lupine server container image: Always, IfNotPresent, or Never.
devices.remotegpu.server.image.pullSecretslist[]Names of existing image pull Secrets for the lupine server Pods, added after global.imagePullSecrets. The Secrets must exist in the HAMi namespace.
devices.remotegpu.server.runtimeClassNamestring""RuntimeClass for lupine server Pods. Set to a class such as nvidia when the NVIDIA container runtime is not the cluster default. Empty omits the field; independent of devices.nvidia.runtimeClassName.
devices.remotegpu.server.tolerationslist[]Kubernetes tolerations for lupine server Pods, as a list of objects with key, operator, value, effect, and optional tolerationSeconds.
devices.remotegpu.server.securityContextobject{}Container securityContext of the lupine server. Set privileged: true on hosts where the NVIDIA container toolkit has accept-nvidia-visible-devices-envvar-when-unprivileged=false, otherwise NVIDIA_VISIBLE_DEVICES is ignored and the server sees no GPU.
devices.remotegpu.server.resourcesobject{}Kubernetes resource requests and limits for the lupine server container, for example {requests: {cpu: 100m, memory: 100Mi}, limits: {memory: 1Gi}}.
devices.ascend.configslistPer-chip capacities and templates; see values.yaml.Per-chip objects shared with the separately deployed Ascend device plugin as vnpus.configs; overrides replace the whole list. String chipName must match the detected chip name; string commonWord identifies the HAMi device type. resourceName, resourceMemoryName, and resourceCoreName are resource-name strings for Pod device-count, memory, and core requests. Pod counts are non-negative integers. Memory requests and memoryAllocatable, memoryCapacity, and template memory use integer MiB (16384 = 16 GiB), without a Gi suffix. memoryAllocatable is usable memory; memoryCapacity is full-device capacity. memoryFactor is an integer request multiplier, applied only above 1. <br>Pod core requests in hami-core/enpu mode are integer percentages, 0-100 (40 means 40%); ENPU treats 0 or omission as 100%. Configured aiCore/aiCPU values are integer hardware core counts, not percentages or virtual-device slots. templates lists driver slice definitions: a string name, integer memory, and optional integer aiCore/aiCPU. The named template must be supported by the driver; editing these numbers does not create a new driver template. The boolean superPod enables Ascend910C module pairing: non-ENPU requests of 1 become 2; other odd counts are rejected. See single-card soft-slicing workload examples. <br>The Ascend950DT entry is for the 9582 SKU with 96 GiB HBM and requires a compatible separately deployed device plugin.
devices.ascend.runtimeClassNamestring""RuntimeClass name to set on Pods requesting Ascend resources when their spec.runtimeClassName is unset. Empty leaves the Pod unchanged; an existing Pod value is preserved.
devices.ascend.hamiVnpuModestring""Default VNPU mode: template, hami-core (alias: hamiCore), or enpu. Node capability annotations take priority. An empty or null value uses template, or hami-core when the deprecated devices.ascend.hamiVnpuCore is true. An explicit mode takes precedence over that flag; unknown modes are rejected.
devices.ascend.deviceSplitCountint10Positive integer virtual-device slots per physical Ascend NPU in hami-core and ENPU modes. Requires an ascend-device-plugin version supporting vnpus.deviceSplitCount (introduced in #144). A positive node vDeviceCount takes precedence; ENPU is capped at 100. Template mode keeps its template calculation.
devices.ascend.enpuPolicystring"elastic"Default ENPU policy: fixed-share, elastic, or best-effort; numeric string aliases "1", "2", and "3" are accepted. Empty uses elastic. A Pod's huawei.com/enpu-policy overrides this value; invalid policies are rejected for ENPU workloads.
devices.ascend.enabledboolfalseEnable Ascend support in the HAMi scheduler and add devices.ascend.customresources to the bundled kube-scheduler's extender configuration. Install the Ascend device plugin separately; this chart does not deploy it.
devices.ascend.imagestring""Not consumed by this chart. Configure the Ascend device plugin image in its separate deployment.
devices.ascend.imagePullPolicystring"IfNotPresent"Not consumed by this chart. Configure the Ascend device plugin's image pull policy in its separate deployment.
devices.ascend.extraArgslist[]Not consumed by this chart. Configure additional Ascend device plugin arguments in its separate deployment.
devices.ascend.nodeSelectorobject{"ascend":"on"}Not consumed by this chart. Configure the Ascend device plugin Pod's node selector in its separate deployment.
devices.ascend.tolerationslist[]Not consumed by this chart. Configure the Ascend device plugin Pod's tolerations in its separate deployment.
devices.ascend.customresourceslistAscend device-count, memory, and core resource names; see values.yaml.Resource-name strings managed by the bundled kube-scheduler's extender when devices.ascend.enabled is true. Include the resource names from devices.ascend.configs; they are not added automatically. This does not register kubelet resources; configure an external kube-scheduler separately.
devices.ascend.hamiVnpuCoreboolfalse
devices.ascend.hamiCorePolicystring"spatial"
devices.ascend.deviceCoreScalingint1
devices.iluvatar.configslistDevice definitions for MR-V100, MR-V50, BI-V150, and BI-V100; see values.yaml.List of Iluvatar device definitions used when devices.iluvatar.enabled is true. Each object contains string fields chipName, commonWord, resourceCountName, resourceMemoryName, and resourceCoreName. commonWord must be unique and match the device plugin's type and annotation names; chipName is not used for matching by the HAMi scheduler. The resource-name strings identify Pod requests: count is a non-negative integer (0 requests no devices); memory is a non-negative integer in 256 MiB units (64 = 16 GiB, without Mi or Gi suffixes). Zero or omitted memory requests use the full device memory. For one GPU, cores are an integer from 0 to 100 (40 means 40%, not 40%); for multiple GPUs, admission sets 100% cores per GPU. See Iluvatar workload examples. Overrides replace the whole list; supply complete objects because omitted fields are not filled from defaults. An empty list removes all Iluvatar device definitions. A non-empty device-config.content or bundled files/device-config.yaml takes precedence over this list.
devices.iluvatar.enabledboolfalseEnable Iluvatar device handling in the HAMi scheduler and include devices.iluvatar.customresources in the bundled kube-scheduler's extender configuration. Requires a separately installed Iluvatar gpu-manager; see Iluvatar setup.
devices.iluvatar.customresourceslistCount, core, and memory resource names for MR-V100, MR-V50, BI-V150, and BI-V100; see values.yaml.Resource-name strings delegated to the HAMi scheduler extender so kube-scheduler skips its own checks for these Iluvatar resources. Used only when both devices.iluvatar.enabled and scheduler.kubeScheduler.enabled are true. Include the resource names from devices.iluvatar.configs; they are not added automatically. Overrides replace the whole list.
devices.alibaba.enabledbooltrueEnable Alibaba PPU device
devices.alibaba.ppuCorePolicystring"default"
devices.alibaba.customresourceslist["alibaba.com/ppu","alibaba.com/ppu-memory","alibaba.com/gpu-core"]Custom resource definitions for Alibaba devices
legacyMetricsboolfalse
prometheus.enabledboolfalseCreate scheduler and device-plugin ServiceMonitors when the API is available. The device-plugin ServiceMonitor also requires devicePlugin.enabled. For local helm template, pass --api-versions monitoring.coreos.com/v1/ServiceMonitor.
device-config.contentstring""Full replacement of device-config.yaml; takes precedence over a bundled file and values. This is a complete document, not a merge; prefer devices.<vendor> fields for partial overrides. Please note that extender resources still use devices.*, keep resource names consistent. Values validation still applies.
legacySelectorLabelsboolfalse

<!-- END GENERATED VALUES -->