新设备类型接入指南

package mydevice

const (
    // 健康握手 Annotation key
    HandshakeAnnos     = "hami.io/node-handshake-mydevice"
    // 设备注册 Annotation key (device-plugin 写入节点设备信息)
    RegisterAnnos      = "hami.io/node-mydevice-register"
    // 设备类型唯一标识
    MyDeviceType       = "MYDEVICE"
    MyDeviceCommonWord = "MYDEVICE"
    // 设备型号过滤 Annotation
    DeviceInUse        = "myvendor.com/use-devicetype"
    DeviceNoUse        = "myvendor.com/nouse-devicetype"
    // UUID 过滤 Annotation
    DeviceUseUUID      = "myvendor.com/use-uuid"
    DeviceNoUseUUID    = "myvendor.com/nouse-uuid"
    // 节点锁 Annotation key
    NodeLockMyDevice   = "hami.io/mutex.lock"
)

var (
    MyDeviceResourceCount  string
    MyDeviceResourceMemory string
    MyDeviceResourceCores  string
)

type MyDeviceConfig struct {
    ResourceCountName  string `yaml:"resourceCountName"`
    ResourceMemoryName string `yaml:"resourceMemoryName"`
    ResourceCoreName   string `yaml:"resourceCoreName"`
}

type MyDevices struct {
    // 按需添加字段（如需保存配置、统计数据等）
}

func InitMyDevice(config MyDeviceConfig) *MyDevices {
    MyDeviceResourceCount = config.ResourceCountName
    MyDeviceResourceMemory = config.ResourceMemoryName
    MyDeviceResourceCores = config.ResourceCoreName

    // 注册到全局 Annotation 映射
    _, ok := device.InRequestDevices[MyDeviceType]
    if !ok {
        device.InRequestDevices[MyDeviceType] = "hami.io/mydevice-devices-to-allocate"
        device.SupportDevices[MyDeviceType] = "hami.io/mydevice-devices-allocated"
        util.HandshakeAnnos[MyDeviceType] = HandshakeAnnos
    }
    return &MyDevices{}
}

func (dev *MyDevices) CommonWord() string {
    return MyDeviceCommonWord
}

func (dev *MyDevices) GetResourceNames() device.ResourceNames {
    return device.ResourceNames{
        ResourceCountName:  MyDeviceResourceCount,
        ResourceMemoryName: MyDeviceResourceMemory,
        ResourceCoreName:   MyDeviceResourceCores,
    }
}

func (dev *MyDevices) MutateAdmission(ctr *corev1.Container, p *corev1.Pod) (bool, error) {
    _, ok := ctr.Resources.Limits[corev1.ResourceName(MyDeviceResourceCount)]
    return ok, nil
}

func (dev *MyDevices) CheckHealth(devType string, n *corev1.Node) (bool, bool) {
    return device.CheckHealth(devType, n)
}

func (dev *MyDevices) NodeCleanUp(nn string) error {
    return util.MarkAnnotationsToDelete(HandshakeAnnos, nn)
}

func (dev *MyDevices) GetNodeDevices(n corev1.Node) ([]*device.DeviceInfo, error) {
    devEncoded, ok := n.Annotations[RegisterAnnos]
    if !ok {
        return []*device.DeviceInfo{}, errors.New("annos not found " + RegisterAnnos)
    }
    nodedevices, err := device.DecodeNodeDevices(devEncoded)
    if err != nil {
        return []*device.DeviceInfo{}, err
    }
    if len(nodedevices) == 0 {
        return []*device.DeviceInfo{}, errors.New("no device found on node")
    }
    for idx := range nodedevices {
        nodedevices[idx].DeviceVendor = MyDeviceCommonWord
    }
    return nodedevices, nil
}

func (dev *MyDevices) LockNode(n *corev1.Node, p *corev1.Pod) error {
    found := false
    for _, val := range p.Spec.Containers {
        if (dev.GenerateResourceRequests(&val).Nums) > 0 {
            found = true
            break
        }
    }
    if !found {
        return nil
    }
    return nodelock.LockNode(n.Name, NodeLockMyDevice, p)
}

func (dev *MyDevices) ReleaseNodeLock(n *corev1.Node, p *corev1.Pod) error {
    found := false
    for _, val := range p.Spec.Containers {
        if (dev.GenerateResourceRequests(&val).Nums) > 0 {
            found = true
            break
        }
    }
    if !found {
        return nil
    }
    return nodelock.ReleaseNodeLock(n.Name, NodeLockMyDevice, p, false)
}

func (dev *MyDevices) GenerateResourceRequests(ctr *corev1.Container) device.ContainerDeviceRequest {
    resourceCount := corev1.ResourceName(MyDeviceResourceCount)
    resourceMem := corev1.ResourceName(MyDeviceResourceMemory)
    resourceCores := corev1.ResourceName(MyDeviceResourceCores)

    v, ok := ctr.Resources.Limits[resourceCount]
    if !ok {
        v, ok = ctr.Resources.Requests[resourceCount]
    }
    if ok {
        if n, ok := v.AsInt64(); ok {
            memnum := int32(0)
            mem, ok := ctr.Resources.Limits[resourceMem]
            if !ok {
                mem, ok = ctr.Resources.Requests[resourceMem]
            }
            if ok {
                memnums, ok := mem.AsInt64()
                if ok {
                    memnum = int32(memnums)
                }
            }

            corenum := int32(100)
            core, ok := ctr.Resources.Limits[resourceCores]
            if !ok {
                core, ok = ctr.Resources.Requests[resourceCores]
            }
            if ok {
                corenums, ok := core.AsInt64()
                if ok {
                    corenum = int32(corenums)
                }
            }

            mempnum := int32(0)
            if memnum == 0 {
                mempnum = 100 // 未指定显存时默认使用整卡
            }

            return device.ContainerDeviceRequest{
                Nums:             int32(n),
                Type:             MyDeviceType,
                Memreq:           memnum,
                MemPercentagereq: mempnum,
                Coresreq:         corenum,
            }
        }
    }
    return device.ContainerDeviceRequest{}
}

func (dev *MyDevices) Fit(
    devices []*device.DeviceUsage,
    request device.ContainerDeviceRequest,
    pod *corev1.Pod,
    nodeInfo *device.NodeInfo,
    allocated *device.PodDevices,
) (bool, map[string]device.ContainerDevices, string) {
    // 参考 Hygon DCU 的标准 Fit 实现
    k := request
    originReq := k.Nums
    prevnuma := -1
    tmpDevs := make(map[string]device.ContainerDevices)
    reason := make(map[string]int)

    for i := len(devices) - 1; i >= 0; i-- {
        dev := devices[i]

        // 1. 类型检查
        // 2. NUMA 亲和性检查
        // 3. UUID 过滤
        // 4. 时间片检查 (Count > Used)
        // 5. 算力上限校验
        // 6. 显存计算（绝对值/百分比）
        // 7. 显存充足性检查
        // 8. 算力充足性检查
        // 9. 独占冲突检查
        // 10. 分配设备到 tmpDevs, k.Nums--

        if k.Nums == 0 {
            return true, tmpDevs, ""
        }
    }

    return false, tmpDevs, common.GenReason(reason, len(devices))
}

func (dev *MyDevices) AddResourceUsage(
    pod *corev1.Pod,
    n *device.DeviceUsage,
    ctr *device.ContainerDevice,
) error {
    n.Used++
    n.Usedcores += ctr.Usedcores
    n.Usedmem += ctr.Usedmem
    return nil
}

func (dev *MyDevices) ScoreNode(
    node *corev1.Node,
    podDevices device.PodSingleDevice,
    previous []*device.DeviceUsage,
    policy string,
) float32 {
    return 0
}

func (dev *MyDevices) PatchAnnotations(
    pod *corev1.Pod,
    annoinput *map[string]string,
    pd device.PodDevices,
) map[string]string {
    devlist, ok := pd[MyDeviceType]
    if ok && len(devlist) > 0 {
        deviceStr := device.EncodePodSingleDevice(devlist)
        (*annoinput)[device.InRequestDevices[MyDeviceType]] = deviceStr
        (*annoinput)[device.SupportDevices[MyDeviceType]] = deviceStr
    }
    return *annoinput
}

// pkg/scheduler/config/config.go
type Config struct {
    // ... 已有配置 ...
    MyDeviceConfig mydevice.MyDeviceConfig `yaml:"mydevice"`
}

// 在 deviceInitializers 切片中添加
{mydevice.MyDeviceType, mydevice.MyDeviceCommonWord, func(cfg any) (device.Devices, error) {
    myConfig, ok := cfg.(mydevice.MyDeviceConfig)
    if !ok {
        return nil, fmt.Errorf("invalid configuration for %s", mydevice.MyDeviceCommonWord)
    }
    return mydevice.InitMyDevice(myConfig), nil
}, config.MyDeviceConfig},

func GlobalFlagSet() *flag.FlagSet {
    fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
    // ... 已有注册 ...
    mydevice.ParseConfig(fs)
    // ...
}

mydevice:
  resourceCountName: "myvendor.com/device"
  resourceMemoryName: "myvendor.com/devmem"
  resourceCoreName: "myvendor.com/devcores"

func validateConfig(config *Config) error {
    if !reflect.DeepEqual(config.NvidiaConfig, nvidia.NvidiaConfig{}) ||
        // ... 已有条件 ...
        !reflect.DeepEqual(config.MyDeviceConfig, mydevice.MyDeviceConfig{}) {
        return nil
    }
    return fmt.Errorf("all configurations are empty")
}

if MemoryFactor > 1 {
    memnums = memnums * int64(MemoryFactor)
}