PLDI 2010: Toronto, Ontario, Canada

Dynamic analysis

• Gregor Richards, Sylvain Lebresne, Brian Burg, Jan Vitek:
  An analysis of the dynamic behavior of JavaScript programs. 1-12
  
• Michael D. Bond, Graham Z. Baker, Samuel Z. Guyer:
  Breadcrumbs: efficient context sensitivity for dynamic bug detection analyses. 13-24
  
• Olatunji Ruwase, Shimin Chen, Phillip B. Gibbons, Todd C. Mowry:
  Decoupled lifeguards: enabling path optimizations for dynamic correctness checking tools. 25-35
  
• Byeongcheol Lee, Ben Wiedermann, Martin Hirzel, Robert Grimm, Kathryn S. McKinley:
  Jinn: synthesizing dynamic bug detectors for foreign language interfaces. 36-49
  

Improving parallelism 1

• Prakash Prabhu, Ganesan Ramalingam, Kapil Vaswani:
  Safe programmable speculative parallelism. 50-61
  
• Chen Tian, Min Feng, Rajiv Gupta:
  Supporting speculative parallelization in the presence of dynamic data structures. 62-73
  
• Mahmut T. Kandemir, Taylan Yemliha, Sai Prashanth Muralidhara, Shekhar Srikantaiah, Mary Jane Irwin, Yuanrui Zhang:
  Cache topology aware computation mapping for multicores. 74-85
  
• Yi Yang, Ping Xiang, Jingfei Kong, Huiyang Zhou:
  A GPGPU compiler for memory optimization and parallelism management. 86-97
  

Invited talk

• Susan J. Eggers:
  2010 Athena lecture. 98
  

Verification

• Jean Yang, Chris Hawblitzel:
  Safe to the last instruction: automated verification of a type-safe operating system. 99-110
  
• Zachary Tatlock, Sorin Lerner:
  Bringing extensibility to verified compilers. 111-121
  
• Adam Chlipala:
  Ur: statically-typed metaprogramming with type-level record computation. 122-133
  
• Michael Emmi, Rupak Majumdar, Roman Manevich:
  Parameterized verification of transactional memories. 134-145
  

Heap management

• Filip Pizlo, Lukasz Ziarek, Petr Maj, Antony L. Hosking, Ethan Blanton, Jan Vitek:
  Schism: fragmentation-tolerant real-time garbage collection. 146-159
  
• Guoqing (Harry) Xu, Atanas Rountev:
  Detecting inefficiently-used containers to avoid bloat. 160-173
  
• Guoqing (Harry) Xu, Nick Mitchell, Matthew Arnold, Atanas Rountev, Edith Schonberg, Gary Sevitsky:
  Finding low-utility data structures. 174-186
  
• Todd Mytkowicz, Amer Diwan, Matthias Hauswirth, Peter F. Sweeney:
  Evaluating the accuracy of Java profilers. 187-197
  

Singular topics

• Woongki Baek, Trishul M. Chilimbi:
  Green: a framework for supporting energy-conscious programming using controlled approximation. 198-209
  
• Kaushik Rajan, Sriram K. Rajamani, Shashank Yaduvanshi:
  GUESSTIMATE: a programming model for collaborative distributed systems. 210-220
  
• Qian Xi, David Walker:
  A context-free markup language for semi-structured text. 221-232
  
• Florian Loitsch:
  Printing floating-point numbers quickly and accurately with integers. 233-243
  

Managing concurrency 1

• Cormac Flanagan, Stephen N. Freund:
  Adversarial memory for detecting destructive races. 244-254
  
• Michael D. Bond, Katherine E. Coons, Kathryn S. McKinley:
  PACER: proportional detection of data races. 255-268
  
• Takuya Nakaike, Maged M. Michael:
  Lock elision for read-only critical sections in Java. 269-278
  

Static analysis and synthesis

• Swarat Chaudhuri, Armando Solar-Lezama:
  Smooth interpretation. 279-291
  
• Sumit Gulwani, Florian Zuleger:
  The reachability-bound problem. 292-304
  
• Matthew Might, Yannis Smaragdakis, David Van Horn:
  Resolving and exploiting the k-CFA paradox: illuminating functional vs. object-oriented program analysis. 305-315
  
• Viktor Kuncak, Mikaël Mayer, Ruzica Piskac, Philippe Suter:
  Complete functional synthesis. 316-329
  

Managing concurrency 2

• Sebastian Burckhardt, Chris Dern, Madanlal Musuvathi, Roy Tan:
  Line-up: a complete and automatic linearizability checker. 330-340
  
• Emina Torlak, Mandana Vaziri, Julian Dolby:
  MemSAT: checking axiomatic specifications of memory models. 341-350
  
• Daniel Marino, Abhayendra Singh, Todd D. Millstein, Madanlal Musuvathi, Satish Narayanasamy:
  DRFX: a simple and efficient memory model for concurrent programming languages. 351-362
  

Improving parallelism 2

• Craig Chambers, Ashish Raniwala, Frances Perry, Stephen Adams, Robert R. Henry, Robert Bradshaw, Nathan Weizenbaum:
  FlumeJava: easy, efficient data-parallel pipelines. 363-375
  
• Heidi Pan, Benjamin Hindman, Krste Asanovic:
  Composing parallel software efficiently with lithe. 376-387
  
• Jin Zhou, Brian Demsky:
  Bamboo: a data-centric, object-oriented approach to many-core software. 388-399
  

Types

• Edwin M. Westbrook, Mathias Ricken, Jun Inoue, Yilong Yao, Tamer Abdelatif, Walid Taha:
  Mint: Java multi-stage programming using weak separability. 400-411
  
• Juan Chen, Ravi Chugh, Nikhil Swamy:
  Type-preserving compilation of end-to-end verification of security enforcement. 412-423
  
• Ross Tate, Juan Chen, Chris Hawblitzel:
  Inferable object-oriented typed assembly language. 424-435
  
• Yit Phang Khoo, Bor-Yuh Evan Chang, Jeffrey S. Foster:
  Mixing type checking and symbolic execution. 436-447
  

Optimization

• Yang Chen, Yuanjie Huang, Lieven Eeckhout, Grigori Fursin, Liang Peng, Olivier Temam, Chengyong Wu:
  Evaluating iterative optimization across 1000 datasets. 448-459
  
• Md Kamruzzaman, Steven Swanson, Dean M. Tullsen:
  Software data spreading: leveraging distributed caches to improve single thread performance. 460-470
  
• Jennifer B. Sartor, Stephen M. Blackburn, Daniel Frampton, Martin Hirzel, Kathryn S. McKinley:
  Z-rays: divide arrays and conquer speed and flexibility. 471-482
  
• Umut A. Acar, Guy E. Blelloch, Ruy Ley-Wild, Kanat Tangwongsan, Duru Türkoglu:
  Traceable data types for self-adjusting computation. 483-496
  

Last update Sat May 18 19:35:01 2013 CET by the DBLP Team — Data released under the ODC-BY 1.0 license — See also our legal information page