Dear viewer, these subtitles were generated by a machine via the service Trint and therefore are (very) buggy. If you are capable, please help us to create good quality subtitles: https://c3subtitles.de/talk/50 Thanks!
Now we have Agnes MIDA
here, Mel, she's going
to talk to us a little bit about parallel
programing and because we know
that serial programing is totally last
decade, rock'em parallel
graphics cards.
Thanks for having me, and I would
especially like to welcome our
stream watchers, especially the ones in
China, in Beijing.
But they are probably watching it
tomorrow.
Hey, come on. I don't know if it's
just on the wrong position.
Probably so.
Should I put it on my online
at.
Who better?
So we are going to start again, and now
it's apparently I hear more of myself,
which is perfect.
And again, I would like to greet the
Chinese peace mission in Beijing.
And I'm very happy to see you here.
I'm going to give you a short overview
about what's happened until now
in parallelism and what
is going to happen in the next few years.
And I hope you will get a
firm reality check if it's worth the
work, actually, or if you actually have
the problem for investing some time
and energy into changing your code
to fit to
the needs for our programing.
And because my battery ran flat on my
placenta, I do dancing around
first. We do a little bit of motivation.
Then I will fully explore
the expense, some basic words
about parallelism so that we know we are
on the same page when we talk about
the old standards, old and
means of single multicore
programing.
And then I move over to accelerator cards
and hopefully you will have a new picture
of the whole story.
In the end, there will be ten minutes Q&A
hopefully, and my help will make sure
that I will get to these ten minutes.
So first, motivation.
Why should we bother doing parallel
work besides playing computer
games?
Well, I'm in research.
So what do we tend to do is
probably analyze the so-called big data.
I'm not a huge fan of the big data
because it's basically a buzzword
for pattern recognition in large
datasets.
And some people think it's the new
crystal ball.
Yeah, OK, you could do big data
with huge parallelism.
You could also do something, in my
opinion, more meaningful.
You could do physics.
And this example, this is astrophysics,
which always creates wonderful pictures,
but they do some Higgs boson analyzing
at the sound or so they have huge
machines working on the
large amount of data.
They have kids.
But I'm not talking about you
can also do some weather calculations
with it, but I'm not talking about them
because here at the university Honberg,
they don't like accelerator cards because
they're very energy intensive.
So they are against them.
But what I do in my work is actually
we are trying to simulate protein
flexibility.
I'm applying for competition.
I'm a student at university.
I work and we try to figure out
how molecules move.
This is a molecule which is very relevant
for your heart.
This is very important for people.
Do you, Pollari, block
your membrane so that your heart actually
beats? If this thing is
broken by medicine you take,
you will die by
a heart attack.
So you do not understand
this protein, this channel.
It's very important to know its
structure, difficult
to determine or to
simulate its movement.
Actually, you can to see
a picture from above the
red colors mean that
it's in the close. Said nothing can
pass through.
The greenside means it's in the open side
now the ions can move through and then
replies and jeopardize the membrane.
This is a very essential stage in
your heart.
So you really don't want to create
medicine that works against this one.
And if you could make the prediction
methods better so that
we can sort medicine out that
works against these stuffs,
we could make medicine a bit a little bit
cheaper.
That's in development, which means
also that my university
sends me to summer school so
that I would get a better overview about
the future trends and the current trends,
which means I now have to show you my
sponsor logos, you know, so I'm funded
by the federal ministry and
a third party, which means by a science.
And I'm happy to say that I'm a
university, which also means I'm a member
of the CCC 8H.
So let's get to the
real topic, let's talk about
parallelisms.
So that everybody can follow
the.
I created a wonderful, colorful picture
and we will go through the details,
we will reconstruct this whole picture
and the talk and then we will hopefully
you can see how it fits all together.
But we will start on a very simple
level.
We will just
start with the headline
because we need to discuss what data
base and task based terrorism in my
definition is.
This may not be the best fighting words,
but this may be words that
you can associate with something.
And in my talk, in my mind,
these tend to associate with food because
I'm a very food oriented person.
When we talk about data pearlescent, it
could be
associated with frying a lot
of omelets.
Your data is the respective agony
to fry the omelet and you have to do
a lot of omelets to feed a lot of people.
To ask Petrelis means that you would like
to cook five course
menu for one person.
You have a lot of tasks you need to do,
but you have only to deliver
them in a certain way.
But you have to cook them in a different
arrangement.
You can definitely mix them up,
obviously, in
increasing the number of people for whom
you're cooking.
So database and task based parallelism
are not a contradiction.
They are a combination.
Good, but obviously you tend
to have problems
when you start to cook for 8000
people, of course, menu from one
menu is a monument to peace is
the name of it.
First of all, your kitchen could be just
small. A thousand people.
It's not so fun, although
you may not have chef cooks all the time.
You may have apprentices.
You also have probably not enough pens
and you don't have enough space
to move from into the fridges.
You also have just probably one
recipe book and
I mean, it's crowded when you want to
read from it.
You also need to deliver your stuff
to the kitchen to a specific spot.
You probably have some problems
transporting the eggs.
And obviously in the end, you
somehow need to serve the cause in the
correct order and it should be hot.
But you can translate these problems into
more techie language, which means
you can say that your kitchen is a
has a global capacity limit.
Your apprentices are actually
related to your complexity of the
process, which in our case means a
single or double precision computation.
You could have probably not enough frying
pans, which means your card is just too
small to cook everything.
At the same time, you can also
have some bandwidth limitations.
You have very wide access limitations
you need to think about and then you
end up with probably coalescing
memory access problems for your
memory works better when you access
it at the same time with a large request
instead of accessing all the time with
small requests.
So you should probably assemble the
request for X and transport one big
package, you know, and in the end,
you know, cooking, you need to
synchronize and keep the meal hot,
so.
This problem
where all the time here,
so they devised developed some standards,
some old standards which were used by
single and multicore clusters and
research where products
to use
their computational resources the
best way, the old
standards, which are not so old, but we
are living in a fast developing age.
I open up an open API
and you can see with the different colors
and the different shading, they are
on two sides.
So database base and space.
And the one of
my man, the red
one, is on the implicit, which I
would say it's on the high
level where you will see what I mean when
you see the first line of code.
First of all, we would like to cook our
menu, general, five courses, how do we
do that?
Well, this we use open API because
we need to dispatch a lot of tasks
and open and let us do this.
Just imagine
that you have a classroom of
many single core multiple machines
like two thousand eight, probably
two thousand five.
And you want to dove to would like to
cook a course of five
course menu.
You first of all, you install
it, which is what I, I'm not talking
about. But then you have this
line, the last one that says how
to run the code and this
says with MPI run and then you have
a and
an abbreviation for a number of processes
to launch, you could set it on
one or you prove you have five computers,
five course to use over your
distributed net so you could set it on
five or eight what you can think of.
And then you have a minus host file,
which will read a text
file in which you write down the
names or addresses or whatever of the
computers you would like to use
for your task.
And then open API will
execute the program on the
specified computers
with the specified amount of processes,
and it will loop over the names in this
host file.
So you can probably have more processors
running on one call than on the
others because it has to probably loop
over.
This is different to the POSIX Red
and Blue Thread Library because Open API
gives you an interface for message
passing.
So when you execute this when you
started, it actually starts
to create a message queuing system
so that the respective processes can
send data and exchange
data with each other.
Actually, when you think about it,
the code to do this is actually quite
short because
you just eat it.
De de de de de.
You are.
You
know,
I have provisions so I can be there
to do this in a different way.
Your first in the episode
will start the year, the killing,
the message queuing system and start
with a lot of overhead.
And then you realize the two in
line 10 and 11, how
big your world is and where your position
in this world is.
And then you can start communicating
an example, informing the user where
this threat is actually was launched.
And then you can probably cook your menu.
This is how you do a task based
model. And I don't think there is
yet a new implementation, real one
in C C++ for this.
So this is still summer and high
tech and very often used
the finish, obviously with NBA finals.
And after that your MP program
has switched off its message,
communication, etc.
and will just run on your signal.
Called again.
So this is short and this is sweet.
So let's look now how we fry an omelet.
Let's go over to the old standard.
How do you do data?
Perla's obviously when you fry
an omelet, you need eggs and the pan
and then you need to apply heat to get
an omelet, which is
basically a matrix multiplication.
I mean, I mean, it's obvious, right, you
apply some heat,
so if you're not so familiar
with matrix multiplication because you
don't move, a lot of this is this is
the hour. Help us light.
And I also uploaded these slides into the
system already, so be sure
to download them and look
back if you're lost.
This is really could
be tricky for some people.
So matrix multiplication actually means
that you that you produce
the product.
There's a sum of products of parts
of the Matrix and I call
the respective necessary
rows and columns to compute the element
and see the resulting element in C
and you do that in picking the first
element in A and multiplying with
with the first element in B in the
colored area.
So you move in both mattresses
over K wide
eye and they are fixed.
This is important.
So you realize that actually to
calculate this specific spot.
You are not,
you know, not connected to the
calculations in four other positions,
so you actually it doesn't matter when
you calculate the respective C part,
you just have to do it some time
and you need a specific amount of data.
OK, but it doesn't matter.
You can do this in parallel and actually
in image processing or in
scientific computing, they do that a lot
in parallel.
And you can
obviously code it
in just for reference, I'm showing
you the test of C code,
which is just full like you need to.
Yeah, exactly. So you need to define your
matron's. And there's in line
three. There is a known
prerequisite for multiplying Metrozoo.
So please
know that. And then you just go over
the whoops fix a day and then
go over and produce your
some product.
So we will not transform most
of the time this code into the respective
Thorold versions.
First of all, to run Oakman P
on the multicore processor,
you should probably test if it's working.
So you write another word here
and you can ask
the system if it actually did work.
As you probably can already see, I
included a header there
for opening up and then there is not
so much code.
There's just this weird pragma in there.
This is how you code open and
open. MPLX is translated
by the compiler to actual code
so the compiler decides how to paralyze
it.
So you inform him, hey, now, now come
some parallel stuff, please.
Executed Perello on
the amount of press and processes you
have in your system and the compiler
just will decide how many processes
there are and how to distribute it.
But it's very short and cute and you can
see the code, instead of focusing
on all the overhead stuff, you should
probably you could do and we will see how
it could look like
if you do some real matrix multiplication
with open MPM, I
will.
First, you have to probably fill your
matrix. This is why this less
important slide you have to analyze.
I got these words.
You have to fill your matrix
with Beda. Apparently the importance that
comes now because now you have
to compute.
As you can see, it's basically the same
code as in a matrix multiplication.
I just wrote an own parallel
above it.
Yeah, now
we're seeing the floor.
OK, and
you free it, then
that's the end of it, you can print it
out and free it.
But actually what it does is
give you a print out and it will
tell you, hey, come on, I fall press.
This is a threat to you and I'm
comfortable doing this and that.
Well, you then the next Fed will say,
oh, I'm computing that.
Well, you too.
Oh, I do that too.
This is not what you want.
So just writing the of it will execute
the code on Karua.
Apparently this is a quote quote.
And so.
We should invest some more
letters into our pragma,
and we did that.
We define some the variables
here, the example, the trunk size and the
cake, and then we extended
our pragma.
Now we tell it that, first of all,
this in the next one blockquote is in
parallel and some
of the information, like the mattresses
are shared.
Everybody in this in this
whole compute unit is going to use
them. But Jahnke are private.
And then we inform it that
here there's a second pragma in line 11,
that there is a follow up now coming
and this whole is important because
the eye that defines the spot
that runs through this loop is
defined as shared.
So this means that the
four threats of running and compute
these values will not
calculate they don't have
the same eye. So they will be different.
And this is what we want.
But they will iterate over the day
and they will not change anything here.
And you can also define how open
schedules, all these things.
So this is a way better.
This is what we want.
And one word for scheduling,
it could be dynamic and you can also
dynamic means it checks if
the respective Fed is done and then it
will load another pair of data
on it for the computation and
it will lower the amount of chunk
into it.
So it will compute in our
situation for.
Well, use for is.
Via this loop and then request
new data.
You can change this, you have a little
bit of overhead when you launch new
processes here, so you should choose
the value wisely and especially check
the time. You may be a bit irritated
or different. It could be changing the
tank size.
This also is relevant for Cuda.
Obviously you have to install it first
and you have to use in this case,
chieftaincy to link it.
And these
were the old standards and now we are
going to accelerate accord's.
We are back to the picture and now we are
going over to the explicit models.
They really have to look into your data
and move the data along stuff and
so on. So this really key way
of doing it, and I'm perfectly
on time, which is great.
And most wanted for this,
we have to make sure that we don't
miss the words, we are
always thinking about
a host and a device.
The host is in most cases, the
CPU sending off work to the device,
the accelerator card, most cases,
which are you are probably used.
These are graphic cards.
And then when you send something
to the device, you send over
a kernel, which is a function which is
launched on the device.
So if I am now switching to kernel,
this is just a name for a function.
Yes. And when you are running Linux, you
need to install the proprietary graphics
drivers, which actually worked
out very fine on my system.
It's not on my work system.
First of all, we can do this now in
Kouda, could I speak programing
language developed by Invidia?
They do invest a lot of marketing money
and share it all
with all the word.
They have a lot of great documentation
about it.
Yeah, but you should choose
wisely, you know.
But it's you will see it's it's actually
quite nice, this one.
What you can see here is, first of all,
the, the kernel.
It's going to the device, which means it
has this global keyword
in front of its definition
that double lines there.
And then in line eight and nine,
it somehow tries to calculate
a row and a column
and it does this and requesens
something like a block idea and
block dimension and the threat
idea.
Obviously, we are talking later about
this. You have graphics cards with
a lot of parallel processing units.
They are a lot of them.
So you need to number them somehow.
And there are different ways of doing
that. You can do this in one dimension
or in two or in three dimensions.
And this is how you compute
the global index
of your respective
Crono Lounge.
And then you may need to consider what
you're going to do this depending on
which position you are in this process,
which happens here because it uses this
computed number and call
to define which part of
the Matrix C it is going to
compute.
So now I have to warn you, my workpiece
didn't like my Linko,
so I was able to test this,
but you can find a better example on
Kouda, so I may have switched
the Ines's. I can guarantee.
This is really tricky.
This is the worst part of our programing.
OK, but we also
have to initialize
on our hosting our main function, our
matrix, and then we have to
in line nine to 11, we have to
allocate memory on the device and
then we have to move the knowledge.
The Matrix is A and B to
the device per hand.
This is kudasai.
You know, we are explicit here.
And then you have to define your
in line 17, 18, your
way, how to figure out
what each Conlon's launch has to do.
So you need to say in
which in how many dimensions you
define the indices you're working
with. And this is done with a stimulating
block thing only as
you can see, my dimwit is just
one one one about my Dimbulah is
exactly the size of my
output c.
Just in two dimensions,
not so nice.
We'll talk about that a little bit.
So this is this code is not safe
for work if Shiraki is too big.
OK, but when you have decided
how you would like to a
number of the threats that are running on
your graphics, quite an example.
You have to launch the counter and inform
the council how it's going to
be addressed. You know, you tell it,
how is the numbering of the respective
countries going to be?
And you just put in the input, the
mattresses to be multiplied and then
the kernel starts to compute the
respective index and so on.
I think I have a summary slide of that,
too. OK, after you've done
your computation, you need to synchronize
again. You need to
fetch the memory from the device
to the host and then you do something
with it for your stuff.
Yeah.
So if you summarize the important parts
are here in Hooda.
First of all, you have your come back
there with your indices computation
very relevant and very
problematic.
And then you have in your main function
the question how you define your
dimensions, how many threats you need to
launch and how you address
them, which are so you have to
fit like 19, 20 to line
three and four.
This must fit and this is
a case for a pen and paper,
and then you lost your thread and the
economy and then you synchronize the
threads to make sure that you are done
with the computation.
This is basically a cooler style.
But there is
this is the insulation, I cannot
guarantee you for the Linko comment, it
should work like this, but I couldn't
reach my sysadmin at work, work
I have heard.
And at home I have an open salekhard
and my work configuration
of I think so.
Now comes the other version of programing
accelerator products, which is called
Open Sea.
For this I used the nice code
from the source I linked
here, but he can't come today.
Very sad. I asked him about it.
Um, and it's actually just a
regular edition, but you will not
really miss it.
Open Seattle is a language that is
developed by Nvidia arm, the
arm, etcetera, so
that it will fit to a lot of devices,
basically devices that have a car.
So it is very flexible
about the device it has to run on,
which means you have to tell everything
to the programing language,
to the to the kernel so
that it knows how to how to execute.
First of all, obviously, you have to
locate your memory and put some stuff
in it.
Then you have to interestingly,
you have to read the file that your
kernel is programed
into your system.
And then on line 14,
you have to figure out on which device
you are actually running and.
Yeah, the I.D.
stuff, and then you have this device
I.D. thing, which is actually kind
of interesting in line twenty, I
will repeat this line.
They don't talk to more senses
about us.
And then you have to create an open
context, put everything together,
and then you have to
start a command queue.
You have to then right
over the memory and memory for
it.
Then you have
to create the program,
then you have to I have to read
it up, you have to build the program and
then you have to create the open kernel,
you know, I mean, don't mix it up,
then you have to set the arguments
of the kernel because it doesn't know it,
apparently.
And then you have to inform
the system how big
of chunks probably you
have to calculate
it. So you have to inform it how
big the overall size of your vector
in this case is or if your matrix
and you have to tell it and how many
pieces one thread should execute
when it started.
And then you launch the
great.
Now, we have launched the colonel,
we have to get the memory back,
so you encourage Buffer
and then you need to delete
everything and release everything, which
is also a lot of code.
So.
Yep, as you can see.
Open seat needs a lot of code.
But because you can configure so
much, you can use it
on a lot more platform than just in
videography cards.
The very interesting thing about it is
actually that you in line
seven can switch to this device
type GPU to CPU and
then you can execute your program without
any problems on your multicore system.
And then you can use your normal debugger
for debugging it, which
is quite nice.
And you just have to change this line.
So, so.
You obviously already has to
install the Cronos open, the
Kroner's is the group in which
and the ARM and I'm MDR
and others are developing this open S.L
language and you have
to compile it is already in the TCC.
Yeah, so.
The next slide is going to be.
This one. So in summary, we always
have the same code, but in in
reality it may look a little bit
different. So you have to define your
accelerator device either explicitly
or implicitly, and then you have to
move the memory, launch the kernel
and tell how many launches it should
have and how many data it should process
in one launch. And then you have to clean
up with more or less code.
You can read a lot of open S.L in special
functions so it stays
flexible and looks a little bit more
cleaner.
But when it's about curliness,
we could also look at open
axi and
this is the new standard situated
next to open and up.
So if you can remember, opening up was
about this pragma stuff.
Open I.C.C..
It's a similar thing in blue just
to our accelerator's.
They are aiming to fuze
it if used with open MPLX.
But it's not so really working
right now that because it's short
and you can then see your actual code,
I will show it to you as well.
This was the matrix multiplication and
open up.
And you can see there is this parallel
shared of this for
loop pragma thing.
And then we take this one
and we convert it to open I.C.C..
We just, yeah, switch their own
up to I.C.C..
And we are pretty much
what else here, again,
in this cold piece,
like an open and open I.C.C.
is actually compiled
to open code or depending
on the compiler to put out code
when you compile it.
So this thing will be translated
into an open civil code, hopefully
fitting to your to
your accelerator device you
have to find on your compiler line,
which means you can compile it for
a lot of devices instead
of for the one that
you had in mind, which is in most
cases better because you can be more
flexible in your development.
After open sead, I think this is
kind of a relaxing
and it's quite interesting,
you can get open see
currently only in
comparatives for which you have to buy
some licenses.
But since November, there is an
e-mail exchange on the D.C.
mailing list that apparently open I.C.C.
is moving into into ATCC
and the next 12 to 15 months,
the first batch is already submitted.
So we can hope that it is available
for.
Yeah, people who don't have a lot of
money for buying all these compiler
licenses that we apparently need.
OK, so.
This is open, I see
that the world does not only consist
of stupid matrix multiplication
code like the one I showed you,
it actually is a bit more difficult
because your matrix could be too
big for the device.
So you actually don't load the whole
matrix into it.
You just load tiles into it
and then you have to walk through
your matrix like
and so you move from one place to another
place and
be a bit more brandee about
it.
Exactly.
Um, so you have to be a
bit more specific about your friends
and be careful.
And so and this is also a part where you
need pen and paper when you start to
program it, because you can mess up so
many things.
And there's another
problem with it.
And this is in Coudert terms, it's
called warb divergence,
because actually, if you
at least look at the graphic records by
Andrian and media, you can see that.
You may say that they are
HeartWare.
How do you say that they are threats
combined by hardware?
So you define the amount
of threats that work together that
launch simultaneously by
your head, in your code, in your
in your main program, when you define the
dimensions of the grid and the block.
But actually, an area as well
as Omed also have hardware
encoding of the sizes of these.
And in an area it's 30 to
this means that they will always
be executed in
blocks of 32 threads.
And you should choose a block size or
a grid dimension size of thirty two or
more, you know, multiplies of thirty two.
This also means that probably your tile
doesn't fit and you do a tired
matrix multiplication to your matrix.
So you have an overlap and now you need
to think about what you do when you have
an overlap, because
when you have an if else branch in
a warp, this means
that you first have
every threat in this wall will execute
first the first
punch, the response and then the else
branch.
So the ones that have something to
do in this branch will work, the others
will sleep, and then the others
that will have something to do in the
response they will work on the others
again, will sleep, will do
some efficiency efficiency.
So you should think about I've just
probably in this case and zeros
in the pure
blue parts or
at somehow figuring
out what divergence which means
if sponges are not nice,
it's better to recompute than do if
branches.
This also holds true for not just
warps but for the whole block.
They just can work through one
instruction. There's a lot of data, so
they have to work through each line and
some of them will be idle.
So if you choose the box size,
not very wisely.
Do you have may have a lot of sleeping
threats the whole time and your device
seems to be busy.
You should look out for that.
And there's another thing that which I
didn't cover in my code, actually
an example.
Invidia GP's are have
a global constant and textured
memory, which is accessible for
everybody.
And then they have shared memory, which
is just accessible for the ones which are
organized in one big block.
They are grouped together the wabster
blocks so they can access the same
shared memory.
And obviously it's way faster to access
the shared memory than access every time
the global memory.
So you first load the
piece of the matrix into your global
memory and then you load the specific
title of your matrix into your shared
memory. And this is the speed-up you
should aim for.
But this can be depending on what
you actually do instead of matrix.
Multiplication can be tricky
and it the how
much, how much speed up you can get
changes of every generation of an
example, the Nvidia cards.
So probably the speed up you got with the
last generation card is not going to
work with the next one because they have
better memory access, which
is why I am actually rooting for open
I.C.C..
So just
an information for the ones
that are looking into these programs,
they didn't do not have a very nice
name.
They have decided that in Kouda, a threat
is a threat and you can combine
threats into a block.
Actually, Blocks consists of walks
based on hardware situation, but,
you know, threads in a group,
these are blocks and then you can order
blocks into a great fine
openside has decided that
threats are actually work.
Items and items can
be grouped in work groups.
They don't know a great and open ICSE
thought. Yeah, well, we need to somehow
accept every definition so
we do a vector, which is a threat.
Fine. And then we somehow say
there are workers and then there is a
gang.
And you should at the moment never use
all three ways of
defining how your criminals should launch
just to please
so.
It could get a bit tricky if you read
if you switch between the various
documentations, just imagine you have
to count through the amount of threats
you are launching and you have to address
and find them again.
And so you have to
use pen and paper and find the fitting
words on the respective documentation.
So.
But we should cover and how
many minutes do I have left?
Wonderful.
Um, this is great
hardware you have heard a lot about in
graphic arts.
And there's also
the talk about this fire on fire thing.
And then something a friend of mine
actually went above and recommended to
me, which is called Kalila.
And I will not cover FPGA,
but everybody who looks into
Parrello parallel
computation of stuff of algorithms
that they can encode into hardware.
FPGA eyes are so fast, you should
think about it and they are cheap.
But if you need a CPU,
a flexible one, you need to look and
do the three other ones.
First of all, you probably all know how
these graphic cards probably look like.
This is a very interesting picture
of a Tesla card.
Tesla cars could cost around two
thousand euros, but so if you don't have
the money, I'm sorry, but you could
probably use your graphics card, but you
already have in your computer, you know,
AMD cards look somehow similar.
They all have the screen vector units
they all use, which is
blue.
Right, the captious, then you have a
dispatcher unit and then they have they
are somehow communicating with the global
memory and fetching some memory.
And there I'm not talking about
the possibilities of reaching that and
that how many Google flops and how
many computations per second, because
reality shows that you actually need to
have a problem to get to these
numbers.
If your problem doesn't fit, you
just don't need to care about the keeg
flops that you client could maximally
reach because you cannot reach it.
Because in example, my my protein is
not so big.
I don't have the say on.
This is a very, very special,
different architecture you don't
need Koula are open to
and you just need simple C or C++
code because it's actually
a consisting of sixty one or more
depending what kind of cells
normal course with connected
with the cash.
And then they are all the you can see in
the above picture they are all connected
overing
so and these they access
this ring. We are Busse which means
if you do not have enough threats to
use every core in this loop.
Your memory bandwidth will
drop.
So think about it.
It's really nice that you can use your
normal zip code, your normal open and
open API code on this, so you don't have
to rewrite a lot.
But you need to think about if you really
can reach the memory bandwidth that you
are aiming for.
You need enough of threats.
If you then look into the processor,
the lower picture, you will probably
realize that this is quite old
core design.
I think it's a Pentium design
and you can say it can execute for
threats on the top there in parallel.
It has two pipelines to actually
pipeline the whole stuff, but there
is just one pipeline with a
connection to your reactor unit and your
reactor is the one that executes code in
parallel.
So, again, you need to put enough work
into this reactor unit to make up for
it.
So it's not perfect, but
it's great because this card runs Linux.
You can open a show with it
and you can run or you can work with it
like a normal cluster.
So your migration efforts are
way smaller than you
might think.
And then there's this one.
Oh, yeah. By the way, AcciÃ³n Fi, it's
probably 2000 euro, but I haven't
met anybody who actually owns it.
There's this suite called Paronella.
As you can see, it's ninety nine dollars,
which is nice
and it has a combination
of an accelerator on
it. The accelerator card is Epiphanny
here. There and it has 16
to 64 microprocessors
on it.
It's a can understand C
C++ and open.
So, so not so bad.
It also has an FPGA
and I read if you don't use the HDMI
output of this small little card because
actually this is a computer
for computer, then you have around
70 percent of this FPGA
for your own use, which is
interesting for figuring out.
And then it also has a process, a dual
core processor, and it's just ninety
nine dollars.
So I would say this is something for I
will make a community.
You can do something with it.
The only thing is at the moment you can
I think they have already sold some
pieces, but the preordering
for the new model is closed
so probably they will open up in January
and then you can shop and try
out your own stuff and have a little
small cluster at home.
Would be cool.
So.
Now, the picture is again complete,
I just edited just in the middle of
the C++ amp
because I was talking a lot about Invidia
and aimed, but
you should never leave out Microsoft
because they are people who
need to develop on Windows even for
parallel applications.
And Microsoft has developed
an extension for C++.
They are shipping it with visitors to
2012.
Apparently it is based in somewhere
situated in the middle of it because it
means that you can go
towards explicit programing.
You can really force it.
Which threats should execute,
in which combination, in which size
on your device.
But you don't have to.
So if you are
going towards Windows, you can use C++
and you look into it, I don't have a code
snippet there, but it's online, the
documentation.
Exactly, I would say,
and then we are coming
already to the end, I think, yes,
the end, which is great
because I did not mention an example,
posted threats. I did mention them in a
small sentence.
I did not mention boost threats.
You know, these are all more on your
these are threat libraries for your
system. They are not aimed for running
on a huge cluster of a lot of nodes.
So they're not they don't bring this
whole message passing interface for easy
communication with them.
So I don't need to cover them.
There's also something like Hossack,
I think it's by Entel and there is also
building.
I have just seen it.
So probably if you're searching for
different, different alternatives,
you should look into that.
And I didn't talk about
Reprograms, even though I love them
because and I only have
two minutes left so I can talk about
them, which is great
task. Skinnerian programs are the
ones that you would like to have for
deploying your programs
on workstations of your users.
If you do not know the workstation of
your user, you can
write a program based on SOPA,
which is developed by the University of
Pado and
stop, you will first benchmark's the
PC and the device, the graphics
card, probably what's on it, and then
decide how many data will send off
to the device and how many data it would
be will be computed on the CPU.
So people your customers, probably
with a graphics card, with the high
end graphics card, could load off
a lot of computation on the
graphics card.
People with a very graphic card
will have the most computation
on their CPU, which is nice and flexible.
All you have to do is actually
provide stuff you or the program that
you're writing with multiple
implementations, which will work
then for the graphic cards
and for the CPU.
So probably one of my inspiration
for your CPU and one Kouda
inspiration for you and give you
an example.
This is actually very interesting because
as these students forth
for a company we
deploy should deploy software for
a different set of customers, and if our
software can actually somehow
meet the needs or the abilities
of the respective customers PC,
I think this is quite interesting.
With this, I'm done
and I would say it's time for questions
now. Thank you for listening.
That was awesome. So for questions, yeah,
just queue up at the mikes, if you like,
and we could take some questions.
All right. We have a question over there.
I want to know whether
Mosaic's and Open Mosaic's still exist.
And do they know how to talk to graphics
cards today? If they do,
you are probably talking about this
this pre-, um,
these versions that were that were
before they tried to make this programing
easier. And I don't know about it because
this would be so difficult for us to
use.
So we moved into this field
when Coolac
because, yeah, I think they are still
alive or somehow something like this are
still alive, but I think they are losing
market share, especially with open sale.
Thank you.
All right. We have another question at
this, Mike.
OK, so it looks to me that we are,
roughly speaking, of course, open selling
and cool. For example, compare
like Java and C a bit because
both Java and Open Sea are more bloated
in code. And what you get out of it when
you compile it is more general code.
But then we all know that Java may be
slower than C.
So I wonder, can you say something about
how the performance compares, maybe in
terms of the of some benchmarks, maybe
also in comparison with
the vector processing instructions like
this e that we have on modern CPU
architectures?
Um, actually I heard a bit
about a benchmark because somebody ran
a very powerful application, the full
parallel application of Montecarlo
simulation on ACCE on fire Coolac
card. And on the side of it there's
a sixteen core into the processor
as far as I know, and I think we actually
have one in our cluster
and a full parallel version.
The other GPU would perform best,
but if they would just be one iteration,
one
word would not parallel.
You know what you
see where one serial
iteration in this piece of code,
the Sandbridge would perform best
and the GPO
would be, even though most of the code
would be perfectly parallel, would not
perform good enough.
So instead of investing so much
time into optimizing for for
this Coudert card or for it, I think they
had a Tesla.
They said now probably I should
skip it and run by Musante,
but which could be busy,
which is also something if you
optimize your control and see how
it will not run as good as for Kouda
and on the other way around.
So it depends on the problem.
Basically, this is one thing and
it depends on you how much time you
invest on optimizing for a specific card.
Thank you.
OK, so we could take another question
from there.
All right.
Did you also look into other programing
languages that
make parallel programing possible or
even easier than with
C, C++, Khuda, Open SEO and stuff
like, for example, Haskell
with the libraries
that they provide?
Because I'm found through my project
to see I don't
there is another language I
don't know anything about Haskell.
I just seen some of the lambdas
that Google developed,
SCO, which is
somehow a replacement for C++,
which also I think aims to be
to kind of make parallel programing more
easier.
And also all of the standards are
also developed for Fortum.
And I would really be happy if this
Lightwood just stay stable,
really.
And so this also
works for Fortum, which is what most
physicists and mathematicians use
that now a lot farther
than that.
All right. Went from there.
Now, again, I.
I have a question regarding open access.
Obviously, there is a lot of magic
implemented regarding data flow
analysis.
And I want to know
whether there's also some magic
for in case your
input or output doesn't fit into
memory like this tiling
case regarding matrix multiplication
you talked about or is it
or do you have to handle it manually?
Um, I think they
do tiling and it depends on
the compiler. The good thing about is
that Open I.C.C.
is for the PCI compiler,
which I which I saw for Invidia
Cards is compiled into Kouda.
So you can actually look into it.
And for Randy Cohen
cards, it's compiled into open s.L, so
you can actually read it before you
launch it. I think they do do an example
tiling because else you can't come to
this Matrix Open.
LGMA says he doesn't.
Gives you enough pragma
possibilities to tell it to tyo
the Matrix, so it needs to do this
on its own and
the more trained the
compiler gets, the the better they
will do it.
So it has to grow, will grow with the
community, I would say.
All right, cool.
I think we have one question from there,
and we have time for one from here, I
guess. OK, um,
I'm as advanced
as you C++ programmer.
A single example is
a little confusing because
you mention you mixing
integer and appointer.
And this one question talking
about is that it's fine
in honor of, uh,
for two
particular architecture.
But the problem is, if you're switching
to 64,
then you get a problem because
the pointer will double and
the pointer size is now eight
and integer in all
standards. I know in C and
C++, uh, defined us
for byte types.
So the question is, is
in Kouda or s.L,
uh, integer either
defined or is all defined,
it should be only 32.
But
I actually cannot answer your question.
I just switched to enter into an
integer so that my written output
on my answer would be more readable.
So it's like getting rid
of the digits
because the size of
it. And you say then
what star?
And this is a problem supply perspective.
OK, with the word programmer.
Yeah, actually I do
program with float's, so
it's just for this use case.
I'm sorry it didn't
broke my computer until now
in my examples, so I'm sorry.
So please don't
make too big integer stuff and
be careful.
All right. I think we have one more from
here.
I haven't worked with graphic arts, but I
worked with parallel execution.
And there it's most of the time I spent
defining what our values, what
are mutable values
and what needs to be shared and stuff.
And then the code you showed, I've hardly
seen any definitions
of what needs to be shared among which
and stuff. Can you say something about
how that works on a on a graphic?
Harder. I mean, I actually
checked it out so that it wouldn't be too
comp complicated.
And what you do is you
just use a specific keyboard in
case of Kouda in front of your
in your kernel when you need to load
an example of small tile into your shared
memory. So use a
specific keyboard.
I would say, I think and and
as encoder, you have to do this
the same way. You have to do this by hand
and then openside.
You could it should figure
it out by itself.
But often I see also allows you a little
bit like, OK, mine to define
for the system what is shared and what
is private.
So.
All right. That has to be our last
question. And so, please, on
your way out, first of all, a round of
applause.