Category Archives: Applications

Contour lines are essential in the mapping and comprehension of hurricane data. However, larger sets of data require more time to be processed. This issue is compounded by the increasing granularity of information output by modern models and can be a significant expenditure of computational resources and time when executed serially. To address this issue, I use the HPX library to generate contour lines on multiple processors simultaneously.Continue reading →

Currently the GPU Technology conference is ongoing. Together with the HPX Backend for LibGeoDecomp Andreas Schäfer submitted a poster about a scalable MMORPG design which eventually will use HPX to make it scale. The title of the poster is A Scalable Backend for True MMORPGs.

HPX is great for developing applications that run both in a shared memory and distributed memory environment. This is accomplished by leveraging the Active Global Address Space (AGAS). By creating components in AGAS we gain the ability to seamlessly write parallel object oriented applications without the need to manually care about passing messages to different localities of explicitly creating threads. While this idea sounds great it is difficult to think about an implementation which achieves exactly that. As such this blog post is trying to walk you through the development of a recursive back tracking brute force solver for combination puzzles and you will discover that recursion allows us in general to exploit parallelism.

This is the first post in a series. This article series will walk you through the complete lifecycle of an HPX application. From the first basic idea, which is covered in this post to a full fledged HPX application exploiting the unique features of HPX to write programs with a unified semantic for local and possibly remote access to objects. The idea to develop such an application was given by Andreas Schäfer who challenged me to beat his MPI implementation. We’ll see how we fared in the last post of this series.

It’s been a while since the last post on this blog representing new development in the HPX world. We are not dead and are still working on providing a new and unique experience to the world of parallel computing! One of our latest efforts was to bring HPX to Android devices. Android is an exciting platform which grew very popular recently.

Having your application work with HPX is unfortunately not as simple as just linking against it. However it can be rather straightforward or rather complex based on the type of application that is trying to be integrated. The complexity derives from the overall design of the application. If the application was designed to be parallel, then integrating should be relatively straightforward. However HPX is not some magic wand that will make your application work in parallel. Applications that are serial or that rely too heavily on global variables will have a more difficult time in integrating. Most parallel applications have already identified the sections of code that do the most work and have abstracted them out to use the parallel library of their choice.Continue reading →

Writing applications with HPX is not difficult. We tried to develop an API which conforms to the usual semantics of with the host language C++. This post is a first in a planned series of articles meant to introduce the concepts of writing HPX applications. As any introduction to a new programming language or programming paradigm, we will start with writing the smallest possible program (historically, this is a program which prints “Hello World!” only). Even if it’s very small it will give sufficient material to explain basic concepts.

One of the core features of HPX is our lightweight user-level threading. User-level threading implements a second layer of thread infrastructure on top of OS-threads (e.g. thread implementations provided by the operating system or kernel). This form of threading is also called hybrid or M:N (mapping N user threads onto M OS-threads) threading.

We recently conducted a benchmark of the scalability of lightweight user-level threads in the face of extremely fine-grained parallelism. Fine-grained parallelism refers to the division of work into very small parallel tasks. By making the tasks very small, the task scheduler is able to load balance more efficiently in the face of highly dynamic applications.

This article presents details of the benchmark we used, and a comparison of HPX with three other software libraries which provide lightweight user-level threading (Qthreads, TBB and SWARM). Continue reading →

The n-body problem, i.e. the prediction of the motion of a group of objects that interact with each other under the influence of a force, is a method that continues to present a computational challenge to scientist in a broad range of application areas, like astrophysics or computational biology. Existing codes are usually scaling-challenged causing overly long runtimes for real-world problem sizes. We hope to overcome some of the challenges that face computing an n-body problem by using a message driven, inherently asynchronous approach based on the HPX (High-Performance ParalleX) library. Continue reading →