►
From YouTube: Best Practices for HPC Software Developers: #6 "Introduction to High-Performance Parallel I/O"
Description
Feiyi Wang, Oak Ridge National Laboratory, presents: "An Introduction to High-Performance Parallel I/O
Abstract: Parallel data management is a complex problem at large-scale HPC environments. The HPC I/O stack can be viewed as a multi-layered cake and presents an high-level abstraction to the scientists. While this abstraction shields the users from many of the I/O system details, it is very hard to obtain parallel I/O performance or functionality without understanding the end-to-end hierarchical I/O stack in today’s modern complex HPC environments. This talk will introduce the basic parallel I/O concepts and will provide guidelines on obtaining better I/O performance on large-scale parallel platforms.
A
A
First
of
all,
I
will
introduce
some
general
concept
related
HP
g
io
environment
and
the
basic
mechanism
to
achieve
io
paralyzation,
then
I
would
look
at
IO
from
three
perspectives
from
a
user
or
applications
perspective
from
the
story
system,
designers
perspective
and
from
performance
perspective,
so
together,
I'm
hoping
to
establish
a
end
to
end
view
on
the
system
and
to
help
you
to
gain
a
deeper
understanding
on.
What's
going
on
underneath.
A
A
Speaking
of
HP
g
io,
besides
the
programming
api,
the
first
thing
comes
to
month
might
be
the
parallel
file
system,
also
known
as
the
TFS
just
to
be
clear.
The
HPC
aisle
is
more
than
just
TFS,
although
the
PFS
is
indeed
a
critical
piece,
and
it
is
the
first
user
interaction
point.
So
at
the
very
high
level,
the
TFS
is
logically
composed
of
three
components:
the
TFS
plant,
the
metadata
services
and
the
I/o
services.
The
figure
here
trying
to
illustrate
how
this
different
opponents
are
related
to
each
other.
A
Tfs
share
a
common
set
of
characterizations.
First,
it
usually
support
the
so-called
global
namespace.
What
that
means
is
it
doesn't
matter
which
compute
node
are
allocated
in
your
job?
When
your
application
starts,
it
can
see
a
consolidated
and
consistent
view
on
the
foul
and
directories.
The
peer
bet
is
also
designed
with
parallelism
and
the
scalability
demand.
A
The
TFS
is
also
said
to
be
high
performance
from
the
network
hardware
side.
It
usually
means
we
go
beyond
the
conventional
Ethernet
and
use,
let's
see,
InfiniBand
the
technology
for
better
latency
as
well
as
sanguinis,
and
the
software
wise.
It
also
makes
use
of
a
highly
customized
or
freaking
system,
along
with
highly
tuned
network
produced
protocol
stack
for
maximum
efficiency,
and
the
scalability
TFS
also
claimed
to
be
POSIX
compliant
here.
It
does
not
really
mean
100%
products,
because
that
would
be
difficult
as
far
as
file
system
products
comprise
goes
what
that
means.
A
In
a
nutshell,
you
can
access
the
system
with
a
file
interface
and
the
issue
open,
read/write,
close
system
cost
to
it.
The
purpose
is
different
from
desktop
or
laptop
file
system.
Lewis
file
system
usually
are
referred
as
the
local
file
system.
In
addition
to
the
obvious
complexity
involved,
another
notable
characterization
of
that
is
the
TFS
is
a
highly
project
contested
and
share
the
resource.
A
With
some
except
exceptions,
the
performance,
isolation
and
the
quality
of
service
are
not
quite
there
yet
so
to
some
degree,
it's
the
similar
to
the
internet.
It's
the
best
of
effort
service,
but
worse
than
Internet,
a
misbehaving
application
more
precisely.
The
workload
it
generates
can
actually
Integra
dated
the
overall
Iowa
system
performance,
and
that's
why
the
operational
team
often
put
in
all
kinds
of
filters
and
alarms
to
monitor
it.
Once
such
job
are
are
identified,
it
will
be
terminated
to
to
mitigate
the
defect.
A
A
The
data
treatment
algorithm
can
be
as
clever
as
it's
needed,
for
example,
it
can
take
into
topology
and
the
locality
into
consideration.
It
can
also
take
the
failure
domain
into
consideration
so
that
the
different
replicas
of
the
data
can
go
into
different,
figured
Oh
monthly
for
torrent,
and
it
can
also
be
as
simple
as
has
been
drawn
here.
A
You
just
spread
out
those
data
chunk
in
a
sequential
way
and
although
I
draw
the
certain
target
here
as
a
single
disc
but
more
than
than
not
in
practice,
multiple
discs
are
going
to
be
founded
together,
using
read
technology
to
store
extra
parity
information
ayat.
This
is
to
improve
both
the
performance
and
the
reliability
and.
A
The
different
TFS
have
different
ways
of
deciding
what
would
be
what
they
call
the
whole
you,
because
this
data,
the
size
of
the
data,
often
called
the
stretch,
size
and
Hawaii
you
construct.
The
data
often
called
the
stripe
way
and
some
TFS
try
to
automate
everything
to
simplify
some
TFS
will
try
to
provide
you
more
control
point
and
the
disk
can
have
a
major
implications
on
the
performance.
A
If
you
have
worked
with
some
Laster
before
you
might
relate
the
story
target
as
the
USP
and
the
software
running
on
top
of
it
as
the
OSS,
and
if
you
come
from
the
GPRS
world,
there's
more
akin
to
the
globe
what
they
call
the
network
share,
the
disc
honesty
and
as
the
server,
but
all
in
all,
this
general
concept
on
the
strapping
pattern
are
quite
applicable
across
the
board
before
I'm
moving
into
the
programming
perspective.
Are
there
any
questions.
A
Let
me
move
on
to
the
programming
perspective
of
parallel,
so
basically
the
task
is
that
we
want
to
process
the
some
amount
of
data
as
quickly
as
possible
and
as
reliably
as
possible.
So
in
a
PC
we
have
many
choices.
It
can
be
as
simple
as
the
pot
exile
or
an
Pio
or
peril
era
at
NASA,
TF
and
html5.
So
I
don't
have
this
detailed
programming
scripted
to
illustrate
all
these
choices,
but
I
did
provide
a
reference
link
at
the
end
of
the
talk.
They
usually
have
more
bearable,
tutorial
and
documenting
documentation.
A
Then
I
have
within
this
talk.
Another
choice
is,
is,
is
another
well-known
choice?
It's
called
adios,
it's
a
middleware
solution,
so
the
key
idea
for
al
use
is:
it
provides
a
richer
set
of
API
as
well
as
optimization,
along
with
the
contribution
directives,
you
can
adapt
to
go
out
to
make
use
of
other
underlying
libraries.
A
It's
it
basically
insulates
you
from
banding
to
a
particular
API,
but
the
downside
of
it
that
you
need
to
have
to
learn
a
new
API
and
for
the
really
complex
I
will
requirement
you.
Might
it
might
be
helpful
or
even
necessary
to
think
about
I?
Imagine
so.
Essentially
you
are
doing
the
marking
from
your
application
data
model.
It
could
be
one
big
2d
or
3d
array
to
the
store
data
model.
A
It
can
be
the
fall
based
or
object,
based
or
whatever
the
third-party
library
provided
model,
and
also
an
automatic
piece
for
this
library
or
the
bus
system
to
match
to
the
bunker
hardware.
Io
Hardware,
not
all
the
marking,
are
efficient
for
every
single
use
case.
So
this
is
where
the
design
trade-off
have
to
take
place.
A
So
next
I'm
going
to
talk
about
three
basic
Iowa
I/o
master,
let's
start
ways
to
see
Rio.
So,
yes,
you
can
do
Sarah,
I,
hope
you
know
HPC
environment,
and
sometimes
it
even
makes
us
so
that
idea
it
is
simple.
All
the
processes
will
start
their
data
to
the
master
process
most
commonly.
If
this
is
a
run,
zero
and
the
master
process
will
collect
the
data
and
the
read
date
not
to
a
file
in
a
serial
mode,
so
read
can
also
take
place
in
the
reverse
order.
A
So
let
me
first
talk
about
the
disadvantage
of
this
approach.
It's
not
terribly
efficient,
as
you
can
tell,
this
is
a
two-stage
process.
Before
you
can
actually
do
the
aisle
you
have
to
communicate
and
a
second,
you
have
it's
not
very
scalable.
If
the
aggregate
decides
desires
for
the
iowa
exceed
the
memory
of
the
master
process,
this
approach
may
not
be
even
feasible.
A
So
what's
the
what's
the
use
case
for
this,
let's
imagine
that
you
have
a
configuration
bar
or
some
kind
of
staging
input
file.
You
want
to
share
with
many
many
processes
and
for
every
process
to
issue
open,
read
and
close
for
such
little
amount
of
data.
It
might
be
impose
undue
burden
on
the
parallel
processor.
A
Instead,
what
you
can
do
is
you
ask
the
master
process
to
read
in
this
file
and
the
2
ampere
broadcast
and
share
the
information
with
the
rest
of
the
processes,
and
this
essentially
are
translating
a
IO
bound
problem
to
a
communication
problem
and
assuming
that
you
have
high
performance,
interconnect
Network.
This
will
be
a
acceptable
solution
to
certain
use
case.
A
The
second
divemaster
working
to
talk
about
is
file
per
process,
so
in
this
ayah
bastard
each
process
will
write.
Is
own
data
to
a
separate
ball?
So
if
you
have
n
for
processes,
you
will
end
up
with
a
number
of
files
on
disk.
So
that's
why
it's
called
an
to
n.
So
the
advantage
of
this
approach
is
it's
simple
program
and
it
can
be
fast.
It's
also
very
natural
because
you
can
clearly
see
where
the
paralyzation
are
happens.
A
The
caveat
with
this
approach
is
that,
as
your
application
skills,
you
have
to
consider
the
many
many
files
you
generate
and
its
impact
on
the
TFS
and,
in
particular,
the
metadata
server
for
single
share
the
directory
with
many
many
files.
This
is
traditionally
a
weak
spot
as
far
as
the
performance
goals,
and
the
second
caveat
is
that
when
you
accumulated
so
many
files
is
a
little
bit
harder
to
manage
when
you
want
to
do
the
post
data
analysis.
A
If
you
want
to
archive
this,
a
set
of
data
files
or
for
long-term
storage
stay
to
HP
SS,
which
is
tape
based,
and
you
probably
have
to
repair
it
up
before
you
do
the
transfer
and
that
this
could
be
a
very
slow
process,
that
those
are
the
cost
that
you
might
want
to.
Consider
and
another
the
third
method
I
want
to
mention
here
is
a
single
shared
power
method,
so.
B
A
Access
method,
each
process
are
going
to
write
their
own
data
to
the
same
file
and
you
have
to
each.
Of
course,
each
process
will
have
to
carefully
calculate
the
offset
to
avoid
over
stepping
on
each
other's
toes,
because
you
end
up
with
one
single
file.
This
is
coded
into
an
mode.
So
the
advantage
of
this
method
is
you
end
up
with
the
single
file,
it's
very
manageable
and
the
wizard
relatively
straightforward
approach.
A
B
So
we
do
have
a
question
from
Eric
at
NASA
Langley.
He
asks
I
have
several
end-to-end
reads
and
writes
in
my
application.
However,
I
can
throttle
the
number
of
ranks
that
are
hitting
the
disc
at
any
one
time,
so
50,000
ranks
aren't
hitting
the
system
all
at
once
when
we're
running
on
50,000
cores,
I'm
sure
that
system
load
and
other
factors
what
factors
come
into
play
when
determining
how
many
ranks
I
should
be
allowing
to
simultaneously
hit
the
I/o
system.
What's
a
reasonable
number
for
common
systems
such
as
Titan,
oh.
A
That's
a
very
good
question.
Yes,
you
did
control
and
try
to
climb
it.
There
are
a
first
first
first,
let
me
say
when
we
benchmark
the
filesystem.
Obviously
we
don't
use
I
interpreted
a
Toronto.
We
don't
use
all
18,000
the
688
compute
nodes
available
and
the
way
generally
for
2,000
computer
node.
We
can
pretty
much
approach
the
best
performance
we
can
get
and
the
other
our
caveat
regarding
the
exact
number
and
optimization
you
you
do
for
this
type
of
system.
Is
it's
a
very
platform
specific.
A
A
So
let
me
move
on
to
the
system
perspective.
So,
as
it's
become
evident
now,
the
HPG
I/o
system
is
a
product
of
a
combination
of
software
and
hardware,
so
an
and
I'll
pass
is.
It
will
be
helpful
for
you
to
gain
a
deeper
understanding.
So
what
this
graph
show
here
are
taken
from
the
tenon
file
system
production
system
with
some
details
removed.
So
let's
say
on
the
left
side,
you
or
application
want
to
persist
a
a
piece
of
data.
A
So
essentially
this
means
your
process
are
going
to
be
launched
from
one
of
the
18,000
688
compute
node.
Each
computer
has
16
physical
cores
and
you're
going
to
be
launched
from
one
whose
process
and
that
data
would
traverse
through
its
read,
eat
horse
network
and
the
rich
one
of
the
Iowa
daughters.
We
have
440
m
done
and
from
that
water
it
will
traverse
through
external
infinity,
on
the
network
with
1600
network
ports
and
well
then
it
would
reach
to
one
of
the
288
storage
servers
from
there.
A
It
will
be
passed
through
a
in
terms
of
network
and
get
on
to
one
of
the
disk
controllers
altogether.
They
manage
about
20,000
160
disks,
so
that
exact,
the
specific
details
of
this
traversal
are
not
important.
What
I
want
to
convey
here
is
from
the
place
where
the
data
is
originated
to
the
final
destination
is
going
to
be
stored
at
this
is
a
wrong
way
to
travel
and
that's
one
of
the
major
factors
that
introduced
the
the
complexity
as
well
as
the
performance
variability.
A
So
this
is
simple
and
natural
starting
point
for
many
systems.
Over
time.
We
have
found
out
that
many
downside
of
this
pattern.
Obviously
it
has
a
wasted
resource
and
also
we
have
to
consider
the
procurement
cost,
whether
you
have
to
spec
all
the
system.
You
need
to
do
technology
evaluation
and
you
have
to
do
the
acceptance
testing
for
it.
A
It
also
have
extra
operational
cost,
which
means
you
have
to
assign
individual
HPC
operation
teams
for
it
and
the
possibly
maintainer
a
variety
of
hardware
and
software
solutions,
and
one
of
the
biggest
in
Binion's
for
user
is
so-called
the
data
atom
problem.
Where
data
generated
on
one
system
and
if
you
want
to
analyze
it
other
visualize,
it
are
different
cluster.
You
have
to
move
the
data
over,
which
is
additional
cost.
A
So
over
time
we
have
made
the
paradigm
shift
the
to
so
called
as
a
data
centric
paradigm.
So
the
idea
of
it
is
actually
quite
simple.
Basically,
we
consolidated
all
the
services
solution
into
this
so-called
center.
The
filesystem-
and
they
will
never
make
sense-
will
monitor
the
centralized
system
of
everything
other
cluster.
A
So
the
obvious
advantage
approved
for
this
approach
is,
it
did
address
the
data
island
problem
and
many
user
likes
it,
but
this
paradigm
is
not
without
its
problems.
For
example,
if
you
pay
attention
here,
I
put
data
availability
on
both
brought
pro-ana
thoughts.
So
let's
talk
about
probe
in
the
whole
system.
A
If
I
want
to
take,
let's
say
the
computer
machine
offline
for
maintenance,
all
the
data
generated
with
that
cluster
will
be
gone
and
nobody
can
access
it
and
with
this
paradigm,
even
if
I
take
the
test
and
compute
cluster
of
lot,
you
can
still
access
your
data
from
other
to
your
cluster.
Let's
see
the
visualization
or
the
Nasus
cluster.
A
An
another
factor
to
consider
is
on
the
mixed
workload.
So,
let's
think
about
the
use
case
in
error,
a
user
make
a
reservation
request
and
the
code
of
the
holo-pendant
machine,
the
biggest
future
cluster
in
our
Center,
which
has
18,000
the
688
the
Pro
to
node.
Does
it
make
sense
for
the
user
or
application
to
expect
to
have
the
best
or
the
peak
performance
as
far
as
I/o
goes?
A
So,
if
you
think
back
in
the
machine
exclusive
pattern
that
might
work,
but
in
this
new
paradigm,
when
you
have
mixed
the
workload
in
place,
even
you
have
exclude
exclusive
access
of
the
compute
cluster.
That
doesn't
mean
you
have
monopoly
on
the
shear,
the
resource
or
the
file
system.
The
other
visualization,
as
well
as
the
analysis
machine,
might
put
a
different
workload
onto
the
system
which
will
interfere
with
your
own
workload.
A
So
the
mix
the
workload
is
really
a
another
factor
that
has
to
be
taken
into
account.
So
just
to
summarize
the
performance
personnel
at
the
15
perspectives,
so
the
system
design
is
about
the
trade-offs.
We
pretty
much
make
compromise
every
every
where
we
make
a
compromise
on
performance
capacity,
scalability,
availability
and,
of
course,
the
past,
and
we
have
seen
the
complexity
and
the
control
of
the
IO
and
2
n
pass
is
very
much
decentralized
and
we
also
need
to
be
mindful
about
the
impact
of
mixed
work.
A
B
We
have
one
question
which
is
revisiting
the
earlier
one
from
another
person,
and
so
you
may
want
to
defer
answering,
but
I'll
I'll
put
it
out
there
now,
so
you
can
be
thinking
about
it.
Ok,
so
this
is
from
Evan
Felix.
And
yes,
how
does
this
hybrid
approach
between
1
to
1
and
end
to
one
work?
So
if
you're,
you
know,
if
you
have
a
18,000
processes
and
you
want
to
write,
use
only
2,000
of
them
at
a
time
right,
because
that
max
is
at
the
system.
Essentially,
how
do
you?
B
A
So
when
people
talk
about
their
performance
numbers,
the
first
question
I
want
to
ask
is
what
kind
of
performance
you
are
going
to
talk
about,
so
we
often
benchmark
the
performance
at
three
levels,
starting
well,
not
really,
starting
by
application
level,
performance,
fast
system
level,
performance
and
the
block
level
performance.
Let
me
see
a
little
bit
more
about
the
broad
hyper
performance.
A
What
that
means
is
given
a
set
of
law
of
discs
and
their
controller
the
bare
hardware,
what
kind
of
aggregate
performance
we
can
get
without
the
overhead
of
the
file
system,
so
that
usually
represents
the
upper
bound
on
how
the
system
can
do,
and
each
level
above
will
add
a
certain
overhead
to
it
and,
in
addition
to
this
different
level
performance,
we
need
to
consider
the
access
patterns.
Are
you
doing
sequential,
read
on
the
right?
Are
you
doing
randomly
banana
bread?
Are
you
making
use
of
small
files?
A
A
lot
of
them
are
using
big
files
and
are
there
any
mix,
the
workload
of
the
gameplay
and
the
could
potentially
interfere
with
your
own
workload?
So
what
I
found
is
having
or
trying
to
establish
a
mental
picture
on
your
performance
correlation
can
go
a
long
way
to
identify
and
clarify
your
potential
idle
problems.
A
So
some
of
the
general
observation
are
the
and
user
experience
performance.
Wise
is
a
little
bit
less
pretty
predictable
in
HPC,
compared
to
your
regular,
desktop
and
laptop
file
system
for
both
the
latency
and
bandwidth
and
I.
Think
it
should
be
pretty
obvious
now
that
the
factors
behind
it
and
also
it
is
very
challenging,
if
not
possible,
to
achieve
the
performance
when
you
in
production
you
are-
and
this
is
also
a
go
back
to
what
I
said
earlier
in
one
week.
A
Let
me
talk
to
the
next
one
first,
so
but
compute
overpowers,
the
I/o
and
a
fraction
of
the
whole
mission
can
actually
overwhelmed
undergoing
a
service
platform.
So
I
mentioned
earlier,
when
we
benchmark
there
are
fast
system.
We
almost
never
use
all
eighteen
thousand
six
hundred
eighty
eight
control
node
and
we
generally
end
up
with
about
the
two
thousand
between
2000
and
4000,
the
compute
node
and
the
given
for
those
camp.
A
You
know
de
we're
not
going
to
launch
processes
on
each
core
and
we
usually
are
making
use
of
two
to
four
cores
on
each
compute
node
and
the
more
course
are
more
processes
on
individual
compute.
Node
will
just
cause
internal
contention
because,
if
you
think
about
it,
this
computer
have
no
directly
attached
the
disk.
It
used,
usually
go
through
a
a
network
port
and
that
the
network
port
itself
create
a
bottleneck.
A
You
do
not
really
need
all
sixteen
processes
to
hope
to
just
saturate
that
single
compute
node,
so
this
next,
the
two
threads
provide
just
some
reference
links
to
the
previous
terms
and
mention,
and
also
one
of
them
is
IO
character.
Addition
through,
which
is
kind
of
popular
here
in
the
HPC
centers
version
we
have
it
deployed
on
heaven
and
also
some
of
the
I/o
library
on
the
middleware
reference
beings.
A
So,
as
a
final
note,
I
should
mention
that
HP
here
io
system
is
a
fast
changing
landscape,
for
example
the
non-volatile
memory
such
as
SSD
Arcanine
popularities
in
both
consumer
space
and
enterprise
space.
So
in
HPC
system
we
do
not
afford
to
have
a
wholesome
tradition
to
that
yet,
but
in
the
next
the
system
is
more
likely,
you
will
see
a
form
of
it
that
it
is
the
first
part.
A
So
that's
why
we
say
that
the
third
system
are
trending
to
be
both
more
here
article
and
more
heterogeneous,
and
that
extra
layer
cause
first
part
means
that
the
I
imagine
I
talked
earlier
will
become
more
complex
and
it
really
require
a
concerted
effort
from
both
the
end-user,
the
application
developer,
the
middle
developer,
the
storage
system
designer
and,
finally,
the
system
provider
to
tackle
this
new
challenge
and
make
the
best
use
of
it.
So
this
conclude
my
talk,
but
before
I
take,
can
you
repeat
the
previous
question?
Anything
yeah,
absolutely.
B
So
this
question
came
from
Evan,
so
Evan
was
following
up
on
the
previous
discussion
of
how
the
how
to
work
with
a
smaller
set
of
nodes
doing
the
actual
I/o.
If
you
don't
want
to
have
all
18,000
nodes
on
the
system
doing
I/o.
So
he
says
how
does
this
hybrid
approach
work
so
that
a
group
of
nodes
do
you
have
some
kind
of
sub
master
and
you
send
that
data
to
one
of
these
guys
and
then
he
is
responsible
for
writing
it
out
or
things
are
there.
A
So
that's
a
that's
a
really
good
question,
so
there
are
at
least
on
top
of
my
mind
that
there
are
two
options
you
can
think
of.
One
option
is:
if
you
are
using
the
learn
public
file,
this
will
be
a
little
more
involved.
You
have
to
you,
have
to
do
the
all
the
communications
and
set
it
up
as
groups,
and
do
it
yourself
the
more
approachable
a
way
to
address
this
is
to
pick
the
Manitoba
and
Pio
and
the
Indian
tribal.
A
So
even
if
upper-layer,
you
are
doing
fairly
small
aisles,
the
aggregator
underneath
is
doing
the
aggregation
for
you
and
collected
all
smiles
and
then
do
the
iowa
food.
So
in
to
some
degree,
this
is
not
either
untrue
and
open
to
one
anymore.
It's
more
like
M,
two
and
M
is
the
number
of
aggregators
in
the
middle.
So
I
would
think
that
that
will
be
a
better
way
to
AK
lasting
issue.
So.
B
A
Another
option
will
be
a
the
viewer
solution.
I
mentioned
earlier
annuals
as
far
as
I
understand.
Annuals
can
pretty
much
do
the
same
for
you.
It
can
use
on
tile
that
kind
of
share
the
structure
or
you
can
use
a
views
own
aggregation
function
to
do
that.
It
will
improve
the
performance.
In
that
particular
case.
You.
B
Know
so
we
have
one
more
question,
but
they
can
I.
Also
ask
you
to
bring
up
the
summary
side.
Actually,
maybe
we
need
to
go
back
for
this
question
to
your
slides.
So
question
is
from
Michael.
He
says
so
in
your
one
of
your
next
to
last
slide,
or
so
you
have
this
thing
about
a
nexus
question.
You're
asking
about
XY
and
Z.
B
A
I
remember
that
function
so
I,
just
before
the
personable
for
the
folks
and
remember
the
question.
The
question
was
important
posed
as
I
have
been
allocated
to
this
X
number.
X
number,
of
course-
and
you
said
your
system
is
capable
of
Y
numbers
and
why
am
I
going
only
getting
the
number
performance
so
I
cannot
generalize
the
function
or
the
answer
to
other
platforms,
but
I
can
provide
a
some
guideline
and
so
for
the
pattern
or
the
evidence
for
system
serving
pattern.
So
what
you
can
think
is
death
on
pattern.
A
Let
me
be
conservative,
450
megabytes
per
second
on
each
search
target,
and
if
you
are
talking
about
random
workload
on
that
started
target
we
are
talking
about
about
1/4
of
it
more
like
of
150
or
200,
so
no
master
would
be
needed.
So
if
you're
talking
about
the
application
level
performance,
you
have
to
think
about
the
kind
of
file
you
are
dealing
with.
A
Are
you
talking
about
a
single
shared
upon
how
large
strip
of
that
power
is
being
strapped
out,
and
then
you
can
do
a
aggregation
and
see
how
much
performance
you
can
squeeze
out
of
it?
That
probably
represents
the
performance
of
upper
bound.
Yoga
manager
will
be
very
much
very
depends
on
the
work
role
and
the
distraction
pattern.
I
hope
this
make
sense
to
you.
A
B
If
I
can
kind
of
summarize
one
of
the
messages
I
think
you've
given
in
this
presentation,
if
I
owe
systems,
are
very
dependent
on
the
specifics
of
the
platform
and
the
specifics
of
the
application.
So
if
you're
moving
an
application
from
one
platform
to
another,
you
need
to
reset
your
expectations
for
the
I/o
performance
on
that
new
system,
and
it
sounds
to
me
like
one
way
to
approach
that
would
be
to
start
by
maybe
talking
to
the
folks
that
run
that
system
and
understand
sort
of
what
the
maximums
are.
B
What
the
kind
of
benchmark
numbers
are
in
that
slide,
that
you
talked
about
the
different
levels
of
benchmarking
and
come
to
and
then
doing
some
experiments
with
your
application
to
try
to
figure
out
the
configuration
that
will
allow
you
to
achieve
them.
You
know
what
you
can
reasonably
get
out
of
that
capability.
Yes,.
A
That's
very
much
to
the
point,
and
also
when
you
do
that
kind
of
optimization
for
each
individual
platform.
You
probably
also
want
to
be
mindful
about
the
application
portability
where
the
optimization
you
do
for
one
platform
may
not
be
that
portable
to
another,
and
so
there
is
a
certain
cost
involved
and
also,
as
you
said,
different
to
compute
the
center.
The
usually
provides
some
kind
of
a
guide,
a
lot
of
user,
your
underlying
infrastructure
or
the
back
best
practice
for
that
particular
platform
and
the
some
of
the
third-party
library
and
see
hdf5.
A
B
B
A
B
B
That's
HPC
best
practices
at
gmail,
comm,
the
plus
session
zero
six
will
help
us
identify
which
webinar
it's
associated
with.
You
can
also
leave
that
out.
If
you
don't
like
typing
too
much.
Also,
please
visit
this
bitly
link
at
the
top
of
the
page
to
make
sure
that
you
get
counted
as
a
participant.
Here
we
will
be
posting
the
recording
online.
The
slides
are
already
available
online
at
the
URL.
That's
shown
here.
B
That's
the
registration
site
at
the
OLC
F,
and
then
I
would
finally
like
to
note
that
our
next
webinar
will
be
about
basic
performance
analysis
and
optimization
that
will
be
Tuesday
August
9th
at
1:00
p.m.
Eastern,
and
the
presenter
will
be
checked
to
slip
of
nurse
so
with
that
I.
Thank
you
all
for
your
participation
and
endless
see
you
in
a
few
weeks
about.