Portfolio — Undergraduate, UCLA

Guanlin (Dave) Peng

Guanlin (Dave) Peng

GPU performance.
Training systems.
Reliable automation.

GPU performance.
Training systems.
Reliable automation.

GPU performance.
Training systems.
Reliable automation.

I’m a Mathematics of Computation undergraduate at UCLA, with expected graduation in December 2027. My interests center on GPU performance and training systems, supported by hands-on work in CUDA profiling, local training experiments, and AI-assisted test automation.

Explore My Work

Seeking internships and 2027 new-graduate opportunities in mainland China.

Personal projects

Selected work

Personal projects in GPU performance and training systems, plus secondary reliability tooling. Each entry separates what was measured, what I contributed, and how the result should be read.

Project 01

CUDA Histogram Optimization & Toolchain Analysis

31.42× median kernel speedup over a naive global-atomic baseline on NVIDIA GB10, measured on a 64 MiB high-contention workload with 8 active bins.

Compared global-atomic and block-private shared-memory histogram kernels on NVIDIA GB10. In a 50-sample-per-variant run built with nvcc V13.4.92, the shared implementation reduced median kernel time from 12.321952 ms to 0.392208 ms, a 31.42× speedup. Every recorded output bin was checked against a CPU reference.

C++

CUDA

Nsight Compute

Nsight Systems

GPU Benchmarking

PTX / SASS analysis

Primary results · Measured 30 Oct 2026

Single GPU · 64 MiB · 8 active bins · 50 samples/variant

DGX Spark / NVIDIA GB10 · Linux ARM64 · 48 SM · compute capability 12.1 · driver 580.178.04.

Input: 64 MiB unsigned bytes, 256 bins, only bins 0–7 active. Launch: 96 blocks × 256 threads.

nvcc 13.4.92 · new build

Primary result

31.42×

algorithm speedup

Naive median: 12.321952 ms

Shared median: 0.392208 ms

Shared P10–P90: 0.387894–0.396678 ms

Min–Max: 0.385440–0.402560 ms

nvcc 13.0.88 · adjacent control

Control run

10.63×

algorithm speedup

Naive median: 11.746224 ms

Shared median: 1.105152 ms

The preserved round2 binary was rerun for this control, not rebuilt.

Algorithm speedup = median(naive) / median(shared) within the same build. Naive uses one global atomicAdd per input element; shared uses a block-private shared-memory histogram followed by global atomic merging.

Toolchain investigation · a separate comparison

2.82×

Shared kernel: 1.105152 ms (13.0.88) → 0.392208 ms (13.4.92), 2.82× faster / 64.51% less time.

Rebuilding unchanged source with the 13.4 toolchain reduced the shared kernel’s median time from 1.105152 ms to 0.392208 ms compared with an adjacent 13.0-built control run on the same GB10. Exported PTX/SASS showed four-way loop unrolling and four independent byte loads scheduled before their dependent shared-atomic updates. The code-generation changes are consistent with improved load-level parallelism, but do not isolate a single compiler component or establish a unique performance cause.

The naive kernel was 4.90% slower in this comparison; the improvement should not be generalized to all kernels.

This build-to-build ratio is separate from the 31.42× algorithm speedup; the two use different baselines and should not be combined.

Static code evidence

The original kernel sources and benchmark harness remained byte-identical. nvcc, ptxas and nvlink version records all report V13.4.92. Build flags: -O3 -DNDEBUG -std=c++17 -arch=sm_121. The ordinary run used native sm_121 code with PTX JIT explicitly disabled; Linux long remained 64-bit.

The 13.0 shared loop processes one input per iteration. The 13.4 PTX is unrolled four ways; its final SASS places four independent LDG.E.U8 instructions before the first loaded-value consumer. The core shared-atomic/global-merge instruction kinds, two barriers and unconditional merge of all 256 bins remain unchanged.

These changes were generated by the toolchain, not a new handwritten kernel optimization. The build comparison also changes compiler components, headers and statically linked CUDART. Static instruction order supports a latency-hiding interpretation but does not prove actual overlap, isolate a compiler pass or establish a compiler bug.

Method

Per build and per implementation: one precheck, 20 warm-ups and 50 formal measurements. Each build recorded 100 formal samples across 142 calls and 36,352 per-bin checks against a CPU reference. Naive/shared execution alternated within each build.

CUDA-event kernel-only timing includes shared-kernel initialization, synchronization and final merging. It excludes H2D/D2H transfers, CPU validation, logging and output clearing outside the kernel. Quantiles use type 7 linear interpolation; no samples were discarded.

Limits & round3 profiling

This fixed eight-active-bin, high-contention input does not represent uniform 256-bin inputs or all histogram workloads. Each build has one ordinary measurement session, not 50 independent sessions. The fixed order was 13.4 then 13.0, without randomized or repeated crossover runs. Fixed clocks, per-sample telemetry and exclusive GPU use were not established. This is a single-GPU histogram microbenchmark, not an LLM training, inference, vLLM throughput or multi-GPU communication result.

Ordinary measurements and validation passed. Nsight Systems timeline capture succeeded; its individual kernel durations are separate from the ordinary-run statistics. Both Nsight Compute attempts failed during kernel preparation (exit code 9), so round3 has no valid new hardware counters.

Historical platform reference · Windows

Same workload definition · distinct measured configurations · not peak claims

NVIDIA GeForce RTX 5090 Laptop GPU

Windows x64

56.5×

historical median kernel speedup

Naive: 7.656368 ms → shared: 0.135440 ms

NVIDIA RTX Spark N1X

Windows ARM64 · nvcc V13.4.92

34.22×

historical median kernel speedup

Naive: 13.001120 ms → shared: 0.379968 ms

These historical values use the same workload definition but distinct measured configurations. The round3 GB10 shared median is approximately 3.22% higher than the historical N1X median; this is descriptive, not proof of equal platform performance.

Results are specific to this high-contention workload and the measured configurations; they are not general histogram or training speedup claims.

Historical profiling · Windows ARM64 / N1X / 13.4.92 session

Nsight Compute analysis on N1X showed substantially fewer global reduction requests at similar achieved occupancy. A separate Nsight Systems capture verified kernel and memory-transfer ordering. These observations come from that earlier session, are separate from round3, and do not establish counter behavior on GB10 or the Laptop GPU.

Single-GPU histogram · CUDA events · CPU-reference validation · Measured 30 Oct 2026 · Evidence reviewed 31 Oct 2026

Project 02

Dual-Node DGX Spark — Training Systems & NCCL

Configured and maintained a two-node DGX Spark environment with PyTorch DDP/NCCL, ConnectX-7 networking and MTU 9000; evaluated synchronized training-loop performance and separate collective microbenchmarks.

Training Systems

PyTorch DDP

NCCL

ConnectX-7

Controlled training-loop measurement

One GPU per node · DP=2, TP=1 · 393,216 global tokens per optimizer update

Evaluated torch.compile using three paired OFF/ON comparisons on two DGX Spark nodes running BF16 GPT-2 with PyTorch DDP. Across six fresh-process runs, mean synchronized training-loop time decreased from 5.164 s to 4.013 s per optimizer update (~22.3%), while global throughput increased from 76.1k to 98.0k tokens/s (~28.7%).

NCCL microbenchmark — separate from training

2 ranks · 16 MiB all-reduce · algorithm bandwidth (GB/s)

One saved dual-rail RoCE configuration: approximately 23.96 GB/s; corresponding single-rail observations: 12.59–12.96 GB/s.

Batch means from 20 timed all-reduces after 3 warm-up calls, using synchronized batch timing and the slowest rank. Configuration and message size matter. These are collective microbenchmark results, not training throughput or a system-wide bandwidth ceiling. Measurements from different dates/configurations are not a strict controlled A/B.

Method & limits

Each run used 10 performance warm-up optimizer updates followed by three 10-update measurement blocks. Timing used CUDA synchronization at block boundaries and the slower rank’s elapsed time. Startup compilation, evaluation and checkpointing were excluded.

These are three paired comparisons across six runs, not 180 independent experiments. The 10-update performance warm-up differs from the 200-update learning-rate warm-up; measurement remained within that learning-rate warm-up.

Correctness comparison covered the first update’s loss and gradients before gradient clipping and the optimizer step. It does not establish equivalent long-term training trajectories or convergence. These short-run results do not establish total training-runtime or time-to-quality benefits. No new profiling was performed; no communication, SM-count, compute or memory bottleneck was established.

Engineering contribution

Environment configuration, experiment setup, logging and evidence review.

Two-node DGX Spark · PyTorch DDP · NCCL · ConnectX-7 · MTU 9000 · controlled training-loop measurements

Project 03

vLLM Inference Reliability Testing & Diagnostic Tooling

Built a two-client burst/idle test program and log-triggered diagnostic tooling for an inference endpoint.

Python

Reliability testing

Diagnostics

Diagnostic tooling

The diagnostic script attempts py-spy stack capture and collects GPU telemetry and container logs. The script exists, but successful historical stack capture is not established.

Observations

A saved client log records 1,872 successful completion responses, followed by endpoint connection failures first detected after an idle interval.

Limits

Successful HTTP completions do not establish semantic answer correctness. Connection refusal does not establish a service crash, the fault mechanism or an idle-only cause. The available record does not establish deterministic reproduction, a confirmed root cause, an effective upstream fix or continuous availability.

Python · two-client burst/idle test · log-triggered diagnostics · saved client log

Internship

Experience

Alibaba Cloud

Jul – Sep 2026

SDET Intern

Owned requirements, design tradeoffs, code review, issue reproduction, UAT and rework acceptance for a general-purpose agent harness integrating Hermes and QoderCLI, with API coverage testing as a UAT use case. Implementation was AI-assisted.

  • Traced 28 real workflow IDs across two UAT batches using run evidence; distinguished execution, human approval and business-test outcomes.

  • Reproduced cross-session callback interference and validated session-scoped deduplication and isolated workspaces; observed 12 concurrent coding-executor processes and verified 15/15 initial workspace-copy integrity checks.

  • Caught a report inferring authentication failures from stale logs; required unexecuted tests to be reported as unexecuted, not passed, failed or skipped, requested rework in the same session, and kept that workflow’s publication stage pending human review.

Agent-assisted QA

Code review

TDD

UAT

28 workflow IDs do not mean 28/28 tests passed. Observed process concurrency does not establish a throughput gain or scaling limit. Initial workspace-copy checks are not safety certification for every workflow.

Background

Education

University of California, Los Angeles

B.S. in Mathematics of Computation

Expected graduation: December 2027

Areas of focus

GPU performance, training systems, performance measurement, and reliable automation.

Technical toolkit

Programming and systems

Python, C++, CUDA, Linux

Training and experiments

PyTorch, nanoGPT, Weights & Biases

Profiling

NVIDIA Nsight Compute

Engineering workflows

Test automation, AI-assisted development, code review, TDD, and UAT

Contact

Let’s talk engineering.

I’m interested in opportunities involving GPU performance, training systems, systems software, and engineering automation.

daaaaavepeng@gmail.com

Email me

Guanlin Peng

Mathematics of Computation · UCLA · 2027

Mathematics of Computation · UCLA · 2027