►
From YouTube: Benchmarking IPLD in IPFS
Description
Hannah Howard demos a benchmarking framework for measuring data transfers.
A
A
B
A
A
You
know
it
has
sort
of
like
all
of
the
major
steps
and
like
and
like
a
traditional
transfer
workflow
in
our
system,
so
there's
the
process
of
adding
the
files
into
the
system
which,
in
the
case
of
like
ipfs,
means
converting
them
to
unix,
fs,
converting
them
to
you,
know
to
ipld
data
and
then
transferring
and
then
serializing
them
back
out
to
flat
files.
So
this
is
a
really
it's
a
really
cool
suite
of
tools.
A
More
recently
we
wanted.
So
you
know
the
data
systems
team
has
been
we've.
Basically
been
trying
to
take
ipld,
prime,
which
is
our
brands,
fake
and
new.
I
was
not
brand
spanking
new
at
this
point,
but
it's
our
it's
our
new
and
super
awesome
new
hotness,
a
version
of
ipld
as
opposed
to
the
old,
the
old
and
busted
libraries
and
we've
been
trying
to
get
them
all
throughout
ipfs,
so
that
we
have
all
the
capabilities
of
ipld
in
ipfs.
A
But
this
entails
a
whole
bunch
of
changes
to
our
stack
and
we
want
to
make
sure
that
when
we
ship
this
thing,
we
don't
break
ipfs.
So
we've
been
using
this
benchmark
and
what
we've
done
is
we've
set
up
essentially
this
benchmark
to
run
a
version
of
our
current
master
version
of
ipfs.
Our
current
released
version
of
ipfs.
A
It,
you
know
essentially
add
files
transfer
them
to
another
node
and
then
and
then
put
them
back
out
as
a
regular
file,
and
then
we
set
up
a
version
that
runs
in
that
runs
with
our
branches
in
ipl
g,
prime
and
ipfs,
and
these
these
early
versions
are
really
just
compatibility
versions.
We
found
ways
to
share
to
shim
in
ipld,
prime,
without
really
taking
advantage
of
its
capabilities
or
optimizing
around
it,
but
we
ran
these
benchmarks
and
we've
gotten
some
results.
A
A
One
of
the
super
cool
things
about
test
ground
is
that
you
can
sorry
if
I'm
going
super
fast
here,
but
is
that
you
can
like
basically
build
a
a
benchmark
where,
with
these
these
composition
files,
where
I
don't
know,
if
you
all,
can
see
this,
this
might
not
mean
anything
to
the
to
the
folks
who
aren't
who
don't
work
with
testron,
but
right
here.
What
I'm
doing
in
this
is.
I
am
actually
replacing
ipfs
with
a
different
commit
shell,
which
allows
me
to.
A
For
ipld,
prime
and
ipfs
and
there's
even
this
other
little
thing,
that's
like
selectors
thing,
which
allows
us
to
pass
in
essentially
a
build
tag
to
go,
which
is
super
cool.
I
just
learned
how
to
use
it
this
morning
because
it
allows
you
to
use
build
tags
and
go
to
like
work
with
different
versions
that
have
breaking
changes
in
their
interfaces,
which
actually
we
the
latest
thing
we
ship
we
had
to
do
with
graphics.
So
that's
like
I
don't
know.
I
I
I
feel
like
tesla.
A
Well,
I
I
could
sing
test
grounds
braces
all
day.
I
feel
like
it's
one
of
the
coolest
products.
Protocol
cuts
is
built
not
related
to
the
distributed
web
per
se,
but
still
an
amazing
product
anyway,
so
yeah.
So
if
I
wanted
to
run
this,
I
would
you
know,
run
my
composition
here
and
let's
go
test.
Ground
run
composition.
A
Oh
my
god.
Apparently
I
I
lose
my
ability
to
type
what
people
are
watching
yeah
and
so,
like
that's
gonna
start
and
then
I
over
here
I
have
my
test
brown
damon.
It's
actually
handling
the
request
and
starting
up.
However,
I
was
not
so
foolhardy
as
to
attempt
to
run
a
test
crown
test
while
on
a
zoom
call
up
and
make
you
all
wait.
So
don't
worry.
These
have
all
been
run
already
anyway.
A
A
A
Fortunately,
we
did
a
little
bit
of
looking
into
what's
going
on
with
like
why
those
things
might
be
a
little
bit
slower
and
I
have
a
hunch
as
to
what
those
are
well.
Okay,
I
already
know,
but
in
any
case
you
can
see
here
that
this
is
loaded
with
some
initial
files,
but
you
can
upload
your
own
results
to.
A
Basically,
automatically
update
this
graph,
so
I've
gone
ahead
and
run
this
earlier,
and
I
have
a
separate
run
here,
which
is,
I
believe
this
is
it.
Oh
goodness.
I
hope
this
is
the
right
version.
Let's
find
out,
I
can't
remember
what
my
last
run
was
called.
I
should
have
called.
I
should
have
named
it
something
more
there.
We
are
yes
yeah,
so
it
turns
out
that
now
we
saw
some
unusual
results
here
in
the
fetch.
A
We're
pretty
sure
this
is
just
garbage
collection
running
because
we're
transferring
a
bunch
of
data
by
the
way.
What
we're
transferring
here
is
a
100
megabyte
directory.
It's
the
like
xkcd
archive
that
I
just
like
got
off
github
as
like
a
demo.
This
is
probably
just
garbage
collection
running,
so
we
are
seeing
some
unusual
results
where,
like
suddenly,
we
under
we
like
outperform
the
normal
version
on
one
run,
but
then
we
underperform
it
on
others.
I'm
pretty
sure
this
is
garbage
collection
related,
but
you
can
see.
A
A
A
If
you
care
about
trusting
your
data,
but
in
the
case
where
we're
loading
off
our
own
hard
drive
that
we
wrote
previously,
we
probably
do
trust
that
data
anyway,
so
we
don't
need
to
rehash
the
cids,
so
it
makes
a
big
difference
when
you're
transferring
big
chunks
of
data.
So
you
can
see
that
you
know
we
made
it.
A
A
Because
we've
we've
been
playing
around
with
different
protobuf
libraries
for
our
nodes
and
we
wanna
use
one:
that's
really
compatible
and
really
well
tuned
to
the
spec,
but
it
looks
like
we
have
some
optimization
work
to
do
there.
So
in
any
case,
it's
kind
of
cool,
though,
to
be
able
to
like
run
these
benchmarks
and
like
get
these
immediate,
you
know
get
these
really
awesome.
Like
immediate
comparisons,
and
you
know
across
all
kinds
of
different
stuff
and
we've
run.
You
know
we
wrote
the
one
day.
A
B
B
A
So
it's
super
cool,
but
we
found
that
like
like
that's
what
he
built
and
then
like
over
the
last
like
few
months
when
I
was
doing
ipfs
work,
we
ended
up
doing
a
bunch
of
refactor
work
to
enable
it
to
support
almost
any
transport
in
any
scenario,
and
right
now
we're
just
doing
a
one-to-one
transfer
there,
but,
like
you,
can
mess
with
all
of
things
you
can
mess
with
latency,
you
can
mess
with
bandwidth.
You
can
mess
with.
You
know
whether
your
disk
store
is
in
memory
or
like
badger.