• Back J, Hua B, Hachisuka T and Moon B. (2020). Deep combiner for independent and correlated pixel estimates. ACM Transactions on Graphics. 39:6. (1-12). Online publication date: 31-Dec-2021.

    https://doi.org/10.1145/3414685.3417847

  • Chakravarthula P, Tseng E, Srivastava T, Fuchs H and Heide F. (2020). Learned hardware-in-the-loop phase retrieval for holographic near-eye displays. ACM Transactions on Graphics. 39:6. (1-18). Online publication date: 31-Dec-2021.

    https://doi.org/10.1145/3414685.3417846

  • Ghosh R, Hsieh C, Misailovic S and Mitra S. (2020). Koord: a language for programming and verifying distributed robotics application. Proceedings of the ACM on Programming Languages. 4:OOPSLA. (1-30). Online publication date: 13-Nov-2020.

    https://doi.org/10.1145/3428300

  • He F and Han J. (2020). Termination analysis for evolving programs: an incremental approach by reusing certified modules. Proceedings of the ACM on Programming Languages. 4:OOPSLA. (1-27). Online publication date: 13-Nov-2020.

    https://doi.org/10.1145/3428267

  • Sang B, Eugster P, Petri G, Ravi S and Roman P. (2020). Scalable and serializable networked multi-actor programming. Proceedings of the ACM on Programming Languages. 4:OOPSLA. (1-30). Online publication date: 13-Nov-2020.

    https://doi.org/10.1145/3428266

  • Madsen M and van de Pol J. (2020). Polymorphic types and effects with Boolean unification. Proceedings of the ACM on Programming Languages. 4:OOPSLA. (1-29). Online publication date: 13-Nov-2020.

    https://doi.org/10.1145/3428222

  • Kallas K, Niksic F, Stanford C and Alur R. (2020). DiffStream: differential output testing for stream processing programs. Proceedings of the ACM on Programming Languages. 4:OOPSLA. (1-29). Online publication date: 13-Nov-2020.

    https://doi.org/10.1145/3428221

  • Kalikar S and Nasre R. NumLock. Proceedings of the 47th International Conference on Parallel Processing. (1-10).

    https://doi.org/10.1145/3225058.3225141

  • Gilad E, Brown T, Oskin M and Etsion Y. (2018). Snapshot-Based Synchronization: A Fast Replacement for Hand-over-Hand Locking. Euro-Par 2018: Parallel Processing. 10.1007/978-3-319-96983-1_33. (465-479).

    https://link.springer.com/10.1007/978-3-319-96983-1_33

  • Kalikar S and Nasre R. (2017). DomLock. ACM Transactions on Parallel Computing. 4:2. (1-29). Online publication date: 10-Oct-2017.

    https://doi.org/10.1145/3127584

  • Liu H, Hu T and Qiu Z. (2017). Automatic fine-grained locking generation for shared data structures 2017 International Symposium on Theoretical Aspects of Software Engineering (TASE). 10.1109/TASE.2017.8285633. 978-1-5386-1924-7. (1-8).

    http://ieeexplore.ieee.org/document/8285633/

  • Kalikar S and Nasre R. (2016). DomLock. ACM SIGPLAN Notices. 51:8. (1-12). Online publication date: 9-Nov-2016.

    https://doi.org/10.1145/3016078.2851164

  • Kalikar S and Nasre R. DomLock. Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. (1-12).

    https://doi.org/10.1145/2851141.2851164

  • Arbel M, Golan-Gueta G, Hillel E and Keidar I. Towards Automatic Lock Removal for Scalable Synchronization. Proceedings of the 29th International Symposium on Distributed Computing - Volume 9363. (170-184).

    https://doi.org/10.1007/978-3-662-48653-5_12

  • Ziv O, Aiken A, Golan-Gueta G, Ramalingam G and Sagiv M. (2015). Composing concurrency control. ACM SIGPLAN Notices. 50:6. (240-249). Online publication date: 7-Aug-2015.

    https://doi.org/10.1145/2813885.2737970

  • Ziv O, Aiken A, Golan-Gueta G, Ramalingam G and Sagiv M. Composing concurrency control. Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. (240-249).

    https://doi.org/10.1145/2737924.2737970

  • Dhoke A, Palmieri R and Ravindran B. An Automated Framework for Decomposing Memory Transactions to Exploit Partial Rollback. Proceedings of the 2015 IEEE International Parallel and Distributed Processing Symposium. (249-258).

    https://doi.org/10.1109/IPDPS.2015.106

  • Liu P and Zhang C. Unleashing concurrency for irregular data structures. Proceedings of the 36th International Conference on Software Engineering. (480-490).

    https://doi.org/10.1145/2568225.2568277

  • Kempf S, Veldema R and Philippsen M. (2014). Combining Lock Inference with Lock-Based Software Transactional Memory. Languages and Compilers for Parallel Computing. 10.1007/978-3-319-09967-5_19. (325-341).

    https://link.springer.com/10.1007/978-3-319-09967-5_19

  • Vechev M, Yahav E and Yorsh G. (2013). Abstraction-guided synthesis of synchronization. International Journal on Software Tools for Technology Transfer (STTT). 15:5-6. (413-431). Online publication date: 1-Oct-2013.

    https://doi.org/10.1007/s10009-012-0232-3

  • Botinčan M, Dodds M and Jagannathan S. (2013). Proof-Directed Parallelization Synthesis by Separation Logic. ACM Transactions on Programming Languages and Systems. 35:2. (1-60). Online publication date: 1-Jul-2013.

    https://doi.org/10.1145/2491522.2491525

  • Golan-Gueta G, Ramalingam G, Sagiv M and Yahav E. (2013). Concurrent libraries with foresight. ACM SIGPLAN Notices. 48:6. (263-274). Online publication date: 23-Jun-2013.

    https://doi.org/10.1145/2499370.2462172

  • Golan-Gueta G, Ramalingam G, Sagiv M and Yahav E. Concurrent libraries with foresight. Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation. (263-274).

    https://doi.org/10.1145/2491956.2462172

  • Marino D, Hammer C, Dolby J, Vaziri M, Tip F and Vitek J. Detecting deadlock in programs with data-centric synchronization. Proceedings of the 2013 International Conference on Software Engineering. (322-331).

    /doi/10.5555/2486788.2486831

  • Marino D, Hammer C, Dolby J, Vaziri M, Tip F and Vitek J. (2013). Detecting deadlock in programs with data-centric synchronization 2013 35th International Conference on Software Engineering (ICSE). 10.1109/ICSE.2013.6606578. 978-1-4673-3076-3. (322-331).

    http://ieeexplore.ieee.org/document/6606578/

  • Liu P and Zhang C. Axis: automatically fixing atomicity violations through solving control constraints. Proceedings of the 34th International Conference on Software Engineering. (299-309).

    /doi/10.5555/2337223.2337259

  • Liu P and Zhang C. (2012). Axis: Automatically fixing atomicity violations through solving control constraints 2012 34th International Conference on Software Engineering (ICSE 2012). 10.1109/ICSE.2012.6227184. 978-1-4673-1066-6. (299-309).

    http://ieeexplore.ieee.org/document/6227184/

  • Hawkins P, Aiken A, Fisher K, Rinard M and Sagiv M. Reasoning about lock placements. Proceedings of the 21st European conference on Programming Languages and Systems. (336-356).

    https://doi.org/10.1007/978-3-642-28869-2_17

  • Lu Y, Potter J and Xue J. (2012). Ownership Types for Object Synchronisation. Programming Languages and Systems. 10.1007/978-3-642-35182-2_3. (18-33).

    http://link.springer.com/10.1007/978-3-642-35182-2_3

  • Afek Y, Avni H and Shavit N. Towards consistency oblivious programming. Proceedings of the 15th international conference on Principles of Distributed Systems. (65-79).

    https://doi.org/10.1007/978-3-642-25873-2_6

  • Ferles K, Sepanski B, Krishnan R, Bornholt J and Dillig I. (2022). Synthesizing fine-grained synchronization protocols for implicit monitors. Proceedings of the ACM on Programming Languages. 6:OOPSLA1. (1-26). Online publication date: 29-Apr-2022.

    https://doi.org/10.1145/3527311

  • Bang J, Kim C, Chen Q, Lee C, Byun E, Sung H, Eom H and Lee J. A Fine-Grained Page Management Scheme For Hpc Manycore I/O Systems. SSRN Electronic Journal. 10.2139/ssrn.4192491.

    https://www.ssrn.com/abstract=4192491

  • Bang J, Kim C, Kim S, Chen Q, Lee C, Byun E, Lee J and Eom H. (2021). Finer-LRU: A Scalable Page Management Scheme for HPC Manycore Architectures 2021 IEEE International Parallel and Distributed Processing Symposium (IPDPS). 10.1109/IPDPS49936.2021.00065. 978-1-6654-4066-0. (567-576).

    https://ieeexplore.ieee.org/document/9460503/

  • Sang B, Eugster P, Petri G, Ravi S and Roman P. (2020). Scalable and serializable networked multi-actor programming. Proceedings of the ACM on Programming Languages. 10.1145/3428266. 4:OOPSLA. (1-30). Online publication date: 13-Nov-2020.

    https://dl.acm.org/doi/10.1145/3428266

  • Drechsler J, Mogk R, Salvaneschi G and Mezini M. (2018). Thread-safe reactive programming. Proceedings of the ACM on Programming Languages. 2:OOPSLA. (1-30). Online publication date: 24-Oct-2018.

    https://doi.org/10.1145/3276477

  • Ganesh K, Kalikar S and Nasre R. (2018). Multi-granularity Locking in Hierarchies with Synergistic Hierarchical and Fine-Grained Locks. Euro-Par 2018: Parallel Processing. 10.1007/978-3-319-96983-1_39. (546-559).

    https://link.springer.com/10.1007/978-3-319-96983-1_39

  • Arbel M, Golan-Gueta G, Hillel E and Keidar I. Towards Automatic Lock Removal for Scalable Synchronization. Proceedings of the 29th International Symposium on Distributed Computing - Volume 9363. (170-184).

    https://doi.org/10.1007/978-3-662-48653-5_12

  • Kempf S, Veldema R and Philippsen M. (2014). Combining Lock Inference with Lock-Based Software Transactional Memory. Languages and Compilers for Parallel Computing. 10.1007/978-3-319-09967-5_19. (325-341).

    https://link.springer.com/10.1007/978-3-319-09967-5_19