Over the past 15 years Professor Abramson has made outstanding contributions to the programming and productivity of supercomputing ‘Grid’ applications. He has devised and implemented innovative tools and techniques that specifically address the ease with which non-expert users can make routine use of supercomputers, a theme that runs through all of his research projects.

Professor Abramson’s work addresses the technical computing software lifecycle, with the specific goals of making it easier to specify and execute large computational experiments; to deploy software to heterogeneous distributed computers; to test and debug software as it evolves; and to support computational experimentation and what-if analyses during execution. To achieve this, he has defined a new layer in the traditional software hierarchy, called upper middleware that sits between other middleware and platform services and applications. Over many years, he and his team have populated this with numerous techniques and tools.

Further, he has served the community though leadership and membership of numerous conference committees, mentored students using innovative programs that address the teaching research nexus, and provided leadership in the computing industry through startup companies. His ideas have found there way into the practice by application scientists, and have been adopted by independent software vendors.

Middleware underpinning programmer productivity

In spite of tremendous advances in middleware and internet software standards, creating high performance ‘Grid’ applications that harness geographically disparate resources is still difficult and error-prone. Programmers are presented with a range of middleware services, a raft of legacy software tools that do not address the distributed nature of the infrastructure, and many other incompatible development tools that often deal with only part of the programming problem. So, a scientist might start with an idea for an innovative experiment but quickly become distracted by technical details that have little to do with the task at hand. Moreover, the highly distributed, heterogeneous and unreliable nature of the environment makes software development extremely difficult. 

For the past 15 years, Abramson’s research has focused on finding more efficient and effective ways of developing these high performance applications.

The Software Lifecycle

All software follows a lifecycle, from development through execution, and back again. Abramson has made significant and lasting contributions covering application specification and development, deployment to remote resources, testing and debugging and execution. He has done this by building a new ‘upper middleware’ layer between end user applications and lower middleware, and has designed and built a number of tools (highlighted in the figure below) with the specific aim of enhancing programmer productivity. 

In brief, he has developed techniques, and software (marked in brackets) for:

1. specifying and automating complex parameter sweeps and searches using legacy applications (Nimrod)
2. testing and debugging scientific software as it evolves or is ported to different supercomputing platforms, using a new approach, called “relative debugging” (Guard).
3. testing and debugging large scientific applications on distributed Grids. These cover new Grid debug services and are implemented through a number of Eclipse based plug-ins (Worqbench, Grid Debug)
4. deploying software over distributed Grids (Distant and Motor). 
5. executing complex what-if simulations from spreadsheets (Active Sheets)
6. executing parameter sweeps from conventional web portals (Nimrod Portal)
7. enabling flexible communication between Grid workflow components (GriddLeS).

Here we highlight some of his most significant contributions in software development and testing and debugging. 

The Nimrod family of tools:

Grid application users don’t want to know about the complexity of the underlying fabric, and wish to concentrate on their domain science.   Difficulty in using the Grid is not a hypothetical concern. Currently, very few scientists use the Grid routinely, and instead rely on local resources, which are under their control. This means that the scale and nature of the work is limited. 

Over the years Abramson has developed a strategy for delivering the high levels of performance, and has built software tools that make it easy for scientists to leverage the computational power of the Grid. Specifically, he has developed the Nimrod family of tools that allow a non-expert to specify large computational experiments using legacy software, and execute these over a range of Grid resources. Nimrod is not a single tool: it incorporates a component that distributes computations to the resources (Nimrod/G); a component that searches for “good” solutions using non-linear optimization algorithms (Nimrod/O); a component that helps evaluate which parameter settings are important using experimental design (Nimrod/E); and a version that supports sweeps and searches on grid workflows (Nimrod/K).

Nimrod has been exploited in diverse application areas, and has widespread community adoption, supporting research in Australia, the UK, Europe, Russia, North and South America. In many cases, groups in these countries have established their own service centres in which users can connect and use Nimrod through a Web portal. Nimrod was among the first high-level tools to allow existing applications to make use of the Grid, and is one of the best-known Grid computing projects internationally. Nimrod has been widely acknowledged and was selected as a finalist in the Australian Technology Awards in 2000.

Nimrod has not only had significant expose in research circles, but is also the target of a US based software startup (Axceleon). A commercial version of Nimrod, called EnFuzion, has wide acceptance in the entertainment and energy markets.

The Guard Relative Debugger

Traditional software methodologies and tools are effective for testing and debugging software that targets a small number of platforms. When the same software needs to be executed on a large variety of systems, existing approaches become ineffective, and new techniques are required. Testing and debugging is incredibly expensive. Independent estimates suggest that 50% or more of software development time can be spent in testing and debugging, and experts waste an enormous amount of time in this phase. To meet this challenge, Abramson developed (and patented internationally) a hybrid scheme called “relative debugging”. Relative debugging makes it possible to test a new version of a program on a remotely distributed platform against other versions that are known to be correct, thereby greatly enhancing the ability to locate and fix errors in the new version of the software. Abramson produced the world’s first relative debugger, Guard, which is available for a variety of sequential and parallel computers. Relative debugging is novel and innovative, as recognized by the award of the best paper at the 1995 IEEE Supercomputing conference. It underpins PhD theses, papers in internationally refereed conferences and journals, a patent application, and a commercial product. Experiments have shown that it is possible to achieve significant time savings using relative debugging. Moreover, software quality is improved in the process. In 2002 Abramson formed GuardSoft, to commercialise the technology, and in 2007 he licensed relative debugging to Cray to underpin activities in programmer productivity as part of the DARPA HPCS program.