Intel Education United States Company newsroom

University of California Berkeley

UC Berkeley needed to make generative LLM inference more efficient through low-precision quantization, but its SqueezeLLM approach depended on custom CUDA kernels that took weeks to implement and optimize and would be costly to port manually to Intel GPU hardware.

1.296 seconds SqueezeLLM 4-bit (0% sparsity) latency
1.7x relative to baseline FP16 inference on NVIDIA A100 for 4-bit inference
128 tokens using the Llama 7B model
2.0x speedup on Intel Data Center GPUs

Reported impact

Business outcome

The migration gave UC Berkeley cross-platform support for its quantized LLM inference kernels with minimal additional engineering work and delivered immediate performance gains on Intel GPUs without manual tuning.

  • Productivity Improvement
  • Scalability

Solution

University of California Berkeley used SqueezeLLM to run generative LLM inference with 4-bit quantization, then ported the custom CUDA kernels to SYCL so the same low-precision inference approach could run on Intel hardware. The team used the Intel oneAPI Base Toolkit to run the SYCLomatic tool, which automatically converted CUDA kernel code into SYCL-compatible implementations with the required kernel definition and invocation changes. To preserve the existing inference flow, the Python bindings were adapted from a CUDAExtension build to the PyTorch XPU CPP extension (DPCPPExtension), letting the migrated kernels be installed with setup.py and called from the existing SqueezeLLM Python code with only minor changes. The converted kernels were then benchmarked on Intel Data Center GPU Max Series systems accessed through Intel Tiber Developer Cloud, where quantized matrix-vector operations for the Llama 7B model delivered immediate performance gains without manual tuning.

Data flow

Existing SqueezeLLM Python code sends quantized inference work through DPCPPExtension bindings into SYCL-converted custom kernels built with Intel oneAPI Base Toolkit and migrated by SYCLomatic. Those kernels run matrix-vector operations on Intel Data Center GPU Max Series systems in Intel Tiber Developer Cloud and return results to the PyTorch-based inference flow for Llama 7B token generation.

Solution architecture

6 components · 3 layers
  1. Compute
    • SqueezeLLM Provides the low-precision quantization method and custom inference kernels used to run generative LLM inference more efficiently.
    • Intel Data Center GPU Max Series Executes the migrated 4-bit inference kernels for benchmarked LLM inference workloads.
    • Intel Tiber Developer Cloud Provides access to the Intel GPU environment used to test and benchmark the ported kernel implementations.
  2. Serving
    • PyTorch XPU CPP extension (DPCPPExtension) Exposes the migrated SYCL kernels to the Python inference code so end-to-end inference can call them from PyTorch.
  3. Orchestration
    • SYCLomatic Converts the existing CUDA kernels to SYCL so the same quantized inference kernels can target Intel GPUs with minimal manual effort.
    • Intel oneAPI Base Toolkit Supplies the development environment used to run SYCLomatic and build the migrated kernel code.

Architecture clues

  • Benchmarking focused on matrix-vector multiplication kernels for Llama 7B inference.
  • The CUDAExtension-based setup.py packaging was changed to DPCPPExtension and DpcppBuildExtension.
  • The migration command shown is dpct quant_cuda_kernel.cu.
  • The port preserved the existing SqueezeLLM Python inference flow with only minor modifications to call migrated kernel bindings.
  • The reported gains were achieved without manual tuning after conversion.

Evidence from the source

"After installing the kernel bindings, the converted SYCL kernels could be called from PyTorch code, thereby enabling running end-to-end inference using the converted kernels."
"Researchers at UC Berkeley have developed SqueezeLLM as a solution to enable efficient and accurate low-precision quantization."
"The SqueezeLLM team used Intel Data Center GPUs made available through the Intel® Tiber™ Developer Cloud to test and benchmark the ported kernel implementations."
"To call the kernel from the Python code, the bindings were adapted to use the PyTorch* XPU CPP extension (DPCPPExtension)."
"Using the CUDA-to-SYCL code migration with SYCLomatic, the efficient kernel methods can be decoupled from the target deployment platform, thereby enabling inference on different target architectures with minimal additional engineering effort."
"We quickly attained a 2.0x speedup on Intel® Data Center GPUs with 4-bit quantization without any manual tuning."
"We, therefore, wanted a solution to be able to quickly and easily port our custom CUDA kernels to SYCL in order to target Intel Data Center GPUs."
Transparency Evidence & methodology 91/100 reference value · 92% confidence · 1 source

Review how this reference was scored and trace each normalized claim back to its documented source.

01

Scoring methodology

How scores are calculated

Customer Reference Value measures usefulness as a customer reference. Evidence Confidence measures the quality and traceability of available evidence, not independent verification.

Customer reference value91/100
  • Problem clarity20/20
    Measures whether the customer's operational problem is specific enough to compare.
  • Implementation depth25/25
    Rewards named components, data flow, integrations, and architecture detail.
  • Outcome specificity16/20
    Measures whether the reported benefit is concrete rather than a generic claim.
  • Quantified impact25/25
    4 metrics describe measurable impact.
  • Deployment scale5/10
    Rewards evidence of a live or scaled deployment and meaningful integration scope.
Evidence confidence92%
  • Source authority25/25
    The deployment is described by the adopting organization or a government source.
  • Claim traceability21/25
    10 of 12 key fields link to a named source.
  • Direct evidence20/20
    7 direct source quotes retained.
  • Date provenance8/10
    The publication date comes from publisher-controlled metadata.
  • Source transparency8/10
    1 source reference document publisher, URL, authority, retrieval, and supported fields.
  • Implementation specificity10/10
    Rewards source-backed components, data flow, quantified impact, and a specific outcome.
02

Traceability

Sources & provenance

Field coverage shows which facts each source supports. Dates are shown only when documented by the source.

  1. University of California Berkeley

    University of California Berkeley customer story

    First-party
    https://www.intel.com/content/www/us/en/developer/articles/case-study/ucberkeley-optimizes-llm-inference-with-squeezellm.html
    Source type
    Customer-published story
    Published
    Sep 3, 2024
    Supports
    • Customer
    • Business problem
    • Solution
    • Products
    • Solution components
    • Data flow
    • Integrations
    • technical area
    • use case category
    • Business outcome
    • outcome category
    • Metrics
    • Architecture
    • evidence quotes
    • Publication date

Date evidence

Not separately sourced Industry, Region, Company size. Treat these normalized attributes as lower-confidence until a dedicated source is added.