►
From YouTube: Instrumentation, Resource Allocation and Monitoring for Smart Contracts on the Blockchain
Description
Venkata Siva Vijayendra Bhamidipati & Michael Chan, eBay
Smart contract performance and debuggability are very important criteria to consider when building mission critical enterprise and public blockchains. In their talk, Vijayendra Bhamidipati and Michael Chan take up Hyperledger Fabric as an example framework to present approaches/ideas towards 1) building instrumentation into the chaincode framework to allow developers to measure the performance of their smart contracts 2) allow for billing to be built into smart contracts 3) building mechanisms that can limit allocation of resources to smart contracts, and 4) building security into blockchain frameworks.
----
Hyperledger – Open Source Blockchain Technologies
Hyperledger is an open source community focused on developing a suite of stable frameworks, tools and libraries for enterprise-grade blockchain deployments.
It serves as a neutral home for various distributed ledger frameworks including Hyperledger Besu, Fabric, Sawtooth, Indy, as well as tools like Hyperledger Avalon, Cactus and libraries like Hyperledger Aries, Ursa. Learn more about Hyperledger projects: https://www.hyperledger.org/use
Case Studies: https://www.hyperledger.org/learn/case-studies
Training & Certification: https://www.hyperledger.org/learn/training
Tutorials: https://www.hyperledger.org/use/tutorials
Webinars: https://www.hyperledger.org/learn/webinars
Events: https://www.hyperledger.org/events
Vendor Directory: https://www.hyperledger.org/use/vendor-directory
Subscribe to the Hyperledger Newsletter: https://www.hyperledger.org/newsletter
Follow-us on Twitter @Hyperledger
Learn about Hyperledger Membership: https://www.hyperledger.org/about/join
#Hyperledger #HyperledgerGlobalForum2018 #Blockchain
A
So
welcome
to
everyone.
My
name
is
Vijay
Andhra
primary
party.
You
can
call
me
Vijay,
I'm
from
eBay
and
I'm,
presenting
this
work,
that
I've
done
that
my
colleagues
Michael
Chan
and
RP
Jain
today
I'm
going
to
talk
about
instrumentation
resource
allocation
monitoring,
a
bit
of
billing,
as
well
as
security
for
smart
contracts
and
blockchain
frameworks.
So,
let's
get
started.
The
agenda
for
today
is
split
into
the
following:
first,
we'll
very
briefly:
visit
visibility
and
metrics.
What
what
do
they
mean?
A
So
the
first
item
on
our
agenda,
visibility
and
metrics.
So
what's
visibility
right?
Think
of
it
as
an
x-ray
or
MRI
or
whatever
you
call
it?
It's
the
ability
to
dissect
your
system
and
analyze
it
completely,
at
least
how
what
it
takes
to
analyze.
So
what
are
some
examples
of
visibility
in
a
blockchain,
rather
in
any,
in
any
context,
not
just
blockchain
things
like
components
that
make
up
your
system,
both
the
core
components,
your
perimeter
components
and
so
on?
How
about
data
flows,
control
flows,
system
policies
right?
A
What
are
the
policies
that
you
configured
on
your
system?
It
could
be
anything
and
then
behavioral
patterns.
What
is
the
behavior
of
your
entire
ecosystem?
So
these
are
all
examples
of
general
examples
of
what
examples
of
visibility
now:
what's
visibility
in
a
blockchain
ecosystem?
Let's
look
at
some
examples.
The
first
could
be
what
validators
are
running
in
your
entire
blockchain
network.
You
know
if
you're
running
a
permission,
blockchain
what
what
permission
views
have
been
configured,
what
smart
contacts
have
been
deployed
on
your
system
right?
You
would
like
to
have
very
good
visibility
into
that.
A
How
about
tokens
if
your
blocks
and
framework
actually
suppose
the
creation
of
tokens
right
you'd
like
to
know
that
if
you
have
created
a
token,
you
would
still
like
to
have
some
visibility
into
it.
Next,
what
consensus,
algorithms,
algorithm
or
algorithms
are
being
used
in
your
network?
What's
the
current
state
a
scale
and
throughput
of
your
deployment,
so
these
two
are
kind
of
related.
You
can
have
a
large
scale
of
operations
but
low
throughput
like
Bitcoin
or
you
could
have
a
large
scale
and
large
throughput.
A
It
really
depends
on
the
consensus,
so
these
are
just
some
of
the
examples
now,
let's
now
that
we
know
what
visibility
is,
let's
look
at
metrics
know:
what's
metrics
right,
it's
really
a
numerical
state
of
any
parameter
that
belongs
to
visibility.
So
there
are
certain
classes
of
metrics.
So
let's
look
at
health
metrics
right.
What
what
are
these?
Basically
anything
to
do
with
the
help
health
of
your
ecosystem?
So
things
like
you
know,
is
any
component
up
or
down
as
a
deadlocked
has
it
blocked?
A
Are
there
any
deviations
from
expected
states
and
so
on?
Next
class
of
metrics
would
be
resource
utilization
metrics?
What's
your
CPU
utilization
network
utilization
right,
io
disk,
basically,
and
things
like
that,
our
memory,
so
here
you
know
in
the
blockchain
setting,
you
would
like
to
know
the
resource
utilization,
that's
being
you
know,
consumed
by
your
blockchain
framework,
as
well
as
your
smart
contracts
in
a
granular
manner.
How
about
the
third
class?
This
is
basically
infrastructural
metrics
in
a
blockchain
setting.
This
could
mean
things
like
if
you're,
using
proof
of
work
right.
A
What's
the
block
read
time,
what's
the
block
right
time,
what's
the
performance
of
your
consensus,
algorithm
looking
like
so
you
know,
these
are
the
things
that
you
need
to
think
of.
This
is
a
separate
class
of
metrics.
Finally,
we've
got
the
business
logic
class.
This
essentially
boils
down
to
your
smart
contracts
right
and
there
you
have
two
broad
classes
within
them.
A
The
first
is
basically
the
latency,
the
overall
latency
or
more
granular
latencies
of
the
functions
in
your
smart
contracts
and
specifically,
if
they're,
making
external
calls
using
something
like
arc
lights,
which
is
a
really
popular
package.
You
know
you
would
want
to
know
the
performance
of
those
calls
as
well,
because
that's
in
a
way
external
to
your
own
system.
A
So
in
this
context,
let's
also
make
a
small
note
on
debug
ability
now,
debug
ability
is
actually
closely
tied
traditionally
to
a
visibility
and
metrics.
This
includes
having
the
ability
to
have
debug
builds.
You
know
having
the
ability
to
do
life
and
offline
debugging
using
those
bills
having
robust
test
frameworks
and
also
logging
logging
is
actually
very
underrated.
It's
very
powerful.
You
can
get
a
lot
of
insights
using
logging
through
log
analytics,
so
you
need
to
also
prepare
to
have
a
very
powerful
and
robust
framework
for
that.
A
So,
what's
instrumentation
any
framework
that
lets
you
basically
create
metrics
emit
those
metrics
collect
those
metrics
and
then
process.
Those
metrics
do
something
with
them
right
analyze,
for
example,
that
it's
categorized
Blaz
instrumentation,
it's
an
overall
umbrella
term.
What
are
the
traditional
resource,
utilization
measurement
of
profiling
techniques
that
we've
all
used
there
broadly
into
classes
again,
one
would
be
language
specific
profiling
tools,
so
this
includes
your
language
profile
is
like
golang,
profiler
or
Python
profiling,
and
and
so
on.
So
these
kind
of
depend
on
the
language
for
support,
but
they're
very
popular
and
very
useful.
A
Next
you've
got
system
level
profiling.
These
are
all
your
H
top
C
top
SAR
VM
start
I'll
start
and
all
these
commands
right,
which
we,
which
admins
use
a
lot
and
very
comfortable
with
so
they're
pretty
useful,
but
they
have
certain
disadvantages.
What
are
the
main
disadvantages?
The
first
thing
is
that
they're
not
granular
enough
right.
What
does
this
mean?
This
means
that
you
can
get
those
metrics,
but
at
the
max
at
a
process,
ID
level
or
at
a
thread
ID
level.
You
can't
go
beyond
that
now.
A
That
said,
that
is
basically
for
your
system
level,
metrics.
How
about
your
no
profiling,
the
language
based
profiling
that
I
mentioned
now?
That's
more
granular
agreed.
However,
it
should
be
planned
ahead
of
time
today.
The
way
it
works
is
that
you
actually
have
to
edit
that
code
you'll
have
to
bring
it
up
in
a
test
or
dev
environment
and
then
measure
it
and
come
to
a
conclusion
saying:
okay,
this
is
okay.
We
cannot
scale
it
fully,
but
we
are
okay
with
it
and
you
push
it
to
production
right.
It's
not
really
ideal.
A
If
you
want
to
push
something
like
that
to
production
and
in
the
case
of
blockchain,
smart
contracts
are
immutable
right
once
you
push
that
in
it's,
it's
hits
there,
it's
big,
then
you
don't
want
that.
So
these
are
the
disadvantages
of
traditional
profiling.
Before
we
continue
I'd
like
to
make
a
note
on
hyper
ledger
caliper.
This
is
a
new
project.
That's
been
incubated,
incidentally,
it
got
incubated
into
the
hyper
ledger
and
relied
on
a
couple
of
weeks
after
we
submitted
this
for
the
talk
as
a
submission.
A
A
So
is
there
an
alternative?
Yes
and
it's
called
EBP
of
extended
berkeley
packet
filter.
So
what
is
EBP
f,
eb
PF
many
of
you
may
have
heard
of
it.
It's
actually
a
very
powerful
framework
that
is
provided
by
the
Linux
kernel.
What
it
does
is
that
it's
highly
programmable
it's
it
has
quite
a
good
instruction
set
that
it
supports.
It
basically
deploys
what
we
call
an
EBP
of
probe
inside
a
very
tiny
virtual
machine,
which
is
really
a
term
to
refer
to
some
sandboxed
space.
A
If
you,
if
you
can
call
it
it's
not
exactly
sandbox,
but
it's
very
secure.
It's
highly
granular
because,
as
we'll
show
you
in
the
demo,
as
I'll
show
you
in
the
demo
next,
it's
extremely
granular.
It
can
be
inline
in
the
sense
that
it
is
almost
always
in
line,
and
it
does
not
require
you
to
modify
your
code.
That
is
the
biggest
draw
of
EBP
of
specifically
are
going
to
be
looking
at
a
functionality
that
was
very
recently
introduced
in
the
BPF
called
FBT.
A
Our
function
boundary
tracing
now
it's
ideal
for
something
like
blockchain
and
smart
contracts.
Why?
Because
it's
immutable
right
now,
all
these
are
immutable
in
the
blockchain
and
you
can
still
go
ahead
and
profile
them
in
production
systems.
Remember
details
in
Solaris
this
is
it
right?
It's
the
equivalent
in
Linux,
as
one
of
my
colleagues
mentioned
qy,
he
said
this
is
the
way
to
make
Linux
great
again.
So
it's
so.
There
are
two
ways
to
run
EBP
of
probes
today
the
first
is
called
Linux
purse.
The
second
is
called
I
was
at
BCC.
A
Both
of
them
are
open
source,
very
popular
there's,
a
third
one
called
play
in
the
works,
but
it's
a
bit
further
from
maturity
as
of
now
so
the
preferred
one
is
IO,
wiser
BCC,
so
I've
already
mentioned
that
it
brings
in
visibility,
I'd
use
a
space
function
level.
I
did
not
mention
that.
Actually
so
this
is
the
big
deal
about
a
BPF
at
user
space
at
function,
car
level,
you
can
get
visibility.
The
demo
will
make
this
clearer.
If
you
couple
this
with
something
like
call
graphing
what
is
called
graphing
in
call
graphing.
A
You
basically
do
a
static
code
analysis
and
then
build
an
entire
directed
graph
of
all.
The
possible
function
calls
in
your
packages
among
your
packages.
This
is
a
very
powerful
feature.
If
you
combine
both
of
these,
you
can
pretty
much
measure
things
like
latency
of
functions
specifically
function
chains
in
a
smart
contract
or
even
in
the
underlying
blockchain
infrastructure,
and
you
could
look
at
resource
utilization
of
these
functions
as
well.
In
our
demo,
we
are
going
to
show
you
the
function
latency,
so
this
is
an
overview
of
our
demo.
A
On
on
this
big
box,
you
see
hyper
ledger
fabric.
We
are
bringing
it
up
in
a
single
node
installation
using
the
dev
node,
which
is
very
convenient.
It
has
a
very
nice
talker
compose
file.
So
what
we
do
next
is
that
we've
created
a
very
simple
smart
contract,
a
chain
code
which
we
called
my
eco
asset.
All
it
does
is
that
it
echoes
an
argument
that
you
sent
to
it.
That's
it
and
we'll
keep
invoking
it.
While
we
are
invoking
it
in
parallel.
A
A
You
actually
have
the
stats
emitter
running
continuously
for
the
sake
of
the
demo,
we've
kind
of
split
it
to
make
it
easier
and
for
people
to
follow
that
writes
to
an
index
on
an
elastic
search
container
that
we
bring
up
in
the
same
box
and
that
render
has
a
couple
of
dashboards
that
you
can
see
on
Cabana,
which
is
again
on
the
same
box.
So
this
is
a
layout
it's
in
team
ox.
So
that's
the
reason
I
created
this.
A
Basically,
you
got
I
hope
the
font
is
okay,
but
you
got
hyper
edge
of
fabric
and
elasticsearch
and
Cabana
running
on
the
left.
What
we'll
do
first,
is
we
look
at
the
chain
code
file
itself?
The
smart
contract
then
we'll
build
it
and
run
it
and
then
we'll
we'll
start
the
EBP
of
tracer
and
then
we'll
start
invoking
the
chain
code
like
around
five
hundred
times.
In
our
case
after
returns,
we
will
start
a
matrix
emitter
that
will
collect
these
metrics
and
emit
them
to
elasticsearch
and
Cabala.
A
A
So
is
everyone
able
to
see
it
better
now?
Okay,
I
should
have
made
the
phone
bigger
anyway.
This
is
the
my
eco
asset.
This
is
basically
in
golang,
which
was
going
to
write
the
chain
code,
and
you
see
that
it
has
an
invoke
function
and
an
init
function.
These
are
standard
fabric,
hyper
logic,
fabric
calls
right,
and
this
is
the
eco
function,
which
is
being
called
by
the
invoke
function,
and
what
it
does
is
that
the
invoke
function
basically
sees
hey.
A
If
an
argument
is
eco
and
it's
getting
an
argument,
if
the
command
is
eco
and
just
call
into
the
cofunction,
that's
it
it's
a
very
simple,
smart
contract,
so
next
step,
like
I
mentioned,
we've
actually
already
built
it
and
executed
it
I'm,
just
showing
you
that
you
know
it
was
already
done.
As
you
can
see,
it's
darker
exact
into
the
chain
code
container,
which
is
a
helper
container,
that
fabric
provides
and
we've
done
a
go,
build
the
GC
flags
over
there,
and
we
are
all
we
are.
A
We
have
already
brought
it
up,
and
we
pointed
it
to
the
pier
on
7:05
now
here:
I'm
opening
the
the
script
which
actually
launches
in
EBP
of
probe,
and
it's
called
funky
latency
dot
pi.
This
is
a
standard
BCCI,
o
visor
EBP
of
rapper
that
has
been
written.
We
did
this
on
purpose,
to
keep
it
all
open
and
simple
for
you
to
follow.
What
we're
doing
here
is
that
if
you
see
that
specific
line,
it
says
micro
asset,
call
and
main
with
the
star
micro
asset
star
and
a
function
as
a
parameter.
A
What
we're
doing
here
is
we
are
passing
a
regular
expression
to
EBP
F
and
we
are
asking
it
to.
You
know
start
profiling
it,
and
this
is
really
powerful.
This
is
extremely
powerful.
So
now,
what
I'm
doing
is
that
I'm
firing
off
this
EVP
EVP
of
probe
and
it's
active
in
this
window?
Now
that
it's
active?
A
What
do
you
do
you
go
ahead
and
start
invoking
the
chain
code
many
times
so
in
that
for
loop,
it's
just
for
I
in
sequence,
500,
and
we
are
saying
a
peer
chain
coding
book,
my
eco
acid,
with
an
argument,
eco
and
arg1
right
with
two
arguments.
The
first
one
is
passed
by
our
chain
where,
as
a
command-
and
the
second
is
taken
as
the
argument
now
that's
running
there
now
you
may
be
wondering
why
is
this
smart
contract
actually
running
constantly?
What
does
it
do?
A
In
the
background
the
smart
contract
establishes
when
you
start
it
up,
a
G
RPC
session
socket
will
appear,
which
is
there
and
every
time
you
invoke
the
smart
contract
or
chain
code,
a
transactions
actually
recorded
in
the
blockchain
itself,
so
the
PR
and
the
order
are
making
these
records.
So
you
actually
know
that
you
know
it's
being
invoked
now.
This
is
a
previous
run
of
this
demo.
We
have
two
dashboards
already
populated
the
function
on.
The
second
is
eco
and
on
the
right
service
in
work,
but
we'll
get
back
there
so
now.
A
What
we're
doing
is
that
we
are
profiling
in
book,
because
here,
when
I
invoked,
it
I
said
well.
The
font
is
like
I'm,
sorry
about
that,
but
I
basically
asked
it
to
you
know
a
trace
the
inbox
function
specifically.
So
the
invoke
internally
calls
eco
in
this
case.
Now
let
it
run
for
a
while
in
that
window,
I'm
opening
the
metrics
emitter
Norris
H.
It's
a
simple
shell
script,
the
metrics
emitter!
How,
before
that
I,
did
the
dr.
A
PS
just
to
confirm
that
hey
everything
runs
as
I'm,
claiming
it
there's
the
chain
code
CLI
peer
and
order
which
are
all
fabric
containers.
You
also
saw
an
elastic
search
in
queue
on
a
container
there.
So,
let's
all
you
know
I'm
now
going
to
execute
the
same
metrics
dot
as
such,
but
before
that
I'll
just
kill
the
EVP
of
probe.
Now
this
doesn't
have
to
be
done.
A
You
can
still
have
it
running
I,
just
killed
it
for
simplicity
and
to
show
what
the
output
looks
like
this
EBP
of
probe
in
this
case
builds
a
histogram
of
the
latencies
of
this
invoke
function,
and
you
can
see
that
there
are
multiple
buckets
of
those
and
when
we
look
at
the
graph
that
gets
rendered
will
become
clear,
so
the
send
matrix.
What
does
it
do?
It
actually
starts?
Reading
this
it
takes
a
bucket
randomized
is
the
value
within
the
bucket
and
then
emits
them
now
in
real
production.
A
You
don't
have
to
randomize
or
do
any
such
thing.
We
are
doing
it
for
the
purposes
of
the
demo.
Now
what
you
see
there
is
that
JSON,
that's
being
spat
out.
That's
actually
each
is
a
record.
Each
is
a
metrics
record,
and
if
you
look
at
the
Cabana
dashboard
you
it's
periodically
increasing
log
counts
are
increasing.
Now
now
that
is
done,
we're
just
refreshing
it
to
show
you
how
the
emissions
working.
Then
we
go
to
the
dashboard
and
we'll
refresh
these
two
dashboards
that
we
saw
earlier
earlier.
A
They
already
had
some
values
right,
so
in
the
last
one
hour,
let's
just
go
ahead
and
refresh
them
now.
What
you
see
is
that
we
did
not
trace
eco,
so
that
stays
there,
but
new
values
for
in
work
are
started
to
get
to
get
traced
and
you
see
that
the
latency
is
around,
but
you
know
it
started
off.
The
last
value
was
at
70,000
nanoseconds,
which
is
70
milliseconds
and
it
came
to
around
35
milliseconds
in
the
next
run.
Right.
Imagine
this.
A
You
have
actually
traced
a
function
chain
main
called
something
called
something
called
something
right:
that's
a
call
graph
entry,
you
tray
start
without
any
modification
to
your
core.
This
is
an
extremely
powerful
thing
as
we'll
see
later.
This
concludes
our
demo.
So
let's
get
back
to
our
presentation.
A
So
now
we've
seen
EBP
F,
but
obviously
there
are
going
to
be
drawbacks
to
anything.
What
are
the
drawbacks
of
EBP
F?
These
are
more
like
current-day
drawbacks.
The
first
thing
is
it's
available
only
on
Linux,
4.4,
kernels
and
beyond.
So
any
older
kernel
or
non
Linux.
You
don't
really
have
this
functionality.
So
what
you
do
an
alternative
is
to
build
this
functionality
into
your
virtual
machine
itself.
That
runs
your
smart
contracts
now
fabric
doesn't
do
that,
but
aetherium
VM
exists
and
you
can
actually
pull
something
like
that.
A
You
can
put
such
kind
of
functionality
into
those
VMs
right.
You
could
do
that
next.
Obviously,
this
will
require
blockchain
support.
The
framework
has
to
do
it,
but
if
you
want
even
more
tracing
you'll
have
to
build
such
functionality
into
the
blockchain
framework
itself,
so
you
can
trace
the
blockchain
frameworks
performance
itself.
So
ideally
you
just
rather
go
with
the
BPF
oranger.
There's
another
thing
about
scalability.
Now
today
for
golang,
for
example,
you
can
attach
around
a
thousand
DB
p
of
probes
at
any
given
time.
A
This
is
being
worked
upon,
it'll
improve
it
time
and
probably
at
this
age
will
not
need
more
than
that,
but
I'm
I'm
always
wrong
when
I
make
such
statements.
So
scalability
is
something
that
we
need
to
think
of.
So
now
we
have
looked
at
visibility
and
metrics.
We
have
looked
at
how
to
get
those
metrics
right
in
a
non-invasive
way.
What
do
you
do
with
that?
One
application
is
billing,
so
let's
look
at
billing:
how
are
you
going
to
build
smart
contracts?
A
Billing
for
blockchain
ecosystems
can
be
of
two
types
based
on
what
kind
of
blockchain
you
are
deploying.
The
first
is
a
public
blockchain.
How
does
billing
in
a
public
blockchain
work
today?
Typically,
it
works
like
this
I
have
a
transaction
I
would
like
to
get
the
transaction
written
to
a
block
in
the
blockchain,
but
when
either
in
the
next
few
minutes
or
in
the
next
X
number
of
blocks,
the
both
are
almost
interchangeable.
So
the
thing
is
say
it
take
ether
in
foreign.
You
set
a
gas
price.
A
If
you
set
a
very
high
gas
price,
it
it's
more
probable
that
your
transaction
will
make
it
to
the
very
next
block
being
returned
to
the
blockchain.
It's
possible,
it's
not
a
given.
So
the
point
here
is
that
variability
is
okay
in
public
block
chains.
As
of
today
that
may
change,
but
as
of
today,
it's
typically
okay.
But
if
you
look
at
a
permission
to
private
blockchain
ecosystem
is
variability
okay,
not
really
because
you
will
really
have
to
think
about
quality
of
service
and
also
about
your
optics.
A
You
cannot
really
afford
delays
in
most
enterprise
deployments.
You
would
like
to
completely
have
no
delays
right,
so
these
are
classes
of
billing.
So
now
that
we've
identified
that
hey,
these
two
are
different.
What
could
be
the
drivers
that
could
drive
something
like
billing
in
enterprise
ecosystems?
There
are
many
examples,
but
essentially
the
point
is
that
it
has
to
be
multivariate.
It
can't
be
too
simple.
So
let's
look
at
some
of
the
examples.
Specific
function
chain
latency,
which
we
just
measured-
that's
an
example:
partnership
service
charges.
What
does
this
mean?
A
You
got
a
permission,
blockchain
with
multiple
partners
right,
you
may
want
to
have
some
preferred
partners
and
some
not
so
preferred
partners,
and
you
may
want
to
charge
them
in
a
differential
way
right.
The
third
thing
is
IP
valued,
smart
contract
services,
so
you
got
some
IP
that
you
are
coding
into
a
smart
contract.
A
You
would
obviously
want
to
do
some
billing,
based
on
that,
how
about
demand
based
contact
server,
surprising,
say:
tomorrow,
you
come
out
with
a
complete
a
competition
blockchain
based
competition
or
competitor
to
uber
or
lyft
right,
and
you
want
to
do
something
like
surge
pricing
right.
You
need
to
be
able
to
take
that
into
account
for
billing
how
about
resource
utilization
based
pricing?
This
is
classic.
You
don't
want
to
lose
the
capability
of
billing
based
on
resource
utilization.
Then
the
last
thing
is
sub-licensing.
How
about
sub-licensing?
A
You
have
a
partner,
you
actually
licensed
some
IP
or
something
to
the
partner,
but
the
partner
goes
ahead
and
sub
licenses.
It.
You
need
to
be
able
to
track
that,
otherwise,
you
you'll
be
losing
money
right,
you'll
be
losing
out
on
royalties.
So
these
are
all
examples
of
how
billing
of
how
billing
should
be
built
in
a
blockchain
ecosystem
and
blockchain
frameworks
in
general
can
help
a
lot
in
build
building
such
building
frameworks
in
a
very
trackable
way.
So
next
on
our
agenda
resource
allocation.
A
So
to
do
something
like
building
you
can't
build,
but
if,
if
your
customer
says
or
your
partner
says,
I
never
asked
you
for
this
right.
What
you
do
you
have
to
have
some
way
of
allocating
of
capping
your
resources
or
giving
a
lot
more
resources.
So,
typically,
when
we
talk
about
resource
allocation
again,
there
are
two
parts
to
this:
one
are
the
engines
that
dictate
the
resource
allocation
policies.
You
need
a
policy
engine
of
some
sort.
The
second
thing
is
your:
you
know,
data
plane
or
you
know
something
that
enforces
this
resource
allocation
right.
A
That's,
basically
your
allocation
engine
or
allocation
plane.
Sorry
excuse
me,
so
let's
take
a
look
at
the
resource
allocation
plane
right.
How
would
you
so
first,
we
are
looking
at
the
data
player
data
plane.
So
how
would
you
implement
such
an
allegation
plane
a
very
low
hanging
through
this
containerization
right?
It's
readily
available
as
a
Linux
construct.
It's.
It
also
has
good
orchestration
support
like
kubernetes.
A
It
allows
for
noted
resource
requests
as
well
as
limits,
but
it's
not
again
that
granular
it
can
be
granular
if
you're
going
to
run
only
one
smart
contract
with
exactly
one
process,
basically
in
each
container
right
that
may
not
always
fit
Enterprise
requirements
too
many
times,
we've
seen
that
we
will
have
to
have
a
lot
of
helper
containers
in
a
single
part
and
they
start
taking
up
logs
I
mean
resources.
A
very
good
example
is
something
like
five
bit
logging.
Basically,
it
can
become
a
system
hog
very
quickly.
So
what
do
you
do?
A
You
can
have
multiple
of
these
blockchain
logical
constructs
in
single
in
space,
but
you
can't
really
allocate
resources
between
them
right.
It
doesn't.
Let
you
do
that.
So
what
we
propose
at
eBay
is
using
something
called
blockchain
aware
native
scheduling,
it's
not
really
using
or
more
it's
like
building.
We
propose
to
build
this.
A
Let's
look
at
what
blockchain
of
a
native
scheduling
means,
but
before
we
look
at
that,
when
we
talk
about
the
source
allocation,
let's
look
at
the
constructs
for
the
blockchain
ecosystem,
so
you
got
business
logic,
specific,
smart
contracts.
You
got
quality
of
service
which
essentially
reflected
in
latency
requirements,
but
you
also
have
classes
of
service.
What
does
this
mean?
Examples
of
this
are
IRT
DRM
and
financial
transactions.
Just
take
a
look
at
these.
These
are
all
very
different
classes
of
service.
A
They
all
have
very
different
environments
and
ecosystems
and
very
different
requirements
right,
so
you
need
to
be
able
to
differentiate
between
these
classes
of
service
when
it
comes
to
how
we
are
gonna
allocate
resources.
This
is
an
important
point.
Then
again,
there
are
the
environments.
Where
are
your
customers
coming
from?
Where
are
your
requests
coming
from?
Are
they
coming
from
mobile
or
desktop,
or
native
apps,
on
mobile
and
so
on
and
so
forth?
Now,
let's
look
at
blockchain
of
an
ad
scheduling.
A
What
this
really
proposes
is
you
know,
build
smart
contact
awareness
into
the
kernel
itself,
that's
kernel
modules
and
or
constructs
right,
like
Linux
containers.
Did
this
with
namespaces
it
built
the
building
blocks
that
made
it
possible
to
build
containers
right
Linux.
Did
that
similarly,
think
on
similar
terms
when
it
comes
to
the
blockchain,
you
build
things
like
consensus,
algorithms,
as
protocol
Suites
into
the
kernel
itself
and
you'll
have
full
native
support
on
every
system
out
there
think
about
embedded
systems.
They'll
have
lean
implementations
of
these
think
about
security
right.
A
A
Now,
now
that
we've
spoken
about
the
data
plane,
let's
look
at
the
control,
plane,
resource
allocation
engine
right,
it's
really
the
control
plane.
It
can
be
again
of
two
types.
You
can
have
a
basic
allocation
engine
with
just
simple
policies,
and
you
can
say:
hey
just
you
know,
I'm
gonna
write
up
these
policies
and
just
you
know,
send
them
off
to
the
allocation
engine
to
actually
do
its
job
right
to
the
data
plane.
However,
what
we
think
is
that
this
should
not
be
so
simple.
A
Rather
it
won't
be
enough
if
it's
so
simple,
it
should
be
more
advanced,
and
specifically,
we
should
leverage
another
statistical
methods
to
identify
patterns
of
usage.
You
need
to
have
a
way
to.
First,
collect
which
we
have
all
the
metrics
and
then
identify
the
patterns
of
usage
and
let
it
drive
your
resource
allocation.
A
A
You
got
Prometheus
instead
of
the
simple
stats
emitter
that
we
had,
you
could
actually
have
those
emitted
by
a
Prometheus
handler
to
a
Prometheus
or
federated
Prometheus
and
lament
you
could
have
stats
the
end
file
beat
and
logstash
file
bit
and
logstash
are
very
popular
for
log
analysis
right
for
log
processing
and
it's
it's
an
entire
log
pipeline.
Then,
of
course,
we
have
elastic,
search
and
cabana,
which
we
just
showed
you
what
it
can
do
now.
A
A
A
Here's
the
thing.
After
looking
at
our
EVP
of
demo,
we
realize
that
if
you
can
trace
it
or
track
it,
you
can
block
it.
So
we
propose
using
two
approaches
for
this.
The
first
we
call
function
based
access,
control
or
F
back,
and
the
second
is
what
we
call:
data
based
access,
control
or
D
back.
Let's
take
a
deeper
look
into
each
of
these
F
back.
What
does
this?
Do
it
blocks
or
allows
invocations
of
specific
function?
Chains
just
think
about
it,
use
the
space
functions
in
the
blockchain
framework,
as
well
as
your
smart
contracts.
A
There's
no
distinction!
Really!
If
you
want
to
make
a
distinction,
you
can
build
that
into
your
logic,
but
any
function
chain
in
any
smart
contract
or
in
the
blockchain
infrastructure
itself.
You
can
block
let
that
sink
in.
You
can
create
whitelists
and
blacklists
of
such
F
back
policies
right
that
you
can
bake
into
the
blockchain
itself,
so
you
use
the
blockchain
to
secure
the
secure
data
policies
that
will
secure
the
blockchain
right.
That's
what
it
really
does.
It
uses
its
own
power
to
secure
itself,
but
what
is
crucial
in
this
idea?
A
Is
that
really,
if
you
think
about
it,
it
is
an
extremely
scalable
way
of
implementing
permission
block
chains.
What
is
the
permission
block
chain?
What
is
the
permission
view
you
really
it
if
you
think
about
it,
it
really
boils
down
to
a
combination
of
a
back
and
a
back,
that's
what
it
is,
and
that
is
what
this
can.
Let
you
do
so
now.
A
D
back
data
based
access
control
same
here
you
block
or
allow
invocations
of
specific
function
chains,
but
then
you
go
beyond
just
the
function:
names
of
the
function
chains
and
start
looking
at
the
parameters
that
those
functions
carry.
This
can
be
extremely
powerful
to
write,
of
course,
with
things
like
encrypted
data.
You
may
not
be
able
to
do
much
today,
but
if
you
were
to
do
this
in
F
back,
then
that
opens
the
door
for
you
to
do
something
like
that
securely,
even
for
encrypted
data.
A
Now
you
can
also
block
our
allowed
reads
of
or
even
rights
of
specific
sets
of
data.
You
know
you
can
have
whitelist
or
black
lists
of
these
d-bag
policies
that
are
baked
into
the
blockchain
itself,
obviously
right,
so
these
are
two
new
paradigms
that
we
proposed.
So
how
would
you
actually
implement
it?
Have
bacardi
back
there
again,
two
approaches.
One
we've
already
showed
you
EBP
F
today,
EBP
F
is
really
programmable.
A
If
you
were
to
look
at
the
underlying
implementation
of
how
EBP
F
does
this,
you
can
take
a
look
at
thing
at
tools
like
seccomp,
a
partner
they
have
been
around
for
a
while
right.
They
use
EVP
of
internally,
but
they
use
what
is
called
a
LAN
lock
feature
of
EBP
F,
where
you
can
either
allow
or
deny
a
line
lock
for
a
specific
function
chain,
but
they
do
it
at
the
ISKCON
level.
Why?
Because
they
are
more,
you
know
the
more
common
and
somehow
no
one.
No
one
has
actually
done
it
for
I.
A
As
far
as
I
know,
no
one
has
done
it
for
user
space
functions
yet,
but
it
should
be
very
simple
to
implement
because
we
already
have
function,
boundary
tracing
which
is
able
to
track
the
very
entry
and
the
exit
or
the
functions.
So
it's
just
going
to
be.
You
know,
applicability
problem
that
we're
going
to
be
solving.
A
A
So
this
is
my
team.
The
blockchain
team
at
eBay
is
Michael
myself,
our
pet
Brian,
Ashok
and
Eric.
There
are
a
couple
of
other
teams
as
well:
Connie
is
here
as
well.
Hi
Connie
so
so
feel
free
to
reach
us
reach
out
to
us
with
any
questions
that
you
may
have,
and
we
will
be
happy
to
respond
as
best
as
we
are
allowed.
A
lot
of
thanks
to
Venkatesh
Brian
as
well
as
Qi,
and
here
are
some
references
that
we
think
are
going
to
be
pretty
interesting
for
the
audience
you
can
go
through
them.
A
C
A
That's
a
great
question,
so
basically
the
question
was:
how
do
you
do
this
across
multiple
nodes?
Right?
It's
pretty
simple!
You
have
agents
or
containers.
There
are
many
ways
of
doing
this,
but
essentially
you
need
some
sort
of
an
entity
on
each
node
that
can
collect
the
metrics
for
you
in
case
of
public
block
chains.
This
may
have
to
be
absolutely
baked
into
the
blockchain
itself
and
somehow
it
you
know
every
every
participant
has
to
allow
for
that
to
be
run.
It
needs
some
level
of
privilege.
A
Obviously,
but
if
you
built
it
into
the
blockchain
framework
itself,
then
it's
fine.
You
can
already
get
it
natively
right
in
case
of
permissions
or
private
blockchains.
It's
a
lot
easier.
Why
am
I
using
two
mics
sorry?
It
can
actually
be
much
much
simpler.
Sorry,
it
can
be
much
simpler
in
the
case
of
permission
block
chains,
because
you
have
a
certain
amount
of
vetting
in
private
or
permission
block
chains.
You
know
that
you're
going
with
trusted
partners,
and
so
you
can
say
that
look
you're
anyway,
participating
in
this
framework.
A
Have
these
agents
have
have
this
code
also
run?
They
can
turn
it
on
and
off
if
the
one
two,
but
you
know
for
something
like
dynamic
resource
allocation
or
you
know,
even
many
many
higher
layers
are
possible
to
build
on
top
of
this
like
superbly
and
for
all
those
you
may
never
want
to
turn
them
off
right.
The
best
thing
about
something
like
EBP
F
is
how
efficient
it
is.
A
It's
it's
on
the
way
to
and
fro
you
know
it's
it's
in
line
so
typically,
to
give
you
an
example,
if
you
were
to
deploy
an
EVP
of
probe
in
the
network
stack,
the
effect
on
the
CPU
for
like
a
10
gig
network
would
still
be
like
point
five
percent,
which
is
negligible.
Absolutely
negligible
maximum
is
1%.
So
this
is
what
makes
EVP
of
flight
really
powerful
and
attractive
I.
B
A
I
I,
don't
not
due
to
two
reasons.
Frankly:
I'm,
not
a
building
expert
but
I,
don't
look
at
it
from
a
product
perspective
while
I
do
a
viola
have
mentioned
some
with
respect
to
things
like
elastic
search
and
Cabana,
because
they're
very
much
open-source
billing
is
not
so
open
source.
As
far
as
I
know,
yeah,
that's
that's
a
problem,
and
you
know
it's
a
framework
like
this
can
actually
make
billing,
maybe
open
source.
You
can
nudge
it
towards
that,
because
this
is
an
open
source,
fundamental
framework
that
exists
already
right.
So
you
could.