Zhijia Zhao/* zh sounds like j */
RIPLE Research Group
Computer Science and Engineering, UC Riverside
I received my Ph.D. in Computer Science from the College of William and Mary in 2015 under the supervision of Prof. Xipeng Shen. In the same year, I joined UC Riverside as an assistant professor, and then became an associate professor in 2020. I am fortunate and grateful to be a recipient of NSF CAREER Award (2018), Regents Faculty Fellowship (2018), Hellman Fellowship (2018), Best Paper Runner-up Award at MobiSys'18, and Best Paper Award at ASPLOS'20. More details are in my C.V..
- Programming system supports for parallel data processing, especially for semi-structured data (like JSON) and graphs;
- Program analysis and software reliability, especially for event-based systems (like Android).
| Auto-Parallelization of Inherently Serial Bitstream Programs
[ASPLOS'20 (Best Paper Award)]
Bitstream programs rely on bitwise operations (e.g., AND, SHIFT, and XOR) to process long sequences of bits. They are widely used in multimedia processing and bitmap indexing. When carrying dependences, the whole bitstream traversal becomes serial. In this work, we propose bit-level dependency analysis and modeling techniques to reduce bitstream programs to finite-state machines (FSMs), thus enabling the use of FSM parallelization techniques to parallelize bitstream programs.
| Data-Parallel Stream Processing of Semi-Structured Data
Semi-structured data, like JSON and its variations, is the de facto standard for information exchange on the web and the basis for modern NoSQL document stores (e.g., MongoDB and Firebase). With nested structures, it is difficult to process such data in a scalable way. To address this, we leverage the automata theory and parallelization techniques to automatically generate data-parallel code with small memory footprint.
| GPU-Friendly Graph Processing
and Incremental Processing of Changing Graphs
Many real-world graphs are large and irregular by nature. These properties make them difficult to take advantages of modern parallel architectures like GPUs, which are mainly designed for regular computations with relatively limited memory capacity. We address these challenges with novel graph transformations that can ``regularize'' the computations and minimize the CPU-GPU data transfer. For compute-intensive iterative queries over a streaming graph, it is critical to evaluate the queries continuously and incrementally for best efficiency. However, the existing incremental graph processing requires a priori knowledge of the query (e.g., the source vertex of a vertex-specific query). We present a principled solution to generalizing the incremental processing using graph triangle inequalities, such that queries, without their a priori knowledge, can also be evaluated incrementally.
| Preserving Mobile App State in Volatile Runtime Environments
[MobiSys'18 (Best Paper Runner-up), OOPSLA'20]
Mobile systems (e.g., Android) expose changes on the device configuration (e.g., orientation, screen size, or keyboard availability) to the apps at runtime to enable rich user experiences. When handled inappropriately, these changes can cause unresponsiveness, state loss, or even app crash. In this work, we analyze the common causes to various runtime change issues and design novel runtime change handling solutions to address them.
| Parallelizing Finite-State Machine (FSM) Computations
FSM serves as the computation model for a variety of performance-critical applications (e.g., pattern matching and decoding). However, the model executes in serial by design – the current transition depends on the prior state. In a series of works, we ``break'' the state dependencies with disciplined speculation (ASPLOS'14, ASPLOS'15) and incorporate multi-level parallelism (PACT'16) and scalability sensitivity into the speculation design (ICS'17). Finally, our recent work (ASPLOS'21) aims at improving the scalability of FSM parallelization solutions.