►
From YouTube: Open Match Community Meeting Feb 2020
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).
B
C
C
Yeah
I
would
multiplayer
guys
company
in
the
UK
with
game
studios
around
the
world
and
looking
at
its
valuating
a
few
of
the
things
that
games
offer
like
open
match.
F
G
H
H
Anyways
I'll
get
started
I
I'll
kind
of
quickly
go
through
the
the
bits
of
the
agenda
that
I
added
just
wanted
to
give
folks
a
an
overview
of
dot.
Ten
and
kind
of
the
plans
ahead.
I
also
saw
in
the
question
hosta
around
ETA,
so
I'll
try
to
address
that
as
well,
so
at
a
high
level
of
410
the
priorities
that
the
key
priorities
for
top
10
are
to
get
a
frog,
get
all
the
API
changes
out
of
the
way
and
to
me
any
core
product
changes
that
are
on
the
horizon
for
one
auto.
H
So
the
way
we
are
right
now,
triaging,
all
the
issues
are
basically.
If
we
think
this
is
like
a
issue
in
the
core
product
that
impacts
users
in
production,
then
we
want
to
prioritize
it
4.10,
so
API
changes
obviously
fall
in
in
that
category.
Any
API
change
is
definitely
one
of
the
key
other
things
we
are
working
on
and
hull.
Let's
go
to
speak
to
details
about
that,
but
is
like
the
scaling
of
it.
H
We
are
trying
to
introduce
a
query
cache,
so
there
are
that's
kind
of
the
stuff
that
we
are
tackling
in
dot
10
out
of
very
high
level.
We
are
still
trying
to
stick
to
like
the
six
week
time
frame,
so
starting
from
last
week,
fall
back
right
now,
I
think
the
end
date
is
around
end
of
March.
That's
when
we
are
targeting
a
dot,
then
act
and
from
then
on.
H
The
road
map
to
one
auto
is
basically
we'll
see
the
feedback
from
doctor
in
and
see
what
folks
are
missing,
get
coming
any
feedback
and
fill
in
any
any
missing
holes
to
dot
one
dot.
Oh
so
I
at
this
point
to
kind
of
be
clear.
There
is
no
like
major
after
dot.
Ten
here
are
the
major
blockers
or
one
dot.
Oh,
so,
if
you.
H
Want
to
prioritize
those
in
inductance
and
so
everything
from
ten
to
one
dot
or
should
be
mainly
from
feedback
from
dot
ten
or
more
of
like
they're
up
there,
a
bunch
of
things
right
now.
We
have
actually
categorized
as
one
dot.
Oh
and
those
are
primarily
like
onboarding
things,
so
we
definitely
want
to
take
them
on,
but
basically
they
aren't
blocking
anybody
from
hosting
it
in
production
they
are
more
like
a
roadblock
for
folks
to
either
get
onto
it
or
simplify
settings.
Documentation.
Stuff
like
that.
H
So
so
that's
kind
of
what
it
is
one
thing
I
would
request
is
we
right
now
have
tried
to
internally
take
a
stab
at
assigning
milestones
to
all
the
pending
issues,
and
so
at
a
very
high
level.
H
So
if
folks
get
a
chance
glanced
all
the
issues
to
see,
if,
if
you
think
the
milestone
assignment
to
them,
is
as
expected,
if
not
feel
free
to
just
discuss
it
on
slack
or
raise
an
issue
to
us
and
we
can
discuss,
ask
were
thinking
and
we
it's
always
open
to
change.
So
just
this
time.
Right
now
is
just
be
anomalies
for
us
to
prioritize
and
plan
the
work,
but
that's
kind
of
what
it
is.
H
So
that
said,
I
think
I'll
quickly
walk
the
other
important
update
from
our.
It
would
be
for
the
query
service,
so
I'll
have
Scott
kind
of
for
just
walk
us
through
what
currently
it
is,
and
what
do
we
plan
for
4.10
and
I
know
there
is
some
discussions
falling
from
that
around,
like
the
other
databases
that
we
should
consider
as
well.
So
maybe
we
can
just
open
up
this
discussion
to
that
yeah.
E
E
We
did
a
bunch
of
Gale
testing,
like
with
her
skills
us
looking
at
unity
or
at
Redis,
and
how
we
were
previously
doing
indexing
or
currently
with
0.9,
doing
indexing
on
open
match,
and
it
just
did
not
scale
well
enough.
So
the
main
cause
of
scale
concern
was
how
I
had
to
do
a
lot
of
range
lookups
and
then
query
all
the
tickets
every
time.
E
So
we
did
I've
several
different
experiments
and
prototypes
one
of
them
was
using
Redis
replicas
to
read
from
those
instead
of
reading
master,
one
of
them
was
a
fully
custom
replacement
of
Redis.
That
did
everything
in
memory
whatever
and
then
the
third
one
was
keeping
Redis
by
having
Curie
kind
of
cache
everything
and
then
like.
E
E
So
what
it
essentially
does
is
that
there
is
the
indexes
with
in
Redis
are
gone
if
you
know
how
they
work
today,
there's
only
really
two
letter
left,
which
is
the
the
set
of
all
tickets
and
the
ignore
list
or
the
like
tickets
that
are
waiting
first
time.
That
kind
of
stuff,
when
the
query
gets
a
query
coming
in
for
filter
tickets,
like
I,
want
to
get
these
tickets
well.
E
First
Oh
of
those
requests
and
group
together,
then
it
will
send
those
to
Redis
to
just
get
the
list
of
ticket
IDs,
and
then
it
has
its
own
internal.
Cache
of
this
is
the
ticket
ID
to
ticket
value,
and
it
will
delete
the
ones
that
it
doesn't
see
any
more
in
the
all
tickets
and
then
it
will
add
ones
that
are
missing,
and
then
it
will
run
the
query
in
memory
in
parallel
and
that
seems
to
be
way
faster.
The.
E
We
didn't
push
the
number
of
profiles,
but
I
know
a
number.
The
number
of
profiles
has
been
a
scaling
concern
so
far
and
we
had
what
960
profiles
running
four
times.
The
second
like
that
and
I
didn't
try
pushing
it
probably
go
much
higher,
but
it
was
at
least
getting
to
there,
which
now
the
other
Redis
based
prototypes
works.
E
F
Can
I
ask
a
clarifying
question?
Yes,
so
it
sounds
like
Redis
was
struggling
to
it's.
Probably
the
Z
range,
if
I
remember,
but
basically,
at
a
certain
point,
a
certain
scale
read.
It
starts
to
be
to
become
the
problem,
which
means
we've
reached.
The
the
kind
of
the
database
has
become
the
bottleneck,
which
means
we
can
start
investigating
ways
of
speeding
up
based
on
you
know,
read
and
write
patterns.
F
So
this
particular
solution,
though,
is
not
so
much
a
query
cache
as
it
is
an
in-memory
ticket
cache
that
has
like
it's
been
optimized
to
take
custom
profile,
queries
and
run
them
faster
with
higher
horizontal
scalability,
yeah.
Okay
and
that's
gonna,
give
us
like
a
much
much
much
higher,
anticipated,
simultaneous
observation
of
lots
of
tickets
with
with
more
interesting
queries
than
we
were
gonna
get
with
with
just
exerted
vanilla,
yeah.
E
Redis
is
single-threaded,
and
so
you
couldn't
really
scale
up
the
parallel
queries
going
against
it
to
a
high
degree,
especially
because
the
C
range
apparently
is
really
slow.
So
it's
just
a
lot
faster
to
have
a
list
of
ticket
objects
in
memory
and
just
filter
like
simple
go
code.
Just
is
this
value
within
this
range?
If
so,
then
it's
in
the
pool,
otherwise
it's
not
kind
of
filtering
no.
I
F
E
H
E
I
I
Let's
see
two
to
four
generally
sure,
I
think
yes,
somewhere
somewhere
around
there,
it
wasn't
like
an
exorbitant
amount
and.
F
F
10,000
tickets
with
one
search
index,
the
query
will
take
about
a
second
on
average
across
those
40
threads
simultaneous.
So
that's
clearly
where,
like
we
can
do
high
reads
simultaneously
and
that's
exactly
what
this
this
thing.
That's
gots
worked
on.
It's
trying
to
do,
yeah
that
your
numbers
line
up
pretty
well
yeah.
E
H
Thing
I
would
add:
is
we
kind
of
tried
to
run
short
this
into
the
release?
That
way,
we
don't
have
to,
like
necessarily
wait
for
the
release
to
be
out
for
folks
to
try
this
out,
because
I
think
this
is
a
pretty
critical
piece
of
what
we
all
have
been
discussing
almost
four
months
now,
if
I,
if
memory
dates
back
correctly
but
I
think
yes,
I
I
think
it's
with
ish
with
Caleb
I
mean
we
have
been
engaging
on
this
for
a
while.
H
So
I
almost
feel
like
now
that
we
have
a
proposal
and
a
solution,
we
are
deliberately
trying
to
get
it
only
into
the
release,
so
that
folks
can
maybe
even
take
a
snapshot
of
the
release
in
between
and
and
try
to
like
just
from
your
workloads
on
it.
Rest
assured
at
this
point
we
have
good
end
to
end
an
integration
test
coverage
that
it
won't
be
completely
broken
like
there
are
not
many
moving
pieces,
so
they
really
should
be
fairly
high
quality
or
outside
of
this
change.
So
it's
not
like.
H
There
are
too
many
other
things
that
you
should
be
concerned
about
taking
or
in-between
drops.
So
so,
maybe
once
we
are
checked
the
sense
card
and
right
now,
actually
the
release
is
almost
clean,
like
that
I
haven't
been
much
changes
since
start
line,
so
you
can
actually
just
have
a
tag
out
for
like
try
this
one
out.
That
way,
we
can
kind
of
keep
moving
with
the
rest
of
the
changes.
Where
folks
can
hammer
the
specific
build
with
a
really
definitely.
H
F
B
F
F
If
you're
gonna
make
only
games
that
have
like
a
minimum
number
of
players
in
it,
but
if
you
were
to
say
doing
like
trickle
in
or
like
Lobby
based
backfill,
where
you
always
say,
yeah
there's
at
least
one
player
has
been
waiting
a
long
time
give
this
player
a
server
that
needs
like
a
hundred
more
players.
So
that's
a
backfill.
You
end
up
in
a
state
where
you
spin
up
thousands
and
hundreds
of
thousands,
tens
of
thousands
of
games
they're
all
doing
backfill.
F
So
now
you
have
a
cold
start,
backflow
problem
and
we
knew-
and
now
we
know
that
we
didn't
have
horizontally
scalable
query
and
even
though
we
still
have
it,
I
think
that
problem
is
still
at
one,
that
we
need
to
try
and
either
get
some
community
feedback
for
or
formalize.
Some
thoughts
for
we've
talked
about
this
several
times
so
I.
H
Actually,
don't
agree,
I
think
just
because
we
can
now
scale
better
sure,
necessarily
change.
The
recommendation
on
backfills
I
think
we
should
battle
right
now.
The
recommendation
was
part
based
on
the
fact
that
we
just
couldn't
handle
it.
Now
that
that
reason
doesn't
stay
anymore,
we
should
still
look
at
like
yes
before
we
actually
just
say
all
now
that
we
can
handle
horizontal
scale.
Just
go
back,
feels
that
shouldn't
be
the
National
recommendation,
but
yeah
thanks
for
sharing
and
I
would
love
to
see.
B
F
We're
still
doing
bench
morning,
things
for
the
head,
but
it's
something
I
might
have
cut
out
there.
We
will
definitely
have
something
for,
like
you
know,
a
write-up
about
how
a
backfill
storm
can
happen
and
kind
of
a
cautionary
tale
about
you
know.
Tying
your
function
runs,
and
your
query
runs
to
the
number
of
servers
you
have.
An
outage
can
be
can
be,
does
I,
wouldn't
say
disastrous,
because
everyone
still
gets
to
play,
but
there's
definitely
a
money
drain.
That
happens
when
you
spin
up
thousands
of
cloud
or
bare
metal
compute,
so
yeah
I.
H
H
Really
did
that
I
don't
need
to
place
too
much,
but
I
think
in
general.
Triple
matchmaking,
like
we've,
had
folks
ask
us
that
before
I
know
we
had.
We
don't
have
like
that
right
now.
Our
recommendation
is
more
of
how
you
can
make
it
work
through
open
match,
but
it's
not
it's
not
ideal
like
open
match,
doesn't
do
any
special
anything
to
make
it
happen.
The
question
that
I
maybe
two
aspects
to
this
again
there
may
be
our
recommendation
for
1.0,
but
they
may
be
like
hey.
H
Can
we
actually
support
this
as
a
first-class
match
right?
So
so
that
is
I
think
there
is
even
put
a
little
matchmaking.
There
is
some
discussions.
We
need
to
have
like
honesty,
I
think
it
go
be
almost
four
of
the
mindset
of
like
oh
with
the
open
match
model.
You
shouldn't
do
it
anymore,
but
I'm
guessing
there
will
be
a
lot
of
customers
who
will
it
be
like,
doesn't
matter
open
much?
How
do
we
want
to
do
it
like
that's
how
we've
been
doing
things?
How
do
we
do
this
with
it
right
so
I
and.
F
I
think
there's
a
very
clear
distinction.
I
was
just
writing
up
about
this
there's
a
very
clear
distinction
you
can
draw.
You
know,
there's
kind
of
two
ways
of
thinking
about
matchmaking
from
I
have
a
Lobby
or
a
metagame
server
or
I
have
like
an
open
world.
That's
always
running
and
I'm,
always
accepting
players
of
1
to
as
many
as
I
can
accept
and
in
be
given
time
and
I
think
it's
worth
discussing
just
because
it's
kind
of
an
interesting
topic
that
sparks
conversation.
F
But
if
you
have
any
reason
for
why
a
player
should
go
to
a
particular
server,
I
think
they'll
be
match
absolutely
like
whether
its
first
class
formalized
or
its
guidance
like
there's.
There
are
ways
to
do
it.
Some
of
it
involves
like
randomizing
the
order
of
tickets
after
you
do
a
query
and
always
taking
1
or
taking
you
know
as
many
as
you
can
using
score
and
the
proposal
to
like
try
and
create
higher
player
density.
So
a
server,
that's
mostly
full.
You
absolutely
want
to
keep
full.
F
So
you
don't
end
up
with
20%
density
across,
like
20
servers
and
kind
of
getting
smart
about
understanding.
Why
the
players
there?
The
other
way,
is
more
just
service
discovery
which
is
I,
don't
have
a
reason
why
any
given
player
should
go
to
any
given
server,
and
so
it's
like
a
glorified
DNS,
yeah
I
sort
of
agree
like
if
you
could
just
list
the
servers
say
how
many
are
on
them
and
then
your
game
client
would
choose
which
one
to
take
like
a
server
browser
service.
F
F
So,
depending
on
how
simple
it
is,
it
gets
a
little
more
difficult
to
totally
grok
with
the
live
behaviors
gonna
be,
whereas
when
it's,
you
know
very
specific
the
thing
you're
trying
to
do
for
this
region
with
these
players
and
I'm
taking
them.
Because
of
this,
you
can
use
scores
and
open
match
to
actually
do
a
pretty
compelling
trickle
in
experience,
but
all
of
that
is
propagated
on
getting
backfill
kind
of
that
guidance
needs
to
be
pretty
crisp
because
that's
something
you're
continuously
doing
at
that
point.
Yeah.
H
Yeah
cool
thanks
for
thanks
for
sharing,
let's
see,
what's
on
the
agenda,
next
open
match
our
GDC.
Actually
a
quick
note,
I,
don't
know
how
many
folks
will
be
at
GDC.
I
just
wanted
to
give
take
this
one
as
a
shout
out
to
like
say
we
will
be
like
Scott
and
I
will
be
there,
and
if,
if
there
are
more
folks
around,
then
we
would
love
to
catch
up.
We
can
kind
of
have
like
a
informal
meet-and-greet
or
just
like
get
face
to
face
how
things
have
been.
H
Be
very
close
to
ten,
so
I
think
it's
kind
of
endgame.
It
will
be
nice
if
folks
are
there
for
us
to
just
kind
of
get
together
and
if
they
say
oh,
oh,
so
we
can
set
something
up.
We
will
send
something
to
the
community
as
well
as
like
just
invite,
but
if
you,
if
any
of
you
folks
are
at
GDC,
then
yeah
I
think
we
should.
We
should
get
together,
I
actually.
A
H
H
Outside
of
that,
let's
see
I
think
these
were
the
questions
that
were
added
and.
A
C
You
yeah
yeah
I'm,
basically
work
him
away
for
the
tutorial
and
I
got
to
the
point.
Where
I
had
the
example
open
in
the
browser
and
I
had
errors
reported
of
in
back
end
match,
SVC
clustered
up,
Michael
couldn't
be
found,
and
then
I
described.
The
pods
looked
at
the
event
stack
and
it
was
saying
failed
to
sync
conflict
map
cache.
B
Because
this
is
definitely
like
any
type
of
like
an
arrow
that
we
see
like
usually
like,
if
you
forgot
to
mount
the
override
config
map
that
is
required,
broken
match
is
the
demo
installation
like
ever
be
kind
of
different,
but
this
time
yeah
I'll
try
to
try
to
reproduce
it.
B
F
F
C
Up
yeah
I
mean
I
used
the
well.
There
was
some
fun
because.
H
C
H
H
You
cool
thanks
outside
of
that.
We
have
a
couple
other
things:
one
was
the
road
map,
so
I
think
I
code,
the
road
map,
I
guess.
The
next
question
was
directed
towards
a
road
map
for
for
1.2
and,
like
I,
said
after
dot
dot.
Ten,
primarily
the
the
one
we
is
you
or
our
hope
in
Stockton
is
the
stable
version,
but
we
wouldn't
label
a
virgin
one
dot
or
till
we
have
the
community
kind
of
tell
us
that
this
looks
looks
good,
so
that's
kind
of
the
the
path
to
an
auto
and
and
stability.
H
So
that's
essentially
the
the
road
password
dot
time.
The
most
real
one
is
like
the
March.
In
this
kind
of
thing.
We
are
targeting
that
so
that's
it.
The
next
one
is
was
om,
use,
match
used
in
production
games
like
the
doodle
and
how
did
it
work
out
so
when
I
think
open
match
was
used
for
doodle
I
wasn't
on
open
match,
I
think
only
Kalyan
probably
was,
but
from
the
from
when
I
have
heard.
Open
match
was
very
different
back
then
so
I
couldn't
really
take
it
as
like.
H
H
They
have
come
up
with
a
game
that
sign
that
uses
open
match
based
matchmaking
and
the
game
is
in
production
right
now
they
have
a
GBC
talk,
that's
scheduled,
so
that
should
be
fun,
but
basically
that's
why
that
is
the
first
official
production
use
case
for
upon
open
matches.
As
far
as
I
can
remember,
Caleb
put
my
a
my
accurate.
Is
there
anything
else
with
the
doodle?
Oh
there
you
go,
there's
Kate
fight,
slow.
H
F
So
yeah
the
the
doodle
so
in
terms
of
production
games
that
the
tech
that
open
match
there's
a
couple
of
well,
let's
talk
about
the
doodle
yeah,
the
the
old
version
of
open
match
once
it
was
like
dot,
two
or
dot
three
that
the
doodle
ran
on
wasn't
really.
It
was
very
much
kind
of
like
a
pool
draining
system,
and
so,
while
it's
based
on
the
same
stuff,
it
didn't
always
guarantee
like
it
had
one
custom
thing
it
was
trying
to
do,
and
so
it
wasn't
intended
to
be
like
a
general,
a
pliable
solution.
F
It
was
only
important
that
they
play
quickly,
and
so
you
know
the
heart
of
that
has
been
brought
forward,
which
is
that
there's
a
custom
thing
they
wanted
to
do.
But
the
thing
that's
really
changed
is
the.
The
current
open
match
is
more
focused
on
kind
of
getting
that
that
query
scale
global
poll
consideration,
game
design
component
of
matchmaking
integrated,
whereas
the
doodles
very
much
like
it
had
won
one
game
design,
which
was
you
hit
a
button?
You
should
be
in
a
match,
so
cool.
H
The
latest
and
greatest
by
the
way,
it's
I
think
that's
six
or
seven
is
what
they
are
using,
but
but
it
is
a
lot
of
the
core
components
haven't
changed
since
then.
We
have
gotten
better
with
the
API.
Is
it
working
better
with
the
scale,
but
a
lot
of
the
core
conference
still
are
similar.
So
so
that's
probably
a
more
real
example.
We.
F
We've
launched
something
last
week
that
uses
parts
of
it
where
we
are
in
the
next.
Like
three
weeks,
we
plan
on
putting
like
pretty
much
what
is
currently
in
dot.
Ten
will
be
a
a
working
production
one
on
our
side,
so
we
can
report
on
that.
Based
on
the
findings
that
we
learned.
One
of
the
findings
was
the
backfill
storm
that
it's
all
the
exact
same
stuff
is
open
match,
especially
the
wave
match
functions
get
ran,
so
that
part
is,
is
open
match
which
is
using
the
whole
stack.
H
A
F
E
F
I
had
sort
of
like
I,
don't
know.
I
wanted
to
I
have
some
some
stuff
we've
been
working
through
as
we
try
to
investigate
how
to
achieve
kind
of
the
next
stage
of
backfill,
and
it
kind
of
feels
like
it's
not
necessarily
so
much
like
it
has
to
be
a
technical
steering
committee
meet
like
conversation.
It
could
be
one
I
know.
Ish
has
had
some
experience,
doing
that,
maybe
it's
worth
I'd
have
talked
about
it.
A
little
more
and
in
the
communities
did
I
cut
out
by
the
way
my
computer's
all
over
the
place.
Okay,.
F
F
Cool
okay,
so
one
of
the
the
core
issues
with
backfill
that
either
you
know
the
old
mash
community
of
match.
Steering
group
the
engineers
eventually
need
to
try
to
like
maybe
work
out
is
currently
you
know
we
we
backfill
by
hitting
the
backend
API,
or
this
is
the
old
way
of
doing
it,
and
that
would
effectively
schedule
the
run
of
a
match
function
inside
of
a
synchronizer
window.
This
will
get
a
little
bit
technical,
but
the
gist
of
it
is
instead
of
running.
You
know
twenty
match
functions
or
twenty
sorry.
F
Twenty
profiles
that
you
know
can
basically
adapt
to
the
population
that
you're
working
with
and
cover
multiple
game
design
concerns,
or
you
know,
facets
of
your
your
problem
space.
You
effectively
have
a
one-off
shot
to
try
and
like
pull
players
out
of
the
pool
and
take
them
into
the
game
server.
Whatever
orchestrates
that
call.
You
know
you
can
design
different
director
based
systems
or
you
know,
call
through
systems
to
try
and
do
that.
But
you
end
up
kind
of
in
the
same
world
which
is
you've
tied.
Your
your
game.
F
That
explains
that
it's
a
host
ticket
and
it
has
an
attribute
on
it
that
explains
that
it's
a
host
ticket,
so
it's
a
backfill
ticket
and
what
that
allows
you
to
do
is
your
match.
Function
can
basically
run
two
queries.
It
could
be
one
but
effectively
two
pool
queries
that
are
going
to
say.
Hey
give
me
all
the
existing
games
that
are
of
my
mode
type
skill.
Give
me
all
the
players
that
are
of
that
mode
type
skill,
I
see.
F
There's
three
games
and
200
tickets,
I'm
gonna
attempt
to
find
the
right
players
to
fill
those
existing
games.
I
will
now
omit
those
as
match.
Proposals
and
I'll
take
the
remain
being
pool
and
basically
create
the
new
proposals
from
that
set.
This
assumes
that
the
match
function
is
going
to
only
produce
the
right,
high
quality
games
and
score
them
appropriately,
so
that
you
know
players
won't
necessarily
get
assignments
because
they're
not
ready
for
high
quality
games.
Yet
so
they'll
come
back
through
the
loop
again
you'll
go
into
the
next
set.
F
So
this
is
great
for
session
based
games.
Where,
like
you
know
the
game,
basically
isn't
starting
until
we
get
the
right
players
in
so
this
is
gonna,
be
I'm
gonna
submit
one
ticket
and
when
that
ticket
gets
resolved,
maybe
I'm
still
missing
one
player,
so
I'm
gonna.
Do
it
once
more
and
eventually
I'm
gonna
stop
sending
back
flow
requests
because
my
problem
has
been
resolved.
So
that's
fine
if
I
only
have
like
one
or
two
players
coming
in,
but
what
happens
when
I
want
to
do
trickle
based
matchmaking?
F
Well,
I
just
have
really
big
games
and
I
expect
to
constantly
be
doing
this.
The
expectation
becomes
that
you're
constantly
working
with
these
tickets,
you
submit
them,
you
pull
for
them.
You
get
results.
So
here's
here's
where
that
it
gets
tricky
one
the
time
it
takes
to
the
game,
server
to
start
and
then
do
back
filling
is
a
huge
headache
for
evaluation.
F
I
say
that
because
I
as
a
developer
put
a
ticket
in
I
get
a
game,
it
starts
back
filling
that
time.
Maybe
it's
a
second
for
the
game
to
start,
maybe
it's
three
seconds
before
the
first
backfill
comes
in
matchmaking
is
executed
like
eight
times
since
then,
and
every
time
it
likely
produces
another
match
for
whoever
came
in,
and
so
there's
kind
of
this
need
for.
Maybe
when
that
match
function
decides
to
make
a
match,
it
can
basically
say
like
hey.
F
This
match,
isn't
full
and
while
that
game
servers
are
starting
up,
we're
gonna
create
this
type
of
like
longer-lived
object.
That
is
going
to
be
considered
as
a
not
full
game
that
needs
filling.
So
that's
that's
one
thing.
The
other
thing
is
that
working
with
tickets
continuously
means
that
you're
constantly
fighting
with
trying
to
land
inside
of
a
window.
F
You
basically
are
in
a
situation
where
you
don't
actually
know
the
state
of
how
many
games
need
how
many
players,
inside
the
context
of
running
a
series
of
match,
function,
spearing
a
cycle
gonna
pause,
because
I
think
I
cut
out
again.
Okay,
so
so
we
sort
of
have
a
good
idea
and
I
kinda
want
to
get
feedback
on
it,
but
I
introduced
it
in
the
previous
one,
which
is
the
idea
that
you
could
basically
introduce
it.
You
don't
necessarily
need
no
match
to
do
this,
but
it
could
be
an
open
match
concern.
F
You
basically
need
your
match
function
and
whenever
your
director
is
to
say,
like
hey,
I'm,
producing
a
match
and
it's
not
full
so
create
this
backfill
request
thing.
The
back
for
a
request.
Thing
is
then
going
to
be.
You
know
immediately
available
as
a
queryable
type
of
either
ticket
or
other
object
pool
inside
of
matchmaking,
and
it's
a
type
of
object
that
a
game
server
could
also
create
or
update,
thus
ensuring
more
or
less
you
get
like
95
to
99
or
a
hundred
percent
of
your
existing
games.
F
H
So
this
back
for
the
object
we
are
saying
becomes
like
essentially
a
false,
plus
persistent
concept
like
today.
Open
much
like
the
matches
are
more
of
ephemeral.
Right,
like
both
match,
is
just
passing
matches
through
and
not
really
retaining.
This
is
almost
is
this:
if
I'm
getting
this
right
like
a
match,
that's
essentially
a
half
match
that
open
match
now
kind
of
hangs
on
to
because
it's
a
yeah,
it's
it's
something
that
of
much
care
is
about
across
runs.
F
This
kind
of
begs
a
little
bit
of
a
question
which
is
like
this
sounds
like
state.
This
sounds
a
bit
like
session,
which
we
hear
notoriously
and
historically
an
open
match.
We've
been
very
anti
session
as
like
a
way
of
interacting
with
game
servers
and
that
there
are
things
you
can
do
with
the
life
cycle
of
this,
but
I
think
you
captured
it
more
or
less.
F
There's
a
thing
it's
gonna
exist,
I
would
say,
exists
for
a
very
short
period
of
time
enough
time
that
a
game
server
should
maybe
like
touch
it
to
keep
it
alive
like
that
type
of
well
you're
pulling
for
a
ticket.
We
effectively
say
you
know
you
can
keep
it
in
there
for
as
long
as
you
want,
but
you
should
write
a
timeout
function.
That's
gonna
like
get
rid
of
tickets
that
have
been
for
you
know
waiting
for
too
long.
Potentially,
if
your
game
design
was
going
to
use
something
like
that
Scott
so.
E
Session
based
games,
where
you're
you're
kind
of
looking
at
it
and
seen
hey
it
makes
sense
for
back
those
to
be
tickets.
Maybe
I
want
to
say
I
also
was
looking
at
just
like
how
he
would
write
a
match
function
and
that's
been
annoying
and
I
kind
of
arrived
at
the
same
conclusion.
Just
from
a
data
locality.
Standpoint
of
your.
E
E
Tracking,
so
you,
if
you're
looking
at,
say
players
within
this
skill
looking
at
this
boat
and
also
skip
servers
looking
at
their
that
are
on
this
mode
already
and
have
players
within
that
skill
range
already.
It
makes
sense
to
kind
of
pull
them
together
instead
of
having
separate
units
for
the
different
map,
the
different
backfill
and
then
also
one
or
you
know,
just
creating
a
new
game
then
having
to
give
the
ticket
data
to
all
the
unemployed.
Everything
together
so
I
definitely
agree
with
that.
E
You
create
a
new
one
right
and
you
want
to
fill
that
space
up
and
you
end
up
with
this
problem
of
as
players
are
leaving
like
you.
Can
go
okay,
one
player
you
can
go
in
now,
but
while
it's
processing
that
going
in
the
backfill
is
that
present
in
the
match
function
fun
that
way!
Yours,
that's
what
you're
saying
right!
Yeah.
B
F
E
One
thing
that
do
right
now
is
have
your
director
kind
of
stay
like
remember
that
hey
I
just
got
some
back
bills
and
there
processing
and
probably
gonna
get
the
back
fill
again
relatively
soon.
So
I
should
tell
my
match
function.
The
next
time
I
run
this
profile
that
hey
I've
seen
and
many
back
fill
requests
recently.
So
if
you're,
if
you
don't
see
any
back,
filler
requests
right
now,
it
doesn't
mean
there's
no
servers.
Looking
for
back
fill,
it
means
they're,
processing,
still
mm-hmm.
E
Getting
that
cycle
shorter,
as
far
as
like
making
this
waiting
for
assignments,
more
more
granular
I
just
had
a
couple
ideas
that
I'll
have
to
read,
but
making
sure
that
the
backfill
games
get
the
fact
that
they
have
a
new
player
coming
really
quickly
and
then
so
they
can
recreate
the
ticket,
possibly
before
the
next.
Like
goal
start
that.
F
Timing
seems
tricky,
though,
so
so
you're
absolutely
right,
and
this
is
why
I
wanted
to
bring
it
up
in
the
community
meetings
that
folks
had
a
way
of
like.
If
you
find
that
you
have
this
problem,
you
can
absolutely
right
it
such
that
your
director
is
like
back
is
like
server
we're
back
full
aware
and
you
can
have
it
set.
Your
director
is
racing.
You
know
the
director
pretty
much
races
today
to
get
all
the
profile
scheduled
inside
the
synchronizer
window.
F
It's
just
that
the
synchronizer
window
is
way
bigger
than
the
race
needs
from
a
backfill
perspective.
At
the
same
time,
you
could
be
doing
the
same
type
of
work
to
make
the
tickets
first
for
backfill
and
then
running
the
the
profiles
and
then
collecting
the
back
floors
assignments
and
then
doing
the
same
thing.
So
there's
totally
ways
of
achieving
the
thing
that's
been
described,
which
is
you
know,
instantaneous,
backfill
and
longer-lived
backfill,
so
yeah,
it's
so
totally
with
you
on
that
one
Scott.
I
A
I
If
you
wait
in
a
little
while
for
it
to
pool
up,
but
we
also
have,
if
you
we've
sort
of
messed
with
this
idea
of
like
trickling
in
and
not
waiting
and
just
sort
of
like
going
as
you
get
things
and
built
into
our
director,
we
have.
We
call
it
the
sanity
checker,
which
is
essentially
it's
kind
of,
like
you
were
saying,
with
like
this
race
condition
where
the
director
is
kind
of
constantly
collecting,
updates
from
players
and
servers
like.
I
Oh,
this
players
switch
to
a
different
playlist
and
they
they
queued
for
something
else,
or
this
server
got
or
lost
new
players
or
whatever.
So
the
matches
coming
out
of
open
match
are
checked
against
the
most
recent
updates
inside
the
director
before
the
match
is
actually
sent
out.
So
we
kind
of
like
double
check
like
oh.
This
player
is
no
longer
looking
for
that
playlist.
I
They
switch
to
something
else
in
the
interim,
and
so
we
throw
that
match
out
and
so
they'll
end
up
just
in
the
next
loop
I
mean
obviously
doesn't
completely
solve
your
race
condition,
because
there's
still
there's
still
a
crossing
in
the
night
as
it
were,
between
the
the
back
end
and
they're,
like
the
game
back
end
and
an
open
match,
but
it
kind
of
reduces
that
a
little
bit.
But
that's
I,
don't
know
I,
guess
that's
just
kind
of
like
what
we
found
sort
of
trying
to
deal
with
this
issue.
I.
F
F
That's
an
issue
that
we're
I,
also
trying
to
like
figure
out
exactly
what
our
strategy
is.
Gonna,
be
whether
it's
an
evaluator.
It
seems
like
the
director,
it
kind
of
becomes
this
brain
in
a
really
interesting
way,
where
you're
gonna
make
a
bunch
of
decisions
and
not
just
kick
a
bunch
of
stuff
down
the
road
because
of
a
match,
because
your
match
functions
like
cool,
because
your
match
functions
aren't
aware
of
the
world
right.
I
Right
and
actually
the
way
you
talked
about
like
how
you
handle
like
backfill
as
tickets
and,
like
the
other
things
you're
talking
about
sort
of
at
the
beginning
of
of
a
few
minutes
ago,
is
almost
identical
to
the
solution
that
we
ended
up
with
where
ya
backfill
is
just
a
specialized
ticket,
it
ends
up
in
the
same
pool.
We
fill
the
backfill
match
it
or
we
try
to
fill
the
backfill
matches
first
and
then
whoever's
leftover
kind
of
goes
into
like
the
new
game
bucket
and
we
make
new
games
from
there.
So
it's
we
ended.
I
F
F
I
F
H
Cool
one
other
thing
I
mentioned
I
was
gonna
mention
Caleb
and
to
the
rest
of
the
folks
as
well.
We've
been
marking
some
issues
as
with
the
label
of
40
SC
discuss
those
are
explicitly
things
where
we
have
a
question
that
we
kind
of
want
opinions
on
or
something
so
we
do
need
not
wait
for
the
DAC
meeting
on.
Some
of
them
are
specifically
added
to
you.
H
E
I
did
want
to
add
I
think
a
little
bit
of
color
to
what
we're
thinking
about
what
the
API
changes
really
quickly.
One
of
them
is
the
after
kind
of
after
your
fetch
match,
missed
call.
After
all,
the
take
care
all
the
matches
come
through
we're
looking
at
kind
of
the
status
of
like
how
things
went,
because
we
do
have
cases
where
we
can
partially
fail,
such
as
your
match
functions,
they're
returning
results,
but
then
it
was
running
too
long.
E
So
we
killed
it,
but
we
still
want
to
give
those
out
because
your
match
function
like
might
be
overloaded.
So
we
want
to
reduce
the
load
on
it
by
letting
the
mattress
that
can
make
come
out
of
it
and
then
I
think
the
other
area
which
we're
trying
to
kind
of
figure
out
is
giving
a
more
solid
ground
to
what
states
tickets
can
be
in
and
how
those
space
move
from
one
to
another
and
how
those
transitions
are
all
safe
and
don't
cause
race
conditions
that
kind
of
stuff.
E
So
that's
a
weird
or
more
broad
discussion,
but
it
has
a
good
chance
of
having
at
least
a
couple.
You
pío
config
variable
name,
changes
just
to
make
it
more
conceptually
clear,
but
there
might
be
some
cases
where
we
have
to
change
behavior,
because
we
want
to
avoid
creating
race
conditions
that
kind
of
stuff
or
help
you
put
not
create
race
conditions,
with
your
with
what
you're
doing
with
how
you're
calling
on
the
match.
So
we
will
see,
but.
H
H
I
think
that's
that's
it.
Once
we
get
closer
to
100,
we
will
have
to
have
another
way
of
like
actually
having
a
different
frame
for
the
api's
I
know.
Internally.
We
do
that
a
lot
for
things
which
are
like
epi
stem
cells
are
like
this
is
the
want
auto
surface,
and
then
you
have
a
beta
surface.
That
can
change,
but
you
know
like
it
needs
to
be
backward
compatible
and
it's
not
far.
So
it's
not
my
things
can
change
forever,
but
there
will
be
like
a
lockdown
for
at
least
400
all
right,
so
yeah.