Support for Huawei Ascend 310 or Ascend 310P

[xuhongqiang-kernel]

I am interested in the scheduling framework xsched for multitasking over diverse XPU types, including GPUs, NPUs, ASICs, and FPGAs. I would like to inquire whether the framework supports Huawei Ascend 310 or Ascend 310P.

Could anyone provide information on whether these specific XPU units are compatible with xsched? Any guidance or pointers to relevant documentation would be greatly appreciated.

Thank you!

[Naplesoul]

Yes, XSched supports Ascend 310 and 310p. Both use the AscendCL interface to submit tasks, and we have tested and confirmed compatibility.
You can try pytorch inference with the following code

#!/usr/bin/env python3
import argparse
import math
import statistics
import time

import torch
import torch_npu
import torchvision.models as models


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Simple ResNet152 NPU inference.")
    parser.add_argument("--rounds", type=int, default=200)
    parser.add_argument("--warmup", type=int, default=20)
    parser.add_argument("--batch-size", type=int, default=1)
    parser.add_argument("--device", type=int, default=0)
    parser.add_argument("--dtype", choices=("fp16", "fp32"), default="fp16")
    parser.add_argument("--pretrained", action="store_true",
                        help="Load torchvision ImageNet weights instead of random weights.")
    opt = parser.parse_args()

    if opt.rounds <= 0:
        parser.error("--rounds must be positive")
    if opt.warmup < 0:
        parser.error("--warmup must be non-negative")
    if opt.batch_size <= 0:
        parser.error("--batch-size must be positive")
    return opt


def percentile(values, p: float) -> float:
    if len(values) == 1:
        return values[0]
    pos = (p / 100.0) * (len(values) - 1)
    lo = int(math.floor(pos))
    hi = int(math.ceil(pos))
    frac = pos - lo
    return values[lo] * (1.0 - frac) + values[hi] * frac


def build_model(pretrained: bool):
    if pretrained:
        weights = models.ResNet152_Weights.IMAGENET1K_V2
        return models.resnet152(weights=weights)
    return models.resnet152(weights=None)


def infer_once(model, x, stream):
    with torch.inference_mode():
        with torch.npu.stream(stream):
            print("begin infer")
            y = model(x)
    stream.synchronize()
    print("end infer")
    return y


def main():
    opt = parse_args()

    print(f"[resnet152] setting NPU device {opt.device}", flush=True)
    torch.npu.set_device(opt.device)
    device = torch.device(f"npu:{opt.device}")
    dtype = torch.float16 if opt.dtype == "fp16" else torch.float32

    print("[resnet152] creating model", flush=True)
    model = build_model(opt.pretrained)
    model.eval().to(device)
    if dtype == torch.float16:
        model.half()
    else:
        model.float()

    print("[resnet152] creating input", flush=True)
    x = torch.randn(
        opt.batch_size,
        3, 224, 224,
        device=device,
        dtype=dtype,
    )

    print("[resnet152] creating torch_npu stream", flush=True)
    stream = torch.npu.Stream()
    torch.npu.current_stream().synchronize()

    print(f"Model: torchvision resnet152 ({'pretrained' if opt.pretrained else 'random weights'})")
    print(f"Input: {tuple(x.shape)}, dtype={opt.dtype}, device=npu:{opt.device}")
    print(f"Warmup: {opt.warmup}, rounds: {opt.rounds}")

    last = None
    for _ in range(opt.warmup):
        last = infer_once(model, x, stream)

    latencies = []
    for _ in range(opt.rounds):
        t0 = time.perf_counter()
        last = infer_once(model, x, stream)
        t1 = time.perf_counter()
        latencies.append((t1 - t0) * 1000.0)

    values = sorted(latencies)
    print(f"Output shape: {tuple(last.shape) if last is not None else '<none>'}")
    print("Latency:")
    print(f"  avg : {statistics.fmean(latencies):8.3f} ms")
    print(f"  p50 : {percentile(values, 50.0):8.3f} ms")
    print(f"  p90 : {percentile(values, 90.0):8.3f} ms")
    print(f"  p99 : {percentile(values, 99.0):8.3f} ms")
    print(f"  min : {values[0]:8.3f} ms")
    print(f"  max : {values[-1]:8.3f} ms")


if __name__ == "__main__":
    main()

Start the xserver and run the code with

export LD_PRELOAD=<xsched output path>/lib/libshimascend.so
export XSCHED_SCHEDULER=GLB
export XSCHED_AUTO_XQUEUE=ON