| The simulation of real physical processes is accomplished by first setting
up a set of partial differential equations, whose solution yields some
function, or set of functions, that describe the phenomena. However, in
most real-world problems the PDE's are not solvable analytically, or their
analytic functions are so complex as to be unapproachable by any method
other than numerical.
In numerically solving PDE's, perhaps the most widely used numerical technique
is finite differencing. Of those the Forward Time, Centered Space (FTCS)
discretization method and is one of the most popular - See Appendix A for
details on this technique). No matter what discretization technique one
chooses (finite differencing or finite elements), for each point an equation,
or set of equations, must be solved.
It should be fairly obvious why discretization techniques lead to a requirement
for massive amounts of memory. A relatively modest 250X250X250 grid would
translate into 15 million points. For each point an equation, or set of
equations, needs to be solved, that involve the adjacent points. If each point
is represented by a 64-bit value, the minimum data-array size approaches 120
Mbytes. Using the FTCS (see appendix) technique each point would require the
processing of the adjacent 24-points (assuming cartesian coordinates) and total
data throughput would be approximately 2.8 Gbytes - exclusive of code space.
Moroever, at the next time step, the process would be repeated using the
previously computed values.
The need to address large amounts of memory is apparent. If handling monster
arrays were all that was required, though, sophisticated virtual memory schemes
might prove to be a reasonable alternative where cost of memory and system
design considerations needs to be factored in. However, the driving force
behind the need for large address space comes as much from high precision
requirements as it does from large memories. Mathematically, one can show a
specific relationship between the mesh sizes, {dX, dY, dZ}, and the time step,
dT, that determine whether a particular implementation is stable. For example,
for a one dimensional spatial grid the stability condition can be derived using
what is termed Fourier-Von Neumann Stability analysis (see attached cc).
dT =< K*(0.5)*(dX)**2
Where K is a constant of proportionality.
This puts a practical constraint on numerical computations. The time steps,
dT, must not be too large or the scheme becomes unstable. On the other hand,
if the spatial resolution is too fine, the scheme becomes to expensive in terms
of computational resources required. The designer of machines for these very
common applications has to solve the problem of how to compute highly resolved
spatial grids without destroying the performance; ergo 64-bit precision CPU's
are the standard for serious applications in this space.
The point is that accuracy and computational throughput, while intimately
related, justify 64-bits for different reasons. 64-bits enable higher
computational throughput, which in turn allows investigators to use more
spatial grid points (or more particles, or spins, etc.,) that give better
approximations to some continuum limit. It is this insatiable desire for more
accurate representations of the real world that is driving the need for 64-bit
precision. It is the time constraints that are driving the large addressing
space issues (Indeed, an 8-bit computer can handle the precision requirements
as well as a Cray XMP - It just takes 3 orders of magnitude longer)
|
| Computers are being used as a research tool to do simulations.
These simulations generally work from first principles (the PDEs,
for example), and apply them to a quantized model (the delta X,
Y, Z, and T). If the model is too coarse, the accuracy of the
simulation suffers.
Note that for some problems, the only way to tell whether a model
is fine enough is to compare one simulation with another that uses
a finer model. Also, there is a trade-off between the deltas --
for example, a larger delta X may be compensated by a smaller delta T.
A less obvious form of quantization is in the floating-point numbers
themselves (the precision -- another delta). Again, one may be able
to compensate between the deltas.
As one or more of the deltas are decreased, others may define the
limits on the simulation, and they will need to be decreased for
further improvement.
Hardware has been getting faster and cheaper, making more problems
amenable to computer simulation. The newly tractable problems are
simply those that were near the limit of whatever limit has been
extended -- speed, accuracy, expense, size, etc. As any dimension
of "computable" has increased, there have always been problems that
fit in that new territory.
Currently, hardware advances are outstripping advances in programmer
productivity. Although most of these simulations have 'locality' going
for them (a reflection of the real world), and so could be solved with
existing memory constraints, the market value of solving simpler problems
and decreasing memory costs have kept programmers from taking advantage
of 'locality' in doing these simulations. It's more cost-effective to
buy more memory.
|