Update README and documentation with the ASPLOS paper arxiv link

README.md

@@ -126,56 +126,17 @@ Please contact [[email protected]](mailto:[email protected]) or [[email protected]](mailto:
 
 # Publication
 
-The first paper on Exo was published at PLDI '22. You can download the
-paper [from ACM Digital Library](https://dl.acm.org/doi/abs/10.1145/3519939.3523446).
-If you use Exo, please cite both the compiler and the paper!
+Exo's major contributions and ideas are published in the following two papers.
+The gist of its design principles and features is summarized in [Design.md](./docs/Design.md).
+
+- [Exocompilation for Productive Programming of Hardware Accelerators](https://dl.acm.org/doi/abs/10.1145/3519939.3523446)\
+  Yuka Ikarashi\*, Gilbert Louis Bernstein\*, Alex Reinking, Hasan Genc, Jonathan Ragan-Kelley\
+  PLDI 2022\
+  The full version with appendices can be found [here](https://people.csail.mit.edu/yuka/pdf/exo_pldi2022_full.pdf).
+- [Exo 2: Growing a Scheduling Language](https://arxiv.org/abs/2411.07211)\
+  Yuka Ikarashi, Kevin Qian, Samir Droubi, Alex Reinking, Gilbert Bernstein, Jonathan Ragan-Kelley\
+  ASPLOS 2025\
+  The full version with appendices can be found [here](https://arxiv.org/abs/2411.07211).
+
+If you use Exo, please cite both the compiler and the papers!
 
-```
-@inproceedings{pldi22:exo,
-  title        = {Exocompilation for Productive Programming of Hardware Accelerators},
-  author       = {
-    Ikarashi, Yuka and Bernstein, Gilbert Louis and Reinking, Alex and Genc,
-    Hasan and Ragan-Kelley, Jonathan
-  },
-  year         = 2022,
-  booktitle    = {
-    Proceedings of the 43rd ACM SIGPLAN International Conference on Programming
-    Language Design and Implementation
-  },
-  location     = {San Diego, CA, USA},
-  publisher    = {Association for Computing Machinery},
-  address      = {New York, NY, USA},
-  series       = {PLDI 2022},
-  pages        = {703–718},
-  doi          = {10.1145/3519939.3523446},
-  isbn         = 9781450392655,
-  url          = {https://doi.org/10.1145/3519939.3523446},
-  abstract     = {
-    High-performance kernel libraries are critical to exploiting accelerators
-    and specialized instructions in many applications. Because compilers are
-    difficult to extend to support diverse and rapidly-evolving hardware
-    targets, and automatic optimization is often insufficient to guarantee
-    state-of-the-art performance, these libraries are commonly still coded and
-    optimized by hand, at great expense, in low-level C and assembly. To better
-    support development of high-performance libraries for specialized hardware,
-    we propose a new programming language, Exo, based on the principle of
-    exocompilation: externalizing target-specific code generation support and
-    optimization policies to user-level code. Exo allows custom hardware
-    instructions, specialized memories, and accelerator configuration state to
-    be defined in user libraries. It builds on the idea of user scheduling to
-    externalize hardware mapping and optimization decisions. Schedules are
-    defined as composable rewrites within the language, and we develop a set of
-    effect analyses which guarantee program equivalence and memory safety
-    through these transformations. We show that Exo enables rapid development
-    of state-of-the-art matrix-matrix multiply and convolutional neural network
-    kernels, for both an embedded neural accelerator and x86 with AVX-512
-    extensions, in a few dozen lines of code each.
-  },
-  numpages     = 16,
-  keywords     = {
-    program optimization, user-schedulable languages, user-extensible backend
-    & scheduling, instruction abstraction, scheduling, hardware
-    accelerators
-  }
-}
-```

docs/Cursors.md

@@ -371,6 +371,6 @@ p2 = reorder_scope(p1, p1.forward(c).next(), ...)
 In this code, the navigation `.next()` is applied to the forwarded cursor `p1.forward(c)`. Attempting to change `p1.forward(c).next()` to `p1.forward(c.next())` will result in incorrect behavior. This is because navigation and forwarding are *not commutative*.
 
 ## Further Reading
-More details of the design principles of Cursors can be found in our [ASPLOS '25 paper](.) or in [Kevin Qian's MEng thesis](https://dspace.mit.edu/handle/1721.1/157187).
+More details of the design principles of Cursors can be found in our [ASPLOS '25 paper](https://arxiv.org/abs/2411.07211) or in [Kevin Qian's MEng thesis](https://dspace.mit.edu/handle/1721.1/157187).
 
 

docs/Design.md

@@ -48,7 +48,7 @@ While the flexibility of fine-grained primitives is necessary for achieving peak
 These user-defined scheduling operations can encapsulate common optimization patterns and hardware-specific transformations such as auto-vectorize, tiling, and even simulate scheduling operations from other USLs (like Halide's `compute_at`).
 They can be put together in reusable libraries, further enabling modularity and portability.
 
-More infomation can be found in the [ASPLOS paper](.) and [Cursor.md](./Cursor.md).
+More infomation can be found in the [ASPLOS paper](https://arxiv.org/abs/2411.07211) and [Cursor.md](./Cursor.md).
 
 ## The AIR Framework: Action, Inspection, Reference
 

docs/README.md

@@ -23,7 +23,7 @@ The scheduling primitives are classified into six categories:
 The following papers provide a high-level and holistic view of Exo as a project:
 
 - [PLDI '22 paper](https://people.csail.mit.edu/yuka/pdf/exo_pldi2022_full.pdf)
-- [ASPLOS '25 paper](.)
+- [ASPLOS '25 paper](https://arxiv.org/abs/2411.07211)
 - [Kevin Qian's MEng thesis](https://dspace.mit.edu/handle/1721.1/157187)
 - [Samir Droubi's MEng thesis](https://dspace.mit.edu/handle/1721.1/156752)
 

docs/System.md

@@ -41,7 +41,7 @@ In this repository, folders are structured as follows:
 
 User-defined features like config, externs, and Memory's parent class implementations are in `configs.py`, `extern.py`, and `memory.py`, respectively.
 
-`internal_cursors` defines primitive cursor movements (see Section 5.2 "Cursor implementation" of our ASPLOS paper) that are used internally by `LoopIR_scheduling` implementations of scheduling primitives.
+`internal_cursors` defines primitive cursor movements (see Section 5.2 "Cursor implementation" of [our ASPLOS paper](https://arxiv.org/abs/2411.07211)) that are used internally by `LoopIR_scheduling` implementations of scheduling primitives.
 `proc_eqv.py` defines a union-find tree which we use to track the equivalence of procedures.
 
 ---

examples/avx2_matmul/README.md

@@ -264,4 +264,4 @@ This will print out the results of running kernel with and without the AVX instr
 Congratulations on completing this example!
 You might have felt that the scheduling operations in this example were very low-level and could be laborious to write.
 We felt the same! We implemented a new feature called Cursors that provides scheduling automation *external* to the compiler implementation.
-To learn more, please take a look at the [cursors example](cursors/README.md) and our ASPLOS '25 paper.
+To learn more, please take a look at the [cursors example](cursors/README.md) and our [ASPLOS '25](https://arxiv.org/abs/2411.07211) paper.

examples/cursors/README.md

@@ -1,6 +1,6 @@
 # Cursor Step-by-Step Tutorial
 
-This example demonstrates Cursors using the tile2D example (as shown in our ASPLOS '25 paper).
+This example demonstrates Cursors using the tile2D example (as shown in our [ASPLOS '25 paper](https://arxiv.org/abs/2411.07211)).
 
 ## Overview