[m-rev.] for post-commit review: add RBMM papers from Leuven

[Zoltan Somogyi]

Can someone in Melbourne please check that this diff does not screw up
the news database? And Quan, please fill in the page numbers at the spots
marked with XXXs.

Zoltan.

news/newsdb.inc:
information/include/papers.inc:
information/papers/*:
	Add Quan's thesis and the papers it is based on.

cvs diff: Diffing .
cvs diff: Diffing bin
cvs diff: Diffing contact
cvs diff: Diffing contact/include
cvs diff: Diffing download
cvs diff: Diffing download/include
cvs diff: Diffing download/patches
cvs diff: Diffing htdig
cvs diff: Diffing htdig/include
cvs diff: Diffing images
cvs diff: Diffing include
cvs diff: Diffing information
cvs diff: Diffing information/bench
cvs diff: Diffing information/deep_demo
cvs diff: Diffing information/developers
cvs diff: Diffing information/dotnet
cvs diff: Diffing information/events
cvs diff: Diffing information/events/images
cvs diff: Diffing information/include
Index: information/include/papers.inc
===================================================================
RCS file: /home/mercury/mercury1/repository/w3/information/include/papers.inc,v
retrieving revision 1.65
diff -u -b -r1.65 papers.inc
--- information/include/papers.inc	27 Jul 2009 06:51:22 -0000	1.65
+++ information/include/papers.inc	3 Dec 2009 23:00:17 -0000
@@ -22,6 +22,85 @@
 
 <li>
 <strong>
+<a href="papers.html#quan-phd">
+Region-based memory management for the logic programming language Mercury
+</a>
+</strong>
+<br>
+Quan Phan.
+<br>
+<em>
+Ph.D. thesis
+</em>
+Department of Computer Science,
+Catholic University of Leuven (KUL),
+November 2009.
+<p>
+
+<li>
+<strong>
+<a href="papers.html#more-precise-rbmm">
+More precise region-based memory management for Mercury programs
+</a>
+</strong>
+<br>
+Quan Phan and Gerda Janssens.
+<br>
+<em>
+Proceedings of the Ninth International Colloquium on
+Implementation of Constraint and Logic Programming Systems (CICLOPS '09),
+</em>
+Pasadena, California, July 2009.
+<p>
+
+<li>
+<strong>
+<a href="papers.html#path-sensitive-ppdp">
+Path-sensitive region analysis for Mercury programs
+</a>
+</strong>
+<br>
+Quan Phan and Gerda Janssens.
+<br>
+<em>
+Proceedings of 11th International Symposium on
+Principles and Practice of Declarative Programming,
+</em>
+Coimbra, Portugal, September 2009.
+<p>
+
+<li>
+<strong>
+<a href="papers.html#runtime-support-ismm08">
+Runtime support for region-based memory management in Mercury
+</a>
+</strong>
+<br>
+Quan Phan, Zoltan Somogyi and Gerda Janssens.
+<br>
+<em>
+Proceedings of the 2008 International Symposim on Memory Management (ISMM '08),
+</em>
+Tucson, Arizona, June 2008.
+<p>
+
+<li>
+<strong>
+<a href="papers.html#static-region-analysis">
+Static region analysis for Mercury
+</a>
+</strong>
+<br>
+Quan Phan and Gerda Janssens.
+<br>
+<em>
+Proceedings of the 23rd International Conference on Logic Programming,
+</em>
+Porto, Portugal, September 2007.
+<p>
+
+<li>
+<strong>
 <a href = "papers.html#pbone-hons">
 Calculating likely Parallelism within Dependant Conjunctions
 for Logic Programs
@@ -957,6 +1036,214 @@
 
 <li>
 <strong>
+<a name="quan-phd">
+Region-based memory management for the logic programming language Mercury
+</a>
+</strong>
+<br>
+Quan Phan.
+<br>
+<em>
+Ph.D. thesis
+</em>
+Department of Computer Science,
+Catholic University of Leuven (KUL),
+November 2009.
+<a href = "papers/quan_thesis.pdf">
+Available here (919K).
+</a>
+<p>
+Region-based memory management (RBMM)
+is a form of compile-time memory management,
+well-known from the functional programming world.
+In this thesis we describe our work of investigating and developing RBMM
+for the logic programming language Mercury.
+Mercury is designed with
+strong type, mode, and determinism systems.
+These systems not only provide Mercury programmers
+with several direct software engineering benefits,
+such as self-documenting code and clear program logic,
+but also give the language developers useful information for optimizations.
+<p>
+The first challenge in realizing RBMM for a programming language
+is to divide program data into regions
+such that the regions can be reclaimed as soon as possible.
+In the thesis we have developed program analyses
+that determine the distribution of data over regions as well as
+their lifetimes in a Mercury program.
+The program then is transformed to a region-annotated program
+containing the necessary region constructs.
+We provide the correctness proofs of the related program analyses and
+transformation, which guarantee the safeness of memory accesses
+in annotated programs.
+<p>
+We have implemented runtime support
+that tackles the special challenge posed by backtracking.
+Backtracking can require regions
+removed during forward execution to be ``resurrected'',
+and any memory allocated during a computation that has been backtracked over
+must be recovered promptly,
+without waiting for the regions involved to come to the end of their life.
+<p>
+We study the effects of RBMM for a selection of benchmark programs
+including well-known difficult cases for RBMM.
+Our RBMM-enabled Mercury system
+obtains clearly faster runtime for two third of the benchmarks compared to
+the Mercury system using the Boehm runtime garbage collector,
+with an average speedup of 20%.
+In terms of memory usage,
+the region system achieves optimal memory consumption in some programs.
+Our in-depth case study reveals the impact of sharing on memory reuse
+in programs in region-based systems.
+<p>
+Finally, we propose region reuse extension to our current region framework.
+Our RBMM system augmented with region reuse
+can automatically improve memory reuse for a popular class of programs
+that otherwise often require non-intuitive manual program-rewriting
+so that RBMM systems can obtain good memory reuse.
+<p>
+
+<li>
+<strong>
+<a name="more-precise-rbmm">
+More precise region-based memory management for Mercury programs
+</a>
+</strong>
+<br>
+Quan Phan and Gerda Janssens.
+<br>
+<em>
+Proceedings of the Ninth International Colloquium on
+Implementation of Constraint and Logic Programming Systems (CICLOPS '09),
+</em>
+Pasadena, California, July 2009, XXX page numbers.
+<a href = "papers/ciclops09.pdf">
+Available here (200K).
+</a>
+<p>
+Dividing the heap memory of programs into regions is
+the starting point of region-based memory management.
+In our existing work of
+enabling region-based memory management for Mercury,
+a program analysis was used to distribute data over the regions.
+An important goal of the analysis is to decide
+which program variables should end up in the same region.
+For a popular class of programs,
+it covetously puts program variables in the same region,
+while more memory could have been reused
+if they had been kept in separate ones.
+In this paper we define a new refined region analysis
+that is keen to keep program variables in separate regions
+by taking into account the different execution paths of a procedure.
+With the more precise, path-sensitive analysis we
+can reduce the memory footprint for several programs.
+<p>
+
+<li>
+<strong>
+<a name="path-sensitive-ppdp">
+Path-sensitive region analysis for Mercury programs
+</a>
+</strong>
+<br>
+Quan Phan and Gerda Janssens.
+<br>
+<em>
+Proceedings of 11th International Symposium on
+Principles and Practice of Declarative Programming,
+</em>
+Coimbra, Portugal, September 2009, XXX page numbers.
+<a href = "papers/ppdp14-phan.pdf">
+Available here (215K).
+</a>
+<p>
+Dividing the heap memory of programs into regions is
+the starting point of region-based memory management.
+In our existing work of
+enabling region-based memory management for Mercury,
+a program analysis was used to distribute data over the regions.
+An important goal of the analysis is to decide
+which program variables should end up in the same region.
+For a popular class of programs,
+it covetously puts program variables in the same region,
+while more memory could have been reused
+if they had been kept in separate ones.
+In this paper we define a new refined region analysis
+that is keen to keep program variables in separate regions
+by taking into account the different execution paths of a procedure.
+With the more precise, path-sensitive analysis we
+can reduce the memory footprint for several programs.
+<p>
+
+<li>
+<strong>
+<a name="runtime-support-ismm08">
+Runtime support for region-based memory management in Mercury
+</a>
+</strong>
+<br>
+Quan Phan, Zoltan Somogyi and Gerda Janssens.
+<br>
+<em>
+Proceedings of the 2008 International Symposim on Memory Management (ISMM '08),
+</em>
+Tucson, Arizona, June 2008, pages 61-70.
+<a href = "papers/ismm115-phan.pdf">
+Available here (148K).
+</a>
+<p>
+Applying region-based memory management (RBMM)
+to logic programming languages poses a special challenge:
+backtracking can require regions
+removed during forward execution to be ``resurrected'',
+and any memory allocated during a computation that has been backtracked over
+must be recovered promptly,
+without waiting for the regions involved to come to the end of their life.
+In this paper, we describe how we implemented runtime support for RBMM
+in the logic programming language Mercury,
+whose specialized implementation
+of the language constructs involved in backtracking
+required equally specialized support.
+Our benchmark Mercury programs run about 25% faster on average
+with RBMM than with the usual Boehm garbage collector,
+and for some programs, RBMM achieves optimal memory consumption.
+<p>
+
+<li>
+<strong>
+<a name="static-region-analysis">
+Static region analysis for Mercury
+</a>
+</strong>
+<br>
+Quan Phan and Gerda Janssens.
+<br>
+<em>
+Proceedings of the 23rd International Conference on Logic Programming,
+</em>
+Porto, Portugal, September 2007, XXX page numbers.
+<a href = "papers/iclp2007.pdf">
+Available here (193K).
+</a>
+<p>
+Region-based memory management is a form of compile-time memory
+management, well-known from the functional programming world.
+This paper describes a static region analysis for the logic
+programming language Mercury. We use region points-to graphs to
+model the partitioning of the memory used by a program into
+separate regions. The algorithm starts with a region points-to
+analysis that determines the different regions in the program. We then
+compute the liveness of the regions by using an extended live
+variable analysis. Finally, a program transformation adds region
+annotations to the program for region support. These annotations generate
+data for a region simulator that generates reports on the memory behaviour of
+region-annotated programs. Our approach obtains good memory consumption
+for several benchmark programs; for some of them it achieves optimal
+memory management.
+<p>
+
+<li>
+<strong>
 <a name="pbone-hons">
 Calculating likely Parallelism within Dependant Conjunctions
 for Logic Programs
@@ -2145,7 +2432,7 @@
 of various forms of polymorphism, and of higher order.
 Existing profilers tend not to produce very useful information
 in the presence of these constructs.
-We present a new profiling technique we call \emph{deep profiling}
+We present a new profiling technique we call deep profiling
 that yields detailed and useful information about programs
 even in the presence of these constructs,
 information that is significantly richer
@@ -3048,8 +3335,7 @@
 <li>
 <strong>
 <a name = "g12_unclean">
-Unclean! Unclean! or Purity Issues in Declarative Constraint Logic
-Programming.
+Unclean! Unclean! or Purity Issues in Declarative Constraint Logic Programming.
 </a>
 </strong>
 <br>
@@ -3066,8 +3352,8 @@
 <li>
 <strong>
 <a name = "aadebug05-talk">
-Divide-and-query and subterm dependency tracking in the Mercury declarative
-debugger.
+Divide-and-query and subterm dependency tracking
+in the Mercury declarative debugger.
 </a>
 </strong>
 <br>
cvs diff: Diffing information/papers
Index: information/papers/ciclops09.pdf
===================================================================
RCS file: information/papers/ciclops09.pdf
diff -N information/papers/ciclops09.pdf
Binary files /dev/null and ciclops09.pdf differ
Index: information/papers/iclp2007.pdf
===================================================================
RCS file: information/papers/iclp2007.pdf
diff -N information/papers/iclp2007.pdf
Binary files /dev/null and iclp2007.pdf differ
Index: information/papers/ismm115-phan.pdf
===================================================================
RCS file: information/papers/ismm115-phan.pdf
diff -N information/papers/ismm115-phan.pdf
Binary files /dev/null and ismm115-phan.pdf differ
Index: information/papers/ppdp14-phan.pdf
===================================================================
RCS file: information/papers/ppdp14-phan.pdf
diff -N information/papers/ppdp14-phan.pdf
Binary files /dev/null and ppdp14-phan.pdf differ
Index: information/papers/quan_thesis.pdf
===================================================================
RCS file: information/papers/quan_thesis.pdf
diff -N information/papers/quan_thesis.pdf
Binary files /dev/null and quan_thesis.pdf differ
cvs diff: Diffing information/reports
cvs diff: Diffing mailing-lists
cvs diff: Diffing mailing-lists/include
cvs diff: Diffing mailing-lists/mercury-ads
cvs diff: Diffing mailing-lists/mercury-ads/include
cvs diff: Diffing mailing-lists/mercury-developers
cvs diff: Diffing mailing-lists/mercury-developers/include
cvs diff: Diffing mailing-lists/mercury-reviews
cvs diff: Diffing mailing-lists/mercury-reviews/include
cvs diff: Diffing mailing-lists/mercury-users
cvs diff: Diffing mailing-lists/mercury-users/include
cvs diff: Diffing news
Index: news/newsdb.inc
===================================================================
RCS file: /home/mercury/mercury1/repository/w3/news/newsdb.inc,v
retrieving revision 1.114
diff -u -b -r1.114 newsdb.inc
--- news/newsdb.inc	30 Nov 2009 03:01:18 -0000	1.114
+++ news/newsdb.inc	3 Dec 2009 23:20:58 -0000
@@ -21,6 +21,12 @@
 */
 
 $newsdb = array(
+"3 December 2009" => array("New papers",
+"We have several papers available from our 
+<A HREF=\"information/papers.html\">papers page</A> that describe
+region-based memory management in Mercury.
+),
+
 "30 November 2009" => array("GCC 4.x supprt",
 "You can now use GCC 4.1 - 4.4 to build Mercury programs in
 low-level C grades, on Linux/x86 and Linux/x86-64.
cvs diff: Diffing tutorial
cvs diff: Diffing tutorial/book
cvs diff: Diffing tutorial/src
--------------------------------------------------------------------------
mercury-reviews mailing list
Post messages to:       mercury-reviews at csse.unimelb.edu.au
Administrative Queries: owner-mercury-reviews at csse.unimelb.edu.au
Subscriptions:          mercury-reviews-request at csse.unimelb.edu.au
--------------------------------------------------------------------------