CCL Home

Research

Software Community Operations

Recent News in the CCL


Packaging Your Applications using Parrot

Parrot is a tool for attaching existing programs to remote I/O systems through the filesystem interface. It works by trapping a program's system calls through the ptrace debugging interface, and replacing them with remote I/O operations as desired. 
This article explains how to generate a self-contained package for your applications (as shown in Figure 1) and then share the package so that others can verify can repeat your applications. The whole process involves three steps. 
Figure 1 Packaging Procedure

Step 1: Obtain all the accessed files 

Run your program under parrot_run and record the filename list and environment variables by using --name-list and --env-list parameters.
% parrot_run --name-list namelist --env-list envlist /bin/bash 
After the execution of this command, you can run your program inside parrot_run
At the end of step 1, one file named namelist containing all the accessed file names and one file named envlist containing environment variables will be generated. 
After everything is done, exit parrot_run:
% exit 

Step 2: Generate a self-contained package

Using parrot_package_create to generate a package based on the namelist and envlist generated in step 1.
% parrot_package_create --name-list namelist --env-path envlist --package-path /tmp/package 
At the end of step 2, one package with the path of /tmp/package will be generated.

Step 3: Repeat your program within your package

Repeat your program within your package. Currently, two mechanisms are provided to help to repeat the original application: parrot_package_run and chroot_package_run.
You can also publish your package so that others can verify and repeat your application.

A) parrot_package_run

% parrot_package_run --package-path /tmp/package /bin/bash 
After the execution of this command, one shell will be returned, where you can repeat your original program. After everything is done, exit parrot_package_run
% exit 

B) chroot_package_run

% chroot_package_run --package-path /tmp/package /bin/bash
After the execution of this command, one shell will be returned, where you can repeat your original program. After everything is done, exit chroot_package_run:
% exit 
Fri, 01 Aug 2014 19:18:00 +0000

CCTools 4.2.0 released

We are pleased to announce the release of version 4.2.0 of the Cooperative Computing Tools including Parrot, Chirp, Makeflow, WorkQueue, SAND, All-Pairs, and other software.

The software may be downloaded here: Download CCTools 4.2.0

This release is mostly a bug fix release, but introduces changes to the Work Queue protocol. Thus, workers from 4.2 do not work with masters pre 4.2.

Among the bug fixes and added capabilities are: Among the bug fixes and added capabilities are:

  • [General] Support for systemd log journal. (Patrick Donelly)
  • [WorkQueue] Several bug fixes (Douglas Thain. Dinesh Rajan, Ben Tovar)
  • [WorkQueue] Improvements to resource accounting. (Ben Tovar)
  • [WorkQueue] work_queue_graph_log, a script to plot
  • Work Queue's log. (Ben Tovar)
  • [WorkQueue] Autosize option for workers to fill Condor slots. (Douglas Thain)
  • [WorkQueue] Added several example applications in apps/ (Dinesh Rajan)
  • [Chirp] Several bug fixes. (Patrick Donelly)
  • [Parrot] Package creation of accessed files for execution
  • repeatability. (Haiyan Meng)
  • [Parrot] Correct mmap handling. (Patrick Donelly)
  • [Parrot] Fix linking to iRODS. (Patrick Donelly)
  • [Parrot] Option to disable CVMFS alien cache. (Ben Tovar)
  • [Parrot] Bug fixes targeting CVMFS. (Ben Tovar)
Thanks goes to the contributors for many features and bug fixes:
  • Jakob Blomer
  • Dan Bradley
  • Peter Bui
  • Patrick Donnelly
  • Nicholas Hazekamp
  • Peter Ivie
  • Haiyan Meng
  • Dinesh Rajan
  • Casey Robinson
  • Peter Sempolinski
  • Douglas Thain
  • Ben Tovar
  • Matthias Wolf
Please send any feedback to the CCTools discussion mailing list . Thu, 31 Jul 2014 12:33:00 +0000

DeltaDB at IEEE BigData 2014

Peter Ivie will be presenting his work on the DeltaDB database model for time-varying schema-free data at the IEEE International Congress on Big Data in Anchorage. The DeltaDB concept is what underlies the query engine for the cctools catalog server.

Tue, 03 Jun 2014 16:50:00 +0000

Journal Paper on MAKER and Work Queue

Our paper on converting the MAKER bioinformatics analysis from MPI to Work Queue, done in collaboration with the Notre Dame Bioinformatics Laboratory was recently accepted for publication in the International Journal of Bioinformatics Research and Applications.

Tue, 03 Jun 2014 16:47:00 +0000

CCL Papers at CCGrid 2014

Three papers from the CCL were presented at the 2014 IEEE Conference on Cluster, Cloud, and Grid Computing in Chicago:
Tue, 03 Jun 2014 16:45:00 +0000

Toward a Common Model of Highly Concurrent Programming

(This is the short version of a talk I gave at the MTAGS workshop at Supercomputing 2013.  See the slides here.)

Historically, highly concurrent programming has been closely associated with high performance computing.  Two programming models have been dominant: shared memory machines in which concurrency was expressed via multiple threads, and distributed memory machines in which concurrency was expressed via explicit message passing.  It is widely agreed that both of these programming models are very challenging, even for the veteran programmer.  In both cases, the programmer is directly responsible for designing the program from top to bottom and handling all of the issues of granularity, consistency, and locality necessary to achieve acceptable performance, with very little help from the runtime or operating systems.

However, a new approach to concurrent programming has been emerging over the last several years, in which the user programs in a much higher level language and relies upon the system to handle many of the challenging underlying details.  To achieve this, the program is successively decomposed into simpler representations, such that each layer of the system can gradually adapt it to the hardware available.

The layers can be described as follows:
  • declarative language (DL) for compactly representing a complete program.
  • directed graph (DAG) to represent the expanded program and its resources.
  • bag of independent tasks (BOT) with explicit input and output dependencies.
  • A shared-nothing cluster to which data and tasks must be assigned.
Several different research communities have arrived at this computing model somewhat independently: the high performance computing community, the scientific workflow community, and the cloud computing community.  In each case, the scale and complexity of the systems in use eventually made it impossible for the programmer or the user to take responsibility for all of the challenges of parallel/distributed computing.  Although each community employs different technologies and has distinct optimization goals, the overall structure of these systems is surprisingly similar.

A (very incomplete) selection of systems that follow this model:


Layer Cloud Stack Workflow Stack HPC Stack
Declarative Language (DL)    Pig Weaver Swift-T
Directed Acyclic Graph (DAG)Map-Reduce    Makeflow -
Bag of Tasks (BOT)JobTracker Work Queue Master Turbine
Distributed Data HDFS Work Queue Workers    MPI

Each layer of the system fulfills a distinct need.  The declarative language (DL) at the top is compact, expressive, and easy for end users, but is intractable to analyze in the general case because it may have a high order of complexity, possibly Turing-complete.  The DL can be used to generate a (large) directed acyclic graph (DAG) that represents every single task to be executed.  The DAG is not a great user-interface language, but it is much more suitable for a system to perform capacity management and optimization because it is a finite structure with discrete components.  A DAG executor then plays the graph, dispatching individual tasks as their dependencies are satisfied.  The BOT consists of all the tasks that are ready to run, and is then scheduled onto the underlying computer, using the data dependencies made available from the higher levels.

Why bother with this sort of model?  It allows us to compare the fundamental capabilities and expressiveness of different kinds of systems.  For example, in the realm of compilers, everyone knows that a proper compiler consists of a scanner, a parser, an optimizer, and a code generator.  Through these stages, the input program is transformed from a series of tokens to an abstract syntax tree, an intermediate representation, and eventually to assembly code.  Not every compiler uses all of these stages, much less the same code, but by using a common language, it is helpful to understand, compare, and design new systems.


Mon, 19 May 2014 19:14:00 +0000

Visualizing 10,000 Cores in Condor

Our Condor pool at the University of Notre Dame has been slowly growing, in no small part due to our collaboration with the Center for Research Computing, where it is now scavenging unused cycles from HPC clusters at the CRC.  When the dedicated batch system leaves a node unused, Condor is started on that node and keeps going until the dedicated system wants the node back.  Depending on the time of year, that leaves anywhere between 4K and 10K nodes available in the Condor pool.

We have tried a number of approaches at visualizing this complex system over the years.  Our latest tool, the Condor Matrix Display started as a summer project by Nick Jaeger, a student from the University of Wisconsin at Eau Claire.  The display shows a colored bar for each slot in the pool, where the width is proportional to the number of cores.

With a quick glance, you can see how many users are busy and whether they are running "thin" (1 core) or "fat" (many core) jobs.  Sorting by the machine name gives you sense of how each sub-cluster in the pool is used:


While sorting by users gives you a sense of what users are dominating the pool:


The display is always a nice way of viewing the relatively new feature of "dynamic slot" in Condor.  A large multi-core machine is now represented as a single slot with multiple resources.  For example, this bit of the display shows a cluster of 8-core machines where some of the machines are unclaimed (green), some are running 4-core jobs (blue), and some are running 1-core jobs (green):



Fri, 14 Feb 2014 16:20:00 +0000

CCL Papers at Supercomputing 2013

Members of the CCL team presented several papers at Supercomputing 2013 in Denver, Colorado:



Mon, 18 Nov 2013 18:34:00 +0000

CCL Workshop October 10-11 at Notre Dame

Join us for the annual CCL workshop at the University of Notre Dame!

http://www.nd.edu/~ccl/workshop/2013

The workshop is an opportunity for beginners and experts alike to learn about the latest software release, get to know the CCL team, meet other people engaged in large scale scientific computing, and influence the direction of our research and development.

Thursday, October 10th
Afternoon: Introduction and Software Tutorials

Friday, October 11th
All Day: New Technology, Scientific Talks, and Discussion

There is no registration fee, however, space is limited, so please register in advance to reserve your place. We hope to see you there!




Fri, 11 Oct 2013 12:00:00 +0000

New Work Queue Paper at IEEE Cluster 2013

Michael Albrecht and Dinesh Rajan will present their latest work titled Making Work Queue Cluster Friendly for Data Intensive Scientific Applications.

In the original design of Work Queue, each worker was a sequential process that executed one task at a time. This paper describes the extension of Work Queue into two respects:

  • Workers can now run multiple tasks simultaneously, each sharing a local cache directory.
  • Workers can be combined into hierarchies, each headed by a foreman, which provides a common disk cache for each sub tree.

The effect of these two changes is to dramatically reduce the network footprint at the master process, and at each execution site. The resulting system is more 'friendly' to local clusters, and is capable of scaling to even greater sizes.
Wed, 21 Aug 2013 12:55:00 +0000

CCTools 4.0 Released

The Cooperative Computing Lab is pleased to announce the release of version 4.0 of the Cooperative Computing Tools, including Parrot, Chirp, Makeflow, WorkQueue, SAND, All-Pairs, and other software.

This is the first release of the 4.0 series, with some major changes:
  • To support new features on WorkQueue, backwards compatibility of master and workers pre-4.0 is broken. Specifically, workers from 4.0 cannot connect to masters pre-4.0, and masters from 4.0 will not accept connection from workers pre-4.0. The API did not change, thus unless you want to take advantage of new features, you should not need to modify your code.

  • All code related to WorkQueue has been consolidated to its own library. When linking work queue applications in C, you will need to use: -lwork_queue -ldttools rather than just -ldttools. If you are using the perl or python bindings, no change is necessary.

  • The auto-mode option -a for communicating with the catalog server is being deprecated. It is now implied when a master, or project name (-M, -N) is specified.

  • Most tools now support long options at the command line (e.g., --help).
Highlights:

  • [WorkQueue] Support for workers hierarchies, with a master-foremen-workers paradigm. [Michael Albrecht]
  • [WorkQueue] Multi-slot workers. A worker now is able to handle more than one task at a time. [Michael Albrecht]
  • [WorkQueue] Resource reports. A worker reports its resources (disk, memory, and cpu) to the master, and each task in the master can specify a minimum of such resources. [Michael Albrecht, DeVonte Applewhite]
  • [WorkQueue] Authentication between master and workers when using the catalog server [Douglas Thain].
  • [WorkQueue] Python bindings now include most C API. [Dinesh Rajan]
  • [WorkQueue] Several bug fixes and code reorganization. [Dinesh Rajan, Michael Albrecht]
  • [WorkQueue] Policies can be specified to work_queue_pool to submit workers on demand. [Li Yu]
  • [Makeflow] Support for task categories. A rule can be labeled with a category, and required computational resources (disk, memory, and cpu) can be specified per category. Makeflow then automatically communicates these requirements to work queue or condor. [Ben Tovar]
  • [Parrot/Chirp] Support for a search system call added. Search allows for finding files in a number of directories with a shell pattern. See parrot_search for more information. [Patrick Donnelly, Brenden Kokoszka]
  • [Parrot] Several bug fixes for cvmfs support. [Douglas Thain, Ben Tovar, Patrick Donnelly]
  • [Monitor] A resource monitor/watchdog for computational resources (e.g. disk, memory, cpu, and io) that can be used standalone, or automatically by Makeflow and Work Queue. [Ben Tovar]
  • [Monitor] A visualizer that builds a webpage to show the resources histograms from the reports of the resource monitor. [Casey Robinson]


Please refer to the doc/ directory in the distribution for the usage of this new features. You can download the software here:
Download




Thanks goes to the contributors for this release: Michael Albrecht, DeVonte Applewhite, Peter Bui, Patrick Donnelly, Brenden Kokoszka, Kyle Mulholland, Francesco Prelz, Dinesh Rajan, Casey Robinson, Peter Sempolinski, Douglas Thain, Ben Tovar, and Li Yu.


Mon, 29 Jul 2013 12:11:00 +0000

Ph.D. Defense: Li Yu

Congratulations to Dr. Li Yu, who successfully defended his Ph.D. dissertation, Right-sizing Resource Allocations for Scientific Applications in Clusters, Grids, and Clouds!

Fri, 26 Jul 2013 12:05:00 +0000

Tutorial on Building Scalable Scientific Applications at XSEDE13

We will be offering a tutorial titled Building Scalable Scientific Applications using Makeflow and Work Queue as part of XSEDE 2013 in San Diego on July 22. Mon, 22 Jul 2013 12:00:00 +0000

Dinesh Rajan Wins Best Talk at CCGrid 2013

Congratulations to CCL graduate student Dinesh Rajan, who won the Best Presentation Award at CCGrid 2013 for his presentation of
Case Studies in Designing Elastic Applications!

Tue, 21 May 2013 13:58:00 +0000

Tutorial on Makeflow and Work Queue at CCGrid 2013

Dinesh Rajan will present a tutorial on Building Elastic Applications with Makeflow and Work Queue as part of CCGrid 2013 in Delft, the Netherlands on May 13th. Come join us and learn how to write applications that scale up to hundreds or thousands of nodes running on clusters, clouds, and grids.


Fri, 22 Mar 2013 11:12:00 +0000

Elastic Apps Paper at CCGrid 2013

Dinesh Rajan will present his paper
Case Studies in Designing Elastic Applications at the IEEE International Conference on Clusters, Clouds, and Grids (CCGrid) in Delft, the Netherlands. This work was done in collaboration with Andrew Thrasher and Scott Emrich from the Notre Dame Bioinformatics Lab, and Badi Abdul-Wahid and Jesus Izaguirre from the Laboratory for Computational Life Sciences.


The paper describes our experience in designing three different elastic applications -- E-MAKER, Elastic Replica Exchange, and Folding at Work -- that run on hundreds to thousands of cores using the Work Queue framework. The paper offers six guidelines for designing similar applications:


  1. Abolish shared writes.
  2. Keep your software close and your dependencies closer.
  3. Synchronize two, you make company; synchronize
    three, you make a crowd.
  4. Make tasks of a feather flock together.
  5. Seek simplicity, and gain power.
  6. Build a model before scaling new heights.



Fri, 22 Mar 2013 10:40:00 +0000

Genome Assembly Paper in IEEE TPDS

A recent article in IEEE Transactions on Parallel and Distributed Computing describes our work in collaboration with the Notre Dame Bioinformatics Laboratory on SAND - The Scalable Assembler at Notre Dame.


In this article, we describe how to refactor the standard Celera genome assembly pipeline into a scalable computation that runs on thousands of distributed cores using the Work Queue. By explicitly handling the data dependencies between tasks, we are able to significantly improve runtime over Celera on a standard cluster. In addition this technique allows the user to break free of the shared filesystem and run on hundreds thousands of nodes drawn from clusters, clouds, and grids.



Thu, 21 Mar 2013 15:19:00 +0000


CCTools 3.7.0 Released!

The Cooperative Computing Lab is pleased to announce the release of version 3.7.0 of the Cooperative Computing Tools, including Parrot, Chirp, Makeflow, WorkQueue, SAND, All-Pairs, and other software.



The software may be downloaded here.



This is a minor release which adds numerous features and fixes several bugs:




  • [WorkQueue] It is now possible to specify chunks (pieces) of an input file to be used as input for worker tasks. [Dinesh Rajan]

  • [Chirp] File extended attributes are now supported. [Patrick Donnelly]

  • [Makeflow] New -i switch now outputs pre-execution analysis of Makeflow DAG. [Li Yu]

  • [WorkQueue/Makeflow] Support for submitting tasks to the PBS batch submission platform added. [Dinesh Rajan]

  • [Makeflow] makeflow_log_parser now ignores comments in Makeflow logs. [Andrew Thrasher]

  • [Catalog] New catalog_update which reports information to a catalog server. [Peter Bui, Dinesh Rajan]

  • [WorkQueue] Various minor tweaks made to the API. [Li Yu, Dinesh Rajan]

  • [Catalog/WorkQueue] Support added for querying workers and tasks at run-time. [Douglas Thain]

  • [WorkQueue] Many environment variables removed in favor of option manipulation API. [Li Yu]

  • [Makeflow] Deprecated -t option (capacity tolerance) removed.

  • [WorkQueue] -W (worker status) now has working_dir and current_time fields.

  • [WorkQueue] -T (task status) now reports working_dir, current_time, address_port, submit_to_queue_time, send_input_start_time, execute_cmd_start_time. [Li Yu]

  • [WorkQueue] -Q (queue status) now reports working_dir.

  • [Makeflow] Input file (dependency) renaming supported with new "->" operator. [Michael Albrecht, Ben Tovar]

  • [WorkQueue] work_queue_pool now supports a new -L option to specify a log file. [Li Yu]

  • [WorkQueue] Tasks are now killed using SIGKILL.

  • [WorkQueue] Protocol based keep-alives added to workers. [Dinesh Rajan]



Thanks goes to the contributors for many minor features and bug fixes:




  • Michael Albrecht

  • Peter Bui

  • Patrick Donnelly

  • Brian Du Sell

  • Kyle Mulholland

  • Dinesh Rajan

  • Douglas Thain

  • Andrew Thrasher

  • Ben Tovar

  • Li Yu



Please send any feedback to the CCTools discussion mailing list.


Mon, 18 Feb 2013 16:29:00 +0000

CCTools 3.6.2 Released!

The Cooperative Computing Lab is pleased to announce the release of version 3.6.2 of the Cooperative Computing Tools, including Parrot, Chirp, Makeflow, WorkQueue, SAND, All-Pairs, and other software.



This is a bug fix release of version 3.6.1. No new features were added.



The software may be downloaded here:
http://www.cse.nd.edu/~ccl/software/download



Changes:




  • [WorkQueue] Corrected memory errors leading to a SEGFAULT. [Li Yu]

  • [Makeflow] Properly interpret escape codes in Makeflow files: \n, \t, etc. [Brian Du Sell]

  • [Parrot] Watchdog now properly honors minimum wait time. [Li Yu]

  • [Parrot] Reports the logical executable name for /proc/self/exe instead of the physical name. [Douglas Thain]

  • [WorkQueue] Race conditions in signal handling for workers were corrected. Tasks now have a unique process group to properly kill all task children on abort. [Dinesh Rajan, Li Yu]

  • [WorkQueue] Corrected incorrect handling of -C option where worker would not use the same catalog server as work_queue_pool. [Li Yu]



Thanks goes to the contributors for this release: Patrick Donnelly, Brian Du Sell, Dinesh Rajan, Douglas Thain, and Li Yu.



Enjoy!


Mon, 11 Feb 2013 13:55:00 +0000

CCTools 3.6.1 Released!

The Cooperative Computing Lab is pleased to announce the release of version 3.6.1 of the Cooperative Computing Tools, including Parrot, Chirp, Makeflow, WorkQueue, SAND, All-Pairs, and other software.



This is a bug fix release of version 3.6.0. No new features were added.



The software may be downloaded here: http://www.cse.nd.edu/~ccl/software/download



Changes:




  • [Work Queue] Fixes bugs that resulted in a cancelled task becoming a zombie. [Dinesh Rajan]

  • [Makeflow] Various corrections to Makeflow manual and html documentation. [Li Yu]

  • [Makeflow] -I and -O options now correctly output file list to stdout. [Li Yu]

  • [*] Added missing debug flag for ldflags in configure. [Douglas Thain]

  • [Work Queue] Now correctly removes directories during cleanup. [Dinesh Rajan]

  • [Chirp] -b is now documented in the man/-h page. [Patrick Donnelly]

  • [Sand] Fixed a wrong error message. [Peter Bui, Li Yu]

  • [Catalog Server] -T option now properly accepts an argument. [Patrick Donnelly]

  • [*] Fixed a bug where the wrong version of perl was used in configure. [Dinesh Rajan]



Thanks goes to the contributors for this release: Dinesh Rajan, Patrick Donnelly, Peter Bui, Li Yu, and Douglas Thain.



Enjoy!


Fri, 02 Nov 2012 15:54:00 +0000

NSF Grant: Data and Software Preservation for Open Science

Mike Hildreth, Professor of Physics, Jarek Nabrzyski, Director of the Center for Research Computing and Concurrent Associate Professor of Computer Science and Engineering, and Douglas Thain, Associate Professor of Computer Science and Engineering, are the lead investigators on a project that will explore solutions to the problems of preserving data, analysis software, and how these relate to results obtained from the analysis of large datasets.


Known as Data and Software Preservation for Open Science (DASPOS), it is focused on High Energy Physics data from the Large Hadron Collider (LHC) and the Fermilab Tevatron. The group will also survey and incorporate the preservation needs of other communities, such as Astrophysics and Bioinformatics, where large datasets and the derived results are becoming the core of emerging science in these disciplines


The three-year $1.8M program, funded by the National Science Foundation, will include several international workshops and the design of a prototype data and software-preservation architecture that meets the functionality needed by the scientific disciplines. What is learned from building this prototype will inform the design and construction of the global data and software-preservation infrastructure for the LHC, and potentially for other disciplines.


The multi-disciplinary DASPOS team includes particle physicists, computer scientists, and digital librarians from Notre Dame, the University of Chicago, the University of Illinois Urbana-Champaign, the University of Nebraska at Lincoln, New York University, and the University of Washington, Seattle.

Thu, 04 Oct 2012 13:09:00 +0000


Tutorial on Scalable Programming at Notre Dame

Tutorial: Introduction to Scalable Programming with Makeflow and Work Queue

October 24th, 3-5PM, 303 Cushing Hall


Register here (no fee) to reserve your spot in the class:

http://www.nd.edu/~ccl/software/tutorials/ndtut12


Would you like to learn how to write programs that can scale up to
hundreds or thousands of machines?


This tutorial will provide an introduction to writing scalable
programs using Makeflow and Work Queue. These tools are used at Notre
Dame and around the world to attack large problems in fields such as
biology, chemistry, data mining, economics, physics, and more. Using
these tools, you will be able to write programs that can scale up to
hundreds or thousands of machines drawn from clusters, clouds, and
grids.


This tutorial is appropriate for new graduate students, undergraduate
researchers, and research staff involved in computing in any
department on campus. Some familiarity with Unix and the ability to
program in Python, Perl, or C is required.


The class will consist of half lecture and half hands-on instruction
in a computer equipped classroom. The instructors are Dinesh Rajan
and Michael Albrecht, developers of the software who are PhD students
in the CSE department.


For questions about the tutorial, contact Dinesh Rajan, dpandiar AT nd.edu.

Wed, 03 Oct 2012 11:03:00 +0000


CCTools 3.6.0 Released!

The Cooperative Computing Lab is pleased to announce the release ofversion 3.6.0 of the Cooperative Computing Tools, including Parrot, Chirp, Makeflow, WorkQueue, SAND, All-Pairs, and other software.



The software may be downloaded here: http://www.cse.nd.edu/~ccl/software/download

This is a minor release which adds numerous features and fixes several bugs:




  • [WQ] Added API for logging functionality. [Christopher Bauschka]

  • [WQ] Python bindings have more complete access to the API available from C. Documentation has also been improved. [Dinesh Rajan]

  • [WQ] No longer manually redirects stdin/stdout/stderr by editing the user provided shell string, it now sets file descriptors directly. User redirections are no longer overridden. [Patrick Donnelly]

  • [WQ, Makeflow] The torque batch submission system is now supported. [Michael Albrecht, Douglas Thain]

  • [Parrot] Now supports extended attributes. [Patrick Donnelly]

  • [Makeflow] Now supports garbage collection of intermediate files. [Peter Bui]

  • [Makeflow] Now supports lexical scoping of Makeflow variables. [Peter Bui]

  • [Makeflow] New MAKEFLOW keyword for recursive Makeflows. [Peter Bui]

  • [WQ] Bindings for WQ now support SWIG versions >= 1.3.29. [Peter Bui]

  • [Parrot] iRODS now supports putfile/getfile operations for much faster file copies. [Douglas Thain]

  • [Parrot] Now includes watchdog support that runs alongside Parrot. [Douglas Thain, Brian Bockelman]

  • [*] CCTools now have been version information from the -v option. Version information is included in debug output with the `-d debug' flag. [Patrick Donnelly]

  • [WQ] work_queue_status output has been cosmetically improved. [Douglas Thain]

  • [WQ] New $WORK_QUEUE_SANDBOX environment variable. [Dinesh Rajan]



Thanks goes to the contributors for many minor features and bug fixes:




  • Michael Albrecht

  • Christopher Bauschka

  • Brian Bockelman

  • Dan Bradley

  • Peter Bui

  • Iheanyi Ekechukwu

  • Patrick Donnelly

  • Dinesh Rajan

  • Douglas Thain



Please send any feedback to the CCTools discussion mailing list. Enjoy!


Wed, 19 Sep 2012 08:41:00 +0000

Papers at e-Science Conference

Members of the CCL will present two papers and two posters at the upcoming IEEE Conference on e-Science in Chicago:



Tue, 18 Sep 2012 16:36:00 +0000

Lecture and Tutorial: Univ. of Arizona

We are doing a guest lecture and tutorial titled Building Scalable Data Intensive Applications with Makeflow and Work Queue at the University of Arizona as part of the Applied CI Concepts class on September 11 and 13, 2012.
Thu, 06 Sep 2012 15:17:00 +0000