Ensuring the long-term reproducibility of data analyses requires results stability tests to verify that analysis results remain within acceptable variation bounds despite inevitable software updates and hardware evolutions. This paper introduces a numerical variability approach for results stability tests, which determines acceptable variation bounds using random rounding of floating-point calculations. By applying the resulting stability test tofMRIPrep, a widely-used neuroimaging tool, we show that the test is sensitive enough to detect subtle updates in image processing methods while remaining specific enough to accept numerical variations within a reference version of the application. This result contributes to enhancing the reliability and reproducibility of data analyses by providing a robust and flexible method for stability testing.

Summary The general increase in data size and data sharing motivates the adoption of Big Data strategies in several scientific disciplines. However, while several options are available, no particular guidelines exist for selecting a Big Data engine. In this paper, we compare the runtime performance of two popular Big Data engines with Python APIs, Apache Spark, and Dask, in processing neuroimaging pipelines. Our experiments use three synthetic neuroimaging applications to process the 606 GB BigBrain image and an actual pipeline to process data from thousands of anatomical images. We benchmark these applications on a dedicated HPC cluster running the Lustre file system while using varying combinations of the number of nodes, file size, and task duration. Our results show that although there are slight differences between Dask and Spark, the performance of the engines is comparable for data‐intensive applications. However, Spark requires more memory than Dask, which can lead to slower runtime depending on configuration and infrastructure. In general, the limiting factor was the data transfer time. While both engines are suitable for neuroimaging, more efforts need to be put to reduce the data transfer time and the memory footprint of applications.

Numerical stability is a crucial requirement of reliable scientific computing. However, despite the pervasiveness of Python in data science, analyzing large Python programs remains challenging due to the lack of scalable numerical analysis tools available for this language. To fill this gap, we developed PyTracer, a profiler to quantify numerical instability in Python applications. PyTracertransparently instruments Python code to produce numerical traces and visualize them interactively in a Plotly dashboard. We designed PyTracerto be agnostic to numerical noise model, allowing for numerical profiling through Monte-Carlo Arithmetic, random rounding, random data perturbation, or structured noise for a particular application. We illustrate PyTracer's capabilities by testing the numerical stability of key functions in both SciPy and Scikit-learn, two dominant Python libraries for mathematical modeling. Through these evaluations, we demonstrate PyTraceras a scalable, automated, and generic framework for numerical profiling in Python.

Supervised learning algorithms generally assume the availability of enough memory to store data models during the training and test phases. However, this assumption is unrealistic when data comes in the form of infinite data streams, or when learning algorithms are deployed on devices with reduced amounts of memory. Such memory constraints impact the model behavior and assumptions. In this paper, we show that under memory constraints, increasing the size of a tree-based ensemble classifier can worsen its performance. In particular, we experimentally show the existence of an optimal ensemble size for a memory-bounded Mondrian forest on data streams and we design an algorithm to guide the forest toward that optimal number by using an estimation of overfitting. We tested different variations for this algorithm on a variety of real and simulated datasets, and we conclude that our method can achieve up to 95% of the performance of an optimally-sized Mondrian forest for stable datasets, and can even outperform it for datasets with concept drifts. All our methods are implemented in the OrpailleCC open-source library and are ready to be used on embedded systems and connected objects.

Neuroimaging study results can vary significantly depending on the datasets and processing pipelines utilized by researchers to run their analyses, contributing to reproducibility issues. These issues are compounded by the fact that there are a large variety of seemingly equivalent tools and methodologies available to researchers for processing neuroimaging data. Here we present NeuroCI, a novel software framework that allows users to evaluate the variability of their results across multiple pipelines and datasets. NeuroCI makes use of Continuous Integration (CI), a software engineering technique, to facilitate the reproducibility of computational experiments by launching a series of automated tests when code or data is added to a repository. However, unlike regular CI services, our CI-based framework uses distributed computation and storage to meet the large memory and storage requirements of neuroimaging pipelines and datasets. Moreover, the framework's modular design enables it to continuously ingest pipelines and datasets provided by the user, and to compute and visualize results across multiple different pipelines and datasets. This allows researchers and practitioners to quantify the variability and reliability of results in their domain across a large range of computational methods.

Road accidents have a high societal cost that could be reduced through improved risk predictions using machine learning. This study investigates whether telemetric data collected on long-distance trucks can be used to predict the risk of accidents associated with a driver. We use a dataset provided by a truck transportation company containing the driving data of 1,141 drivers for 18 months. We evaluate two different machine learning approaches to perform this task. In the first approach, features are extracted from the time series data using the FRESH algorithm and then used to estimate the risk using Random Forests. In the second approach, we use a convolutional neural network to directly estimate the risk from the time series data. We find that neither approach is able to successfully estimate the risk of accidents on this dataset, in spite of many methodological attempts. We discuss the difficulties of using telemetric data for the estimation of the risk of accidents that could explain this negative result.

Information systems such as cellular networks produce large volumes of data, making the characterization of network faults a difficult task. In this work, we introduce a new fault analysis framework based on association rule mining and validate it to identify the root cause of faults in information systems. The paper describes a strategy using association rules to specifically target faults while improving runtime performance relative to the standard Apache Spark implementation. We also introduce a novel association rule filtering strategy called Cover Set filtering that prunes and merges rule sets to produce high-quality, concise and interpretable results. The proposed framework is evaluated with real-world telecommunication datasets. Comparing this framework approach with other strategies, we demonstrate a better rule diversity in general and a sufficiently compact analysis of the faults. The validation of our experimental results was conducted by telecommunications experts, who confirmed the clarity and value of the results for a quantitative assessment of cellular network failures.

Mondrian Forests are a powerful data stream classification method, but their large memory footprint makes them ill-suited for low-resource platforms such as connected objects. We explored using reduced-precision floating-point representations to lower memory consumption and evaluated its effect on classification performance. We applied the Mondrian Forest implementation provided by OrpailleCC, a C++ collection of data stream algorithms, to two canonical datasets in human activity recognition: Recofit and Banos et al. Results show that the precision of floating-point values used by tree nodes can be reduced from 64 bits to 8 bits with no significant difference in F1 score. In some cases, reduced precision was shown to improve classification performance, presumably due to its regularization effect. We conclude that numerical precision is a relevant hyperparameter in the Mondrian Forest, and that commonly-used double precision values may not be necessary for optimal performance. Future work will evaluate the generalizability of these findings to other data stream classifiers.

The emergence of Big Data in recent years has resulted in a growing need for efficient data processing solutions. While infrastructures with sufficient compute power are available, the I/O bottleneck remains. The Linux page cache is an efficient approach to reduce I/O overheads, but few experimental studies of its interactions with Big Data applications exist, partly due to limitations of real-world experiments. Simulation is a popular approach to address these issues, however, existing simulation frameworks do not simulate page caching fully, or even at all. As a result, simulation-based performance studies of data-intensive applications can lead to misleading results and inaccurate conclusions.In this paper, we propose an I/O simulation model that captures the key features of the Linux page cache. We have implemented this model as part of the WRENCH workflow simulation framework, which itself builds on the popular Sim-Grid distributed systems simulation framework. Our model and its implementation enable the simulation of both single-threaded and multithreaded applications, and of both writeback and writethrough caches for local or network-based filesystems. We evaluate the accuracy of our model in different conditions, including sequential and concurrent applications, as well as local and remote I/Os. We find that our page cache model reduces the simulation error by up to an order of magnitude when compared to state-of-the-art, cacheless simulations. Our model is publicly available in the WRENCH framework, making it usable in a wide range of simulation studies.

Open-access neuroimaging datasets have reached petabyte scale and continue to grow. The ability to leverage the entirety of these datasets is limited to a restricted number of research laboratories with both the capacity and infrastructure to process the data. Whereas Big Data engines have significantly reduced application performance penalties with respect to data movement, their applied strategies (e.g. data locality, in-memory computing and lazy evaluation) are not necessarily practical within neuroimaging workflows where intermediary results may need to be materialized to shared storage for post-processing analysis. In this paper we evaluate the performance advantage brought by Intel®Optane™ DC persistent memory for the processing of large neuroimaging datasets using the two available configurations modes: Memory mode and App Direct mode. We employ a synthetic algorithm on the 76 GiB and 603 GiB BigBrain, as well as apply a standard neuroimaging application on the Consortium for Reliability and Reproducibility (CoRR) dataset using 25 and 96 parallel processes in both cases. Our results show that the performance of applications leveraging persistent memory is superior to that of other storage devices, with the exception of DRAM. This is the case in both Memory and App Direct mode, irrespective of the amount of data and parallelism. Furthermore, persistent memory in App Direct mode is believed to benefit from the use of DRAM as a cache for writing when output data is significantly smaller than available memory. We believe the use of persistent memory will be beneficial to both neuroimaging applications running on HPC or visualization of large, high-resolution images.

Road accidents are an important issue of our modern societies, responsible for millions of deaths and injuries every year in the world. In Quebec only, in 2018, road accidents are responsible for 359 deaths and 33 thousands of injuries. In this paper, we show how one can leverage open datasets of a city like Montreal, Canada, to create high-resolution accident prediction models, using big data analytics. Compared to other studies in road accident prediction, we have a much higher prediction resolution, i.e., our models predict the occurrence of an accident within an hour, on road segments defined by intersections. Such models could be used in the context of road accident prevention, but also to identify key factors that can lead to a road accident, and consequently, help elaborate new policies. We tested various machine learning methods to deal with the severe class imbalance inherent to accident prediction problems. In particular, we implemented the Balanced Random Forest algorithm, a variant of the Random Forest machine learning algorithm in Apache Spark. Interestingly, we found that in our case, Balanced Random Forest does not perform significantly better than Random Forest. Experimental results show that 85% of road vehicle collisions are detected by our model with a false positive rate of 13%. The examples identified as positive are likely to correspond to high risk situations. In addition, we identify the most important predictors of vehicle collisions for the area of Montreal: the count of accidents on the same road segment during previous years, the temperature, the day of the year, the hour and the visibility.

Neuroimaging datasets are rapidly growing in size as a result of advancements in image acquisition methods, open-science and data sharing. However, the adoption of Big Data processing strategies by neuroimaging processing engines remains limited. Here, we evaluate three Big Data processing strategies (in-memory computing, data locality and lazy evaluation) on typical neuroimaging use cases, represented by the BigBrain dataset. We contrast these various strategies using Apache Spark and Nipype as our representative Big Data and neuroimaging processing engines, on Dell EMC's Top-500 cluster. Big Data thresholds were modeled by comparing the data-write rate of the application to the filesystem bandwidth and number of concurrent processes. This model acknowledges the fact that page caching provided by the Linux kernel is critical to the performance of Big Data applications. Results show that in-memory computing alone speeds-up executions by a factor of up to 1.6, whereas when combined with data locality, this factor reaches 5.3. Lazy evaluation strategies were found to increase the likelihood of cache hits, further improving processing time. Such important speed-up values are likely to be observed on typical image processing operations performed on images of size larger than 75GB. A ballpark speculation from our model showed that in-memory computing alone will not speed-up current functional MRI analyses unless coupled with data locality and processing around 280 subjects concurrently. Furthermore, we observe that emulating in-memory computing using in-memory file systems (tmpfs) does not reach the performance of an in-memory engine, presumably due to swapping to disk and the lack of data cleanup. We conclude that Big Data processing strategies are worth developing for neuroimaging applications.

Big Data has become prominent throughout many scientific fields, and as a result, scientific communities have sought out Big Data frameworks to accelerate the processing of their increasingly data-intensive pipelines. However, while scientific communities typically rely on High-Performance Computing (HPC) clusters for the parallelization of their pipelines, many popular Big Data frameworks such as Hadoop and Apache Spark were primarily designed to be executed on dedicated commodity infrastructures. This paper evaluates the benefits of pilot jobs over traditional batch submission for Apache Spark on HPC clusters. Surprisingly, our results show that the speed-up provided by pilot jobs over batch scheduling is moderate to non-existent (0.98 on average) despite the presence of long queuing times. In addition, pilot jobs provide an extra layer of scheduling that complicates debugging and deployment. We conclude that traditional batch scheduling should remain the default strategy to deploy Apache Spark applications on HPC clusters.

Evaluating the computational reproducibility of data analysis pipelines has become a critical issue. It is, however, a cumbersome process for analyses that involve data from large populations of subjects, due to their computational and storage requirements. We present a method to predict the computational reproducibility of data analysis pipelines in large population studies. We formulate the problem as a collaborative filtering process, with constraints on the construction of the training set. We propose 6 different strategies to build the training set, which we evaluate on 2 datasets, a synthetic one modeling a population with a growing number of subject types, and a real one obtained with neuroinformatics pipelines. Results show that one sampling method, "Random File Numbers (Uniform)" is able to predict computational reproducibility with a good accuracy. We also analyze the relevance of including file and subject biases in the collaborative filtering model. We conclude that the proposed method is able to speedup reproducibility evaluations substantially, with a reduced accuracy loss.

Lightweight Temporal Compression (LTC) is among the lossy stream compression methods that provide the highest compression rate for the lowest CPU and memory consumption. As such, it is well suited to compress data streams in energy-constrained systems such as connected objects. The current formulation of LTC, however, is one-dimensional while data acquired in connected objects is often multi-dimensional: for instance, accelerometers and gyroscopes usually measure variables along 3 directions. In this paper, we investigate the extension of LTC to higher dimensions. First, we provide a formulation of the algorithm in an arbitrary vectorial space of dimension n. Then, we implement the algorithm for the infinity and Euclidean norms, in spaces of dimension 2D+t and 3D+t. We evaluate our implementation on 3D acceleration streams of human activities. Results show that the 3D implementation of LTC can save up to 20% in energy consumption for low-paced activities, with a memory usage of about 100 B.

We aim to predict and explain service failures in supply-chain networks, more precisely among last-mile pickup and delivery services to customers. We analyze a dataset of 500,000 services using (1) supervised classification with Random Forests, and (2) Association Rules. Our classifier reaches an average sensitivity of 0.7 and an average specificity of 0.7 for the 5 studied types of failure. Association Rules reassert the importance of confirmation calls to prevent failures due to customers not at home, show the importance of the time window size, slack time, and geographical location of the customer for the other failure types, and highlight the effect of the retailer company on several failure types. To reduce the occurrence of service failures, our data models could be coupled to optimizers, or used to define counter-measures to be taken by human dispatchers.

During the panel discussion, participants observed that the workshop topics represent the wide range of issues that are currently investigated in this field.On the one hand, typical methods of Big Data environments, such as the programming language Python and the programming framework

Splitting and merging data is a requirement for many parallel or distributed processing operations. Naive algorithms to split and merge 3D blocks from ultra-high resolution images perform very poorly, as a result of seek times. In contrast, naive algorithms to split and merge 3D slabs perform optimally as seek time is significantly minimized. We introduce and analyze sequential algorithms (Clustered reads, Multiple reads, Clustered writes, and Multiple writes) that leverage memory buffering to address this issue. Clustered reads and Clustered writes, access image chunks only once, but they have to seek in the reconstructed image. Multiple reads and Multiple writes minimize seeks in the reconstructed image, but they access image chunks multiple times. Evaluation on a 3850×3025×3500 brain image shows that our algorithms perform similarly to the optimal configuration provided that enough memory is available. Additionally, Multiple reads supports on-the-fly compression of the merged image transparently but Clustered reads does not, due to its use of negative seeking. We conclude that splitting and merging large 3D images can be done efficiently without relying on complex data formats.

Simulation is a fast, controlled, and reproducible way to evaluate new algorithms for distributed computing platforms in a variety of conditions. However, the realism of simulations is rarely assessed, which critically questions the applicability of a whole range of findings. In this paper, we present our efforts to build platform models from application traces, to allow for the accurate simulation of file transfers across a distributed infrastructure. File transfers are key to performance, as the variability of file transfer times has important consequences on the dataflow of the application. We present a methodology to build realistic platform models from application traces and provide a quantitative evaluation of the accuracy of the derived simulations. Results show that the proposed models are able to correctly capture real-life variability and significantly outperform the state-of-the-art model.

Science gateways often rely on workflow engines to execute applications on distributed infrastructures. We investigate six software architectures commonly used to integrate workflow engines into science gateways. In tight integration, the workflow engine shares software components with the science gateway. In service invocation, the engine is isolated and invoked through a specific software interface. In task encapsulation, the engine is wrapped as a computing task executed on the infrastructure. In the pool model, the engine is bundled in an agent that connects to a central pool to fetch and execute workflows. In nested workflows, the engine is integrated as a child process of another engine. In workflow conversion, the engine is integrated through workflow language conversion. We describe and evaluate these architectures with metrics for assessment of integration complexity, robustness, extensibility, scalability and functionality. Tight integration and task encapsulation are the easiest to integrate and the most robust. Extensibility is equivalent in most architectures. The pool model is the most scalable one and meta-workflows are only available in nested workflows and workflow conversion. These results provide insights for science gateway architects and developers.

Programs may generate different results depending on the computing system where they are executed. Consequently, distributed applications are restricted to a few computing sites to avoid being flawed by numerical variations. We propose algorithms to increase the use of infrastructures while controlling the risk created by numerical variations. Our algorithms rely on a classification of the computing sites updated regularly depending on (i) the amount of observed numerical differences, and (ii) the number of tasks to execute. We simulate our algorithms on a 40-site infrastructure using SimGrid, in 3 different configurations. Results show that for one of the configurations, our algorithm speeds up the execution by a factor of about 4 in 10% of the cases. For the remaining cases and the other 2 configurations, we show that sites cannot be aggregated unless a high risk of numerical variations is tolerated. We conclude that site classifications are a promising approach to handle numerical variability among computing sites. Results could be further improved by integrating more a-priori information in the classifications.

SUMMARY In spite of numerous works studying file replication strategies on distributed systems, data management policies remain mostly handled by manual operators or very basic algorithms on production grids. Among other causes, this situation is due to the lack of models taking job reliability into account. In this paper, we study file replication using new metrics to evaluate the reliability of distributed storage configurations. A stateful storage availability model is introduced to cope with the inability of the stateless model to account for the commonsense intuition that limiting the number of storage hosts involved in the execution of an application improves reliability. We describe the job success probability and the brittleness entropy, a metric describing the uncertainty of the job failure rate associated to a storage configuration. Results, obtained on synthetic data and on traces extracted from the European Grid Infrastructure, show that the stateful model is more accurate than the stateless on real data, and that it can describe the consequences of limiting the number of storage hosts on application reliability. These findings open the door to the design of new file replication strategies taking storage availability into account. Copyright © 2014 John Wiley & Sons, Ltd.

The implementation of a grid network to support large-scale epidemiology analysis (based on distributed medical data sources) and medical data sharing require medical data integration and semantic alignment. In this paper, we present the GINSENG (Global Initiative for Sentinel e-Health Network on Grid) network that federates existing Electronic Health Records through a rich metamodel (FedEHR), a semantic data model (SemEHR) and distributed query toolkits. A query interface based on the VIP platform, and available through the e-ginseng.org web portal helps medical end-users in the design of epidemiological studies and the retrieval of relevant medical data sets.

The emergence of hardware virtualization, notably exploited by cloud infrastructures, led to a paradigm shift in distributed computing by enabling complete software customization and elastic scaling of resources. However, new software architectures and deployment algorithms are still required to fully exploit virtualization in web platforms used for scientific computing, commonly called science gateways. We propose a software architecture and an algorithm to enable and optimize the deployment of virtual machines on clusters and clouds in science gateways. Our architecture is based on 3 design principles: (i) separation between resource provisioning and task scheduling (ii) encapsulation of VMs in regular computing tasks (iii) association of a virtual computing site to each disk image. Our algorithm submits and removes VMs on clusters and clouds based on the current system workload, the number of available job slots in active VMs, the cost and current performance of clouds clusters, and a parameter quantifying the performance-cost trade-off. To cope with variable queuing and booting times, it replicates VMs on independent computing sites selected from a minimization of a make span-cost linear combination in the Pareto set of non-dominated solutions. Make span and cost are estimated from the last measured queuing, booting, and task execution times, using an exponential model of the gain yielded by VM replication. We implement this algorithm in CBRAIN, a science gateway widely used for neuroimaging, and we evaluate it on an infrastructure of 2 clusters and 1 cloud. Results show that it is able to reach some points of the performance-cost trade-off associated to VM deployment.

SUMMARY Distributed computing infrastructures are commonly used for scientific computing, and science gateways provide complete middleware stacks to allow their transparent exploitation by end users. However, administrating such systems manually is time consuming and sub‐optimal because of the complexity of the execution conditions. Algorithms and frameworks aiming at automating system administration must deal with online and non‐clairvoyant conditions, where most parameters are unknown and evolve over time. We consider the problem of controlling task granularity and fairness among scientific workflows executed in these conditions. We present two self‐managing loops monitoring the fineness, coarseness, and fairness of workflow executions, comparing these metrics with thresholds extracted from knowledge acquired in previous executions and planning appropriate actions to maintain these metrics to appropriate ranges. Experiments on the European Grid Infrastructure show that our task granularity control can speed up executions up to a factor of 2 and that our fairness control reduces slowdown variability by 3–7 compared with first‐come, first‐served. We also study the interaction between granularity control and fairness control: our experiments demonstrate that controlling task granularity degrades fairness but that our fairness control algorithm can compensate this degradation. Copyright © 2014 John Wiley & Sons, Ltd.

This paper presents an end-to-end SimGrid-based simulation of a Monte-Carlo computation deployed on the European Grid Infrastructure. We describe a simulation framework allowing to replay executions from real traces. Middleware services, namely the file catalog, storage elements, the DIRAC pilot-job system, and the MOTEUR workflow engine are simulated by SimGrid processes. The deployment of pilot jobs, performed on EGI by the gLite WMS and batch queues, is simulated by a random selection of platform hosts, and a matching of their latencies and failure times with real traces. The Monte-Carlo application workflow is calibrated to address performance discrepancies between the real and simulated network and CPUs. The simulation is evaluated against real executions of the GATE Monte-Carlo application. Results show that SimGrid can be used to study the performance of applications running on EGI. Simulated and real make spans are consistent, and conclusions drawn in production about the influence of application parameters such as the check pointing frequency and the number of mergers are also made in simulation. This opens the door to better and faster experimentation on production grids.

This paper presents the Virtual Imaging Platform (VIP), a platform accessible at http://vip.creatis.insa-lyon.fr to facilitate the sharing of object models and medical image simulators, and to provide access to distributed computing and storage resources. A complete overview is presented, describing the ontologies designed to share models in a common repository, the workflow template used to integrate simulators, and the tools and strategies used to exploit computing and storage resources. Simulation results obtained in four image modalities and with different models show that VIP is versatile and robust enough to support large simulations. The platform currently has 200 registered users who consumed 33 years of CPU time in 2011.

Isolating users from the inevitable faults in large distributed systems is critical to Quality of Experience. We formulate the problem of probe selection for fault prediction based on end-to-end probing as a Collaborative Prediction (CP) problem. On an extensive experimental dataset from the EGI grid, the combination of the Maximum Margin Matrix Factorization approach to CP and Active Learning shows excellent performance, reducing the number of probes typically by 80% to 90%.

Distributed computing infrastructures are commonly used through scientific gateways, but operating these gateways requires important human intervention to handle operational incidents. This paper presents a self-healing process that quantifies incident degrees of workflow activities from metrics measuring long-tail effect, application efficiency, data transfer issues, and site-specific problems. These metrics are simple enough to be computed online and they make little assumptions on the application or resource characteristics. Incidents are classified in levels and associated to sets of healing actions that are selected based on association rules modeling correlations between incident levels. The healing process is parametrized on real application traces acquired in production on the European Grid Infrastructure. Implementation and experimental results obtained in the Virtual Imaging Platform show that the proposed method speeds up execution up to a factor of 4 and properly detects unrecoverable errors.

Medical image simulation produces virtual images from software representations of imaging devices and virtual object models representing the human body. Object models consist of the geometry of the objects (e.g. organs, tissues, pathological structures, etc.) and of their physical parameters used for the simulation. The diversity of this information makes it difficult to share and reuse across simulation modalities and users. We address this issue by explicitly describing object models using a semantic approach. In particular, we developed an ontology that contains the relevant concepts and relations of the domain of object models for image simulation. This ontology is used to annotate object models and to describe their content and structure. In this paper, we present the construction steps of this ontology, the representation choices and we illustrate how it is used to annotate object models.

This paper describes a framework for the integration of medical image simulators in the Virtual Imaging Platform (VIP). Simulation is widely involved in medical imaging but its availability is hampered by the heterogeneity of software interfaces and the required amount of computing power. To address this, VIP defines a simulation workflow template which transforms object models from the IntermediAte Model Format (IAMF) into native simulator formats and parallelizes the simulation computation. Format conversions, geometrical scene definition and physical parameter generation are covered. The core simulator executables are directly embedded in the simulation workflow, enabling data parallelism exploitation without modifying the simulator. The template is instantiated on simulators of the four main medical imaging modalities, namely Positron Emission Tomography, Ultrasound imaging, Magnetic Resonance Imaging and Computed Tomography. Simulation examples and performance results on the European Grid Infrastructure are shown.

Segmenting 3D images is critical in medical imaging but the parameterization of segmentation algorithms is difficult due to their computation heaviness and complex interactions between the parameters. This paper targets the exploration of deformable-model-based segmentation parameter spaces to search for salient ranges. We propose a framework exploring the parameter space with a genetic algorithm and interactively clustering the segmentation results. The framework only requires a limited number of parameters, it does not make any assumption on the segmentation algorithm and it does not require any ground truth or gold standard. Results obtained on a 3D image of the heart show that the proposed method has good robustness capabilities and that it is able to efficiently exhibit interesting parameter ranges.

This paper presents the design, implementation, and usage of a virtual laboratory for medical image analysis. It is fully based on the Dutch grid, which is part of the Enabling Grids for E-sciencE (EGEE) production infrastructure and driven by the gLite middleware. The adopted service-oriented architecture enables decoupling the user-friendly clients running on the user's workstation from the complexity of the grid applications and infrastructure. Data are stored on grid resources and can be browsed/viewed interactively by the user with the Virtual Resource Browser (VBrowser). Data analysis pipelines are described as Scufl workflows and enacted on the grid infrastructure transparently using the MOTEUR workflow management system. VBrowser plug-ins allow for easy experiment monitoring and error detection. Because of the strict compliance to the grid authentication model, all operations are performed on behalf of the user, ensuring basic security and facilitating collaboration across organizations. The system has been operational and in daily use for eight months (December 2008), with six users, leading to the submission of 9000 jobs/month in average and the production of several terabytes of data.

Production-grid users experience many system faults as well as high and variable latencies due to the scale, complexity and sharing of such infrastructures. To improve performance, they adopt different submission strategies, that are potentially aggressive for the infrastructure.

This paper presents the integration of a workflow management system into the VL-e medical software architecture. Workflows are designed with the Taverna workbench, and then executed with the MOTEUR engine on the EGEE grid through the VBrowser, which is the basic front-end for grid-enabled applications in the VL-e medical project. Data management is handled by the virtual file system of the VL-e toolkit. The resulting system provides a high-level interface to execute grid applications.

In this paper, the expressiveness of the simple Scufl data-flow language is studied by showing how it can be used to implement Turing machines. To do that, several non trivial Scufl patterns such as self-looping or sub-workflows are required and we precisely explicit them. The main result of this work is to show how a complex workflow can be implemented using a very simple data-flow language. Beyond that, it shows that Scufl is a Turing complete language, given some restrictions that we discuss.

Production grids are complex and highly variable systems whose behavior is not well understood and difficult to anticipate. The goal of this study is to estimate the impact of the variability of those infrastructures on the performance of workflow-based applications. A probabilistic model of workflows execution time is proposed and evaluated. Results show that the variability of the EGEE grid infrastructure impacts the execution time of a particular medical image analysis application by a factor 2. The model gives interesting insights on the grid behavior for different application parallelization modes.

In this paper, we study grid jobs submission latency. The latency highly impacts performances on production grids, due to its high values and variations. It is particularly prejudicial for determining the status and expected duration of jobs and it makes outliers detection difficult. In previous work, a probabilistic model of the latency has been presented. It allows to estimate the best timeout value considering a given distribution of jobs latencies. This time-out value is then used in a job resubmission strategy. The purpose of this paper is to evaluate to what extent updating this model with relevant contextual parameters can help to refine the latency estimation. Experiments on the EGEE production grid show that the choice of the resource broker or the computing site has a statistically significant influence on the jobs latency. We exploit this contextual information to propose a reliable job submission strategy.

Grid workflows can produce thousands of results that should be properly organised to enable further analysis. Typically results are stored on locations hard-coded in the workflow or in the components, limiting reusability. In this paper we present an approach to (re)organise the output files generated by a grid workflow in a distributed storage environment. We propose to perform a post-mortem mapping of workflow results into a directory structure. This mapping is based on data provenance information and exploits grid catalog features, namely logical file names, to avoid data replication. By defining different mappings, users can generate their own semantic view of results generated during a workflow execution, which fosters user-friendliness, whereas preserving workflow reusability. An implementation on the Virtual Resource Browser (VBrowser) framework is detailed and evaluated on neuroimaging workflows. Results show that the complex directory structure of an image analysis application cane properly generated by our system. An initial performance evaluation of the mapping resolution and directory structure creation indicates that this approach provides a practical, simple, yet powerful solution to an important roadblock for the adoption of workflows to implement complex image analysis pipelines.

The impact of lossy compression has often been discussed in the medical area. In this study, an evaluation of the impact of lossy compression on the performance of rigid registration algorithms for medical images is proposed. The robustness, repeatability and accuracy of these algorithms is estimated through a statistical procedure for each compression ratio. Results are obtained thanks to a grid technology handling the computation cost of the method. Experiments reveal that the impact of compression is quite negligible below a significant compression ratio if the registration algorithm has a good multi-scale handling. Beyond this threshold, feature-based methods are highly penalized.

In this paper, we examine how the execution context of grid jobs can help to refine submission strategies on a production grid. On this kind of infrastructure, the latency highly impacts performances. We present experiments that quantify the dependencies between the grid latency and both internal and external context parameters on the EGEE grid infrastructure. We show how job submission managers, job execution sites and the submission date can be statistically correlated to grid performances.

This paper presents a method to optimize the timeout value of computing jobs. It relies on a model of the job execution time that considers the job management system latency through a random variable. It also takes into account a proportion of outliers to model either reliable clusters or production grids characterized by faults causing jobs loss. Job management systems are first studied considering classical distributions. Different behaviors are exhibited, depending on the weight of the tail of the distribution and on the amount of outliers. Experimental results are then shown based on the latency distribution and outlier ratios measured on the EGEE grid infrastructure1. Those results show that using the optimal timeout value provided by our method reduces the impact of outliers and leads to a 1.36 speed-up even for reliable systems without outliers.

Grids technologies enable the deployment of complex data-intensive scientific applications. Nonspecific scientific codes may benefit from grid computing capabilities by (i) assembling codes in workflows (code parallelism) and (ii) processing large amounts of data (data parallelism). We designed MOTEUR, a service-based workflow manager, to describe data-intensive scientific applications in a compact framework and to efficiently process the resulting computations by transparently exploiting different parallelism levels. Theoretical performances are analyzed and results are shown based on a real application to medical image databases processing

Production grids have a potential for parallel execution of a very large number of tasks but also introduce a high overhead that significantly impacts the execution of short tasks. In this work, we present a strategy to optimize the partitioning of jobs on a grid infrastructure. This method takes into account the variability and the difficulty to model a multi-user large-scale environment used for production. It is based on probabilistic estimations of the grid overhead. We first study analytically modeled environments and then we show results on a real grid infrastructure. We demonstrate that this method leads to a significant time speed-up and to a substantial saving of the number of submitted tasks with respect to a blind maximal partitioning strategy.

Data intensive medical image processing applications can easily benefit from grid capabilities. However, the setting up of complex medical experiments is not straight forward on current grid infrastructures. To ease such experiments we are developing a generic and grid-enabled workflow framework, relying on current standards. We show results on a concrete application to medical image registration assessment. We discuss the limitations induced by current standards and tools and how they were overcome for deploying the application.

Digital medical image processing is a promising application area for grids. Given the volume of data, the sensitivity of medical information, and the joint complexity of medical datasets and computations expected in clinical practice, the challenge is to fill the gap between the grid middleware and the requirements of clinical applications. The research project AGIR (Grid Analysis of Radiological Data) presented in this paper addresses this challenge through a combined approach: on one hand, leveraging the grid middleware through core grid medical services which target the requirements of medical data processing applications; on the other hand, grid-enabling a panel of applications ranging from algorithmic research to clinical applications.