►
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
So
before
we
talk
about
compiling
how
to
compile
codes
actually
I
want
to
mention,
like
a
nurse,
has
a
lot
of
precompiled
applications
and
libraries.
So
we
use
module
utility
to
manage
our
software,
nearly
all
the
software.
So
for
those
who
whole
new
to
module
the
module
ism
is
a
tool
we
use
it.
Can
dynamically
modify
use
as
a
shell
environment?
A
So
you
don't
have
to
make
yourself
environment
to
include
all
the
software
you
have,
so
you
can
selectively
configure
yourselves
so
usually
it
it
works
s
by
loading
or
unloading
module
file,
so
a
module
file.
It
contains
the
information
to
configure
the
shell,
so
you
can
define
past
and
load
the
library
paths
and
main
paths
etc,
and
they
also
can
load
some
dependent
modules
and
they
can
do
more.
So
you
can
use
module
avail
command
to
see
the
available
software
at
no
risk
and
the
module
commander
looks
for
module
paths.
A
The
environment
the
director
is
contained
in
that
environment
variable
to
see
what
are
available.
So
we
recommend,
before
you
really
try
to
compile
anything.
You
can
take
a
look
and
many
of
the
hard
to
compile
stuff
already
there,
so
you
can
make
use
of
the
already
installed
software.
So
some
of
the
software
has
access
control,
something
like
a
bus,
it's
open
to
the
users
who
have
own
license
only
so
other
than
that.
Most
of
our
self.
We
are
open
to
everybody,
so
this
talk
will
focus
on
and
basically
the
basics
of
compiling
code.
A
So
I
will
talk
about
how
you
can
take
care
of
the
compilation
and
ink
lines.
Basically,
you
can
see
the
fuel
components
in
the
red
boxes,
basically
I'm
going
to
talk
about
the
compilers
and
compiler
flags
tools,
and
then
the
include
pass
and
library
pass
and
the
in
libraries
to
put
in
the
link
line.
A
So
I
will
generally
talk
about
how
to
compile
on
curry
and
Edison
and
the
career
as
well
as
it's
just
a
general
form,
and
then
I
will
expand
a
little
bit
of
okay
and
now
so
this
is
a
Korean
Haswell
configuration
so
as
you
I
want
to
read
through
all
those
you
can
find
this
information
in
our
web.
Basically,
I
want
to
emphasize
the
curry,
and
Edison
is
specially
K&L
with
the
rest
of
the
tool
it
has.
They
have
a
sufficiently
different
architecture,
then
effect,
so
they
deserve
like
separate
a
build
for
each
platform.
A
A
This
one
enabled
K&L
specific
flag,
which
is
there
the
minus
X,
Mike
avx-512
and
the
other
one
is
not.
This
is
a
enabled
Haswell
specific
effect.
So,
basically,
and
here's
a
comparison
when
your
running
has
a
bell
binary
on
K&L
what
you
would
get
so
basically,
depending
on
the
reference
you
will
see
35%.
This
is
running
as
well
by
Rhian
care.
Now
that
is
the
K&L
binary.
You
can
see
about
35%
performance
difference.
A
So
that's
why
we
recommend
you
better
build
separate
binary
for
each
platform,
so
we
have
three
compilers
available
on
our
systems,
Curie
and
Edison.
So
when
we
talk
about
the
program
environments,
usually
we
talk
about
the
compiler
and
it's
matching
software
stack.
So
software
stack,
we
have
a
two
components:
one
is
from
Cray
provided
and
the
other
one
is
nursing
staff
provided.
So
if
you
log
into
quarry
actually
for
your
type
of
module
list,
you
can
see
there
are
a
bunch
of
modules
already
loaded
for
you.
We
call
it
the
default
programming
environment.
A
Not
sure
what
I
put
there,
but,
basically
just
to
say
our
default
is
Intel,
so
there
is
a
good
reason
for
us
to
do
that,
because
our
processors
are
Intel
Intel
processors,
Edison
is
Ivy,
Bridge
and
curry
is
as
well
and
indicator
now
they
are
all
Intel
processors,
so
the
tip
number
one
to
compile
code
on
on
our
systems
on
Kure
systems
actually
use
the
compiler
wrappers.
So
for
fortune
code
used
ft
n
for
C
code,
use
the
C,
C
and
C
capital
CC
for
C++
code,
so
so
that
there
are
some
difference.
A
If
you
are
used
to
work
on
Department
clusters,
like
Linux
box,
you
may
use
to
get
used
to
the
you
know
that
the
using
the
native
a
compiler
calls,
in
that
case,
all
the
compilers
by
defaulted,
a
will
to
build
the
dynamically
linked,
the
binaries,
but
the
compiler
wrappers
on
our
system.
Actually
this
is
a
Cray
provided,
so
they
use
the
static
by
default,
which
means
it
will
build
static
clearly
in
code
binary.
A
So
this
is
for
performance
at
the
scale,
but
by
option,
if
you
prefer,
you
can
build
a
dynamically
linked
one
by
using
the
extra
flag.
So
it's
a
dynamic
or
you
can
define
environment
variable
here
to
make
sure
the
linking
is
dynamic,
but
to
keep
in
mind
like
if
you
run
like
your
application
at
the
scale,
then
at
the
largest
scale
the
dynamically
link
of
the
binaries
may
suffice
and
performance
hit.
A
So
in
general
we
recommend
static.
Linking
so
one
thing
I
want
to
mention
is
compiler
refers
to
cross
compilation,
so
we
compile
on
login
notes
and
then
the
resulting
binaries
will
be
running
on.
We
will
run
them
on
computer
nose
so
on
career
as
well,
because
Logan
knows
it
as
well
and
computer
knows
has
well,
they
are
fine.
There
is
no
cross
compilation
issue
basically,
but
for
if
you
compile
on
Cori
login
knows
and
compile
for
K&L,
then
you
may
run
into
issue
like
the
generated
binary
would
not
run
on
as
well.
A
So
we
not
talk
about
how
you
use
a
configure
script
and
other
build
a
system
like
make
and
see
make
etc.
But
I
want
to
mention
for
the
configure
line.
If
you
do
cross
compiling
on
login
node
beautiful
K&L,
then
you
may
need
to
put
this
host
equal
to
more
general
on
x86
t4
there.
Just
to
overcome
that
configure
pilot
check
issue
or
sometime,
you
may
need
to
directly
compile
on
your
on
the
computer
note.
A
You
know
high
priority
queue,
so
it
basically
in
five
minutes.
You
either
get
on
note
or
you're.
Just
the
submission
will
be
cancelled,
so
it
will
be
quick,
so
you
can
try
this
and
compile
directory
on
computer
notes.
But
one
note
for
that
is:
okay,
now
is
a
pretty
slow.
The
clock
speed
is
almost
a
half
of
the
Haswell,
so
you
may
see
it's
really
slow
unless
you
have
to
usually
you
need
to
compile
on
login
notes,
so
there
are
reasons
why
we
recommend
the
compiler
wrappers.
A
Definitely
the
number
one
reason
is
it's
easy
because
it
helped
it
handles
all
the
link
line.
I
mean
the
compiled
and
inclined
automatically.
So
all
your
needed
to
do
is
compile
a
wrapper
and
then
your
code
name
that
will
be
automatically
linked
to
the
libraries
but
water
library
to
link
depends
on
what
what
kind
of
modules
are
loaded
in
your
environment
so
before
that
actually
compiler
wrapper
to
multiple
things.
So,
first
the
thing
it
will
include
the
architecture
specific
flags
into
the
compilation
so
for
quarry
care.
A
Now,
if
we
all
load
the
the
right
module,
then
it
will
include
that
X
Mike
avx-512
flag,
which
is
included
the
specific
instructions
of
all
K&L.
This
is
a
for
Intel
for
canoe,
it
will
included,
is
in
other
words,
you
know
all
the
compiler
I
mean
the
processor.
Specific
of
flagons
will
be
added
automatically
for
you,
so
this
is
important
in
compiler,
rapid
us
and
the
other
one.
Is
it
will,
depending
on
the
modules
a
lot
either
here?
A
If
we're
loaded
is
Mike
care
now,
on
the
quarry,
K&L
knows
the
back
and
when
it
links
to
the
library's,
it
will
pick
up
the
right.
One
I
mean
some
of
the
crepe
provided
the
libraries
and
the
nurse
provided.
The
libraries
have
a
separate,
beautiful
care
now
and
as
well.
So
in
that
case,
compiler
rapper
can
you
know
selectively
prop
I
mean
choose
the
proper
library
to
link.
So
in
that's
what
happened
in
the
back
end.
A
So
that's
another
thing
and
the
other
important
thing
is,
although
compiler
apples
dual
out
for
you,
but
if
you
want
to
explicitly
list
something
in
the
compile
inclined
and
overwrite
the
default,
you
can
do
it,
so
it
will
take
the
precedence
over
the
default.
You
know
what
compiler
wrapper
does
so
pretty
often
we
see
that
the
some
user
called
it
has
a
minus
X
host
option.
So
I
would
like
to
just
mention
you.
Can
you
know
remove
that
if
you
use
compiler
wrappers,
it's
basically
that
one
will
optimize
the
code
to
the
host.
A
We
are
you
running
the
compare
the
compilation
on
so
this
is
another
good
one.
If
you
use
that
it
will
overwrite
the
compiler
Flags,
the
minus
X
Flags
added
by
the
compiler
wrapper,
so
pay
attention
to
that,
so
what
the
compiler
wrappers
link
by
default.
So
if
we
allow
me
into
quarry
and
then
just
get
a
hello
word
skeleton
code
and
then
just
to
compile
it
under
the
hood,
it
will
link
to
multiple
libraries.
A
So
if
you
type
of
module
is
two,
we
have
a
lot
of
those
listed,
but
the
one
directory
will
interact
with
in
your
compilation
is
something
like
a
gray
M
peach
and
then
here,
like
krei,
has
well
a
module
and
then
also
the
most
important
one.
Is
the
in
tell
the
compiler
modules?
So
if
we
look
at
this
is
a
little.
You
may
not
see
right
now,
but
you
can
later
look
at
the
slide.
A
A
Can
to
see
quickly,
but
it's
a
it's
linked
to
the
it
links
to
the
leaves
I
live
orally,
so
that
those
the
apex,
JPEG
applause
and
those
libraries
will
be
linked
in
by
default.
So
and
also
the
mpg
like
krei
mpg
module
is
loaded,
so
the
NPI
library
will
be
linked
by
default.
So
here
I
want
to
just
remind
your
one
sheet
trick.
So
there
is
a
minus
WL
and
that's
why
and
then
the
symbols,
this
this
option
is
linker
option.
A
It
will
be
very
useful
to
check,
especially
when
we
know,
like
multiple
libraries
support
the
same.
You
know
routines
alive,
you
know
functionalities,
then
you
want
to
see
where
the
exact
that
the
symbols
are
come
from.
Then
this
one
can
tell
you
where
it
is
from.
So
it's
cut
off
down
here,
but
you
can
see
in
in
my
case,
I
I
was
compiling
in
the
default
environment.
A
It
will
be
linked
to
live
side
by
default,
so
compiler
recommendation
I
would
be
very
cautious
on
this,
so
we
may
do
like
a
test
with
a
bunch
of
benchmark
and
tell
you
which
compiler
is
best,
but
it's
it's
a
moving
target.
Actually,
we
it's
harder
to
just
to
say
which
one
is
best,
so
my
recommendation
is
just
every
compiler
has
its
own
advantages,
so
something
like
Intel.
If
you
use
this
this
Intel
compiler,
you
have
better
chance
to
get
the
processor
specific
optimization,
especially.
We
have
seen
a
good
performance
with
the
Intel
compiler.
A
If
you
use
it
on
K&L,
especially
the
processor
is
new
I.
You
will
have
a
better
chance
to
use
Intel
compiler
and
after
why
I
think
other
compiler
will
also
catch
up,
but
that's
a
one
of
the
advantage.
You
can
get
optimized
version
for
specific
process,
data
type
and
then
career
compiler
is,
is
a
really
good
one,
especially
you
use
a
fortune
code
and
it
has
a
lot
of
new
features
and
optimizations
and
and
Cray
also
have
a
lot
of
optimized
that
libraries
come
with
their
software
stack.
A
So
this
is
a
good
option
for
some
of
the
calls
and
then
also
the
canoe
is
widely
adopted
by
the
you
know,
open
software.
So
it's
also
good
to
use
that.
So
my
recommendation
is:
if
you
work
with
third-party
code,
then
you
can
use
the
compilers
the
vendor
or
code.
The
developers
used
to
test
their
code
and
then,
if
we
really
care
about
the
performance,
then
you
can
explore
different
compilers,
so
the
compiler
Flags.
A
Actually
there
are
a
lot
of
options
you
can
use,
but
I
would
be
more
conservative
here.
So
usually
I
think
the
default
is
good
enough.
Let's
say
for
Intel
compiler.
If
you
don't
do
anything
by
default,
the
optimization
level
would
be
OH.
So
this
is
pretty
good
in
and
in
addition,
we
have
that
process
a
specific
flag
that
that
a
X
flag
X
flag
already
there,
so
the
default
would
be
really
good.
So
no
actually
the
default
is
0.
So
you
need
to
take
kara.
You
put
something
there
for
optimization
Kure.
A
They
claimed
that
you
was
all
true,
but
basically
they
are
never
in
so
Suri
is
pretty
high,
but
definitely
the
default
is
sufficient
and
then
we
would
recommend
like
a
more
conservative,
optimization
level,
basically
default.
That's
I
I
would
like
to
say,
but
one
thing
I
want
to
mention
is
different.
A
The
compiler
has
a
different
default
behavior,
so
I
would
recommend
that
you
check
with
the
compiler
worldõs
output,
which
is
that
the
line
over
here
it
will
tell
you
what
kind
of
compiler
flags
enter
the
compilation
and
also
a
lot
of
our
link
information
as
well.
So
it's
good
to
keep
in
mind
that
the
verbose
option
is
really
useful
tool,
so
here
I
want
to
mention,
when
you
compile
remember
to
adorn
the
validity
check.
So
some
software
provides
some.
You
know
tests
to
it.
A
So
one
thing
I
order
like
to
mention
is
regarding
the
default
behavior,
so
the
Intel
and
the
conv
compiler
I
mean
regarding
the
OpenMP
default
behavior.
So
the
default
number
of
says
this
compiler
would
use,
is
here
I
said
that
all
CPU
slots
available
for
available
for
the
for
the
binary.
So
here
the
the
process
thread
affinity
is
important.
So
if
your
binary,
it's
not
a
pin
to
the
certain
CPU,
it
has
a
some
room
to
drift
around
then
by
default.
It
will
use
all
the
cores
of
CPUs
available
on
that.
A
So
it's
important
difference
so
curry
by
default
it
will
use
openmp
stress
only
one,
so
I
would
like
to
mention
this
is
because
our
compiler
wrappers
it
does
a
lot
of
things
for
you
and
linked
to
the
system
provided
the
library
and
many
of
them
actually
is
a
multi-threaded
library.
So
maybe
you
accidentally,
you
link
the
to
the
OpenMP
library.
Probably
if
you
don't
provide
the
correct
thread,
affinity,
a
process
affinity,
you
may
run
into
some
issues-
it's
not
it's
not
often,
but
it's
better
to
be
aware
of
this.
A
So
I
would
emphasize
the
verbose
output
from
compiler,
wrappers,
actually
I
I,
think
I
learned
so
much
from
this
output.
I
think
this
is
the
most
useful
tool,
especially
Korea,
and
they
they
do
a
lot
of
for
us.
So
they
want
us
to
do
nothing
just
to
provide
the
source
code
for
the
after
the
compiler
wrappers
and
then
under
the
whole
that
they
try
to
optimize
the
library
structures
and
they
named
differently
and
research
doctor
and
all
the
time
they
changed,
the
library
name.
A
So
if
you
do
these
were
both
output,
you
can
learn
what
is
the
library
names
and
what
the
pass
is
included
and
all
the
details.
It
can
tell
you
so
especially
some
time
we
win.
Receiver
use
a
ticket
to
say:
oh
okay,
I,
don't
know
how
to
link
to
mkl
right.
So
in
that
case
we
usually
say:
okay
go
to
the
lab
web
and
find
advisor
the
link
advisor,
but
you
can
learn
a
lot
from
the
warbles
output
as
well,
so
something
like
correct
compiler
provided
that
mkl
option.
This
is
Intel
specific
option.
A
If
you
use
that,
then
you
will
see
the
compiler
will
both
output.
It
will
link
here
like
the
MK
library,
MK
library
is
not
a
single
one.
It
has
a
multiple
choice
in
and
there
are
multiple
libraries
to
put
so
if
you
do
it
manually,
you
may
feel
it's
it's
too
difficult,
but
you
you
can.
If
we
really
needed
to
do
that,
then
you
can
look
at
this
and
then
modify
as
an
idiot.
So
you
can
see
what
what's
entered
the
link
line.
A
So
I
think
this
is
a
really
good
place
to
learn
stuff,
what's
happening
under
the
hood.
So
regarding
the
available
libraries.
So
as
I
mentioned
earlier,
we
have
two
big
sets:
one
come
from
Cray
provided
software
and
then
another
one
is
nurse
staff
provided
so
create
packages.
If
they
are
pack
down
to
the
create
developer
toolkit,
we
call
it
the
CDT
all
the
times.
Usually
this
releases
like
every
month
but
the
way
basically
install
every
three
months.
We
release
one
major
major
version,
so
usually
CDT.
A
The
version
goes
like
two
digit
a
four
year
and
then
dot
and
another
two
digits
for
the
month.
So
you
can
see
from
the
the
CDT
words
and
you
can
see
when
and
it's
released
and
in
which
year
you
can
find
out
those
info
so
to
find
out
what
are
available
again.
We
need
to
use
this
module
avail
and
then,
if
you
are
care
about
the
specific,
the
modules
with
a
specific
situation,
you
can
use
this
capital
S.
This
is
actually
the
crazy
addition
to
the
module
utility.
A
A
And
for
nurse
:
I
didn't
have
a
chance
to
mention
that
Maggio
Pez.
Actually,
if
you
do
echo
dollar
Maggio
PES
in
capital,
actually
you
can
see
multiple
passes
included
in
that
you
know.
Environment
variable
and
some
of
them
come
from
opt
and
crepey
somewhere,
like
that,
and
some
of
them
comes
from
user
common
area.
So
whatever
comes
from
user
come
and
those
are
provided
by
a
nursing
staff
and.
A
Ok,
so
yeah,
so
basically
so
once
you
find
the
some
libraries
available,
then
you
can
do
yeah.
You
can
do
just
a
module
load
and
then
use
the
compiler
wrapper
and
the
enter
the
name.
This
is
how
you
do
it
so
I
put
at
least
either
some
examples
over
here.
You
can
read
it
later.
Basically,
it's
just
to
use
a
compiler
wrapper
and
then
do
that
so
I
want
to
mention
a
couple
of
things
so
far.
A
Nurse
provided
library
actually
we're
in
the
process
of
combine
like
crazy
convention,
so
some
of
the
modules
already
in
the
Creator
format,
so
they
can
interact
with
the
compiler
wrappers,
so
you
load,
the
module.
Compiler
wrapper
can
pick
up
the
included
path
and
I
Brody
past,
but
the
some
of
them
not
but
the
way
to
find
environmental
variable,
something
like
add
CSL.
It
will
define
good
one
for
you
to
use.
So
it's
convenient
for
you
just
to
put
the
environmental
variable
there.
A
So
I
put
an
example
of
how
to
link
with
Mal
and
then
also
how
you
link
dynamically
and
also
some
of
the
users.
Are
they
they
want
to
use
Intel
compiler.
So
this
is
the
exception
when
you
should
know
to
use
compiler
wrapper
because
compiler
wrapper
by
default.
It
will
link
the
Korean
peach
unless
you
just
unloaded
that
Korean
pits
in
your
default
environment.
So
this
is
an
example.
So
a
couple
of
tips
like
when
you
run
into
unresolved
the
symbols.
A
This
is
the
tree
because
I'm
using
all
the
time,
so
basically
one
thing
people
easily
to
Illinois
is
the
some
of
the
library
you'll
find
it's
there,
but
the
compiler
repossess
it
doesn't
exist.
It's
not
found.
One
of
the
reason
could
be
the
competitor
library
in
the
other
library.
For
me
only
so
that's
the
problem.
So
this
is
one
of
the
case
and
another
one.
A
This
read
elf
or
first
gravities
is
stuff
and
go
to
the
potential
directories
and
search
for
the
symbol
and
then
look
read
the
symbol
and
see
if
that
is
defined,
then
that's
available
in
that
library.
So
you
can
put
that
in
your
link
line
so
for
K
or
now.
Actually,
since
I
I
don't
have
times
of
the
number
one
thing
I
want
to
mention
is
just
to
switch
to
the
crepey
mic
care
now
and
then
compile
as
as
usual
as
you
do
for
the
career
as
well.
Okay,
I
think
I
can
skip
all
those.
A
Details
about
the
practice
tips
for
you
and
one
thing
I
want
to
mention,
is:
if
your
compile
code
and
you
want
to
reserve
the
reserve
the
program
environment,
then
there
is
a
tools
to
you
can
use
its
mojo
snap.
We
have
a
website
and
talk
about
how
you
it,
but
basically
modules
in
episode
is:
do
the
scenario
for
your
module
environment
and
then
later
you
can
do
module,
restore
the
file
name,
you
can
get
the
original
programming
environment
and
then
also
there
are
CDT
modules.
This
is
a
great
developer.
A
Toolkit
module
can
make
you
swap
to
previous
acidity
version
and
then
also
really
big
tip,
for
you
is
the
using
shift
shifter.
So
this
one
can
preserve.
Not
only
the
user
can
control
user
control
software,
it
can
also
preserve
the
OS.
So
we
have
a
web
instruction
on.
You
know,
learning
more
information
on
that
and
also
at
the
beginning,
you
can
see
module
list.
There
is
a
RTD
module
which
can
help
you
retrieve
with
some
linking
information.
A
So
you
can
look
into
the
web
and
also
run
that
command
and
see
what
you
can
get
so
I
put
up
the
our
updated
policy
here.
Basically,
just
tell
you
every
three
months
we
install
new
CDT
and
then
every
six
months
we
will
an
update
program
environment,
so
you
can
find
that
actual
change
in
our
timeline,
page
for
both
Edison
and
curry.
So
if
you
want
to
share
your
installation,
you
can
go
through
these
steps.
I
think
this
is
here.
A
This
is
right
contains
some
tips
that
will
be
very
useful
for
you
to
share
your
installation
with
others.
One
last
point
is:
we
are
in
the
transition
to
switch
to
spec
to
install
our
new
support
in
the
software,
so
I
would
like
to
recommend
you
to
go
to
this
website
downloaded.
This
is
just
the
Python
packages
is
easy
to
use
and
then
type
spec
is
to
find.
A
If
the
software
is
there
already,
the
recipe
is
there,
then
you
can
just
type
spec
install
and
that
one
we
we
notice
this
one
is
especially
powerful
to
install
synthetic
version
of
the
libraries.
Those
are
missing
from
the
user,
River
64.
So
some
of
the
libraries
cause
our
OS
is
a
small.
It
doesn't
contain
the
static
static
version,
so
this
is
a
very
powerful
tool
to
do
that
and
once
you
get
more
familiar,
you
can
try
to
build
your
code
with
the
spec
as
well.
So
in
summary,
just
few
Soyuz
compiler
wrappers.
A
For
K&L
remember
to
swap
this
architecture
speed
the
modules
load,
this
creepy
mic
K&L
and
then
build
on
doggie
nose
as
part
as
part
wherever
possible,
and
then
the
verbose
output
of
compiler
is
really
useful.
So
you
can
learn
a
lot
from
there.
So
I
there
are
a
couple
of
tips
you
can
just
read
through
the
slides.
You
can
find
it
by
yourself
and
the
last
point
is
a
try
out
the
spec.
It's
really
powerful
tool
and
you
really
enjoy
to
use
it
especially
to
build
a
user
live
64
stuff.