E

DAa

b

a

ARA

KDGCW

1

btpmtoptGcot

bsmo

1d

Journal of Computational Science 1 (2010) 41–47

Contents lists available at ScienceDirect

Journal of Computational Science

journa l homepage: www.e lsev ier .com/ locate / jocs

mbedding optimization in computational science workflows

avid Abramsona,∗, Blair Bethwaitea, Colin Enticotta, Slavisa Garica, Tom Peacheya,nushka Michailovab, Saleh Amirriazib

Faculty of Information Technology, Monash University, Clayton, 3800, Victoria, AustraliaDepartment of Bioengineering, University of California San Diego, 9500 Gilman Drive, La Jolla, USA

r t i c l e i n f o

rticle history:eceived 29 March 2010ccepted 30 March 2010

eywords:esign optimizationrid computingardiac modelsorkflows

a b s t r a c t

Workflows support the automation of scientific processes, providing mechanisms that underpin mod-ern computational science. They facilitate access to remote instruments, databases and parallel anddistributed computers. Importantly, they allow software pipelines that perform multiple complex sim-ulations (leveraging distributed platforms), with one simulation driving another. Such an environmentis ideal for computational science experiments that require the evaluation of a range of different sce-narios “in silico” in an attempt to find ones that optimize a particular outcome. However, in general,existing workflow tools do not incorporate optimization algorithms, and thus whilst users can specifysimulation pipelines, they need to invoke the workflow as a stand-alone computation within an externaloptimization tool. Moreover, many existing workflow engines do not leverage parallel and distributed

computers, making them unsuitable for executing computational science simulations. To solve this prob-lem, we have developed a methodology for integrating optimization algorithms directly into workflows.We implement a range of generic actors for an existing workflow system called Kepler, and discuss howthey can be combined in flexible ways to support various different design strategies. We illustrate thesystem by applying it to an existing bio-engineering design problem running on a Grid of distributed clusters.

. Introduction

Scientific workflows are evolving as a platform for automatingoth experimental and “in silico” science. These make it possibleo specify experiments involving a range of different real and com-utational activities, such as instrument control, data integration,odelling and analysis, and visualization. Workflows are some-

imes created using a graphical programming environment. Theutput of one activity can be passed as input to the next, forming aipeline of arbitrary complexity. Some workflow engines managehe execution across a range of distributed resources, and leveragerid computing middleware and approaches where appropriate toontrol and interact with remote resources. An enormous numberf workflow engines have been built, each with different charac-eristics and features. A good review can be found in [30].

Workflows are particularly useful for computational science,

ecause they make it possible to perform a number of differentteps (possibly on different computers) and to build a pipeline thatodels a complex process. For example, in aircraft engine design,

ne might need to compute a mesh for a given engine compo-

∗ Corresponding author. Tel.: +61 03 9905 1183; fax: +61 03 9905 5146.E-mail address: davida@csse.monash.edu.au (D. Abramson).

877-7503/$ – see front matter © 2010 Elsevier B.V. All rights reserved.oi:10.1016/j.jocs.2010.04.002

© 2010 Elsevier B.V. All rights reserved.

nent, and pass this to a finite element computation that models thestresses in the part; this process alone might involve several dif-ferent packages on different computers, in combination with someuser interaction to guide the design process. It is not difficult toimagine more complex variations on this example – we might wantto add thermodynamic models, fluid flow through the parts, etc.,resulting in very complex and large workflows.

A common use for computational models is the determinationof a system that is optimal in some sense. For example, an engineermay seek shape parameters for a component that will maximise itsfatigue life [19]. A radiotherapist may compute the dosage deliv-ered to various parts of the body in a clinical situation to find aregime tailored for the needs of each patient, maximising the doseto a tumour whilst minimising the dose to healthy tissue [10]. Or ageophysicist modelling extensional features of a stretched, brittlelayer may wish to tune the parameters in order to give the bestfit to observed faulting behaviour [22]. The efficient approach tosuch tasks is to run the models repeatedly within an optimizationalgorithm. There are many generic algorithms that can be used in

this process; the choice of the most efficient algorithm will dependon the smoothness and shape of the response surface, the graphof the optimality criterion against the parameters varied. In prac-tice the nature of that surface is unknown, so the modeller may tryvarious algorithms on the one problem. A toolkit that offers a vari-

4 omput

es

w“euciiapeettK

drtoepgt

eotssp

2

ptmptct(atnr

tcftcoofd

ifptI

2 D. Abramson et al. / Journal of C

ty of optimization algorithms is a useful to a scientific workflowystem.

Recently, we designed a range of components for an existingorkflow engine, Kepler [5,6,14,20], which allow a user to add

parameter sweep” operations to an existing workflow [2]. Thisxtension makes it possible to run a workflow repeatedly, eval-ating different input conditions. The new components generateombinations of parameter values up front, and these are streamednto the computational pipeline. Further extensions to Kepler maket possible to expose and exploit the dynamic parallelism that is cre-ted in such pipelines, making it possible to run the time consumingarts in parallel [3] on distributed high performance computers. Forxample, if there are sufficient resources available, it is possible toxecute each design scenario in parallel, without modification ofhe original workflow. This system, called Nimrod/K, is based onhe well-established Nimrod family of tools in combination withepler.

In this paper we extend our parameter sweep actors to supportesign optimization using a range of non-linear optimization algo-ithms. We design a further range of components that are suitedo optimization, using an extensible technique that allows to notnly add new techniques later, but also to mix and match differ-nt techniques using the basic building blocks. The system exploitsarallelism between independent paths in the workflow, within aiven search algorithm, and also by running multiple searches athe same time.

The paper proceeds with a general discussion of workflowngines, with a particular focus on Kepler, followed by a descriptionf the Nimrod tool family. We then show how we have integratedhe new optimization components into Kepler, producing a newystem called Nimrod/OK. We illustrate the new solution withome real case studies, and briefly compare our solution to relatedrojects.

. Scientific workflow engines

Over recent years we have developed expertise in massivelyarallel parameter sweep workflows, using the Nimrod family ofools [4]. Nimrod makes it very easy to run complex computational

odels whilst varying the input parameters – either across a com-lete sweep or as part of a search. Specifically, Nimrod containsools that perform a complete parameter sweep across all possibleombinations (Nimrod/G), or search using non-linear optimiza-ion algorithms (Nimrod/O) [26] or experimental design techniquesNimrod/E) [25]. Importantly, the number of jobs, and thus the par-llelism, can be varied at run time, and the Nimrod scheduler placesasks on the available resources at run time. However, Nimrod wasot designed to execute arbitrary workflows. Thus, it is difficult toun sweeps over workflows, and workflows containing sweeps.

Scientific workflow engines, on the other hand, allow a usero perform complex calculations by combining a set of connectedomponents, or actors. Actors represent a wide range of activitiesrom computations, to access to distributed databases and scien-ific instruments. Typically, data tokens move between actors, andan be streamed from instruments and databases, through a rangef computational processes. “Grid workflows” allow actors to runn distributed resources. They can be invoked in a variety of ways,acilitating virtual applications that span multiple organizations,ata sources and computers.

Whilst many different scientific workflow tools have been built,

n this paper we focus on Kepler [5,6,14,20]. However, many of theeatures in Kepler are similar to the other engines, and a good com-arative review can be found in [30]. Kepler’s engine orchestrateshe execution of a workflow in a controlled and repeatable manner.t builds upon Ptolemy II [16], a Java-based software framework,

ational Science 1 (2010) 41–47

including a graphical user interface called Vergil. Ptolemy II is usedfor the modelling, simulation, and design of concurrent, real-timeembedded systems. Kepler inherits a number of “directors” fromPtolemy, providing an extensive range of execution mechanisms.

In spite of their significant power, the Kepler runtime, and manyother current workflow systems, do not support dynamic parallelexecution of a workflow and its components. This means that usersmust explicitly program parallel and distributed computation intothe workflow itself, complicating and often dwarfing the basic sci-entific processes or business logic. Typically this involves addingactors to execute graph nodes in parallel – either by replicating theworkflow statically, or adding looping constructs that scatter andgather threads.

In another recent paper, we showed how to augment Keplerwith a new orchestration mechanism called the Tagged Data FlowArchitecture Director (TDA) [3]. This extends Kepler by providingpowerful mechanisms for exposing and managing parallelism inthe workflows, resulting a new tool called Nimrod/K.

In tagged token machines, tokens contain both a data field anda special tag field – or “colour”, which is used to separate threadsof execution. Importantly, an instruction fires when it has a tokenon each of its inputs that have the same colour values. Parallelismis implemented simply by creating tokens with different colours.

Tag values are manipulated by a set of special tag manipula-tion actors, although the tag flow implementation is usually hiddenfrom workflow designers. Underlying a number of the commonKepler directors (PN and SDF) are FIFO queues located on each ofthe inputs on an actor. Normally, when multiple tokens arrive on aninput port, they are queued and can be processed when the actor isavailable. Our TDA director follows the same procedure, but with aseparate queue for tokens with different tags. This means that mul-tiple tokens with the same tag value queue up, whereas tokens withdifferent tag values can be consumed in parallel. Multiple actorscannot read from the same queue because they only read fromqueues with the same tag value assigned to them, and no two actorsare given the same tag value. Importantly, this approach requiresno changes to existing actors, which are usually unaware that theyhave been cloned. More details about the TDA are available in [3].

Nimrod/K provides an ideal platform for using workflows foroptimization because it allows us to exploit parallelism withinthe computational pipeline, the optimization algorithm itself andbetween multiple optimizations. So, Nimrod/K extends the existingNimrod family of tools significantly by adding Nimrod’s parametersweep technology to Kepler.

We have already added parameter sweeps actors to Nim-rod/K [2] and shown that complete enumeration of parametercombinations, or partial combinations using experimental designtechniques, can be performed in parallel. In this paper we show howwe have extended this to support non-linear optimization opera-tions that can be used in combination with existing workflows toform “Optimization Workflows”.

3. Optimization using Nimrod/O

Before exploring the new optimization actors we have addedto Kepler, we discuss how Nimrod/O can be used to perform auto-matic optimization using an existing computational model. Thereare two types of situation where the user of a computationalmodel may wish to optimize some aspect of the output. The firstoccurs in system design where a simulation of a physical, financial

or behavioural system is used to optimize some output, maxi-mal performance or durability, say, or minimal cost or risk. Theother situation is more common in computational modelling wherethe inputs are unknown but the outputs are required to fit someexpected or observed values. This latter class, called inverse prob-

omputational Science 1 (2010) 41–47 43

lbbd

paOcbfmfws

tovmsrbopis

miwleiaafe

aottavviaatatj

4

flfaaKtfs

D. Abramson et al. / Journal of C

ems, are approached as optimizations, minimising the differenceetween observed and desired outputs. Both types of problem haveeen successfully solved using Nimrod/O across a wide range ofisciplines [15,26,24,1,27].

The types of optimization algorithms used for both classes ofroblems are iterative, starting from some point in the search spacend normally converging to some (potentially local) optimum.ften the search space will have multiple local optima. Further,omputational models often include noise in their outputs, causedy discretization errors for physical models, or finite sample errorsor Monte-Carlo simulations. This noise may add spurious local

inima to the search landscape. Consequently, multiple searches,rom a variety of starting points, are commonly used to determinehether the optima found are global optimum, and because each

earch is independent, they can be executed in parallel.A large variety of search algorithms have been employed for this

ask. The efficacy and efficiency of each depends on the nature of thebjective landscape. For example, the BFGS algorithm [8] convergesery rapidly if that landscape is sufficiently smooth. However, theethod employs estimates of the downhill direction, which may be

eriously compromised if the surface is noisy. In such cases a moreobust method such as the Nelder–Mead simplex algorithm maye more effective [23]. For models of systems with discontinuousbjective functions, such as structural buckling [12], or allocationroblems [8], downhill information may be tenuous, and biolog-

cally inspired methods such as genetic algorithms may be moreuited.

When faced with these issues it is often difficult to choose theost appropriate algorithm in advance. Accordingly, we have found

t is often necessary to try a variety of different algorithms, eachith multiple starting points to address the problem of multiple

ocal minima. Nimrod/O expedites such an approach by making itasy for a user to specify the use of multiple algorithms, and further,t executes these multiple searches in parallel to solve the problems quickly as possible. Further, each iteration of an algorithm usu-lly involves execution jobs in batches, depending on the potentialor internal parallelisation of the algorithm. Nimrod/O will executeach batch in parallel where possible.

This parallelism has led to modification of search algorithms,nd reassessment of their efficiency [26]. If the user is concernednly with the wall clock time for convergence of an algorithm thenhe number of batches, rather than the number of jobs, becomeshe salient measure of efficiency. Our implementation of variouslgorithms often takes advantage of this fact. For example, in theenerable Hooke and Jeeves algorithm [13], the “exploration phase”aries each coordinate of the current point up or down until anmprovement is detected, a serial search evaluation one point at

time. If n is the dimensionality of the search space then therere potentially 3n points that might be reached. Our implementa-ion has an option called “parallel Hooke and Jeeves” that evaluatesll these possible points concurrently. Such a variant may makehe method more competitive with alternative algorithms whenudged by the number of batches required.

. Nimrod/OK – optimization workflows

Optimization algorithms may themselves be viewed as work-ows, usually involving repetitive looping so that results are passed

rom one iteration to the next. But optimization codes are tradition-lly monolithic with various components tailored to a particular

lgorithm. Implementing the functionality of Nimrod/O within theepler workflow engine exposes the components of the optimiza-

ion process, giving the user a clear view of the data flows andacilitating substitution of these components. The result is an exten-ion of Kepler that we have termed Nimrod/OK.

Fig. 1. Optimization as a workflow.

Fig. 1 shows a possible workflow associated with the commonlyused the Nelder–Mead Simplex optimization algorithm [23]. First,the domain of the search is defined by specification of the inputparameters, their nature (floats, integers or text parameters) andranges. Within this domain the next component will select startingpoints for the multiple optimizations. Each starting point will begina simplex search. The search algorithm generates sets of points thatare sent for evaluation, a “batch of jobs” in Nimrod/O’s terminology.Running the models represented by these jobs produces numericalresults that are used to decide the next generation of points. Thiscycle continues until some convergence criterion has been achievedwhereupon a final point is forwarded as the result of the search.Fig. 1 also shows a component that evaluates constraint conditionsimposed by the user. This calculates the margin by which a searchpoint violates any constraints, and imposes penalties accordingly.If the constraint is a “hard” one then the point is completely forbid-den, obviating the need for model evaluation.

Implementing such optimizations as a workflow, the fundamen-tal decision is whether to treat the components as persistent statefulor stateless (functional) actors. Actor state includes the memory ofthe domain, for example, the starting point and other informationrepresenting the state of the optimization. The alternative is notto store the state in the actors, but to circulate such informationaround the workflow with the point sent for evaluation. We havechosen the latter as the more flexible solution. It enables modifica-tion of these settings by the insertion of monitor/control actors. Itallows workflows to be diverted into novel paths, for example theresults of one algorithm may, after some number of iterations, besent to a different algorithm. Our mechanism for forwarding thisstate information is the Tagged Data Flow Architecture of Nimrod/K.(This tags the job information with a Java object that contains allthe information required.)

Fig. 2 shows a sample Kepler workflow in Nimrod/OK. The Definesearch space actor and the Select search space points actor corre-spond to the Domain Definer and Points Generator of Fig. 1. Theuser enters appropriate specifications into these actors by settingthe actors’ parameters. In this implementation the initial pointsmay be selected randomly, or be regularly spaced throughout the

domain, or be specified directly.

The points selected are forwarded to a Simplex Optimizationactor, which initiates several simplex searches, one for each start-ing point. These searches produce batches of jobs that are sent to

44 D. Abramson et al. / Journal of Comput

Fig. 2. Use of new optimization actors.

ttarftatWtp

tsdcw

Nsst

Fig. 3. Use of multiple optimization algorithms.

he evaluation actor, in this case one that runs a MATLAB computa-ional model. The results from the MATLAB actor are then sent to anctor that computes the RMS error, illustrating that optimizationuns can be performed across pipelines of computations. Settingsor the optimization, such as the precise variant of the algorithm,he convergence criterion, and the action to take if a job fails, maylso be entered as optimization actor parameters. Conveniently,hese settings may be modified whilst the optimization proceeds.

hen convergence is obtained, the final optima are forwarded tohe Display actor. Statistics on the optimizations are sent to Dis-lay2.

A more complex optimization is shown in Fig. 3. After the selec-ion of the initial points, the workflow branches into two separateearch algorithms: simplex and Hooke–Jeeves. Under the Nimrodirector these optimizations will (where resources allow) run con-urrently. Both actors forward jobs to the Kepler expression actor,hich supplies the objective function in this example.

The workflow shown in Fig. 4 illustrates the flexibility ofimrod/OK, performing optimizations within a wider parameter

weep. The sweep actor (previously described in [3]) performs aweep over one of the input parameters; each value of that parame-er then spawns a separate search. (Such an approach is convenient

Fig. 4. Optimizations within a sweep.

ational Science 1 (2010) 41–47

where some of the parameters are discrete values.) Here the searchalgorithm is a subdivision search that repeatedly refines the domainas indicated by evaluation at a grid of points. This is applied for afew iterations. The best point found is then diverted to a simplexsearch.

It is worth highlighting the significant differences between thenew functionality discussed here and our previous implemen-tations of Nimrod/O. Nimrod/O optimization algorithms are selfcontained, and can only be altered by changing the code of Nim-rod/O itself. Importantly, they cannot be combined with each other.Nimrod/OK exposes key components in each optimization algo-rithm, allowing them to be reconfigured and used in novel ways(as shown in Fig. 4). This allows optimization algorithms to sharecommon functions (like defining the search space, detecting startpoints, etc.), and the sharing is obvious by examining the work-flow. Further, new optimization algorithms (or components) can beintegrated more easily because they are added as new actors, ratherthan by modifying the existing code base. Finally, and perhaps mostimportantly, Nimrod/O does not allow pipelines of computationswhere each step might run on a different platform. In contrast,Nimrod/OK does this because it leverages an existing workflowengine, Kepler, plus our additions in Nimrod/K that exploit par-allelism transparently. Whilst our examples only illustrate smallpipelines, clearly, they can be arbitrarily complex.

5. Case study

Here we further illustrate the new optimization actors by solv-ing an inverse problem in cardiac electro-physiology research. Theelectrical activity of the heart is based on cycles of ion transfer viacell surface membrane. There has been much research on devel-oping robust and accurate models of myocyte behaviour so thatin silico experiments can be performed on complete cardiac sys-tems. The research has significance from basic science through totherapeutic drug design.

The Shannon–Bers model [28] is a system of coupled differ-ential equations that mimic the ionic flows in rabbit heart cells.In [21], the authors have extended this model to investigate theeffects of addition of metabolic factors on the ventricular myocyteexcitation–contraction coupling. The model is implemented usingMATLAB. In order to validate the model, some final outputs werecompared against experimentally known values. This involvedexploring a range of numbers for nine input metabolic constantsand selecting the combination which produced the closest outputto the desired value.

This is a typical inverse problem, approached by minimisingthe sum of the squares of the differences between model valuesand experimental ones. Our first demonstration repeats this opti-mization using Nimrod/OK with the workflow shown in Fig. 2. Itdemonstrates that the system can utilise proprietary software.

A 9-dimensional optimization may be computationally expen-sive. However, a fractional factorial investigation using Nimrod/Einto the effects of these nine inputs suggested that they fell into fourmutually exclusive groups that showed no interaction betweengroups [7]. This indicated that four separate optimizations, oneover each subgroup, would be more efficient. A second experiment,shown in Fig. 5, ran these four searches as a single workflow. Toachieve this, the Define search space actors were customized withsome of parameters specified as constants, allowing only the activeparameters to vary. The searches are 2, 1, 3 and 3-dimensional,

respectively.

Again, we highlight that it would not be possible to implementthe workflow shown in Fig. 5 with original Nimrod/O tool. Insteadwe would have had to execute 4 independent Nimrod/O runs withsignificant additional complexity.

D. Abramson et al. / Journal of Computational Science 1 (2010) 41–47 45

Fig. 5. Partition of the optimization domain.

dca

Twaasob

lnttvi5rfib

Fig. 7. Job concurrency for subdomain searches.

TP

Fig. 6. Job concurrency for full domain search.

Experiment 1 performed simplex searches over the 9-imensional space, using the workflow shown in Fig. 2. Theomputations are performed on a distributed Grid of Linux clusters,s shown in Table 1.

128 starting points were randomly selected within the domain.able 2 summarises the results of these searches, showing the best,orst and average search results. We also show the number of jobs

nd batches required to achieve the best and worst results, and theverage number of jobs and batches. The best search gave a con-iderably better (smaller) result than the average, at the expensef more computational effort as shown by the numbers of jobs andatches of jobs. This shows the utility of multiple searches.

Job executions averaged 3 m 21 s, but with substantial paral-elism the full experiment was completed in 7 h 37 m. Fig. 6 plots theumber of jobs executing over the duration of the experiment. Ini-ially the simplex method evaluates the objective at the vertices ofhe starting simplex. In this case each of the simplexes has ten suchertices, so the experiment began with 1280 jobs. Thereafter, most

terations require just four new evaluations, so the load dropped to12 jobs, except for the occasional peak where a new simplex wasequired. As searches completed the load dropped in stages; thenal longest running optimization required only four processorsut dominated the experiment wall clock time.

able 1roperties of the Grid Testbed.

Machine # Cores Hardware

East 160 Intel(R) Xeon(R64 Intel(R) Xeon(R

West 160 Intel(R) Xeon(RSouth 160 Intel(R) Xeon(R

Fig. 8. Job concurrency for both experiments.

The second experiment used the configuration shown in Fig. 5.This time, 32 optimizations were used for each of the four domains,with randomly selected starting points. Although this generated128 parallel searches, these had low dimensionality and hencerequired smaller initial batches.

Each parameter, in the optimizations where it was varied,attained a best value close to that for the 9-dimensional search.However the lower dimensionality promoted faster convergence asshown in Fig. 7. This is demonstrated in Fig. 8, which superimposesa plot of the concurrency of Experiment 2 on that for Experiment1. Execution wall clock time was 1 h 23 m, a substantial reductionover Experiment 1.

6. Related work

Our work has many similarities with that of Crick et al.[11], which recognises the significant advantages in combiningoptimization tools with existing “generic” workflow tools. One dif-ference is the choice of workflow engine, Kepler as opposed to

Taverna [15], and in particular the extensions in Nimrod/K thatsupport dynamic parallelism in the workflow [17]. This meansthat optimization algorithms that have internal parallelism, suchas Simplex and Genetic Algorithms, can exploit multiple processestransparently. Further, it is simple to combine a parameter sweep

Location

) E5310 @ 1.60 GHz Monash University, Melbourne) 5160 @ 3.00 GHz

) E5310 @ 1.60 GHz Deakin University, Geelong) E5310 @ 1.60 GHz RMIT, Melbourne

46 D. Abramson et al. / Journal of Comput

Table 2Results for searches over the full domain.

Index Objective Jobs Batches

acdw

gfuGwgcKtaaeee

7

rTsmaIrCG

nfflTtee

otv

ocsap

A

uiiC

[

[

[

[

[[

[

[[[

[

[

[

[

[

[

[

[

[

Min 0.00042 154 37Average 0.0015 142 35Worst 0.0038 34 7

ctor with an optimization run to perform multiple searches con-urrently. But more importantly, we have developed a library ofifferent optimization components that can be mixed in powerfulays.

Our work also has a lot in common with Geodise, where theoal is to “expose optimization services in a flexible, generic inter-ace that can be easily integrated into various environments andsed to compose different optimization workflows.” [29,18]. Ineodise, optimization algorithms are exposed as Web services,hich can be invoked by a workflow system, or any other pro-

ramming language that can execute Web service calls. In ourase we have embedded our work in an existing workflow engine,epler, and have built Kepler actors that perform the optimiza-

ion functions. We are exploring building hybrid optimizationlgorithms by combining different actors, and this is presum-bly possible within Geodise, although we have not seen anxample of such a workflow. As discussed above, the Nimrod/Kngine allows us to exploit parallelism in the workflow transpar-ntly.

. Conclusion

Nimrod/OK recasts then traditional tasks of optimizing theesults of computational models within the workflow paradigm.his adds flexibility to the design of such experiments as demon-trated by the various workflows shown where various searchethods are connected in novel configurations. This work lever-

ges the wide offering of workflow actors supplied by Kepler.t also builds upon the Nimrod/K framework allowing concur-ent execution of the computational models, utilising multiplePUs on a local machine or the resources of a computationalrid.

Whilst the implementation shown here uses Kepler, the tech-iques could be applied to any number of workflow systems. The

actoring of optimization components is independent of the work-ow tool, and these could be mapped into other systems such asaverna and Triana. However, Nimrod/K is somewhat unique inhe way it exposes parallelism, and this would need to be consid-red if the optimization algorithms were added to other workflowngines.

This paper has demonstrated the usefulness of the approachn an important computational biology application, calibration ofhe input metabolic constants in a computational model of rabbitentricular myocytes.

In future developments, we plan to expand the range ofptimization algorithms implemented, and then explore novelombinations of these. For example, combining some greedy localearch heuristics in an evolutionary algorithm, such as a geneticlgorithm, might improve the overall search. Deft choice of com-onents should make this possible.

cknowledgements

This project is supported by the Australian Research Councilnder the Discovery grant scheme. We acknowledge our colleagues

n the MeSsAGE Lab. at Monash University and the Cardiac Mechan-cs Lab. at UCSD, and the contribution of the Monash e-Researchentre. We also acknowledge the US NSF funded PRIME project,

[

[

ational Science 1 (2010) 41–47

(supporting Amirriazi and Chitters) and thank colleagues, in par-ticular Peter Arzberger, for their strong support.

References

[1] D. Abramson, A. Lewis, T. Peachey, C. Fletcher, An Automatic DesignOptimization Tool and its Application to Computational Fluid Dynamics, Super-Computing 2001, Denver, November 2001.

[2] D. Abramson, B. Bethwaite, C. Enticott, S. Garic, T. Peachey, Parameter SpaceExploration using Scientific Workflows, ICCS 2009, SU Center for Computation& Technology, Baton Rouge, Louisiana, U.S.A., May 25–27, 2009.

[3] D. Abramson, C. Enticott, I. Altinas, Nimrod/K: Towards Massively ParallelDynamic Grid Workflows, IEEE Supercomputing 2008, Austin, Texas, November2008.

[4] D. Abramson, J. Giddy, L. Kotler, High Performance Parametric Modelingwith Nimrod/G: Killer Application for the Global Grid, in: Int’l. Paralleland Distributed Processing Symposium (IPDPS), Cancun, Mexico, May 2000.www.messagelab.monash.edu.au/nimrod/.

[5] I. Altintas, C. Berkley, E. Jaeger, M. Jones, B. Ludäscher, S. Mock, Kepler: Towardsa Grid-Enabled System for Scientific Workflows, in the Workflow in Grid Sys-tems Workshop in GGF10 – The 10th Global Grid Forum, Berlin, March 2004.

[6] I. Altintas, A. Birnbaum, K. Baldridge, W. Sudholt, M. Miller, C. Amoreira, Y.Potier, B. Ludaescher, A Framework for the Design and Reuse of Grid Workflows,Intl. Workshop on Scientific Applications on Grid Computing (SAG’04), LNCS3458, Springer, 2005.

[7] S. Amirriazi, S. Chang, T. Peachey, D. Abramson, A. Michailova, Optimizing Car-diac Excitation-Metabolic Model By Using Parallel Grid Computing, Biophysics2008, Long Beach, California, February 2008.

[8] C.G. Broyden, The Convergence of a Class of Double-rank Minimization Algo-rithms, Journal of the Institute of Mathematics and Its Applications 6 (1970)76–90.

10] P.W. Chin, D.G. Lewis, J.P. Giddy, A Monte Carlo solution for external beam pho-ton radiotherapy verification, The Monte Carlo Method: Versatility Unboundedin a Dynamic Computing World, Chattanooga, Tennessee, April 2005, 17–21.

11] T. Crick, P. Dunning, H. Kim, J. Padget, Engineering design optimization usingservices and workflows, Philosophical Transactions of the Royal Society A 367(2009) 2741–2751.

12] B.G. Falzon, D. Hitchings, An Introduction to Modelling Buckling and Collapse,NAFEMS, 2006.

13] R. Hooke, T.A. Jeeves, Direct search solution of numerical and statistical prob-lems, Journal of the ACM 8 (1961) 212–229.

14] http://kepler-project.org/, accessed 10 March 2010.15] http://messagelab.monash.edu.au/EScienceApplications/, accessed 10 March

2010.16] http://ptolemy.eecs.berkeley.edu/ptolemyII/ptIIfaq.htm, accessed 10 March

2010.17] http://www.taverna.org.uk/, accessed 10 March 2010.18] http://www.geodise.org/, accessed 10 March 2010.19] R. Jones, D. Peng, P. Chaperon, M. Tan, D. Abramson, T. Peachey, Structural opti-

mization with damage tolerance constraints, Theoretical and Applied FractureMechanics 43 (2005) 133–155.

20] B. Ludäscher, I. Altintas, C. Berkley, D. Higgins, E. Jaeger-Frank, M. Jones, E. Lee,J. Tao, Y. Zhao, Scientific Workflow Management and the Kepler System, Con-currency and Computation: Practice & Experience, Special Issue on Workflowin Grid Systems 18 (2006) 1039–1065.

21] A. Michailova, W. Lorentz, A. McCulloch, Modelling transmural heterogeneityof KATP current in rabbit ventricular myocytes, AJP-Cell Physiology 293 (2007)C542–C557.

22] L. Moresi, D. May, T. Peachey, C. Enticott, D. Abramson, T. Robinson, CapturingIntuition through Interactive Inverse Methods: Examples drawn from Mechan-ical Non-Linearities in Structural Geology, Eos, Transactions of the AGU, 85(2004), Fall Meeting Supplement.

23] J.A. Nelder, R. Mead, A simplex method for function minimization, ComputerJournal 7 (1965) 308–313.

24] T.C. Peachey, C.M. Enticott, Determination of the best constant in an inequalityof Hardy, Littlewood and Polya, Experimental Mathematics 15 (2006) 43–50.

25] T.C. Peachey, N.T. Diamond, D.A. Abramson, W. Sudholt, A. Michailova, S.Amirriazi, Fractional factorial design for parameter sweep experiments usingNimrod/E, Journal of Scientific Programming 16 (2008) 217–230.

26] T. Peachey, D. Abramson, A. Lewis, Model optimization and parameter esti-mation with Nimrod/O, in: The International Conference on ComputationalScience, May 28–31, University of Reading, 2006.

27] T. Peachey, D. Abramson, A. Lewis, D. Kurniawan, R. Jones, Optimization usingNimrod/O and its Application to Robust Mechanical Design, PPAM 2003, Czesto-chowa, Poland, Lecture Notes in Computer Science 3019 (2004) 730–737.

28] T.R. Shannon, F. Wang, J. Puglisi, C. Weber, D.M. Bers, A mathematical treatment

of integrated Ca dynamics within the ventricular myocyte, Biophysical Journal87 (2004) 3351–3371.

29] G. Xue, W. Song, S.J. Cox, A.J. Keane, Numerical optimization as grid services forengineering design, Journal of Grid Computing 2 (2004) 223–238.

30] J. Yu, R. Buyya, A taxonomy of workflow management systems for grid com-puting, Journal of Grid Computing 3 (2005) 171–200.

omput

and has received over $8 million in research funding. He also has a keen interestin R&D commercialization and consults for Axceleon Inc, who produce an industrystrength version of Nimrod, and Guardsoft, a company focused on commercialising

D. Abramson et al. / Journal of C

David Abramson has been involved in computer archi-tecture and high performance computing research since1979. Previous to joining Monash University in 1997,he has held appointments at Griffith University, CSIRO,and RMIT. At CSIRO he was the program leader of theDivision of Information Technology High PerformanceComputing Program, and was also an adjunct Associate

Professor at RMIT in Melbourne. He served as a pro-gram manager and chief investigator in the Co-operativeResearch Centre for Intelligent Decisions Systems and theCo-operative Research Centre for Enterprise DistributedSystems. Abramson is currently an ARC Professorial Fel-low; Professor of Computer Science in the Faculty of

ational Science 1 (2010) 41–47 47

Information Technology at Monash University, Australia, and science director of theMonash e-Research Centre. Abramson has served on committees for many confer-ences and workshops, and has published over 200 papers and technical documents.He has given seminars and received awards around Australia and internationally

the Guard relative debugger. Abramson’s current interests are in high performancecomputer systems design and software engineering tools for programming paralleland distributed supercomputers.