►
From YouTube: 2020-05-05 :: Ceph Crimson Meeting
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
B
I
ensured
an
exchange,
my
pre-designed
documentary-
and
there
are
some
things:
do
you
want
to
go
in
this
meeting?
All
you
guys
will
be
first
I.
C
Hi
buddy
I
was
working
on
the
scrubbing
yeah,
like
I,
said
in
in
the
cone
meeting
and
I
sent
you
all
some
of
my
summary
of
the
attempt
to
use
the
SML
and
said
thanks
for
the
feedback
I'm
back
to
doing
it
in
Berlin.
C
C
C
C
One
more
question
before
sorry:
I
forget
the
yeah.
Sorry
I
forgot,
I
I
chased
a
perfect
license
to
steal,
I
am
to
jetbrains,
say
line
and
I
was
wondering
if
anyone
ride
it
made
a
purseful
import
of
the
safe
project
into
seaman.
C
C
E
C
C
D
A
E
So
I
got
through
I
had
a
a
version
of
the
documentation
that
is
sort
of
similar
to
what
I
add
to
the
Google
Doc
well
back
and
to
the
to
replace
Eastern
rst,
and
you
know,
documented
and
adjusted
all
the
interface
files
that
they
matched
the
new
format,
etc,
and
so
I
went
ahead
and
push
the
first
PR,
which
is
just
the
journal
and
cache
extent
interface,
I'm
continuing
to
work
on
refining
the
LBA
tree.
Although
I
left
a
link
to
it.
E
F
Last
week,
I'd
continue
to
work
on
the
index.
Lubrication
and
I
have
implemented
a
special
version
of
lookup
for
note
type,
0,
&,
1
and
I
feel
it
is
too
verbose
and
complicate
here
and
decide
to
generalize
this
logic.
The
working
branch
is
is
this
is
1,
and
this
is
introducing
3
lookup
stages,
for
example,
for
know
type
0,
&
1.
It
has
three
stages.
F
The
first
one
is
to
look
up
the
the
fixed
key,
and
the
second
is
to
look
up
the
string
key
and
if
it
is
matched
then
the
third
third
stage
is
to
look
at
the
snap
and
generation,
but
for
know
type
2.
It
only
has
two
stages:
it
just
need
to
look
up
the
string
key
and
the
snap
and
generation
and
for
know
type
3.
F
It
only
needs
to
if
it
only
have
has
one
stage
that
it's
just
to
look
at
this
natural
and
generation
and
secondly,
the
local
history
of
each
stage
needs
to
be
remembered
in
order
to
shut
circuit,
the
search
if,
if
the
partial
case
is
already
matched
in
the
parent
lookup.
So
this
is
part
of
the
implementation
of
of
the
string.
D2
plication,
so
so
the
reason
of
this
is
is,
although
at
block
level,
each
node
have
very
different
layouts,
but
I
think
they
can
share
the
same.
Similar
look
up
logic,
so
I
am
trying
to.
A
E
F
E
D
A
B
D
A
B
So
I
open
my
and
design
document
the
Google
Doc
so
for
our
extend
my
tree
design.
So
there's
two
layer
add
rice
translation.
So
here
you
can
see
that
in
the
chart.
So
there
is
exchange
allocation
tree
I,
assume
that
we
can
use
a
RPE
tree
to
serve
this
allocation
tree.
It
is
mark
the
logical
address
to
the
physical
address
and
the
route
is
stalled
in
the
super
block
of
our
disk
under
each
oh,
no,
the
tree,
each
node
leaf
atom
will
in
contain
exchange
my
tree
root.
B
B
One
way:
look
up:
Onoda
we
get
it.
Onoda
extend
map
free,
use,
the
object,
logical
off
site
to
search
the
external
map
tree
to
get
a
logical
dress,
and
then
we
use
that
out
logical
dress
that
a
lot
of
exchange
address
to
search
the
air
bee
tree
to
get
the
physical
address.
So
the
precondition
is
that
I
assume
that
X
exchange
allocation
tree
and
up
you
tree.
It's
a
sentry
just
a
one
tree
here
and.
B
B
We
just
allocate
from
the
segment
ID
of
cider
in
sequence,
we
counted
the
the
externally.
We
want
hidden
extracted
files,
we
want
it
just
a
second
layer
allocated,
it
does
disk
space.
Then
we
map
at
the
logical
drafts
in
the
LPO
tree,
so
the
LP
tree
will
serve
the
allocation
tree.
They
do
the
mapping
and
that
they
they
have
the
free
address
information.
B
B
When
your
might,
where
you
get
outside
our
object,
and
it
may
be
not
the
extent
logical
extent
outside
there
may
be
inside
the
logic
extension
so
so
here
is
the
relationship
between
the
between
the
and
the
complex
part
is
the
plone
when
the
objector,
when
we
do
some
hello
first,
we
have
to
create
a
new
object,
new
all
node,
and
they
will
share
that
new.
All
node
and
the
old
owner
will
share
the
extend
map.
That
means
we
have
to
clone
exchange
map
so
only
to
the
extent
the
tree
clone
or
we
can
follow.
B
B
The
first
thing
you
have
to
to
calendar
this,
the
chair,
node
and
reduce
the
first
know
the
reference
and
the
fact
the
new
know
the
reference
to
one
and
then
set
the
charity
child
know
the
reference
to
Reverend
account
to
to,
and
then
also
when
you
are
injured
H
you
have
to
reduce
the
old
one
to
reference
to
one
under
certain.
You
want
to
a
reference,
come
to
be
one.
So
this
is
the
kalam
tree
the
steps
of
Kelowna
tree.
This
is
cologne
for
the
extend
my
tree
stats.
B
B
Yeah,
so
so
that
is
one
way
cologne
to
the
Cologne
steps
up
and
for
the
extended
tree.
It's
kinda
map
trees,
their
share
at
the
beginning,
at
the
initial
they
share
most
of
the
note
when
you
modify
the
new-
and
you
know
that
you
just
following
the
steps
to
create
a
new
node
and
set
that
reference
count,
and
this
is
further
extended
map
tree.
Another
one
is
for
the
he
exchange.
So
I
think
we
should
they
have
to
update
the
P
exchange
physical
extent,
reference
in
the
extend
allocation
tree,
though,
what.
E
E
B
E
Up
you'll
notice
that
you
only
need
to
increment
the
ref
count
of
the
first
block.
That's
different,
though
these
leaf
things
that
that
there
are
the
things
that
actually
point
at
the
logical
extents.
You
don't
need
to
increment
to
increment
the
ref
counts,
not
until
you
actually
propagate
the
change.
All
the
way
down.
Dude
I
mean
so
once
you
once
you
have
to
leaf
nodes,
pointing
at
the
same
extent
yeah.
You
have
to
route
the
ref
count,
but
not
until
them.
B
Emitted
here
so
when,
for
example,
if
the
there
is
a
file
a
to
file,
one
is
another
ones
clone
copy
and,
for
example,
the
file
full-on
disco
occupied,
102
and
103
key.
So
behind
us
perfectly
and
the
the
new
one
is
the
powerful
is
the
coke
is
clone
if
they
dude
the
Panda
right
to
the
disk
to
the
file
their
Apple
right
at
10k,
they
will
have
another
physical
extension
yeah.
E
So
what
what
you'll
do
is
when
you
create
bars
the
second
node
right
for
each
one?
That's
that
that
you
reference
again
you'll
call
increment
ref
count
on
that
yeah
and
similarly,
when
you
delete
one
of
these
things,
you'll
call
tariffs
on
all
the
relevant
things.
It'll
get
rid
of
the
ones
that
drop
to
zero
and
otherwise
yeah.
So.
B
B
A
A
E
I'm
thinking,
I,
don't
I,
don't
see
this
as
a
fixed
point.
If
someone
has
a
good
reason
not
to
do
it.
That
way,
then
we'll
talk
about
it,
but
that's
my
current
guess:
I.
B
E
A
A
E
A
A
E
B
B
E
B
E
Well,
it's
I've
been
thinking
of
extent
allocation
as
the
thing
that
allows
me
to
iterate
through
a
segment
and
figure
out
which
segments
have
to
which
extents
have
to
be
moved.
So
we
have
two
mappings.
We
need
to
maintain
one
from
logical
addresses
to
physical
addresses
and
one
from
physical
addresses.
Logical
addresses,
I'm
flexible
at
this
point.
But
that's
that's
what
I'm
thinking
will
be
the
case.
A
E
E
B
E
Right,
we,
no,
no
that's
the
elbe,
I
I,
don't
have
anything
called
the
extent
allocation
tree.
What
I
have
is
I,
suppose
the
LBA
tree,
which
Maps
logical
addresses
to
physical
addresses
and
I,
think
the
Pegman
usage
tree
or
something
that
map's
the
physical
addresses
that
are
still
alive
back
to
their
logical
addresses
for
garbage
collection
purposes.
So.
B
E
E
B
E
D
B
E
B
B
E
E
Wanker,
for
instance,
butter.
If
s
has
a
non-trivial
allocation
problem,
they
have
to
find
space
of
the
disk
to
put
an
extent
for
us,
though,
because
we're
always
sequentially
writing
to
a
segment
that
parts
trivial.
The
hard
part
is
figuring
out
how
to
clean
a
segment
but
yeah
for
your
purposes.
What
you've
been
referring
to
as
an
extent
allocation
tree
is
the
Albee
entry.
A
B
B
E
B
B
E
Saying
that,
if
the
root,
if
if
the
tree
is
ever
small
enough
to
fit
in
the
root,
then
that's
all
you
ever
have
right?
That's
that's
true
of
every
beat
of
every
tree
right
for
for
Eddie
be
tree
implementation.
If
the
entire
key
space
can
fit
in
one
node,
that
will
happen,
it
will
be
in
the
root.
You
won't
have
any
other
notes
right.
E
That
way
in
the
pretty
common
case
like,
for
instance,
every
rgw
object
if
there
were
only
one
little
bitty
extent
in
the
o,
node
that
or
one
little
bitty
bite
range
in
the
O
node.
That
just
tells
you
where
to
find
the
data,
that's
it
no
actual
tree,
because
the
tree
is
one
block
large
and
it's
tiny.
A
E
E
Exactly
it'll
it'll
it
it
may
in
some
cases
reduce
the
height
of
the
tree
by
one
which
is
worth
it
and
again
you
choose
the
size
based
on
how
big
you
want
the
Ono
together.
It's
not
like
you
have
to
make
the
oh,
no
dick
I'm
just
suggesting
this
is
one
way
to
look
at
it.
It
naturally
gets
you
that
flexibility,
where,
for
simple
cases
you
it's
just
in
the
auto
and
you're
done
and
for
complicated
cases.
It
naturally
extends
out.
B
E
A
A
E
D
A
E
So
I
don't
know
that
I'd
worry
too
much
about
the
in
lighting
part.
That
can
be
a
thing
we
worry
about
in
baby
version,
3
of
the
doc
I
think.
The
next
part
is
indeed
to
write
down
the
on
disk
structure
for
the
interior
and
leave
notes
and
feel
free
to
have
a
look
at
the
way.
I
did
the
LBA
tree
I.