The Frugal System
The Frugal System is a metacomputing package that distributes jobs
intelligently on a Jini network.
Why "Frugal?" The Frugal System spends the network's
resources carefully. At all times, it thinks about the future
cost of each decision -- about making sure that conditions of high
processor load or memory exhaustion never happen.
R. Sean Borgstrom created
the Frugal System as one part of the doctoral dissertation research, titled
"A Cost-Benefit Apprach to Resource Allocation in Scalable Metacomputers", which was
carried out under the supervision of Dr. Yair Amir.
Formal release of source and binaries is
expected in early August 2000. The Frugal System is currently developed at the
Center for Networking and Distributed
The Johns Hopkins University.
For more information about the Frugal System and active research
on competitive metacomputing systems, take a look at the
CNDS web site.
Stable Performance / Near-Optimality: The Frugal
System's maximum usage of the system resources -- the memory
and CPU of the machines on the network -- is guaranteed to approximate
that of the best possible job scheduler within a logarithmic
factor. This holds even if that optimal scheduler knows the future
and Frugal does not!
Proven Efficiency: In tests, the Frugal System's
decision strategy outperforms naive strategies by about 39%.
It beats carefully optimized strategies by a factor of about 13%.
That's how much faster users can expect the average job to
Easy to Use: With the Frugal System, it is easy to
build Java and Jini programs that run, not on the machine where
the user launches them, but on the best machine for that job.
What This Means For You: Using the Frugal System on
your Jini network will improve the expected performance of each
job and provide good system performance in the worst case.
Machines on the network will maintain relatively low loads and a
low incidence of thrashing throughout the network's lifetime.
The "frugal" strategy spends system resources carefully, and is
almost never caught short!
The Frugal System consists of 2 parts:
To use the Frugal System, a program simply looks up the manager on
the Jini lookup service, asks the manager for the reference for an
appropriate compute engine, and sends its work to that engine. The
engine performs the computation and returns the results.
- A compute engine that allows a machine to run jobs created on
other machines, and
- A "Manager" that decides on which compute engine a given
job should run.
Documentation for the Frugal System can be found at
Frugal Packages off the
metacomputing webpage. Step-by-step instructions and
general information appear in the edu.jhu.cnds.Frugal package
You can download the Frugal System here.
The Frugal System development was partially funded by a grant from the
Defense Advance Research Projects Agency (DARPA) to Johns Hopkins
University. The U.S. Government retains certain rights in this software.