Please, Translate the following English into Korean: 
Hi, I'm <PRESIDIO_ANONYMIZED_PERSON> from Carnegie Mellon University and I'll be providing a summary of our work on pOpt, a practical optimal cache replacement policy for graph analytics workloads. Graph analytics has many important applications ranging from path planning and social network analysis to graph neural networks. However, graph analytics workloads are notorious for their poor cache locality which leads to suboptimal performance. As we can see from this chart, due to poor cache locality, graph applications can spend up to 80% of their execution time just waiting for requests to come back from t-run. And the main reason graph applications have poor cache locality is because typical input graphs are extremely sparse, so we can't just use an adjacency matrix representation. Instead, graph applications need to use a compressed representation for memory efficiency reasons. However, using a compressed representation basically makes the access pattern irregular. And this is problematic for graph applications because often we are dealing with large input graphs. For example, if we consider a typical input graph with 32 million vertices and assume 4 bytes per element, the size of the irregular data footprint comes out to be 128 megabytes, which is much larger than what can fit in a reasonably sized last-level cache. And because of this, existing cache replacement policies do not capture significant reuse for graph applications. Our analysis revealed that even state-of-the-art cache replacement policies only provide a marginal benefit compared to the LRU replacement policy. And the primary reason for this is that the state-of-the-art replacement policies are all heuristics-based solutions, and the heuristics that they use do not capture the complex reuse patterns of graph application data. So while existing replacement policies are not a great fit for graph applications, in this work we were able to show that Baredi's optimal cache replacement policy is actually viable for graph analytics. So very quickly, what's Baredi's optimal cache replacement? If we have a scenario where a cache is completely filled with elements and we want to insert a new element into this cache, then Baredi's optimal replacement policy would look into the future to find out when each element in cache is going to be referenced next. And then the policy would evict the element in cache which is going to be accessed furthest in the future. And just by this definition, it's probably clear that Baredi's optimal replacement policy is often impractical because it relies on paracular knowledge of the future. However, in this work we were able to show that for graph analytics workloads, the graph's transpose efficiently encodes the next references for all vertices at all points in the execution. Hence, the graph's transpose allows us to perform Baredi's optimal cache replacement. To see how the graph's transpose can be used for optimal cache replacement, we're going to be looking at a typical graph kernel which is a CSC traversal as shown in the slide. Essentially what this kernel does is that it visits the non-zero elements of the adjacency matrix in a column by column fashion. And because we are using the CSC, any accesses to a data structure based on source IDs ends up being irregular. Given these application properties, how do we do optimal cache replacement when we have irregular elements in cache? For example, if we have source data is 1 and source data is 4 in the cache, how do we perform Baredi's optimal replacement and find the optimal candidate for eviction? So recall that this execution is a column by column traversal. So if you want to find out when source data is 1 is accessed next, all we need to do is scan across the rows of vertex S1 to find out that source data is 1 will be accessed next while processing the neighbors of vertex T4. And as a matter of practice, whenever we are looking at efficient encodings of row information, we are going to be looking at the CSR or the compressed pass row format. Similarly, using the CSR, we can find out that source data is 4 will be accessed next while processing the neighbors of vertex T2. So now that we have the next references for both of these elements, as per Baredi's optimal replacement policy, we can evict source data is 1 since it's accessed later in the execution. So as a quick summary, what we saw here was for a CSC traversal, the CSR, which is the transpose, contains all the necessary information required for optimal cache replacement. And if you are able to use the transpose for optimal replacement, then we can provide significant gains. So here's the chart from before, but we have included the results for transpose based optimal replacement or T-OPT at the end. And we can see that compared to the state of the art cache replacement policies, T-OPT provides significantly better NLC miss reductions. However, these T-OPT results are still idealized because they don't include the overheads of using the transpose for optimal replacement. The main overhead of T-OPT or using transpose for optimal replacement is that depending on the cache's content at replacement time, we may have to make irregular accesses to the graph's transpose. And because these transpose accesses are irregular at cache replacement time, we may have to perform additional DRAM accesses. So to avoid overheads, we rely on quantization. Particularly, we divide the execution into coarse-grained regions called epochs, and then we only track next references of vertices at the granularity of epochs. Adding the execution into epochs allows us to construct a new data structure called the re-reference matrix. The re-reference matrix is essentially just a quantized representation of the next reference values in a graph's transpose. And because this data structure re-reference matrix is quantized, its footprint is small. And hence we can fit this data structure within the loss-level cache. And hence now when we perform cache replacement, all the information is within the LLC and we don't need to perform any additional DRAM accesses. Our system is called p-opt or practical optimal cache replacement and it uses the re-reference matrix to drive an approximation of BILAD's optimal replacement. And we can see that p-opt is able to significantly outperform existing replacement policies LRU and DRIP across a range of graph applications. What's interesting is that p-opt's results are only 12% away from the ideal case scenario where we are able to access precise replacement information for zero cost. This just goes to show that p-opt's quantization tricks do not significantly impact replacement quality information. So in summary, in this book we presented two key ideas. The first key idea was that the graph's transpose can actually allow us to perform BILAD's optimal cache replacement. And the second key idea was that we can quantize the transpose data to allow us to perform practical optimal replacement which provides LLC misreduction even after accounting for overheads. For more details, please check out our paper. We have also released the cache simulators for p-opt. And now I'd be happy to take your questions.