►
From YouTube: turbo eWASM - Guillaume Ballet
Description
Berlin Ethereum Meetup - 2018/12/7
B
B
B
C
C
A
B
Anyway,
so
how
does
he
wasn't
compared
to
was
some
well,
it
basically
was
regular,
wasn't,
except
that
you
import
functions
that
would
initially
up
until
now
corresponds
to
a
specific
instruction
in
the
in
the
EDM.
So
functions
like
you,
get
the
conveys
get
get
the
code
of
the
caller
gets
things
like
that
that
I
used
to
be
instructions
now
there
are
just
function,
calls
so
you
just
import
them
so.
C
B
B
B
D
D
D
B
B
Old
EDM
is
going
to
disappear.
It's
still
go.
It's
still
going
to
stay
first,
because
we
we
have
all
those
contracts
that
need
to
to
remain
and,
as
like
I'll
explain
in
a
couple
minutes,
while
some
is
still
a
work
in
progress.
So
there's
a
lot
of
reasons
to
keep
investing
in
solidity
in
any
VM
and
all
this
all
this
environment.
So
yeah.
B
B
B
They
don't
know
like
those
compilers,
they
don't
know
you're
targeting
any
specific
market
blockchain
environments,
so
they
will
produce
a
new
binary
that
has
something
called
the
runtime,
so
there
will
be
a
lot
of
cruft
that
is
basically
here
to
prepare
for
anything
that
can,
and
that
can
happen
and
and
yeah
all
that
Trust
takes
a
lot
of
space.
Some.
D
B
That's
a
bit
of
a
challenge
and
yes,
the
the
biggest
trade-off
when
it
comes
to
wisdom.
Is
that
like
I
was
saying
you
have
a
medium
binary,
you
start
at
the
first
instruction
and
you
execute
it
all
the
way.
Until
you
stop
in
wisdom,
you
require
a
little
bit
more
work.
Actually
a
lot
more
work.
You
need
to
transform.
You
need
to
validate
into
validity
binary.
It's
not!
Yes,.
B
Have
to
go
through
the
entire
program
check,
everything
is
fine.
All
the
loops
are
properly
inflated,
and
things
like
that,
so
it's
been
designed
for
an
application
that
has
that
would
last
like
that
would
run
a
long
time
so
think
Gmail
in
have
Gmail
in
your
browser
could
be
printed
in,
wasn't
clearly
you're
going
to
spend
like
10
seconds
waiting
for
Gmail
to
load
the.
D
C
B
Running
for
4
hours
and
hours
at
a
time
in
the
case
of
smart
contract,
the
load
overhead
is
a
bit
of
a
problem
because
the
smart
contract
executes
and
then
you
have
to
load
another
module
which
is
which
corresponds
to
another
contract.
So
it's
not
as
it's
not
as
easy,
or
at
least
it's
not
as
simple.
C
B
You
could
optimize
it
this
way.
It
wasn't
to
you
noted
once
and
for
all
the
module
is
there
and
you
keep
calling
it
again
and
again.
But
at
this
point
it
starts
looking
more
like
your
service
and
that's
really
what
the
core
of
this
proposal
is
about.
Start
thinking
about
recompiles,
more
like
your
service
than
the
library,
so
we
keep
them
permanently
running
and
because
in
the
regular
operating
system,
which
is
where
Paul
and
I
the
world
that
Paul
and
I
come
from
an
operating
system
to
service
system
to
have
better
access
rights.
B
B
B
B
To
a
quick
reminder
about
parallel
execution,
so
right
now
you
need,
when
you
receive
a
blog,
you
have
transactions
and
almost
all
sorry,
all
of
those
transactions
get
executed
before
the
mining
starts,
and
it's
very
important
that
sequential
I'm
going
to
explain
why.
What
we
would
like
to
have
is
something
where
yeah.
So
what
I
meant?
If
you
look.
B
B
So
what
we
would
like
to
do
is
the
second
case,
which
is
to
have
all
the
transactions
right
between
the
two
CPUs
and
and
be
able
to
to
get
to
get
to
the
mining
faster
and
that's
all
the
more
important,
because
when
you're
actually
syncing
with
the
network,
the
mining
is
gone.
So
the
transaction
is
everything
preventing
you
from
from
being
up-to-date.
B
Yes,
so,
but
at
least
the
the
picture
is
still
here
so
yeah,
so
I
try
to
explain
in
water
parallelism
it
to
be
difficult.
I
propose
switch
transactions,
so
those
squares
on
the
Left
are
represented
States
and
when
you
apply
the
transaction,
each
transaction
apply
like
thirties
of
rights
or
reads
from
squares,
so
the
transaction
one
will
be
represented
by
a
wreath
of
rights
to
the
right
square,
the
two
to
green
square
and
so
on
and
now
yes
next
makes
the
slides
to
still.
B
So
what
needs
to
happen
is
that
the
exact
order
of
the
transaction
needs
to
be
reproducible
reproducible,
because
if
you
don't
you
just
dump
all
the
transactions
in
your
block,
someone
seems
to
block
execute
the
transactions
like
in
parallel
yeah,
but
with
a
different
number
of
of
CPUs
or
something
like
that,
and
it
turns
out,
the
order
is
invertible
isn't
broken
and
therefore
you
have
no.
You
have
no
consensus
that
you
have
a
fourth,
so
yeah
like
this.
The
difficulty
in
partitioning
is
really
determining
which
which
non-conflicting
a
transactions
can
be
run
together
or
concurrently.
B
B
B
Requires
a
little
tweak
to
the
current
model,
where
each
transaction
has
to
declare
upfront
or
beforehand
which
which
addresses
is
going
to
touch.
So
in
the
first
case,
you
have
a
transaction
pool
on
the
left
and
each
transaction
says
I'm
going
to
address
those
addresses
and
if,
for
example,
the
number
one
and
number
two
overlap,
so
the
scheduler,
the
transaction
scheduler,
will
say
well
clearly
those
overlaps
so
I'm
going
to
put
them.
They
should
be
executed.
B
Sequentially
by
CPU
1,
&,
3,
&
4,
the
overlap
so
they're
going
to
be
executed,
sequentially
by
CPU
and
then
once
it's
done.
You
just
wait
for
completion,
and
then
you
start
what
one
of
the
things
what
I
working
on
his
left
partitioning.
So
the
idea
is
to
do
more
or
less
the
same
thing,
but
without
actually
changing
the
interface.
B
So
the
way
that
would
happen.
So
you
have
two
CPUs
two
transactions
running
on
two
different
CPUs
and
you
have
the
global
state
at
the
far
right,
so
transaction
one
is
right
in
two
locations:
actions
to
in
the
location
and
then
in
the
next
step,
transaction
two
tries
to
right
in
the
second
location,
but
it's
a
location
that
has
already
been
written
to
by
by
transaction
one.
So
what
we
do
we
simply
idle
and
it
feels
a
bit
wasteful.
But
what
you
have
to
realize
is
that
if
you
compare
it
to
to
the.
C
B
B
B
That
means
that
you
could
technically
run
several
transactions
in
parallel
at
calling
the
same
contract,
but
not
touching
touching
the
same
area
and
yeah.
It
would
need
some
special
kind
of
services.
First,
keep
doing
that.
I
will
get
back
to
so
I.
Just
this
is
a
fantastic
code,
of
course,
but
the
idea
is
that
yeah,
you
have
an
array
that
contains
all
your
tokens,
so
this
is
some
kind
of
a
or
C
20
token.
B
C
B
C
B
C
B
B
B
B
I
have
a
bit
of
a
complicated
diagram,
but
you
still
have
the
transaction
pool
here
and
you
have
a
cache
of
contracts
and
you
can
see
that
transaction
1,
for
example,
through
transaction
3,
all
correspond
to
the
same
address.
So
they
want
to
call
the
same
contract
and
it's
been
capped,
so
the
scheduler
are
going
to
say.
Ok,
we
clearly
access
the
same
contract,
let's
put
them
in
serial
in
seed
points
on
the
first
CPU,
and
then
we
see
that
transaction
2
also
corresponds
to
2
cache
contracts.
So
we're
gonna
ask
CPU
to
2
to.
B
Now
the
cache
is
still
containing
the
contracts,
so
we
should
benefit
from
that
and
then
transaction
3,
our
transaction
for
sorry
is,
is
not
like.
Its
contract
is
not
in
the
cache,
so
you
execute
it
afterwards.
You
going
to
have
to
load
it
from
disk.
It's
a
bit
of
a
pain.
One
thing
you
can
do,
however:
that's
that's
a
diagram
that
has
been
used
at
Def.
Con
is.
C
B
Was
talking
about
the
model
like
the
the
MapReduce
execution
model
before
I
was
talking
about
the
the
other
that
I
didn't
give
a
name
to,
but
let's
call
it
the
commutative
transaction
model,
I
don't
know,
and
those
things
could
depend
on
the
type
of
traffic.
If
you
are
at
the
time
where
you
have
a
lot
of
cryptokey
like
or
nico
a
lot
of
transactions.
Looking
the
same,
you
don't
want
to
use
the
same,
the
same
service
as
if
you're
executing
a
regular,
regular
contract
that
just
yeah
RC
20
token,
for
example.
B
So
you
can
have
several
blocks
that
were
all
generated
using
a
different
execution
model
and
of
course,
the
only
thing
that
matters
is
that
if
your
contract
is
not
available
or
if
the
miner
doesn't
want
to
run
that
contract,
you
should
always
be
able
to
fall
back
to
the
standard
execution
and
now
I
start
using
the
big
words
governance.
It's.
C
B
There's
always
a
debate.
Governance
is
a
big
debate,
so
why
I
find
this
idea
interesting
in
spite
of
being
a
bit
a
bit?
Undefined
still
is
that
you
don't
have
to
really
vote.
If
you
want
like
to
have
a
four
to
agree
with
everybody,
you
can
just
deploy
your
own
service
if
people
if,
for
example,
miners,
don't
agree
with
your
with
your
service
with
what
your
contract
does,
what
your
service
does.
Well,
they
just
won't
run
it.
B
They
will
refuse
your
transaction,
so
you
can
go
to
a
different
to
a
different
miner
to
propose
that
that
transaction
and
the
only
thing
that
matters
with
that
model
is
that,
even
if
you
refuse
to
access
to
run
a
given
contract,
if
you
end
the
block
that
does
use
it,
but
there's
a
transaction
that
they'd
use
it
you
need
to
be
able
to
so.
The
hope
is
that
it
will
result
in
less
force
or
at
least
reduce
the
need
for
forts,
but
yeah.
B
B
C
B
So
indeed,
like
some
of
those
ideas
are
already
implemented
in
yet,
for
example,
there's
some
caching,
in
fact
peter
currently
is
doing
a
lot
of
work
on
that.
Actually
it's
a
pillar
of
fuel
etc
number,
but
one
of
the
two
is
doing
something
on
that,
so
why
why
is
it
real
related?
It's
not
so
I
mean
the.
B
A
B
Yes
and
good
in
the
sense
that
yes,
I
started
measuring,
but
for
that
I
mean
by
my
not
to
sing
the
entire
blockchain
and
fortunately
I
didn't
reach.
I
have
some
free,
some
pre
diagrams
at
home,
but
they
just
were
where
I
am
at
at
the
moment
is
right
after
the
dowel
hack.
So
you
have
a
lot
of
conflicts
coming
up.
People
are
calling
the
same
contract
over
and
over.
So
it's
not
giving
me
an
overview,
but
yes,
I'm
looking
into
that
and
I
will
tend
to
publish
that.
Hopefully,
before
the
end
of
the
year.