Christian Navasca

PhD Student
Computer Science Department
University of California, Los Angeles
cnavasca253@cs.ucla.edu

About Me

Hi! My name is Christian Navasca. I'm currently a PhD student at UCLA, advised by Prof. Harry Xu. I received my BS('18) in Computer Science from UC Irvine.

My research aims to improve the scalability and performance of Big Data systems and the runtime systems that they are built on. I help to design and implement techniques ranging from improving data transfer costs, to changing data representation, and even to improving dynamic compilation in JIT compilers. My work aims to challenge decades old assumptions in managed runtime design, and align them with the needs of Big Data workloads that are found today.

My current CV can be found here.

Publications

  • Christian Navasca, Cheng Cai, Khanh Nguyen, Brian Demsky, Shan Lu, Miryung Kim, and Harry Xu. Gerenuk: Thin Computation over Big Native Data Using Speculative Program Transformation, the 27th ACM Symposium on Operating Systems Principles (SOSP), Huntsville, Ontario, Canada, October 2019. [ PDF ] [ Slides ]
  • Khanh Nguyen, Lu Fang, Christian Navasca, Guoqing Xu, Brian Demsky, and Shan Lu. "Skyway: Connecting Managed Heaps in Distributed Big Data Systems", the 23rd International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), Williamsburg, VA, March 24-28, 2018. [ PDF ]

Research Projects

  • Machine Learning for stack allocation
    • Abstract: Managed languages such as Java and Scala allocate objects on the heap and periodically use garbage collection (GC) to remove dead objects. Instead, objects could be stack allocated, enabling automatic object deallocation when a method returns. A major issue with stack allocation is finding the capturing stack frame of an object, the last stack frame where an object is alive. To do this, we must precisely predict object lifetime. However, traditional static and dynamic analyses are not precise or fast enough to handle this decision at runtime. Our insight is that there is some learnable correlation between allocation context and the capturing stack frame. In this work, we aim to use a machine learning model to predict, given an allocation site, the capturing stack frame of an object. We associate every active stack frame with a region of memory to allocate objects, which is deallocated when a method returns. We can then efficiently handle mispredictions by using techniques found in region-based GC.
    • This work is under development.
  • Project Totus: Using machine learning to improve JIT optimizations
    • Abstract: Managed runtimes such as the JVM use profile guided optimizations during JIT-compilation. By using dynamic information, the code generated by the JIT compiler can be more optimized than statically compiled code. One such optimization is inlining virtual method calls. If we observe a single receiver type at a callsite, we can avoid dynamic dispatch by inlining that receiver type's method. But, if we observe many receiver types at a callsite, we fall back to dynamic dispatch. However, we shouldn't always consider every receiver type that we observe. For example, if a receiver type is never used again, it shouldn't be considered during an inlining decision. In practice, it is very difficult to accurately make this inlining decision, even for a single callsite. The same callsite can behave differently throughout execution, across runs, and in different applications. In this work, we use a machine learning model to predict, given a callsite and profiling data, the correct type(s) to inline. Similar to other speculative JIT optimizations, we can handle mispredictions through recompilation.
    • This work is under development.
  • Gerenuk: Removing objects through speculative program transformation
    • Abstract: Big Data systems are typically implemented in object oriented languages such as Java and Scala due to the quick development cycle they provide. These systems are executed on top of a managed runtime such as the Java Virtual Machine (JVM), which requires each data item to be represented as an object before it can be processed. This representation is the direct cause of many kinds of severe inefficiencies. Gerenuk is a compiler and runtime that aims to enable JVM-based data-parallel systems to achieve near native efficiency by transforming a set of statements in the system for direct execution over inlined native bytes rather than objects. The key insight leading to Gerenuk‚Äôs success is two-fold: (1) analytics workloads often use immutable and confined data types. If we speculatively optimize the system and user code with this assumption, the transformation can be made tractable. (2) The flow of data starts at a deserialization point where objects are created and ends at a serialization point before they are sent to the disk or network. This flow naturally defines a speculative execution region (SER) to be transformed. Gerenuk speculatively compiles a SER into a version that can operate directly over native bytes that come from the disk or network. The Gerenuk runtime aborts the SER execution upon violations of the immutability and confinement assumption and switches to the slow path by deserializing the bytes and re-executing the original SER.
    • This work was published in SOSP'19 [ PDF ]
  • Skyway: Connecting managed heaps
    • Abstract: Managed languages such as Java and Scala while prevalently used in the development of large-scale distributed systems, incur non-trivial overheads. For instance, when performing data transfer across machines, the source system needs to serialize objects while the destination must perform deserialization. This process is both performance-inefficient and labor-intensive. Skyway is a JVM-based technique that can directly connect managed heaps of different JVM processes. Under Skyway, objects in the source heap can be directly written into a remote heap. Skyway provides performance benefit to any JVM-based system by completely eliminating the need (1) of invoking serialization/deserialization functions, thus saving CPU time, and (2) of requiring developers to hand-write serialization functions.
    • This work was published in ASPLOS'18 [ PDF ]