Garbage collection (GC) pauses are a notorious issue threatening the latency of applications. To mitigate this problem, state-of-the-art concurrent copying collectors allow GC threads to run simultaneously with application threads (mutators) in nearly all GC phases. However, the design of concurrent copying collectors does not always lead to low application latency. To this end, this work studies the behaviors of mainstream concurrent copying collectors in OpenJDK and mainly focuses on long application pauses under heavy workloads. By analyzing the design of those collectors, this work uncovers that lengthy pre-reclamation cycles (including GC phases before actual memory release), high GC frequency, and large metadata maintenance overhead are major factors for long pauses. Therefore, this work proposes Jade, a concurrent copying collector aiming to achieve both short pauses and high GC efficiency. Compared with existing collectors, Jade provides a group-wise collection mechanism to shorten pre-reclamation cycles while controlling GC frequency. It also embraces a generational heap layout and a single-phase algorithm to maximize young GC's throughput. The evaluation results on representative latency-critical applications show that Jade can reach sub-millisecond-level pauses even under heavy workloads and significantly improve applications' peak throughput compared with state-of-the-art concurrent collectors.

Symbolic execution can automatically explore different execution paths in a system under test and generate tests to precisely cover them. It has two main advantages-being automatic and thorough within a theory-and has many successful applications. The bottleneck of symbolic execution currently is the computation consumption for complex systems. Compositional Symbolic Execution (CSE) introduces a summarisation module to eliminate the redundancy in the exploration of repeatedly encountered code. In our previous work, we generalised the summarisation for any code fragments instead of functions. In this paper, we transplant this idea onto LLVM with many additional features, one of them being the use of incremental solving. We show that the combination of CSE and incremental solving is mutually beneficial. The obvious weakness of CSE is the lack of context during summarisation. We discuss the use of assumption-based features, available in modern constraint solvers, as a way to overcome this problem.

The choice of relay nodes significantly affects the performance of wireless cooperative networks. Previous research mostly focused on dedicating one relay node to a source node in the network. However, fairness can be improved by sharing each relay node among more than one source node. This paper first defines the shared relay assignment for (max-min) fairness (SRAF) problem, and formalizes it using a mixed integer program. We then propose a heuristic algorithm (RRA) to solve this problem. The algorithm mainly uses the binary search and rounding mechanisms to implement the shared relay assignment, so that the minimum throughput of all source nodes is improved. The theoretical analysis proves that the proposed algorithm can reach the approximate performance of 2+ε, where ε is an arbitrarily small positive number. An improved version of RRA, called IRRA, can improve the minimum throughput while still preserving the worst-case performance. Our simulations show that the IRRA algorithm can achieve about 18% improvement over the best existing approach in the minimum throughout among the source nodes.