Specialising Simulator Generators for High-Performance Monte-Carlo Methods

Languages that integrate functional and logic programming with a complete operational semantics are based on narrowing, a unification-based goal-solving mechanism which subsumes the reduction principle of functional languages and the resolution principle of logic languages. In this article, we present a partial evaluation scheme for functional logic languages based on an automatic unfolding algorithm which builds narrowing trees. The method is formalized within the theoretical framework established by Lloyd and Shepherdson for the partial deduction of logic programs, which we have generalized for dealing with functional computations. A generic specialization algorithm is proposed which does not depend on the eager or lazy nature of the narrower being used. To the best of our knowledge, this is the first generic algorithm for the specialization of functional logic programs. We also discuss the relation to work on partial evaluation in functional programming, term-rewriting systems, and logic programming. Finally, we present some experimental results with an implementation of the algorithm which show in practice that the narrowing-driven partial evaluator effectively combines the propagation of partial data structures (by means of logical variables and unification) with better opportunities for optimization (thanks to the functional dimension).

In this thesis a new method for the analysis of power transients in a nuclear reactor is developed, which is more accurate than the present state-of-the-art methods. Transient analysis is important tool when designing nuclear reactors, since they predict the behaviour of a reactor during changing conditions, such as a control-rod movement, induced by an operator, or an accident scenario. The current methods for transient analysis apply deterministic solvers to calculate the neutronic response, but not only do these deterministic solvers always need to discretise the problem, they also often apply more fundamental approximations such as homogenization or diffusion. Therefore a stochastic method is needed, which only has a statistical uncertainty. A challenge for applying the Monte Carlo method on transient analysis, is the different types of particles which must be simulated in a single simulation. It is common for a neutronics calculation to simulate the prompt neutrons, however the simulation of precursors is new. The main challenge when simulating precursors lies in their long lifetime, which is seconds, whereas the prompt neutrons have a lifetime of microseconds. This has been solved by dividing the transient problem into time intervals and forcing the precursors to produce a delayed neutron is all time intervals. This will ensure prompt-neutron chains in all intervals. The prompt neutrons will form prompt-neutron chains, which poses another challenge for the Monte Carlo method. The chain length of these prompt neutrons varies a lot and the can also split into many branches, which averages out in a real power reactor, but is difficult to simulate on a computer. To improve the chain-length statistics, a new variance reduction technique is developed, which dictates that a single neutron will emerge from each interaction. This emerging neutron can be the result of a scattering event or a fission event. Finally, a dynamic simulation scheme, which can run in parallel, has been devised, simulating all time intervals consecutively. Also, a method for sampling the initial conditions is created and this scheme is implemented in a purpose-built Monte Carlo code and in a general-purpose Monte Carlo code. The two codes have been tested in several cases and they behave as expected, agreeing with deterministic method where expected, but deviating when the deterministic methods are no longer valid. In order to simulate realistic transients in a power reactor, feedback has to be taken into account. To achieve this, the dynamic Monte Carlo method has been coupled to a thermal-hydraulics code, using an explicit scheme. The results of this coupled simulation are compared to a state-of-the-art coupled diffusion calculation in a NURISP-benchmark calculation and the results agree well, except for a small deviation towards the end. The exact source of this deviation should be further investigated, but the difference is small, when realising that there is already a deviation in the steady-state results. The results demonstrate the feasibility of performing a fully dynamic transient analysis, using only Monte Carlo for the neutronics part of the calculation. Transients can now be calculated, with detailed modelling of any complex geometry and with continuous energy, which is especially useful for newly developed reactor types and one-of-a-kind research reactors.

The first Futamura projection enables compilation and high performance code generation of user programs by partial evaluation of language interpreters. Previous work has shown that online partial evaluation can yield the same peak performance as a specialized JIT compiler. However, this comes with the downside of additional compile time: Online partial evaluation of language interpreters has to specialize interpreter code on the fly to the dynamic types used at run time to create efficient target code. As a result, the time spent on partial evaluation itself is a significant contributor to the overall compile time of a method. The second Futamura projection solves this problem by self-applying partial evaluation on the partial evaluation algorithm, effectively generating language-specific compilers from interpreters. This typically reduces compilation time compared to the first projection. Previous work employed the second projection to some extent, however we are not aware of any usage of the generic second Futamura projection in a state-of-the-art language runtime. To solve the problems of self-application and code-size explosion, this paper proposes CompGen, an approach based on code generation of subsets of language interpreters. It is loosely based upon the idea of the second Futamura projection. Our implementation of CompGen for GraalVM shows that our usage of a novel code-generation algorithm allows us to generate efficient compilers that emit fast target programs which easily outperform the first Futamura projection in compilation time. We evaluated our approach with the high-performance JavaScript implementation of GraalVM and standard JavaScript benchmarks, showing that our approach achieves >2X speedups of partial evaluation.

Many functional logic languages are based on narrowing, a unification-based goal-solving mechanism which subsumes the reduction mechanism of functional languages and the resolution principle of logic languages. Needed narrowing is an optimal evaluation strategy which constitutes the basis of modern (narrowing-based) lazy functional logic languages. In this work, we present the fundamentals of partial evaluation in such languages. We provide correctness results for partial evaluation based on needed narrowing and show that the nice properties of this strategy are essential for the specialization process. In particular, the structure of the original program is preserved by partial evaluation and, thus, the same evaluation strategy can be applied for the execution of specialized programs. This is in contrast to other partial evaluation schemes for lazy functional logic programs which may change the program structure in a negative way. Recent proposals for the partial evaluation of declarative multi-paradigm programs use (some form of) needed narrowing to perform computations at partial evaluation time. Therefore, our results constitute the basis for the correctness of such partial evaluators.

Spatial variability of Darcy velocity is presented due to the heterogeneity of aquifer parameters. The uncertainty qualification of velocity suffers great challenge in the complex porous media. This work focuses on the use of sparse grid collocation method in velocity simulation. Since the sparse grid collocation method provides a non-intrusive way to incorporate any existing deterministic solver, the mixed finite element method is combined as the deterministic solver to retain the local continuity of Darcy velocity. We decompose the error of the velocity into three components, and illustrate that the Karhunen-Loeve truncation brings more error into velocity approximation than into head. The convergence properties of velocity moments restrict the application of sparse grid collocation method in the problems with small correlation lengths. This work provides insights towards the application of sparse grid collocation method to velocity modeling. It is demonstrated that for which problems the sparse grid collocation method is expected to be competitive with the Monte Carlo simulation. Further work about the anisotropic sparse grid collocation method should be extended to circumvent the obstacle of dimensionality.

Programmable Rewriting Strategies in Haskell: — White Paper —

On-line partial evaluation algorithms include a generalisation step, which is needed to ensure termination. In partial evaluation of logic and functional programs, the usual generalisation operation applied to computation states is the most specific generalisation (msg) of expressions. This can cause loss of information, which is especially serious in programs whose computations first build some internal data structure, which is then used to control a subsequent phase of execution - a common pattern of computation. If the size of the intermediate data is unbounded at partial evaluation time then the msg will lose almost all information about its structure. Hence the second phase of computation cannot be effectively specialised.In this paper a generalisation based on regular approximations is presented. Regular approximations are recursive descriptions of term structure closely related to tree automata. A regular approximation of computation states can be built during partial evaluation. The critical point is that when generalisation is performed, the upper bound on regular descriptions can be combined with the msg, thus preserving structural information including recursively defined structure. The domain of regular approximations is infinite and hence a widening is incorporated in the generalisation to ensure termination. An algorithm for partial evaluation of logic programs, enhanced with regular approximations, along with some examples of its use will be presented.

Functional logic languages combine the operational principles of the most important declarative programming paradigms, namely functional and logic programming. Inductively sequential programs admit the definition of optimal computation strategies and are the basis of several recent (lazy) functional logic languages. In this paper, we define a partial evaluator for inductively sequential functional logic programs. We prove strong correctness of this partial evaluator and show that the nice properties of inductively sequential programs carry over to the specialization process and the specialized programs. In particular, the structure of the programs is preserved by the specialization process. This is in contrast to other partial evaluation methods for functional logic programs which can destroy the original program structure. Finally, we present some experiments which highlight the practical advantages of our approach.

We show that a type system based on the intuitionistic modal logic S4 provides an expressive framework for specifying and analyzing computation stages in the context of functional languages. Our main technical result is a conservative embedding of Nielson & Nielson's two-level functional language in our language Mini-ML, thus proving that binding-time correctness is equivalent to modal correctness on this fragment. In addition Mini-ML can also express immediate evaluation and sharing of code across multiple stages, thus supporting run-time code generation as well as partial evaluation.

The generic programming approach is popular in functional languages (for example, OCaml, Haskell). In essence, it is a compile-time generation of code that performs transformations of user-defined data types. The generated code can carry out various kinds of transformations of the values. Usually, transformations are represented as functions that implement algorithms of transformation. New transformations could be built from these transformation functions and user-defined ones. The representation based on functions has a downside: functions behave as final representations, and hence it is not possible to modify the behavior of the already built function. If the current set of transformations does not suit well, software developers are obliged to write a completely distinct transformation, even in the case when the new transformation is almost identical to the existing one. This work proposes to build transformations that are extensible after construction. The object-oriented programming paradigm will be followed, transformations will be represented not as functions but as objects. Instead of calling a transformation function, one of the object’s methods will be called. The transformation itself will be split into methods. The extensibility is supported by adding new methods and overriding existing ones. In this paper, the authors propose an approach to represent transformations as objects in the OCaml functional programming language. Every alternative in data type definition has a corresponding object method. This design allows the construction of many distinct transformations. The cases where too many methods are not desirable are also discussed. The method is applicable to represent extensible transformations for polymorphic variant data types in OCaml when other methods fail to do it. The method is not bound to any particular domain. It allows the creation of extensible transformations in OCaml. It could be ported to other functional languages supporting object-oriented programming.

A new declarative programming paradigm, constraint functional logic programming (CFLP) is presented, which unifies systematically all features of constraint, functional and logic programming. CFLP extends constraint functional programming (CFP), which supports equation solving over a functional program, to general constraint programming permitting the use of constraints for programming as well as for posing queries. It also generalises constraint logic programming (CLP), by admitting user-defined functions as a purely functional subsystem of a CLP language. This paper presents the motivation for designing CFLP and its semantics. Programming examples are given in the concrete CFLP language Falcon.KeywordsLogic ProgramLogic ProgrammingConstraint ProgrammingConstraint SystemFunctional ProgrammingThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This paper introduces a novel statistical method, referred to as the stochastic reduced order model (SROM) method, to predict the variability of cable crosstalk subject to a range of parametric uncertainties. The SROM method is a new member of the family of stochastic approaches to quantify propagated uncertainty in the presence of multiple uncertainty sources. It is nonintrusive, accurate, efficient, and stable, thus could be a promising alternative to some well-established methods, such as the Stochastic Galerkin and stochastic collocation (SC) methods. In this paper, the SROM method is successfully applied to obtain the statistics of cable crosstalk subject to single and multiple uncertainty sources. The statistics of uncertain cable parameters is first accurately approximated by SROM, i.e., pairs of very few samples with known probabilities, such that the uncertain input space is well represented. Then, a deterministic solver is used to produce the samples of cable crosstalk with the corresponding probabilities, and finally the uncertainty propagated to the crosstalk is quantified with good accuracy. Compared to the conventional Monte-Carlo simulation, the statistics of crosstalk obtained by the SROM method converge much faster by orders of magnitude. Also, the computational cost of the SROM method is shown to be small and can be tuned flexibly depending on the accuracy requirement. The SC method based on tensor product sampling strategy is also implemented to validate the efficacy of the SROM method.

Datatype-generic programming is defining functions that depend on the structure, or shape, of datatypes. It has been around for more than 10 years, and a lot of progress has been made, in particular in the lazy functional programming language Haskell. There are morethan 10 proposals for generic programming libraries orlanguage extensions for Haskell. To compare and characterise the many generic programming libraries in atyped functional language, we introduce a set of criteria and develop a generic programming benchmark: a set of characteristic examples testing various facets of datatype-generic programming. We have implemented the benchmark for nine existing Haskell generic programming libraries and present the evaluation of the libraries. The comparison is useful for reaching a common standard for generic programming, but also for a programmer who has to choose a particular approach for datatype-generic programming.

It is our great pleasure to welcome you to the 3rd ACM SIGPLAN Workshop on Functional High-Performance Computing. FHPC 2014 brings together researchers who explore declarative high level programming technology in application domains where large-scale computations arise naturally, and high performance is essential. The workshop is in its third year. Our goal is to establish FHPC as a regular annual forum for researchers interested in applying functional programming techniques in the area of high-performance computing. Functional programming is increasingly recognized as presenting a nice sweet spot between expressiveness and efficiency for parallel programming, reconciling execution performance with programming productivity. Making FHPC'14 happen depended on a number of people and organizations, which we would like to acknowledge here. We thank the authors for providing the content of the programme. We would like to express our gratitude to the programme committee, who worked very hard in reviewing papers and providing suggestions for their improvement. Special thanks go to ACM SIGPLAN and the ICFP workshop chairs for accepting our workshop proposal and being flexible with organizational matters. The call for papers attracted 11 submissions. The number of submissions was a little disappointing, but the quality was reassuringly high. An international programme committee selected 10 contributions for publication. These papers cover a variety of topics. Some touch upon optimizing compilation techniques and programming techniques for GPU applications. Others consider patterns for distributed programming, the use of functional programming in a computational science application and compilation techniques for embedded and standalone languages. In addition to the refereed contributions, FHPC'14 features an invited talk. Our original plan was to welcome Keshav Pingali but a medical emergency means that that we hope to return to this another year. Instead, Dimitrios Vytiniotis from Microsoft Cambridge will present Ziria, a Software Defined Radio platform, based on functional programming, that is easily programmable and produces high performance code. We have put together an exciting programme; we look forward to lively discussions during the third FHPC workshop, and a successful follow-up FHPC workshop at ICFP 2015.

A major obstacle in partial evaluation (program specialization) is the need for binding time improvements. By reorganizing a source program, the residual programs obtained by specializing the source program may be improved: more computations can be ...