Tao Xie

Tile-based programming frameworks are increasingly adopted to write high-performance GPU kernels in domains such as deep learning and scientific computing. While these frameworks enhance productivity and hardware utilization, their multi-stage compilation pipelines introduce distinct code generation bugs that are tightly coupled to input shapes, data types, and backend targets. These bugs often manifest as silent wrong results or performance issues, making them difficult to detect using existing compiler testing tools. Additionally, the unique programming conventions of tile domain-specific languages complicate root cause identification, while fixing such bugs demands specialized knowledge of tile abstractions and compilation pipelines. Despite the growing adoption of tile-based systems, their code generation bugs remain largely unexplored. This paper presents the first systematic study of tile-program code generation bugs. We curate 401 bug reports from GitHub and identify 301 tile-program codegen bugs for analysis, characterizing their root causes and symptoms , the input patterns that trigger them, the test oracles that detect them, and the strategies for fixing these bugs. Our study provides foundational insights for building debugging, testing, and repair tools tailored to tile-based compiler infrastructures.

The conventional threading model multiplexes software threads onto hardware cores. This model inherently suffers from the overhead of 1) context switching, 2) scheduling, and 3) system event notifications (e.g., I/O interrupts). As computing enters μs-scale, such overheads become the key bottleneck of a wide range of domains: networking, concurrency control, and microservice scheduling, etc. Existing software solutions, such as cooperative scheduling and polling, sacrifice correctness and/or CPU efficiency, while hardware offers only point solutions with suboptimal performance. To eliminate the threading overheads without introducing difficult tradeoffs, our key insight is that hardware should directly expose schedulable, basic units of execution (i.e., software threads) instead of computational resources (i.e., cores). We propose threadlet, a new hardware abstraction that is lighter than a software thread by removing uncritical state (e.g., floating-point registers). A core caches a few active threadlets in its register file, while spilling the rest to the memory hierarchy. Thus, context switching incurs minimal overhead by simply resuming execution with the next threadlet's state. Moreover, threadlet comes with hardware support that can express diverse OS scheduling policies, enabling fast and flexible scheduling. Finally, as a hardware abstraction, threadlets directly interface with microarchitectural mechanisms (e.g., cache coherence) for efficient event notifications. We build a supporting architecture on an FPGA and a research OS for threadlet, outperforming prior works by 3× to 47× on real-world applications. Our artifact is publicly available at https://github.com/TELOS-syslab/Threadlet.

Fuzzing-based simulation testing has become a fundamental technique for assessing the safety of autonomous driving systems (ADS). It operates by iteratively mutating simulation scenario configurations, scheduling scenario execution, and monitoring ADS-involved accidents. However, existing ADS fuzzers commonly rely on simplistic criticality metrics (e.g., inter-vehicle distance) for prioritizing critical scenarios during fuzzing, and lack deterministic guidance about how these heuristic-based critical scenarios should be further mutated to finally induce ADS-responsible accidents. Therefore, these existing fuzzers would inevitably miss truly critical driving scenarios or report various non-ADS-responsible accidents. To address these limitations, our key insight hints that EGO-to-NPC interactions (i.e., those recorded during the execution of a given scenario) offer comprehensive spatial-temporal information for reliable selection of critical scenarios and deterministic scenario mutation. Following this insight, we propose ExplorIt , a simulation-based ADS fuzzer enhanced with systematic formalization of interaction behaviors. Specifically, ExplorIt formalizes the runtime EGO-to-NPC interactions through drivable area estimation. That is, vehicles that share overlapped driving areas are considered to have interactive relationships. Under this modeling, ExplorIt can then deterministically mutate scenarios to curate more critical interactions by making EGO and NPC head for shared drivable areas. Extensive experiments on Apollo 8.0 demonstrate ExplorIt ’s effectiveness, revealing 6.7 times more unique ADS-responsible accidents than baseline tools (i.e., DriveFuzz, SAMOTA, and AutoFuzz). Moreover, 83.2% of the reported accidents are ADS-responsible, compared to just 16.8% with baseline tools.

Automated game testing requires deep semantic reasoning to navigate complex dynamic environments, but directly applying end-to-end Vision-Language Models (VLMs) at an industrial scale incurs prohibitive execution-time overhead and token costs with limited testing effectiveness. To resolve the trade-off between reasoning depth and execution speed in automated game testing, we present AstraGame, a VLM-based game testing framework that leverages a decoupled architecture to orchestrate collaboration between specialized small models and large cognitive VLMs. Specifically, we propose to parallelize perception and reasoning tasks for temporal saturation, implement widget-level semantic caching to transform repetitive inference into efficient cache lookup, and structure action protocols for token efficiency. Evaluation results show that AstraGame substantially improves exploration coverage by 37.78% compared to state-of-the-practice approaches. Extensive deployment across 24,000 unique mini-games on WeChat, one of the world's largest mini-game platforms, demonstrates that AstraGame achieves a 58% reduction in end-to-end latency, increasing the proportion of games yielding valid and comprehensive materials for game content moderation from 38% to 63%. To date, AstraGame has identified over 180,000 functional and compliance issues actionable by developers, validating that industrial-scale intelligence requires shifting focus from isolated VLM inference to comprehensive system orchestration.

Automated approaches of web GUI testing are widely used to reduce labor costs in quality assurance of web applications by mimicking human interaction to trigger failures through GUI actions (e.g., clicks). However, these approaches often generate lengthy GUI traces containing unnecessary actions before triggering a failure, complicating the identification of root causes of failures for developers. Trace reduction approaches have been proposed to remove unnecessary actions from failure-triggering traces. Existing approaches of trace reduction typically employ algorithms from the Delta Debugging (DD) family. However, these approaches suffer from inefficiencies due to exhaustive trial-based strategies and fail to account for action preconditions and the varying time intervals between actions. To address the limitations, in this article, we propose Booster, with the following two key components. (1) Multi-level state abstraction. Booster identifies unnecessary actions through a hierarchical abstraction of GUI states, preserving the preconditions of actions on different abstraction levels to minimize the number of failed trials. (2) Time-Guided Hierarchical Delta Debugging (TGHDD). Booster optimizes the reduction process by applying our TGHDD algorithm, which partitions the action trace according to the estimated execution time of actions instead of action counts, ensuring a more balanced time distribution across partitions and enhancing the efficiency of the trace reduction. We evaluate Booster on traces generated by state-of-the-art automated approaches of web GUI testing, WebExplor and WebRLED. Experimental results demonstrate that Booster greatly outperforms the state-of-the-art approach named SimplyDroid and the traditional Delta Debugging in terms of efficiency, on average with 43.4% and 72.1% less time cost, while obtaining 60.2% and 38.8% shorter length of the reduced traces in a 24-hour time budget. Additional experiments confirm the effectiveness of Booster's individual techniques.

Scaling generalist GUI agents is hindered by the data scalability bottleneck of expensive human demonstrations and the ``distillation ceiling'' of synthetic teacher supervision. To transcend these limitations, we propose UI-Oceanus, a framework that shifts the learning focus from mimicking high-level trajectories to mastering interaction physics via ground-truth environmental feedback. Through a systematic investigation of self-supervised objectives, we identify that forward dynamics, defined as the generative prediction of future interface states, acts as the primary driver for scalability and significantly outweighs inverse inference. UI-Oceanus leverages this insight by converting low-cost autonomous exploration, which is verified directly by system execution, into high-density generative supervision to construct a robust internal world model. Experimental evaluations across a series of models demonstrate the decisive superiority of our approach: models utilizing Continual Pre-Training (CPT) on synthetic dynamics outperform non-CPT baselines with an average success rate improvement of 7% on offline benchmarks, which amplifies to a 16.8% gain in real-world online navigation. Furthermore, we observe that navigation performance scales with synthetic data volume. These results confirm that grounding agents in forward predictive modeling offers a superior pathway to scalable GUI automation with robust cross-domain adaptability and compositional generalization.

Post-training GUI agents in interactive environments is critical for developing generalization and long-horizon planning capabilities. However, training on real-world applications is hindered by high latency, poor reproducibility, and unverifiable rewards relying on noisy visual proxies. To address the limitations, we present GUI-GENESIS, the first framework to automatically synthesize efficient GUI training environments with verifiable rewards. GUI-GENESIS reconstructs real-world applications into lightweight web environments using multimodal code models and equips them with code-native rewards, executable assertions that provide deterministic reward signals and eliminate visual estimation noise. Extensive experiments show that GUI-GENESIS reduces environment latency by 10 times and costs by over $28,000 per epoch compared to training on real applications. Notably, agents trained with GUI-GENESIS outperform the base model by 14.54% and even real-world RL baselines by 3.27% on held-out real-world tasks. Finally, we observe that models can synthesize environments they cannot yet solve, highlighting a pathway for self-improving agents.