So, for sharing the lunch time with me, thank you.
So, I will present a firm work for building digital communication chains, which is called
affect.
So, to give a little bit of background, so, because of the context here, so, affect
is a software developed for providing solution for software different radio.
So, this has started a little more than 10 years ago, and well, most of the components
and also the contents of the components, and also the goals to, as you know, to
replace some of the hardware components into software components.
And, I will start with a very basic basic chain.
So, affect is the goal is to under that kind of a chain where you have a source, several
layers of encoding sort of algorithms, and then some channels and that some noise.
And, it would be able to use in two ways, either for simulating a cooperation
algorithms for the purpose of validating algorithms, and we show that they have the
proper question right that we expect.
So, when we do the simulation, we know we launch a lot of random messages that we modify
some control noise, and we check that what we have at the output is much, what we
send it in the input.
And also, it can be used in real communication chains, for instance, which has been used with
some satellite usage or some video processing also.
And, it involves three complete three academic teams in France, two in Bordeaux.
So, there is the IMF laboratory in Bordeaux, which is more in April, Nixon and numerical
communications.
There is the team storm in Latin New Year in Bordeaux, which is more on computer
science and HPC and Tivalsock at lip 6.
I will detail it a little more.
So, Tim Storm, which is the team I belong to, is a team that is initially only on computer science
and HPC.
So, it will be far from radio and SDR, we develop techniques for optimizing codes and programming
for mixed supercomputers.
But, no, we also target smaller devices for radio.
The team from IMF laboratory in Bordeaux is more than three domains.
So, analogy can mix their clits, algorithms, and also numerical communications.
So, this is the main specialist of the team.
And, there is a team also in Paris at lip 6 laboratory, which is from over at the interface
between the two domains, computer science, classical computer science and radio.
So, the effect is organized that way.
So, there is the top layer where you have all the management for the modules.
The communication modules, so the simulator and also the great mix for the aerocoic team codes.
And then, the effect is a bit on top of two pieces of 12 pairs of 3PU, which is the runtime part,
which is in charge of ending the task and mapping them on the CPU course,
and scheduling and optimizing.
And also, the MIP laboratory, which is dedicated on programming,
giving access to the lower level SMD and 36 proteins.
So, I will literally turn more, there is this component.
So, first, the MIP laboratory, this is a super-spersed laboratory.
So, what we call the wrapper laboratory, which means that it is only a header on the laboratory,
which is included at compile time by the compiler, through templates.
And the way it works, so it provides an abstract layer that we express a new program with.
So, if, for instance, here we have a MIP laboratory, which symbolizes vector or g store form,
the same D and system set, that we load with several components.
And then, we do some array matrix here.
And then, when you compile this part of code on different abstract functions,
that are supported, so, for instance, we support the instruction set from Intel,
so, for instance, for AVX, the assignment that you see here,
we translated into the corresponding AVX2 intrinsic from Intel.
Likewise, the operation here, the plus is translated into the plus for AVX2 instance.
And if you compile the same code on a norm, actually, true,
then it will be translated into the new on instance, set instead.
So, the interest is that you keep your code largely independent of that work,
actually, actually, that you are targeted.
And so, it allows you to be quite potable and still to have a lot of control on the
the instruction that you use.
And also, this laboratory is evolving, so, we are also working on SVG.
This is the new iteration of SIMG entrancics and instruction set on ARM,
and also on supporting RISPID and the V extension of RISPID.
And then the second big part of effect is the stream view on timestamp,
which is in charge of unlinked the work and mapping that work on RISPID.
So, it is fully used to use a supersprose thread and use a thread to execute the code
and the work that is submitted by the task in the chain of communication.
So, for that, the programmer uses an API that is a kind of embedded language in
supersprose for building as we change.
So, here is an example, a very basic example where we have just four tasks.
So, the task will be the element that act on the flow of data.
So, you can imagine that on a flow of radio information, work on each
circuit or in frame.
And so, you create the component here.
So, we have a two notion, we have the task, which is the actual routine that we will be used.
And a module is slightly higher level abstraction that groups,
about tasks to get done of data related, for instance.
If you have a coding algorithm, we will add the corresponding decoding algorithm
that will be part of the same module from a server quantity.
And then, so you create your module object and then you build your chain.
So, you bind the task.
Its binding operation is managing both the memory allocation for the refers and also passing data
from one task to the user.
And then, you build the rubbed that into sequence and then you execute the sequence here,
which will do the actual processing of data.
So, this is the simple version.
Then, you can have also more complex aggregated of tasks.
And, for instance, here you have several inputs of several inputs.
My question more to actual change that I have to build.
Also, you have conditional, so you can have branching here.
And you can select different paths according to the data that you find in the frames that you process.
So, it's kind of if else or switch case that you would love in a global run.
You have also loops, of course.
So, you can identify it.
If you have some kind of synchronization in your communication chain to synchronize on the signal.
So, you can repeat a part until some condition is reached.
And then, what we are asked to actually use parallelism is the notion of park line.
So, here you can see that the task can be grouped into several stages.
And each stage will be mapped onto one CPU core.
So, stage one here will be mapped on one core.
Here, we have two trees, tasks in the second stage that will be mapped on the same core.
And then, another stage here.
So, you can, if you want, control everything about the mapping of the stages and all the things are grouped.
And also, we provide some way to optimize, to automatize the mapping of this work on two cores.
So, first step is to automatically replicate the stages that can be run on several threads.
So, the condition for that is that this stage must be steadily.
So, it must not have some state that is kept from one frame to another frame.
If this stage is steadily, that means that, for instance, the frame one can be processed on one thread.
And then, the second frame coming to be processed in parallel in the second thread and so on.
If there is an internal state between the frame, then this is not possible because then you have a dependence and then you cannot replicate this part.
Just to show you a little more, because with a small, so you can see here the pipeline that is replicated and then it's mapping on the CPU core.
So, here until know everything is under the pipeline, so you can see in the code here that we build the stages.
We build mapping on the threads and also we indicate on which core we map each thread.
And also, to give more flexibility and more automativism.
We have some work on automatically mapping the network on the multicore, our architecture.
So, there is a thesis from Jan Oran in Bordeaux, who has been working on this topic, so she is in last year of PhD now.
And she designed an algorithm to map this task and stages onto the CPU cores.
So, again, we will distinguish through two kinds of parallelism.
So, we would have the first pipeline, parallelism, which is just a parallelism intact.
So, we have the one thread here and one thread here.
If we cannot be sure, or if we know that there is a dependency between the stages.
And if we know that there is no dependencies between some stages here, we will allow a replication with the algorithm.
So, the idea is this way, so we will consider two kinds of tasks.
So, the stage task and the stage full task.
And this is the way that it would work.
So, we have some information about the duration of the task.
We assume the assumption that we make is that this task will have the same duration for each frame.
This is the assumption from that, from that algorithm for no.
And we have a frame that enters the process.
And so, it will go to the stage one here and then to stage two, the three.
And then once the stage one has been incomplete, we can let the second frame enter the stage one here.
And you can see that the frame one is no switching stage two on the different core.
And so on.
And you can see here also that we have some parallelism here.
So, we can process the task one in the task five here and the task six here.
And so, the result from that is presented in the in the paper that you can find on the web.
That described the algorithm that is used for that, which is called attack.
So, it has been proved optimal for change when we have the assumption that the task has constant time.
For a given stage each task, we have the same time.
And the way that it behaves.
So, we compare it with other mapping algorithms that are existing right now.
So, for instance, the algorithm that was known as best we thought that, which is called Nicole here.
And so, the experiment that we do here, we have on X, the number of resources that we are able to use.
And on why the megabyte in the passive one that we are able to reach.
And we have two metrics with the dots.
There's our, the metrics that are measured and the strike lines are the metrics that are simulated.
So, what do you see if we were close to what we were expected in terms of results.
And we can see that attack gets the best results.
So, it is able to reach the highest bandwidth.
While using the lowest number of resources, we can see that some alternatives.
So, in terms of the year, the year is able to reach also the same level of bandwidth.
But, it uses more resources for that.
Who does the waste here?
So, here, there's other, the numbers are corresponding to the graphs.
So, what is stimulated, what is measured and the number of resources that we are used to, which is best bandwidth.
Also, some examples of using a fake in the red chain.
So, that was a work between Airbus and IMS laboratory.
What, between a chain for transmitting a video for, for satellite.
So, it's called DVBS2.
So, it's a quite complex chain.
So, each, you can see, we have eight stages.
Some stage, we can see on several tasks, five tasks here.
And this is the recording path.
And we measured, find going level the performance of all these stages.
So, you can see in red, it is the stage at cost the most.
And which is a state full.
So, we cannot parallelize this one.
And you can see that stage seven year is the one that cost the most, but which is parallelizable.
So, it doesn't have an internal state.
So, we can replicate it on several course.
And what we obtain here, using parallelism.
So, this is an example here.
So, if we use a, we need a sequential version.
We are, we have this, this throughput.
So, for Maca-By,さCon, but if we run the same computation on multicore.
So, using parallelism.
So, using replication of the stage at this expensive,
then, we were able to reach 55 Maca-By for, for the same computation.
So, let's not, not do large computations.
So, we have sort of been working on targeting a heterogeneous processor.
So, in this example, I'm not talking about GPU, but using a processor with different
kind of course, a big little, for instance.
So, here is an example.
So, it was a capable processor, but we did also some similar tests with the machines.
So, the way that this machine is laid out is that you have a full percent of performance
course, and you have some small consumption course that are the course here, and we experimented
on the framework of effect computation on top of this machine.
So, first, we made three tests, so one using the West scheduler.
So, we let Linux choose how to map the slides.
And the colors here correspond to the occupancy of each course.
So, you can see that we have four blue course here, so this corresponds to this blue cluster here.
And likewise, we have green, and also we have the blue consumption course in yellow light and brown here.
So, this first test is using Linux, and then we use different pinning by hand, so pinning for throughput or pinning for maximizing energy saving.
And we can see that we can get some interesting gain.
So, for instance, the G1 here for pinning for throughput, so we have a slight gain in throughput.
And also, we have view in terms of energy consumption.
But also, if we are able to allow for lowering the throughput a little bit,
we can have some significant energy efficiency gain here, so what is 20% here.
Okay, so we also have been working on providing some easier way to program with effect.
So, as I said, effect is in C++, and by default, you have to do C++ and to program it.
So, it is not very high level C++ is relevant that we use.
But still, it can be difficult for people that are not used to do that, or that work usually with MATLAB, for instance, for designing error correction algorithms.
So, we also have a way to access effects to Python, with two modules, so key effect is just a translation of the API into Python.
And also, we have the path modules that are used to write C++ custom modules and link them into key effects.
So, to have the benefit of both tools and for the efficiency, when needed, and for the ease of use, when it is prefer.
So, this allows, for instance, for having some not-book that you can use to experiment with parameters,
and immediately results in two checks.
Here's an example of all it looks, you can see that we set the parameters here, so it is very similar to all you would write it in MATLAB.
And then we build the modules for the chain, and then we have the execution here, and we can do the simulation.
So, this allows you to quickly iterate with different parameters and check for different kind of solution, for instance.
We also are expanding with Julia, for the same purpose, but with the feedback that Julia is compile, and also compile that using just in time compiler, so we potential to get more performance than Python.
And also, if you are familiar with Python, you know that there is a global lot in Python that prevents efficiency with disreading.
Even if there is a lot of effort removed, it's still there for no.
So, we are expanding with Julia to interface it with effect, we have been expanding with different kind of packages that provide the interesting between Julia and C++.
And for no, we seem that the G1A package would be the most interesting choice in terms of support for thread, for execution, and also the quality of support for execution.
So, I'm calling C++ from Julia and her recipe.
So, we did some experiment again to know the overhead of during Julia instead of programming directly with C++.
So, it's a very simple case that we did here, it's just to have some work load to do.
And so, on some AMD horizon platform here, so this is the chain that we use.
And so, this is the result that we gain.
So, in black you have the C++ latency, and you can see that with Julia.
So, you know, the C++ here, so that the two versions here.
The two versions are corresponding using copy or not, between the stages, because it is an important part, I will explain why.
And you can see that with Julia, there is quite a gap in terms of latency.
So, in X here, this is the data size.
So, it's an idea of the length of the task that you have.
And at which point it becomes a particular to use Julia in terms instead of C++, getting the frame size for instances.
And the reason for this gap is mainly due to a raw management in Julia to keep things safe.
So, if for your proposed, you are able to go on in one safe manner, then you can lower the cost of using Julia quite significantly you can see here.
And if that makes sense for the usage and that's the target.
And you can see also the difference between using a copy, which is right here, and using a zero copy transfer in blue here.
So, this is still experimental, and also on the Julia part, the interfacing module, the Z itself experimental, so this is a polling.
And Julia also is a polling, so maybe the result would be better in the coming years.
Okay, and well, this is ongoing work for us for now.
And one almost last point is also kind of a sort of, sorry.
So, we are also being linked across the, for actually a short users, and to experiment with different kind of architectures.
So, we are very interested or safe to use different kind of small boards.
It's very similar, I think, to what's even represented just before.
And we are planning to open at least partially this platform to the enthusiasm.
And we are still, there's a possibility to get a concept on that machine.
And right now, it is made of four partitions.
So, we have some AMD, Ryzen, some Intel Core here, and so, was in, is in four, is in five, with your lake, and also different kind of accelerators.
I didn't mention that today, but we also have worked on accelerators again.
So, when we get AMD, Intel, and also the least, we probably have over time, as we integrate, there's this components.
And also some information about the network that we have here, but it's quite normal.
And we try to use more data for a full, but at a moderate power consumption.
So, we try to find a trade-off here.
So, if you want to see, you can contact Adrien Castline, or tipsis.
So, this is in the slide, and the slide, the online also, so we can get the advice, if you need it.
Okay, and one last point in my talk is the online bear fair comparator.
So, bear fair is the, by the way, the front mirror rate comparator.
And it's a comparator for different kind of error coaxing algorithm.
So, you can have that on the website, and see if I have a failure network that can show you.
Let's see.
That seems to work.
So, this is the page of, of effect, and you have the bear fair comparator here.
So, it loads the database of past experiments with different kinds of error coaxing algorithm.
And so, it will appear in the short moment, I think.
And then you can compare the results of this measurement.
So, for instance, you choose one set of parameters.
So, you can see the byte error rate and the formula rate for that set of parameters.
And you can compare that with other algorithms or different sets of parameters.
And also, if you want, you can also upload the file.
So, it's not uploaded on the or machine, it's uploaded in the website.
And the JavaScript instance, so that you can compare your own results with the literature.
So, well.
So, it loads to see what is the set of the art and all of you can.
Or you will put it in yourself compared to the set of the art.
Okay, so, to conclude.
So, as I said, it has been an effort for about 12 years.
Now, about building an open source.
So, for different audio environments.
With focus on parism, so, multicore parism, vector parism also.
It's also completely free.
So, it's a MIT license.
And all the components also are open source, we and an MIT license.
So, you have the all the links here.
And also as I said, there is this this cluster.
That will be open also at this part to the public.
Okay.
So, if you have any question.
Thank you.
Yeah.
Hi, thanks a lot for your work.
I really assembled your MIT PC and called a decol code and my own project.
Yeah.
I needed to build an MIT PC matrix, optimize it.
So, I wrote your MIT PC code and I wrote an MIT code and so I can build a GPU.
So, process this project because I have a lot of GPU power, but not all of it's GPU power.
Would you be interested in microtubulating some of this call back to the project?
Sure.
Definitely yes.
We work on that perfectly.
This is why our code is on GitHub so that we can integrate that.
And also why we use an open source license.
We are really interested in making a connection.
Yes.
Okay.
Just send me an email and then we will contact you with the dry people.
There are some yes.
This is not the main focus for some part of the team.
At least for the people that are working more on the communication layer.
There are more on using CPU or FPGA or so.
But GPU is still in the option because for simulation, GPU is probably the best option anyway.
Okay.
Perfect.
Thank you.
Yeah.
That's a good point.
Of course, we are aware that we are doing this.
The main idea is to have a very small code base that we can hack easily or need.
There is not much to that.
Just a little bit more control on what we do.
This is just one project next to another project.
And also there are some exchanges between the project.
Yeah.
You mentioned, I think it's a, you probably still do you.
Yeah.
The idea is that it allows you to map the,
Can see blocks and the possibilities.
Yeah.
We have some dynamic.
I mean, is this project still not quite time?
For no yes, but we are working on having a dynamic building or so.
In the team, we also have a user on time system that are already doing dynamic.
Excuse me.
Do you have the idea to address the blue?
No.
To map.
Yeah.
The way it's.
Yeah.
Did you read the code behind that?
Did you read the codes?
Can maps if it works to the different.
Yes.
For no, we, we use prior knowledge.
So we know that, for instance, one task will be large and one task will be small.
And then.
When you develop, actually.
Yeah.
You need to know this.
And you will map your sources.
Yeah.
And the processing based on your actual knowledge of the.
Yes.
Yeah.
And this is still not.
Design time.
Yeah.
But this can be configured quite easily.
So you will just have to compare now.
And you know, my question was the fact that.
The point I had in mind was, do you.
Can we do.
Pack up.
I mean, you have a.
The main person.
You change.
Mm-hmm.
The box.
And you have a.
A failure.
And you want to have a.
The.
Yeah.
We're.
Yeah.
We're.
Yeah.
And also we're.
We're working on.
And that's.
And being able to.
To have more.
More control at runtime.
So having.
For instance.
That's that may not be always of the same.
You're sure.
Or.
For instance.
If.
You know, you're you are in a situation where you are.
A lot of knowledge.
And then you move and you.
You have less noise.
So probably some.
Contation would be less.
It's a.
So.
We work on.
Having a way to.
Exactly and.
Somebody.
I sort of said.
Didn't tell the.
But.
But what.
That is.
Right collection materials.
Yeah.
We have.
OK.
And if.
OK.
If.
But.
OK.
And then one.
And I.
So.
And it.
The.
It's not a bit of a change, or it's an awesome bottleneck.
So from the way I understand it, that you stop, change the code, we compile, and we run.
So we stare at each other tools to steer what's going on.
Yeah, yeah, yeah, yeah, there are tools to correct me trees and display the cost of each task,
and see which task is taking a lot of time, and the chance you put it to clear the number of things.
Yeah.
I'm curious about it, might you please?
Yep.
So, did you develop the activities to me?
And you put the 26, is there an influence?
Like, one way or the other, do you already look into, how will it look like?
And it's going to have to be used for that, or instead, like, far out of the future?
So, so, I'm used to the beginning.
Also, you have your, I might repeat it like that.
Yeah.
And it's a nice job by messing my instructions to the vector extension.
Yeah.
The space of things you've lost, but there will soon be a thing.
Yeah.
And then that's because I know that there is a thing.
Yeah, at some point, if the C++ instance,
those, all that we need, we can just forget instead of me.
We did the work on me, basically, because when we start working on effect, we didn't have
an alternative that we are fitting, but we needed it.
But as soon as the need is completely fulfilled by C++, then we just move to C++ and that's it.
And the other thing is, like, in the past, they have a lot of problems.
And they, like, have a part of the different projects.
Yeah.
And all of them, especially about, I guess, how you want to treat the use,
because that is in place, because it's really quite nicely,
and you just want to have, like, the end quarter of the quarter.
Yeah.
So, you have a work course, an idea of how we can, like, the printed use,
so it's easy to integrate it into a, and other projects.
Actually, the, all the modules are no separate it.
So, the first, the, the stream view part was part of the effect.
It was just a one piece of code, and then we extracted it and no,
stream view can be used as well.
So, I didn't present that here, but we have,
a work on using stream view, for instance, for astronomy,
for processing astronomy.
There has been already some, some work on detecting,
meteors.
So, change that used the DVB as to,
system to, to collect some, some video,
and detect some meteors in the, in the video.
And also, since there's a,
a change of task, what is in the task is a,
a convenient component of SGR or communication,
so you can put anything that, that you need.
So, that could be AI for instance, or whatever.
Contدمist was curious about the SEC Marks,
So basically, I want to, like,
logistic and important before hearing and the,
for what gravity tries to remove all the,
a monthly printing and what not.
Just to use the helicopter we use.
So, that, you can do that.
If you don't know the, effect,
the effect is no, the set of modules,
for why you are quite soon, so you have a series of schemes that are implemented and you can just target the schemes directly.
Well, if you look at the way that the chains are built, you can see that there is a little blue in the effect part itself.
Everything, almost everything is in the stream view part. So in the effect, you just have routines and classes and you just feel your data to the classes and methods and then you get the results.
I think you are not very difficult. I don't know if there are examples exactly on that point, but it's not very difficult, I think to do that.
So in this part, I will not be able to answer it, because I am really on the computer science.
But well, from the letter I know about the filter, I think that would be okay, because that's the purpose.
It's really the idea to find the data or feed some information and we use it, or loop for some things.
So again, there are just blocks and tasks and what is inside the task is quite free.
So you have two possibility, either you can use a pointer that we followed, so then it is zero copy or if you need to change the data, because you decode and it's larger or it's not the same type, then you can change the type.
So this is already the same type as in the other foot of a task, so it's completely free.
Yeah, yeah.
Yeah.
In the simplest part, there is only the synchronization between the blocks. In the Julia part, you have the override of calling Julia and entering the Julia context.
And also if you are in this version, you have also the cost of the error management of Julia, which is quite important.
So this is the main source of override here, but the synchronization is what you have mainly in the simplest part, you just have the blocks between the task.
So you cannot really have unless you go to atomize or to those are means of synchronization, but I think not many other alternatives to the data.
Okay, so I think it's time to get a break and about to have lunch also.