[Swift-user] Job bundles

[Ioan Raicu]

Hi,
I had a similar discussion with Nika, and here was the summary of what I 
told her (in the context of GRAM4):
GRAM4 has two elements that dictate how many nodes and processes it gets 
(in the XML RSL).
<count>processCount</count>
<hostCount>hostCount</hostCount>

The <hostCount> is the number of nodes you want, say 1.  The <count> is 
the number of processes that you want to start in total.  To compute the 
number of processes per node, you would simply take 
processCount/hostCount.  Now, the catch is that all the commands and 
argument to the particular GRAM4 call will have to be the same, so you 
won't be able to specify to GRAM that you want 8 processes per node say, 
but to run a different process for each of those 8.  You will have to 
have this kind of logic internally in your app.  If Swift works the way 
I think it works, I don't think you will be able to use multiple 
processors unless at least one of the following is true:
1) the application is already multi-threaded, and implicitly can use 
multiple cores
2) the LRM allows the partitioning of the SMP machine into smaller 
pieces; for example, with 8 processor node, if it lets you submit 8 jobs 
that only need 1 processor, and it will launch 8 different jobs on the 
same node, then you are fine... the parallelism will be done 
automatically by the LRM, as long as you ask for only 1 process at a 
time; on the TG at least, I don't think this is how things work, and 
when you get a node, regardless of how many processors it has, you get 
full access to all processors, not just the ones you asked for.
3) the bundling component in Swift somehow should be able to control how 
many concurrent jobs it should perform; by default, I suppose it 
serializes the entire bundle, but you could imagine having a parameter 
that allows you to increase the parallelism if you know the application 
is not CPU bound for example

Choices #1 and #2 are the easiest, as you don't have to do anything 
special from Swift's point of view.  Choice #3 requires that Swift 
handle the parallelism.  GRAM4 as far as I know will not handle this.  
Maybe the Swift team can shed more light on option #3, if there is such 
an option.

Ioan

Yuqing Deng wrote:
> Hi,
>
>  I am using swift to run workflow on login-abe.ncsa.teragrid.org at
> ncsa.  Abe is allocated on node basis.  Each of the node has 8
> computing cores.  My jobs are all serial.  What happens is that only
> one jobs runs on one core per node.  It there a way to bundle jobs so
> that 8 of them
> could run simultaneously on a node?  I have tried to use
>    <profile namespace="globus" key="xcount">8</profile>
>    <profile namespace="globus" key="host_xcount">1</profile>
> in the sites.xml file.  But doing that seems to run the same job eight
> times on a node.
>
>  Thanks,
>
>  Yuqing
> _______________________________________________
> Swift-user mailing list
> Swift-user at ci.uchicago.edu
> http://mail.ci.uchicago.edu/mailman/listinfo/swift-user
>
>   

-- 
============================================
Ioan Raicu
Ph.D. Student
============================================
Distributed Systems Laboratory
Computer Science Department
University of Chicago
1100 E. 58th Street, Ryerson Hall
Chicago, IL 60637
============================================
Email: iraicu at cs.uchicago.edu
Web:   http://www.cs.uchicago.edu/~iraicu
       http://dsl.cs.uchicago.edu/
============================================
============================================