►
From YouTube: OMR Architecture Meeting 20220414
Description
Agenda:
* JitBuilder 2.0 update [ @mstoodle ]
* Extend PR testing to add build flags [ @babsingh ]
A
Welcome
everyone
to
the
april
14th
omr
architecture
meeting
today
we
have
two
topics
to
discuss.
One
is
a
presentation
from
mark
stoodley
on
the
latest
in
jet
builder
2.0
and
then
some
extension
work
to
to
the
pr
testing
to
be
able
to
test
build
flags
from
from
bev
neat
so
mark
whenever
you're
ready,
you
can
take
over
the
screen.
B
Yep,
okay,
so
today
I'm
going
to
give
an
update
on
some
things
that
have
been
going
on
with
the
jit
builder
2.0
library.
So
if
you
recall,
I've
been
going
through
an
exercise
of
redesigning
the
jit
builder
library,
that's
in
eclipse,
omar
and
trying
to
bring
new
features
and
new
capabilities
to
it
and
expand
it
to
become
a
fully
fledged
compiler.
B
I
l
I've
talked
about
this
a
couple
of
times
at
the
omar
architecture
meeting
before
so
I'm
not
going
to
rehash
through
all
of
that
stuff,
although
there
have
been
things
that
have
changed.
Obviously,
since
I,
since
I
I
talked
last,
but
I
did
want
to
focus
on
you
know
a
few
things.
First
I'll
just
give
a
sort
of
brief
refresher
on
the
goals.
I've
changed
the
order
of
some
of
these
things
to
reflect
how
important
I've
been
treating
them.
B
Although
it's
not
a
fully
prioritized
list,
I
wouldn't
say
so.
The
the
main
goals
here
are
to
enhance
the
capability
of
jitbuilder
to
make
it
a
fully
fledged
compiler
il.
As
I
mentioned,
I
am
trying
to
maintain
the
flavor
of
the
existing
api,
and
and
for
that
I
really
want
sort
of
the
primary
use
cases
that
I
expect
people
to
be
using
to
remain
straightforward
and
easy
to
write.
B
2,
is
supposed
to
be
more
easily
extensible
and
and
be
able
to
have
people,
add
their
own
types
and
their
own
operations
of
fairly
arbitrary
complexity,
and
so
it
was.
It
was
thinking
harder
about
how
to
make
this
part
of
jet
builder
2.0
work
better.
That
resulted
in
me
taking
a
backward
step
on
backwards.
Compatibility.
B
B
So
I'm
trying
to
do
more
of
that
work
as
I
go
now,
so
that
there
is
a
body
of
regression
tests
as
well
as
something
in
some
senses,
their
code,
samples
as
well,
but
just
validating
the
correctness
of
the
the
things
that
I'm
building
and
then
finally
improving
usability.
So
you
know,
over
the
years
the
jit
builder
has
been
used.
B
There
have
been
a
number
of
well
I'll
call
them
complaints,
because
they
really
are
about
the
way
that
jit
builder
works
and
how
it
how
it's
not
always
easy
to
understand
errors
when
they
happen
or
figure
out
what
it
is
that
went
wrong
on
how
to
fix
it.
So
I'm
trying
to
fix
some
of
that
by
in
part,
because
in
part
by
making
it
a
more
fully
fledged
compiler
il
you
get
things
like
introspectibility,
printability
and
so
on.
B
But
you
know
trying
to
improve
on
things
like
how
how
easily
verifiable
it
is
that
you've
done
the
right
thing
and
improve
the
handling
of
errors,
so
that
you
can
understand
what
went
wrong
and
then,
of
course,
it's
a
compiler
il.
So
you
should
be
able
to
traverse
it.
You
should
be
able
to
analyze
it.
You
should
be
able
to
do
transformations
on
it
and
last
time
I
was
here,
I
talked
about
a
debugger
which
is
actually
in
a
non-functional
state
right
now.
B
B
So
that's
my
form
of
an
apology
for
don't
be
too
over
underwhelmed
by
any
of
this
all
right.
So
well,
that's
interesting!
That's
it!
That's
it!
It's
an
extra
slide
shouldn't,
be
there
so
right
so
a
bit
of
a
refresher
on
some
of
the
key
elements
of
jit
builder.
So
it's
a
compiler
framework,
so
you
operate
on
values,
values
have
types
you
arrange
operations
that
are
being
performed
in
jetbuilder
into
builders,
which
I
liken
to
it's
kind
of
like
the
stuff.
B
That's
between
curly
braces
in
you
know
in
a
c
or
c
plus
program
right,
it's
kind
of
like
a
code
path,
but
it's
more
than
a
code
path
because
it
can
have
other
things
embedded
inside
them
and
type
dictionaries.
There's
lots
of
new
stuff
that
has
been
created
as
as
part
of
this
update.
So
I
didn't
used
to
have
a
thing
called
a
compiler
I'll
talk
about
it
more
in
the
in
the
next
few
slides
and
it
carries
along
with
it
things
like
configs
for
detailing
what
to
do.
B
Strategies
compile
strategies,
compile
compilation
passes
a
compilation.
Object.
Extension
is
one
of
the
big
new
things.
That's
that's
there
now,
which
is
the
the
basic
mechanism
by
which
new
types
and
operations
and
capabilities
get
added
to
to
a
jet
builder
compiler,
there's
a
few
more
il
bits
that
have
been
kind
of
outlined
here
with
operation
and
literal
and
literal
dictionary
and
symbol
and
symbol.
Dictionary
didn't
used
to
have
symbols.
B
Literals
didn't
have
a
literal
dictionary
before
same
kind
of
analysis
and
transformation,
as
I've
talked
about
previously.
Obviously
the
debugger
is
non-functional,
but
it
will
be,
it
will
be
present.
There's
these
things
called
jb1
code,
generator
and
method
builder,
which
are
used
to
help
actually
generate
code
using
jet
builder,
one
from
from
jit
builder.
Two,
this.
I
guess
it's
a
little
bit
of
a
sign
that
I
haven't
really
thought
through
very
well.
B
B
You
know
you
can't
start
from
nothing.
So
I've
created
a
thing
called
the
jit
builder
core
library,
which
really
contains
a
lot
of
the
very
not
exactly
not
necessarily
abstract,
but
it
doesn't
have
a
lot
of
sort
of
hardcore
things
that
you
can
use
in
it
directly,
although
it
does
have
compiler
in
it,
which
is
something
you
do
use
directly.
B
So,
let's
just
kind
of
look
through
these
things
a
little
bit
so
there's
kind
of
like
il
components
here
that
are
sort
of
the
basis
under
on
which
the
the
jit
builder
2.0
il
is
constructed,
and
a
lot
of
these
are
familiar
concepts
for
people
who
have
used
jit
builder
before
or
even
for
people.
Who've
just
worked
on.
Compilers
before
you
know,
at
builder,
as
I
mentioned,
is
kind
of
like
a
code
path.
B
So,
let's
see
very
much
here
yeah,
so
the
the
the
core
library
here
when
it
gets
built,
actually
builds
together
with
jit
builder
one
there
is,
there
is
actually
a
class
called
jb1,
so
that
is
a
class,
not
the
jitbuilder
one
library
itself.
But
in
fact,
when
you
build
lib,
jb
core,
it
actually
loads
the
or
it
also
includes
libgitbuilder.a
from
the
from
the
chip
build
of
the
jitbuilder
library.
B
B
B
B
A
compiler
object
basically
has
a
lifetime
that
extends
across
all
of
the
compilations
that
you
would
do
with
it,
and-
and
there
are
some
things
that
it
carries
around
with
it,
like
a
config
object.
So
you
can,
you
can
make
set
configuration
options
that
extend
across
all
of
the
compilations
that
you
would
do
you
have
a
type
dictionary
so
that
your
you
can
define
types
that
will
be
visible
to
every
compilation
that
you
do.
B
B
They
at
the
jit
builder,
two
level
different
compilers.
Don't
really
have
very
much
of
a
notion
of
each
other.
So
you
know
one
compiler
object,
isn't
really
aware
of
any
other
compiler
objects
that
are
there,
but
obviously
because
it's
all
leveraging
the
omar
compiler
under
the
covers
via
jitbuilder
one
library,
you
know
they're
all
putting
their
generated
code
into
a
single
code,
cache
repository
and
they're
all
leveraging
the
same
compiler
infrastructure
under
the
covers.
B
No
because
it's
the
old
mark,
it's
just
the
omar
comply,
it's
just
the
omar
compiler,
providing
that
okay.
So
right
now
the
omar
compiler
doesn't
have
a
notion
of
different
threads.
So
if
you
create
threads
and
use
them
to
access
the
omar
compiler,
you
have
to
manage
all
of
the
synchronization
for
that
right.
Now.
B
Okay,
so
one
of
the
limitations
of
the
omar
compiler
right
now,
which
sucks,
but
it
would
be
great
to
fix-
and
I
think
I
think
it's
one
of
the
things
that
we
will
ultimately
end
up-
fixing
here,
all
right,
so
extensions
plug
new
things
into
a
compiler.
So
as
as
I
mentioned
before,
lib
jb
core
doesn't
really
define
any
concrete
types
or
operations
to
be
able
to
do
anything.
B
So
as
a
as
a
library,
it's
not
all
that
useful
by
itself,
and
I
did
that
actually
purposefully,
because
I
wanted
to
put
pressure
on
how
easy
it
was
to
extend
and
add
new
types
and
operations.
If
I
provided
a
whole
bunch
of
base
types
and
base
operations
in
lib,
jb
core,
there
wouldn't
be
as
much
pressure
on
making
it
easy,
because
it
would
only
be
kind
of
extra
stuff
for
stuff,
that's
outside
the
project
that
ends
up
using
those
facilities.
B
So
I
didn't
want
that
to
happen.
So
I
I
decided
to
keep
everything
very
abstract
in
the
in
the
core
and
everything
else,
even
even
the
support
for
the
traditional
types
and
operations
that
you
would
use
as
part
of
jit
builder,
the
dipole
one
library,
you
have
to
get
it
via
an
extension,
and
so
that's
where
this
extension
class
comes
in.
It's
a
subclass
that
you
can
create
extensions
by
subclassing
and
the
most
obvious
example
of
that.
B
What
I've
got
right
now
is
in
the
I
created
a
name,
space
called
base
which
has
a
base
extension
class,
which
is
where
all
of
the
builder
one
operations,
type
symbols,
etc
are
being
defined
and
are
or
are
loaded
into
the
compiler,
and
that
process
is
not
complete.
It's
actually
a
relatively
small
set
of
things
that
are
there
right
now.
Just
because
again,
I
haven't
had
a
whole
lot
of
time
to
work
on
this
and
b.
B
It's
it's
the
additional
focus
on
trying
to
test
test
everything
as
it
goes
in
slows
down
the
movement
of
stuff,
but
but
nonetheless,
it's
it's
got
a
it's
got
enough
to
do.
Matrix
multiply
right
now,
my
famous
example,
and
and-
and
it
also
has
supports
for
structs
and
and
pointers-
and
things
like
that.
B
So
the
way
you
use
these
things
is
so,
when
you're
creating
an
extension,
you
you
basically
the
the
the
typical
use
case
here.
Is
that
you're
you're
going
to
build
it
all
into
a
shared
object
which
can
be
loaded
dynamically
and
it
relies
on
you
implementing
a
create
function,
which
is
the
thing
that
gets
that
the
compiler
will
look
up
when
you're
when
it
asks
to
load
a
particular
extension.
B
B
Extension
has
to
have
a
version,
and
it
has
to
have
a
name,
so
that
name
that
I
mentioned
up
there
is
base.
But
if
you're
creating
your
own
extension,
you
know
you
can
you
can
give
it
its
own
kind
of
name.
Typically,
this
name
is
is
what
you
would
have
in
the
lib.
Like
a
you
know,
the
the
base
extension
is
called
lib
base
dot.
So
so
this
would
be
lib
myextension.so,
and
that
name
helps
the
compiler
automatically
look
up
where
the
library
is
and
load
it,
etc.
It's
kind
of
a
convenience
thing.
B
It
doesn't
have
to
be
done
this
way,
but
this
is
the
way
that
I've
kind
of
consistently
done.
This
is
that
there's
a
semantic
version
class
that
I've
implemented
as
part
of
my
extent
as
a
part
of
extension.
Sorry
part
of
jit
builder
2,
which
extension
relies
on
having.
So
you
have
to
have
a
version
of
your
library
which
you
maintain
and
then
the
the
load
extension
function
that
I
showed
on
the
previous
slide.
You
can
actually
specify
a
particular
version.
B
B
Here
we
could
create
my
type
class
and
then
there's
a
number
of
functions
that
are
that
you
need
to
implement
from
the
base
class
type
that
helps
kind
of
specialize,
how
that
type
will
be
used,
and
I
expect
this
number
will
grow,
but
right
now
it's
at
a
it's
at
about
eight,
some
of
them.
Some
of
them
define
a
few
extra
ones.
So
it's
like
10
but
they're,
generally
speaking,
quite
simple
little
functions
that
need
to
get
implemented.
There
are
things
like
print
literal.
You
know.
Are
these
two
literals
equal?
B
If
it's
a
numeric
type?
What
is
a
zero?
How
do
you?
What
does
a
zero
literal
look
like
and
what
is
a
that
should
be
identity,
not
identify
sorry
et
cetera,
so
they're
they're,
just
a
number
of
these
little
functions
that
you
have
to
go
and
implement
for
a
type,
and
then
you
add
a
public
field
to
your
extension
class
and
our
example
here
is
my
extension
to
hold
an
object
of
that
class
type.
B
So
here's
this
const,
my
type
class,
my
type
right
and
and
then
it
needs
to
get
initialized
as
part
of
the
constructor
for
the
extension
object
and
there's
a
way
to
do
that.
So
the
my
type
field
gets
initialized
by
calling
register
type,
which
is
something
that's
defined
by
extension
in
your
subclass
and
and
you
pass
it
a
my
type
class
and
I'll
talk
a
little
bit
about
this
loc
thing
later
on.
But
basically
this
is
a
source
code
location
that
helps
with
error
error
handling.
If
anything
happens,
to
go
wrong.
B
Can
specialize
your
type
any
way
you
want
by
adding
you
know
other
things
into
it,
but
there
are
a
few
things
that
you
have
to
implement
in
order
to
define
things.
So
these
are
how
things
like
int,
8
and
16
and
32
and
64.
float
32
float.
64
are
the
new
float
and
double
so
I
decided
to
sort
of
cons
to
make
that
more
consistent
in
terms
of
expressing
the
names
and
etc.
So
all
the
primitive
types
are
defined.
This
way
inside
the
base
extension.
B
One
thing
to
point
out
is
that
all
types
are
now
constant
pointers,
so
it's
impossible
to
modify
a
type
after
it's
been
created,
which
is
kind
of
why.
I
have
to
do
this
crazy
thing
during
the
constructor
here,
but
it
it
does
mean
that
types
are
now
nicely
const.
Throughout
the
whole,
you
can't
do
anything
with
a
non-constant
type.
Basically,
you
can't
get
access
to
one,
even
change
it
all
right.
So,
once
you've
got
types
you
can
create
values,
but
you
need
operations
to
actually
produce
values.
B
So
how
do
you
add
new
operation
types?
It's
actually
quite
similar
to
creating
a
new
type?
You
have
to
create
a
subclass
of
operation
in
this
case
or
one
of
its
subclasses
they're,
actually,
a
bunch
of
structural
subclasses
of
operation
that
are
created
to
help
make
this
easier.
So,
for
example,
there's
a
operation.
B
B
B
Jb1
codegenerator
and
jb1
method,
builder,
primarily
the
method
builder
class,
that's
implemented
in
lib,
jb,
core
and
so
on.
So
you
also
have
to
add
some
public
bits
into
your
extension
class
so
that
people
can
figure
out
how
to
use
this
operation.
One
of
them
is
a
thing
called
an
action
id
so
now
that
operations
are
completely
dynamic
and
not
sort
of
statically
embedded
into
the
language.
It's
not
an
enum
anymore
that
you
can
use.
So
it's
it's
actually
just
a
just
an
id
number
that
gets
assigned
by
the
compiler.
B
The
compiler
assigns
actions
as
you
register
operations,
and
so
you
need
to
store
what
that
number
is.
That
corresponds
to
to
a
particular
operation,
and
then
you
need
a
function
that
allows
you
to
actually
create
operations
of
this
type.
So
it's
the
extension
object
that
now
that
creates
operations
in
in
jitbuilder
one
it
used
to
be
a
builder
object.
So,
on
the
builder
I'll,
show
an
example
of
this
in
a
minute,
but
you
used
to
call
operations
on
a
builder
object
and
pass
it
operands.
B
So
in
jetbuilder
one
you
would
access
types
from
basically
cached
versions
that
are
stored
off
of
the
trial
builder
object,
so
there's
there's
just
in
32
float
32
whatever
you
can
just
access
them
directly
from
when
you're.
When
you're
writing
your
your
code.
That's
accessing
these
operations!
Sorry.
B
When
you're
accessing
the
code
that
acts
that
it's
accessing
these
sites
or
the
needs
to
use
these
types,
you
can
just
use
them
as
names,
because
they're
provided
already
in
the
base
class
of
the
thing
that
you're
extending,
which
is
an
il
builder
object.
Other
types
are
also
maintained
inside
the
type
dictionary.
So
you
would,
you
ended
up
passing
type
dictionaries
around
everywhere,
so
you
can
get
access
to
the
types
that
are
inside
them.
B
Operations,
as
I
mentioned
briefly,
are,
are
done
off
of
the
off
of
the
builder
object
right.
So
you,
if
you've
got
some
builder
object
here.
A
tri
l
builder
object
and
you
want
to
add
one
to
a
particular
value.
You
can
you
can
do
something
like
this
right.
You
can
on
the
builder.
Actually,
so
on
the
builder,
you
would
load
a
a
variable
called
value
and
that
would
return
a
tr
il
value.
B
There
are
still
type
dictionary
objects
that
hold
types
but
they're
a
little
bit
less
commonly
used.
I
found
at
least
in
the
very
small
number
of
code
samples
that
I've
done
so
at
this
point.
So
here
again
you
got
some
builder
b.
That
is
the
it's
the
code
path,
where
these
operations
are
supposed
to
be
injected.
B
So
I've
I've
defined
a
something
called.
A
pseudo
operation
called
increment
which
actually
expands
out
into
take
a
value,
add
something
to
it
and
and
give
it
to
you
back.
So
it's
sort
of
an
easier
way
of
accessing
something.
This
should
really
be
identity,
not
zero,
because
adding
zero
to
something
is
probably
not
very
valuable,
but
that's
a
mistake
anyway.
B
B
So
if
you
pass
the
wrong
kind
of
symbol
here
or
something
I
don't
know
something
you
couldn't
load,
for
example,
it's
probably
a
bad
example,
but
something
you're
not
allowed
to
load
and
down
in
the
depths
the
guts
of
of
trying
to
create
that
operation.
It
discovers
that
that's
not
valid,
it
can
know
where
this
line
of
code
is
that
created
it
and
tell
you
about
it.
I'll.
Give
you
an
example
of
that
here.
B
B
This
is
what
you,
the
location,
is
what
you
use
when
you're
defining
a
function,
so
it
expands
out
into
the
into
three
parameters
that
have
the
right
types
for
receiving
these
values,
and
then
paslock
is
a
way
of
passing
the
the
location
that
got
passed
in
for
a
function
to
another
function.
So
it's
not
it's
you're
not
trying
to
get
the
location.
B
That's
inside
the
function,
you're
trying
to
get
the
location
that
was
passed
in
to
this
location
so
anyway,
so
these
these
become
very
easy
to
use
after
a
while,
you
get
very
used
to
them
and
it
makes
it
it
makes
it
really
easy
to
pass
the
location
in
around
and
it
means
that
you
can
get
really
useful
error
messages
when
you're,
when
you're
working
with
these
things.
So
as
an
example,
here's
one
of
the
tests
that
runs
as
part
of
the
the
regression
testing
for
the
base
extension.
B
This
is
testing
for
the
ad
operation.
It's
verifying
that
if
you
provide
types
that
are
not
valid
for
an
ad
operation,
that
it
will
throw
an
error
and
it
uses
an
exception
to
throw
back
the
error
and
then
it
has
an
error
code,
that's
specific
to
what
to
what
happened
here.
So
it
doesn't
actually
assert
anymore,
which
is
one
of
the
things
that
the
original
jitbuilder
library
used
to
do
is
kind
of.
B
You
know
you're
kind
of
stuck
if
the
thing
asserts,
because
it
just
asserts
and
dies,
there's
no
way
of
kind
of
recovering
from
that.
So,
rather
than
having
a
model
where
everything
asserts,
I'm
trying
to
modify
everything
so
that
they
throw
an
exception
and
return,
a
value
that
can
then
be
inspected
and,
as
part
of
the
exception
object,
it
gets
passed
back.
There's
a
message
that
gets
excuse
me
sort
of
assembled
at
the
error
point
and
it
can
say
in
this
case
you
know
the
end.
B
You
have
had
an
ad
operation
that
had
invalid
input
types.
It
tells
you
what
the
left
type
was.
This
is
the
type
identifier
for
it.
What
its
size
was,
what
its
type
is
and
what
kind
of
type
it
is
as
a
primitive
type
and
the
same
for
the
right
and
then
it
tries
to
it
gives
a
little
explanation.
The
left
and
right
types
are
expected
to
be
the
same
for
integer
types.
So
obviously
these
are
not
the
same
integers,
also
not
quite
the
right
thing
to
say
there.
B
So
I
can
improve
that
and
then
there's
also
this
other
point
as
if
one
of
them
is
addressed,
then
the
other
one
should
be
whatever
the
word
size.
Integer
type
is
for
the
platform
that
you're
running
on.
So
it
gives
you
a
little
error
message,
and
this
is
something
that
can
be
printed
out.
It
can
be
not
printed
out.
B
You
get.
You
also
get
an
error
code
that
corresponds
exactly
to
an
ad
with
invalid
input
type
so
that
when
you,
when
you
come
back
from
trying
to
compile
a
function
it
will,
it
will
tell
you
that
you,
this
is
the
error
result
that
you
got
and
it's
the
same
kind
of
mechanism
that
I
showed
for
types
and
operations.
The
compiler
error
codes
are
things
that
can
be
extended
by
an
extension
to
say
these
are
the
kinds
of
errors
that
my
extension
option
operations
can
throw
and
features.
B
B
As
I
mentioned,
I'm
trying
to
improve
a
lot,
the
testability
of
things
and
how
much
things
get
tested.
So
I'm
leveraging
the
google
test
from
omar
to
do
that.
The
intent
here
is,
for
you
know,
building
up
tests
for
everything
as
jitbuilder
2
gets
augmented.
So
it's
as
I
said
it's
one
of
the
reasons
why
progress
has
been
slower
because
writing
tests
is
not
always
as
straightforward
as
as
writing
the
code
in
the
first
place,
especially
if
you're
just
porting
something
across,
but
you
don't
have
tests
to
pour
across.
B
It
has
found
some
bugs
during
you
know
through
that
process.
So
I
think
it's
clearly
been
worthwhile
as
a
as
an
exercise.
It
means
those
bugs
didn't,
hang
there
latent
waiting
for
me
to
find
them
in
some
more
complex
scenario
or
have
to
debug
them
in
some
more
complex
scenario,
although
I'm
not
a
hundred
percent
happy
with
how
all
of
these
tests
are
written
at
the
moment.
So
I
think
this
is
one
area
where
some
improvement
would
be
quite
valuable
so
in
terms
of
what's
being
tested.
B
B
There's
also
in
the
base
extension,
it
defines
a
pointer
type
which
allows
you
to
do
load
at
store
at
kind
of
things.
There's
a
struct
type,
which
has
been,
which
is
also
tested
with
a
variety
of
different
kinds
of
fields.
Make
sure
that
you
can
store
to
one
field
and
it
doesn't
affect
the
value
of
other
fields
of
varying
types.
B
It
also
creating
recursive
types
is
an
interesting
challenge
when
all
types
are
const,
so
there's
there's
kind
of
a
a
builder
notion.
That's
been
in
that
I've
introduced
in
for
for
creating
struct
types
and
pointer
types
that
that
allows
you
to.
Basically,
it
provides
a
mechanism
for
being
able
to
define
a
type
that
refers
to
either
itself
or
to
another
type
that
hasn't
yet
been
fully
complete
defined.
B
B
B
All
right-
and
you
can
see
that
things
don't
quite
work
yet,
so
this
is
the
top
level
directory
of
the
jitbuilder2
project
right
now,
so
it
has
all
of
those
things
that
I
pointed
out
on
one
of
those
slides
there's
a
make
file
in
it
to
make.
It
is
very
easy
to
make
the
jb
core.
So
I'm
not
going
to
talk
about
that
very
much.
B
What
I
did
want
to
go
and
do
is
first,
I
wanted
to
go
into
the
samples
directory,
which
has
this
map
mult
thing,
which
currently
doesn't
work,
as
you
can
see
the
compile
failure
right
up
there.
So
there's
a
there's
actually
an
issue
at
my
repo
for
this
that
I
opened
just
before
this
talk,
because
I
discovered
this
recently.
B
B
This
is
the
matrix,
multiple
sample,
compiler
typos
everywhere,
and
then
the
next
step
is
to
load
the
base
extension,
which
is,
I
kind
of
showed
this
code
in
the
presentation
already.
So
it
should
be
quite
familiar
if
it
returns
if
it
returns
null.
Obviously
it
couldn't
load
that
extension,
so
you
can
deal
with
that
and
then
I
wrote
this
code.
This
multiply
code
so
that
it
could
actually
work
on
any
any
type
of
dense
matrix
data.
B
B
This
is
the
jit
builder
2
type
that
corresponds
to
float
so
there's
a
little
bit
of
user.
You
know
craziness
here
and
there's
an
initial
init
matrices
is
just
an
initialization
function
that
initializes
a
float
array
properly.
So
there's
some
quirkiness
here,
but
it's
the
the
core
stuff
is
actually
kind
of
interesting.
So
this
is
that
template
here
so
right,
so
you
handed
it
a
compiler,
a
base
extension
object
from
which
we
can
get
the
compiler.
B
It's
going
to
initialize
the
matrices
of
the
appropriate
type
right,
calling
the
init
function.
To
do
that.
You
then
create
an
a
function
so
in
in
gypbuilder1.
This
would
have
been
a
method
builder.
It's
now
called
a
function
which
builder
too
and
the
function
is
not
itself
a
builder
anymore,
but
it
has
a
an
entry
point.
B
You
know
it's
a
long
string
of
connections,
but
anyway
you
can
basically
get
you
can
basically
get
textual
output
of
the
of
the
thing
as
you're
running
it
and
then
and
then
you
just
call
dot,
compile
on
it
to
compile
it
in
this
particular
case,
you're
handing
it
a
log
so
it'll
it
will.
It
will
we'll
print
out
on
the
on
the
in
this
case,
on
standard
out
c
out,
because
that's
the
one
we
created
it
for
it
will
do
the
compile
with
compile
successful.
B
Then
you
ask
you
can
ask
the
function
for
its
native
entry
point,
which
is
what
this
guy
does
and
then
you
can
call
it
and
it
will
hand
you
back
the
right
results
all
right.
Let's
take
a
look
at
what
this
map
multi
guy
looks
like
because
he's
got
a
you
know
just
like
in
builder
one
the
constructor
defines
what
the
api
is
for
the
function
and
the
build
il
function
defines
what
the
what
operations
to
perform
that
still
exists
in
in
that
mult.
B
So
let's
go
find
that
guy
up
here.
Okay,
so
here
is
the
constructor
so
again
defining
the
the
api.
So
this
looks
very
similar
to
the
way
it
would
have
worked
in
jip
builder,
one.
Nothing
really
changed
in
terms
of
being
able
to
define
the
source
code
location
for
this,
of
the
name
of
the
function,
defining
parameters
and
defining
locals.
As
I
mentioned,
you
have
to
create
symbols
now
and
you
have
to
know
what
those
symbols
are
in
order
to
access
them.
B
B
B
There
all
right
does
that
help
people.
I
can't
see,
if
anybody's
agreeing
to
me
so
I'll
assume
that
it
does
right
so
define
things
like
define,
parameter
and
things
like
define.
Local
now
return
a
symbol
pointer,
which
you
can
just
kind
of
scroll
off
into
your
into
your
object,
so
you
can
remember
them
and
access
them
later
and
again.
B
The
purpose
of
this
of
the
constructor
of
this
function
is
to
is
to
define
what
the
abi
is
to
or
what
the
what
the
parameters
and
what
the
return
types
are
for
this
function,
and
so
that's
what
we're
doing
to
find
parameters
we're
defining
return
types,
there's
a
sum
local
that
gets
defined
here
as
well.
It
doesn't.
This
doesn't
have
to
be
done
in
the
constructor
it
could
be
done
later
on,
but
we
did
that
okay
and
then
the
other
piece
gets
done
in
build
il.
B
B
Now
you
have
to
ask
for
the
builder
entry
of
the
function,
and
that
gives
you
a
builder
object,
which
you
can
then
use
to
pass
to
other
operations.
To
do
things
so
I
mentioned
there's
some
source
code
location
handling
here,
so
source
location
is
the
way
that
you
can
start
passing
in
things.
So
this
one
creates
a
source
location
that
just
has
a
function
name
so
map
mult
as
the
function
name
by
default.
B
All
the
operations
that
you
perform
then
just
become
calls
off
of
the
the
base
extension
and
you
end
up
passing
the
builder
object
that
you
want
to
do
it
in
and
passing
obviously
the
location.
So
we
load
all
of
the
array
pointers.
We
load
the
side,
the
size
of
the
array
dimensions,
we
create
zero
and
one
constants
using
the
base
extension
to
get
those
we're
creating
those
as
in
32s
in
this
particular
case.
B
So
these
are
all
these
are
used
as
part
of
the
for
loop,
counting
just
to
simplify
that
to
that
code,
and
then
I've
mostly
managed
to.
I
don't
know
if
you
can
see
all
this,
but
this
is
basically
the
code
of
the
three
loops
of
the
matrix
multiply
and
I've
kind
of
used
a
stylistic
way
of
writing
this.
When
you
create
a
for
loop
op,
I
open
the
I
open,
a
curly
brace
so
that
this
is
the
code
that
should
be
it
it.
B
B
The
other
change
that
I've
made
here
is
that
for
loops
now
actually
return
a
thing
called
a
for
loop
builder,
which
makes
it
a
little
bit
easier
to
work
with
them.
So
you
can
have
a
you
basically
pass
in
the
parameters
of
the
of
the
for
loop
iteration.
So
this
is
a
for
loop
in
builder
b,
that
will
iterate
on
a
symbol
called
I
semi
here,
which
is
the
one
we
just
defined.
B
So
it's
going
to
use
I
as
the
iteration
symbol
for
the
symbol
over
the
variable
over
which
you
iterate
and
it's
going
to
go
from
0
to
n
by
1.,
and
then
it
returns
this
for
loop
builder
object
and
from
the
for
loop
builder
object.
You
can
get
to
access
to
things
like
the
builder
for
the
loop
body
or
if
you
need
to
call
a
break,
you
can
get
a
builder
that
corresponds
to
the
break
label
or
to
the
continue
label
so
that
you
can.
B
You
can
direct
control
flow
towards
those
towards
those
parts
of
the
for
loop,
and
basically
the
the
for
loop
builder
object
gives
you
all
the
information
about
the
for
loop
that
you
can
query.
You
can
also
get
access
to
the
iterator.
Like
all
of
these
things,
you
can
also
access
from
the
for
loop
builder
itself,.
B
So
here
we
can
load
the
value
of
I
in
this
loop,
so
anything
that
uses
I
from
this
point
forward,
we'll
be
using
the
the
current
value
of
the
iteration
variable
right.
We
got
I
loop
loop
variable
and
then
you
can
just
kind
of
fall.
This
is
the
outer
eye
loop.
This
is
the
middle
j
loop
and
this
is
the
inner
k
loop
that
does
the
dot
product
here.
B
B
So
this
this
is
something
that
I've
done
in
the
code
sample,
but
obviously
I
think
it
would
make
sense
at
some
point
to
define
a
dense
array
extension
which
would
provide
a
you
know,
load
array
or
a
reload
operation
which
would
just
do
all
of
the
stuff.
And
then
you
in
your
code
base
you
just
you're
in
your
in
the
code
you're
generating
you
just
see
an
array
load
that
takes
in
the
the
you
know
these
these
basic
parameters.
B
B
B
B
That's
kind
of
the
next
big
user
of
a
variety
of
operations
I
did
mention,
you
can
add
compiler
return
codes,
so
these
get
defined
in
largely
the
same
way.
There's
a
type
called
compiler
return
code,
and
you
can,
you
can
create,
create
your
own
ones
and
then
there's
all
of
the
operations
which
basically
these
are
the
kinds
of
things
that
you
used
to
call
in
builders,
and
now
you
can
call
here
I'll
get
in
here
and
these
these
things.
B
I
call
pseudo
operations
because
they
don't
actually
appear
in
the
il,
but
they
help
you
build
il.
That's
that's
sort
of
more
pleasant
to
read
so
increment.
I
misused
this
in
the
presentation,
but
increment
takes
a
symbol
and
and
increments
it
by
pump,
so
basically
it
loads
it
loads.
The
value
adds
the
bump
and
stores
back
to
the
symbol,
so
you
don't
have
to
create
so
many
so
much
text
to
do
that
anymore.
B
Different
ways
of
providing
source
locations
us
these
are
helpers
to
create
different
kinds
of
constants
which
existed
in
jet
builder,
one
because
chipbuilder1
didn't
have
a
common
notion
of
a
const
that
you
could
create.
It
didn't
have
literals
that
are
really
well
defined,
so
there
are
helpers
here
which
correspond
to
the
things
that
you
used
to
see
in
builder
one,
but
really
they
all
implement.
They
all
basically
call
this
guy,
which
is
const
and
you
you
provide
a
literal,
and
this
literal
can
be
of
many
different
actual
literal
kinds.
B
B
I
guess
I
can
talk
a
little
bit
about
quickly,
so
the
way
that
operation
checking
works
is
it
uses
a
an
additional
class
called
a
type
checker,
which
it's
not
really
a
a
well-defined
thing,
but
you
can
create
a
class
which
has
the
code
that
will
validate
the
different
operations
in
the
extension
and
then
also
what
to
do
if
a
failure
happens,
and
so
this
code
all
ends
up
being
embedded
in
the
add
functions.
I
guess
sorry
this.
This
code
will
all
get
embedded
in
add
in
mul
and
in
sub
and
for
loop
up.
B
B
It
made
more
sense
to
me
to
to
maintain
the
structure
that
the
base
extension
has
but
have
a
way
to
add
more
validation
or
better
different
validations
into
that
process.
So
each
extension
has
a
has
a
list
of
extension
checkers,
so
the
complex
extension
can
define
its
own
base
extension
checker,
which
adds
support
for
the
complex
type
and
if
it
doesn't
see
a
type
it
recognizes,
then
it
just
lets
the
lets
a
later
base.
B
B
B
B
All
right
all
right,
current
status,
so
there
are
currently
some
omr
dependent
changes
that
are
required
to
use
git
builder.
Two
there's
about
seven
commits
that
I've
currently
got
in
a
pull
request
at
omar
that
will
hopefully
be
merged
soon.
But
as
of
the
start
of
this
call,
I
don't
think
they
had
been
merged.
B
I
have
actually
pushed
the
current
state
of
jet
builder
2
to
this
repository
at
my
in
my
own,
in
my
own,
my
own
user,
which
people
can
download
and
fetch
from.
I
am
currently
developing
this.
I
just
created
it
today,
but
I've
been
developing
this
independently
of
walmart,
basically
so
that
I
can
start
tracking
history
and
and
do
commits
and
make
changes
to
stuff
without
really
overloading
the
omr
committers
with
changes
since
yeah
at
omar.
B
We're
not
allowed
to
merge
our
own
changes,
so
I
didn't
want
to
create
a
whole
bunch
of
burden
for
the
omr
project.
While
I
iterated
on
trying
to
figure
out
what
the
heck
I'm
doing
with
chipbuilder2.
So
I've
taken
this
code
and
I've
put
it
into
my
own
private
repo.
There
I
did
add
a
readme.
It
does
have
a
license,
as
I
pointed
out
in
the
talk
there
is
a
is
a
compile
failure
that
I
have
to
fix
in
the
code
sample,
but
that'll
get
fixed
shortly.
B
I
I'm
just
gonna
not
accept
changes
from
anyone,
but
that
doesn't
mean
I
don't
want
to
interact
with
people
so
the
this
that's
the
whole
reason
why
I
created
the
repository
was
so
that
people
would
have
something
that
they
could
download
and
have
a
way
to
interact
with
me
on
it.
So
if
people
have
you
know
if
they
try
it
out
and
and
have
feedback
or
if
they
see
something
that
they
don't
like
or
think
they
could,
you
know
think
that
would
be
better.
B
I
would
be
perfectly
happy
for
people
to
open
issues
at
that
repo
to
to
interact
with
me.
You
can
always
reach
me
at
the
omar
slack
instance.
I
monitor
that
on
a
fairly
regular
basis,
particularly
in
the
jit
builder
channel
and
yeah
or
email.
If
you
want
but
yeah,
that's
basically,
that's
it.
That's
the
end
of
the
talk
there
so
I'll
finally
pause
and
see.
If
anyone
has
questions.
A
B
Well,
yeah,
so
the
issue
with
the
issue
with
standard
string
with
jitbuilder
one
was
because
it
is
part
of
the
compiler
code
base.
It
enter
this.
The
string
interacts
memory,
allocation
handling,
work,
interacted
badly
with
first
string
and
the
memory
allocators
of
the
omar
compiler.
So
that's
that
was
the
fundamental
problem
there
and
we
never
really
got
to
the
bottom
of
the
solution
there
jit
builder
2
does
not
build
as
part
of
omar,
so
it's
a
completely
separate
independent
library.
It
uses
omar
and
it
uses
lib
libgitbuilder.a.
B
The
thing
that
gets
generated
by
the
the
jit
builder
build,
but
it
is
not
part
of
the
omar
code
base
and
therefore
it
doesn't
actually
leverage
and
that's
kind
of
a
problem
in
a
way
it
doesn't
leverage
any
of
the
memory
allocator
stuff,
that's
in
the
omar
compiler,
and
that's
actually
something
that
I
would
like
to
fix.
I
would
like
to
maybe
not
necessarily
use
the
omar.
B
I
haven't
decided
that
yet
I
would
like
to
have
a
managed
memory
allocation
story
for
jit
builder
2
before
things
get
too
much
further
forward,
but
memory
allocation
sucks.
So
I
kind
of
I've
been
deferring
that
trying
to
get
things
a
little
bit
more
capable
and
so
that
people
could
actually
try
it
out
and
do
stuff
with
it.
B
I've
been
using
standard
string,
standard,
vector,
standard
deck
in
a
couple
of
places,
so
it
does
currently
use
the
standard
template
library,
but
that's
not
a.
I
don't
think,
there's
any
like
baked
in
requirement
to
do
that.
They're
just
containers,
so
I've
also
been
sort
of
toying
in
the
back
of
my
head
with
not
using
those
containers
because
they
carry
with
them
a
set
of
other
problems.
E
B
I
would
guess
so.
This
isn't
something
that
I've
validated,
but
my
guess
would
be
that
the
bulk
of
the
compilation
time
is
still
in
the
omar
compiler
component
right.
So
I
haven't.
I
have
not
been
focusing
terribly
much
on
the
performance
of
the
jit
builder
2
code
base
itself,
although
I'm
not
I'm
not
actively
trying
to
make
it
slow,
but
I'm
also
not
really
paying
very
much
attention
to
it.
B
A
A
E
C
C
A
C
A
A
E
A
A
A
C
F
C
A
I
think
that
was
trying
to
go
for
maximum
flexibility
here
by
being
able
to
specify
like
any
set
of
these
options
or
build
flags,
I
mean
the
other
potential
way
of
doing.
It
is
if,
like
the
alias
that
that
irwin
had
mentioned,
if
we
maintained
like
a
list
of
sort
of
approved
flags
or
something
that
you
could
enable,
then
you
could
you
could
associate
a
name
or
a
tag
for
each
of
them
and
you
just
specify
that
tag
in
the
build
yep.
That
way.
F
C
A
F
F
F
C
D
C
D
D
B
I
think
that's
probably
driven
most
of
the
probably
driven
actually
which
it
actually
raises
kind
of
a
policy
question
that
I
was
or
a
policy
point
that
I
wanted
to
make
in
regards
to.
So
I
think
it
is
useful
to
be
able
to
specify
these
flags
to
be
able
to
better
test
a
pr
that
has
code
that
would
otherwise
be
disabled
in
the
testing
table.
But
I
think
we
should
explicitly
maintain
the
policy
that
you
in
order
to
get
the
acceptance
of
a
pr
it
has
to
pass
without
these
special
flags
there.
A
A
Can
you,
please
repeat
the
question?
Well
I
just
this.
What
are
the
semantics
of
what
you're
trying
to
achieve
here
is
to
take
the
c
flags
that
you
specify
on
the
on
the
on
the
on
the
trigger
here
and
add
that
to
the
c
flags,
that's
and
present
in
the
make
files,
or
is
this
to
replace
the
c
flags
that
are
in
the
make
file.
A
A
I'm
going
to
suggest
that
you
create
a
separate
issue
for
this
particular
feature
so
that
we
can
socialize
it
a
bit
and
invite
some
discussion
I'd
like
to
hear
adam's
opinion
as
well
on
on
some
of
these
things,
but
I
mean
from
my
perspective
I,
like
the
I
like
the
idea
of
it.
I
think
we
just
have
to
kind
of
refine
it
a
bit
just
to
see
how
it's
going
to
work
in
practice.
A
A
C
B
A
All
right,
okay!
Well,
I
think
it's
a
good
idea.
Let's
we'll
look
for
the
for
the
issue,
then,
when
it's
when
it's
created,
okay,
all
right,
so
that
was
the
last
topic
for
this
week.
We
have
another
architecture
meeting
in
two
weeks
from
now
the
agenda
is
proposed.
Agenda
is
already
open.
So
if
you
have
any
suggestions
for
a
topic,
please
find
that
and
and
add
it.