National Energy Research Scientific Computing Center (NERSC) Parallelware Training Series: Motif-guided Parallelization of ZPIC with OpenMP and OpenACC, Oct-Nov 2020, 12 Nov 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: 6 Parallelware tools demo

Description

Part of the Appentra Parallelware Training Series at NERSC: Motif-guided Parallelization of ZPIC with OpenMP and OpenACC, October to November 2020.

Please see https://www.nersc.gov/users/training/events/parallelware-training-series-oct-nov-2020 for more information and presentation slides.

A

[Instructor] okay,, so hopefully you are seeing now the new machine, client.

A

That I'm running and you connect to cori.

A

I opened a terminal here where I loaded the module files.

A

That you have listed in the slides., you can see them there, but you can get the list of them over here, the trainer.

A

And the analyzer on the gcc compiler.

A

With support for openacc., I have allocated a gpu now that I'm actually running.

A

And I will run the demo, again, you can see the commands.

B

[Participant], sorry to interrupt., can you make slides the window bigger and the fonts a little bigger as well?.

A

[Instructor] hopefully,: this is better.

B

[Participant] and that's windowed stuff is not full screen and then the terminal is just half of it.

A

[Instructor] yeah,, it's kind of intended.

A

So later I can open a trainer.

A

But it's nice here?.

B

[Participant] yeah, yeah, thank you.

A

[Instructor] okay, yes, interrupt me anytime.

A

It's not clearly that the sound of the images.

A

Okay,, so I was saying we are on a gpu node.

A

We have printed and analyzed loaded, so we will start doing a demo of parallelware trainer.

A

The first of the two products that we presented.

A

So the first thing I will do is I will just allowance parallelware trainer,.

A

Can simply do that by invoking.

A

I will also make this up here.

A

Let me know if it's too wide for your screens or anything.

A

Hopefully it's okay., so you just seeing an screenshot.

A

Of this graphical user interface that the parallelware trainer offers., it's kind of like a lightweight, integrated development environment, where you can just open.

A

Any source folder that you have any project.

A

And start experimenting right away with different parallelizations. and it's divided in the projects explorer,.

A

Where you can just wrote the different source, files, click them out,, create any file like any id, editor and just the version manager.

A

That we have several consoles here on the bottom.

A

So the parallelware trainer,.

A

It comes with a glossary that comes in handy when you are learning.

A

So, like I said before, the trainer is intended for experimenting and learning.

A

Then a more advanced user will probably be more comfortable.

A

With parallelware analyzer that offers this and some other features.

A

Then here you can browse different terms and get different levels of details.

A

And it also comes with some bundle examples that you can install from here..

A

So I will just do that.

A

I will do this in the scratch.

A

Okay,, so it confirms that it was successfully copied.

A

The example folder there.: I will just open that folder right away.

A

So this is the folder I've created just now.

A

And here you have different folders, okay?.

A

The text folder have different examples for what manuel show before, where you can get.

A

For instance, defects and recommendations.

A

Will quickly show this. so again you have all this information available.

A

Inline in the parallelware trainer that defect.

A

Or these are the recommendations, here.

A

But I'm interested now in showing you a demonstration.

A

With a pi code example., so here you have other codes, we will use mandelbrot a layer.

A

For analyzer- and you have these three examples that cover the basic quick start with trainer.

A

So it's something, high. You will see.

A

That there is a readme file where it shows different features of analyzer that this example will cover..

A

So by going through these examples in the quickstart folder,, you can get an idea of all the features offered by analyzed.

A

So right now we will work with this pi file..

A

I just doubled click in the project explorer., and it shows here on green circle, which is an opportunity for parallelization., but before parallelizing it. I want to execute this and see what the sequential version,.

A

What performance does it have?.

A

I will just check here..

A

I will increase the size of the problem.

A

So it takes a little bit more time. I use my laptop, which is slower and you can just click run.

A

Of course, we just opened a folder with source files.

A

So I turn it doesn't have any idea how to build and run your code. So we will fill that information.. We're entered the make file, the make command. Sorry.

A

And then the make run command, program, click, okay,.

A

And then it will first be lit and then right.

A

So you see that in it's dedicated console.

A

You see the output for each states., so this is the output for the build and then the output for the run., so it took over one second to execute.

A

The sequential version of the code., so let's see what trainer can do for us.. Let's click the green circle.

A

We've seen before there are a bunch of options here we can select for openmp/ openacc standards,.

A

Cpu, gpus and different paradigms.

A

just leave it as it is try with the follow options.

A

What the parallelization looks like., so maybe you've just noticed that a version.

A

Was created here on the right in the version manager., you can at any time restore the version, clicking on this button or create a new version here.

A

For instance, we will create now a pi_omp new version.

A

So one of the key things that you can do with trainer in a very quick way is to switch back and forth between different versions and perform experimentation.. So let's experiment with this paralyzed version of pi.

A

So I would just click run,, it is building again the executing., and now we see that the time is slightly over half a second, okay? before it was one. Second, now it's down.

A

To a little bit more than half a second.

A

Okay, so now we've covered the first parallelization.

A

We can make some tests here to see what actually,.

A

How many threads they are being run here.?

A

I will add these prints.

A

You get that information with, all right,.

A

So, let's try out build it. Again.

A

So this is inside of the parallel region,. It's thread is reporting the total number of threads.

A

In this group, which is four,, that's great., but parallelware also allows you to customize.

A

This using environment variables, which is, sorry,.

A

Which is quite typical when you are using openmp.

A

So we can just enter here a smaller number of threads.

A

And now, when we run again, it will update.

A

Sorry, I messed with the output..

A

Are we clear just to make it clear?? So I run again- and here you have just two threads.

B

The time increased a little bit.

A

But not so much.

A

okay,, so I just wanted to show.

A

How you can easily set up here., I will remove it now and let's go back.

A

To the original version., so we have saved this parallelized version, here.

A

I will not restart the original.

A

My work has been wasted, since I created that version.

A

And let's try it with a different parallelization.

A

So I will stick with openmp for multi threading for the cpu., but I want to try a different strategy before by default. Parallelware trainer.

A

Use a reduction over the some variable, but right now we want to try something different and see if it makes a difference in performance.

A

So I will use something called explicit: privatization.

A

Which, as using right now., it is creating a private variable.

A

But that's what production does behind the scenes.

A

Is this private variable that is private to each of the threads running parallel.

A

I will just click run now. We see.

A

That the time is pretty similar, okay?.

A

So if we wanted,, we can again set this version like by a explicit, for instance,, explicit privatization.

A

I will restore during the session again and try something different. This time.

A

we have another strategy which is atomic protection,.

A

Which will use their atomic clause from openmp.

A

So, let's see,, what does that look? Like?.

A

It's this panel right here.

A

So we hit around,, we can see that this is taking already.

A

A little bit longer to execute.

A

and as a matter of fact,, this is quite inefficient, because this process a lot of synchronization between the threads.. Since I don't want to spend too much time.

A

With the demo,, I will just stop the process, but this can go on for quite a few seconds.

A

So we can stop the task at any time in here.

A

And aborted up there 27 seconds., so this was way, way worse than what we were doing.

A

Okay,, so back again to the original: let's try something different again.: let's keep experimenting with different options that we have in trainer..

A

Now I want to go for the gpu.

A

So I will have to change the combined common because I don't have in there make file the instructions to do the copulation with offloading..

A

So we just enter here the comments before, gcc-. If I go with openmb,, I need to specify.

B

First, you can update your make file here.

A

Okay,, hopefully, I believe correctly.

A

Let me just try one second, okay.

A

That seems like the syntax is correct, right., so back to the parallelization options..

A

So now I will try openmp path.

A

With offloading to the gpus.

A

Okay,, so here we have the directives.

A

Because see what happens when you run this.

C

Well, actually, it's worse, but I think it's because I forgot that you need.

C

To run it through as run.

C

So that it takes advantage of the gpu, on cori.

A

Well, that's what the difference is still over three seconds.

A

So it seems that for this computation.

A

The time that we got on the gpu is worse, okay?.

A

Let's try with openacc, see if it makes any difference.

A

(Keyboard clacking).

B

Oh, sorry,, I forgot, I have to chance the flag here.

A

From openmp to openacc.

A

Otherwise, this nevermind.

A

That flag and clear this.

A

So it seems that the openacc implementation.

A

Turning out a little bit, better. [participant] so now comment here on gpu with gcc compiler.

B

Is not as good as the other compilers I mentioned.

B

In my talk, which is via for openmp.

B

And an hpc sdk for open ntc.

B

So this is just for,, you know, grab devs and code of modification purposes,.

B

Use gcc is great, but for your performance, please use other compilers.

A

[Instructor] yeah, absolutely right.. I get the same applies like you said before, for openacc,.

A

I mean, depends on the exact terminology,. Do you want to change your compiler here? We're just doing all the demos would gcc, but that's absolutely right.

A

And you should pay good attention to that.

A

Okay,, so I know I'm spinning a little bit.

A

We are a little bit tight on time, but hopefully you've seen the different options.

A

That you can perform or you can implement.

A

With parallelware trainer different parallelizations and how you can quickly switch between different versions.

A

Here I just saved one of these versions, but we can just restore it. Again.

A

we'll have created more versions, as I did different parallelizations., and the key here is that you can experiment, and you can also dive in these terms here.

A

And have these glossary, which is really, really handy when you're learning and you're getting started with this course? Making quick modifications.

A

You also have the defects and recommendations that should guide you whenever you make an important mistake.

A

Or something that we can detect., so we hope that you benefit from all this.

A

So I don't manuel if you have any remarks regarding trainer.

A

Or we shall move to analyzer?.

C

[Manuel], I think we shall move to analyzer..

C

I think this covers the basic usage to experiment.

C

With the trainer using the cpu or the gpu,.

C

The versioning system., so I think it's covers the basis of the usage.

C

Of the tools, so I think it's good, thank you.

B

[Participant], it's great,. Thank you for that. yeah,. I think it covers what we need to learn. Firsthand.

B

[Instructor] right, okay.

A

So, let's move back to the here.

A

Again, we are still in the node. we executed parallelware trainer from there, so we could run.

A

The commands directly on the gpu node.

A

Of course, more remarks along the lines of the compilers.

A

This may not be the best practice for your scenarios.

A

You may be interested in cpus or building on the learning nodes..

A

So bear that in mind that here we just want to make.

A

The demos as fast as possible.

B

[Participant], can you increase the font size a little bit again, please?.

A

[Instructor] yes,: this is better?.

B

[Participant], it's better if you could make it even bigger.

A

[Instructor], let's see if it hits in the screen,, I hope so. yes, feel free to interrupt me again. If it's not okay.

A

So, going back to the demos,, we've been seeing the funcionality that parallelware trainer had.

A

Now this functionality is available in analyzer and some more., so I will move to the same examples.

A

That I installed with parallelware trainer.

A

So,, you can see again what we've seen before.

A

Perhaps some examples here for the checks.

A

There are three of the biggest start and some other codes that you can experiment with.. So right now I will focus on mandelbrot.

A

And is just a simple single file,. Let me see.

A

And like manuel presented before.

A

Parallelware analyzer is composed of four tools.: it's pwreport pwcheck,, pwloops and pwdirective..

A

So the first tool that we recommend is pwreport,.

A

It is the entry point that provides high level reports that should help you get an idea of what the code looks like.

A

Here is a simple code, mandelbrot a single file, but this works as what we see at the end. It will have enough time for large code, bases.

A

In this case, we will see the code coverage summary.

A

Of the analysis and then a summary of what it has found.

A

in this case,, one recommendation,, two opportunities for value: section,, okay?,.

A

So one of the key things is that we want to always suggest.

A

Where to go next, again, pwreport is the first tool.

A

That should use the entry too.

A

So if you want to get some details.

A

On what is not analyzable, for general recommendation,.

A

If you are interested in the defects and recommendation,.

A

It tells you to use pwcheck and for opportunities, pwloops.

A

So, let's start by using pwcheck.

A

(Keyboard clacking).

A

It reports here- one recommendation- would be this one over here and then a summary on the bottom of all the different recommendations, in this case,. It just detected this one.

A

It is telling you that you should rather pass the individual.

A

Extract fields as parameters instead of the whole metrics.

A

We can also tweak the code a little bit to show you an example of another recommendation.

A

So what we will do is this either variable here.

A

I will move it outside the loops,, the declaration.

A

Here can I guess.

A

(keyboard clacking).

A

That should be enough., so around pwcheck again, there you get the new recommendation, okay?. Now it finds a couple of them. So I can do some of it.

A

So here you have it., it is telling you that you should move back to declaration inter to the innermost possible scope,, which in this case is where it was currently defined for a defined before right here..

A

So this is another example, one of those examples that manuel went over before.

A

That is really interesting in many, many scenarios, okay.

A

So this is a quick claims or what you can get with pwcheck.

A

Also very mind that we are seeing this case recommendations, but it can also report defects..

A

This is very useful, for instance, when you want to use this tool in any scenario.

A

Where you integrate these, for instance,, a continuous integration and continuous delivery, system,.

A

Such as jenkins., so in it's pull to your git repository,.

A

You will run pwcheck and ensure that there are no data races.

A

One of the analysis that pwcheck has is a data race.

A

Analysis, we love to do a csv file.

A

That you can easily process., so one of the targets is that we easily integrate with these kinds of tools that allows you to automate.

A

This kind of checks, like for instance, the data race analysis,, so that the movement issues regarding the gpu.

A

So, back to what pwreport was telling us before.

A

We can now try pwloops., so I just know it was talking about how we can use pwcheck.

A

To detect effects, but we're going to need recommendations.

A

This will be like the first stages,, the stage number one,, the manuel introduced before,, which was preparing the code for parallelism.

A

So you would rather use these recommendations.

A

To prepare the code at rest, those that are for instance, in your hot spots, in your code, that you need to prepare for instance, to bring to the gpu, okay?.

A

So we will be preparing the code for parallelism.

A

Now that you have identify those hot spots,, follow that recommendations to better code.

A

Now we are done with the stage one now I want to move to stage two,, which consists in creating an parallel version of your code.

A

So pwlooks can help you with that..

A

Let's execute pwloops for the mandelbrot file.

A

I will provide a report with the different loops.

A

That defines in the code and different properties.

A

So the first properties, whenever we can analyze this code.

A

This means that the language features present in the code are supported by parallelware..

A

So, of course, it's a requirement.

A

That we are able to analyze the code., they need codes which compute patterns we have being able to identify the code.. So this is a key just to allow us to gives you.

A

An opportunity for parallelism. so for instance, in this case,, we detect that there is a forall pattern and a multi threading opportunity here in mandelbrot, at line 30, okay?.

A

And we also provide you with information that we can parallelize it with the two pwdirectives.

A

This is what this means here. and also there is no value for the parallelized column, in that there is no a directive use of primary.

A

This is not a loop that it has been already parallelized, okay?, so say that we are interested for instance,.

A

In the loops in this function, mandelbrot,.

A

We can use the different sub analysis available in pwloops.. One of the useful analysis will be the data scoping analysis,.

A

Which provides more detail about the different variable issues. I will filter here. The manedlbrot function.

A

Okay, so lots of information which are for each loop, here, we'll have one on line. 30.

A

Another one at line 31 into the variables.

A

That are part of those loops and what kind of variables there are, what kind of uses is there are in that loop.

A

When it's, for instance, for height, read, only. use for the variable.

A

Code, it is a read and write whenever the variables have temporary, which is key for some operations.

A

When we are producing code,, whenever we detect a forall pattern,, what kind of memory pattern we detect,, for instance here for the output array, which is written normally, there's a formal compute pattern.

A

And these are all major axis. and then some information about the open fields.

A

Is the openacc pragmas.? One of the great feedback that we receive is that this simplifies anonymously.

A

The job of those people who have to parallelize code.

A

And spend a lot of time analyzing the different.

A

Data scoping of the variables that are in a loop, which is a key step before you go parallelize.

A

By inserting, for instance, directives.

A

So, yeah, along these lines,.

A

You have another analysis which maybe of interest.

A

It is the memory footprint analysis.

A

So I was showing you over here,. Let me scroll up a bit.

A

That output array is of very much interest.

A

And in the memory footprint analysis,, we can actually see the array ranges.

A

That they are accesses in this case for rating.

A

This again is very useful information when you are paralyzing and you need to know what pieces of information are involved.

A

Not always the whole arrays written to read from.

A

Maybe only a subset.- and this is key for instance, when offloading to the gpu,, because you want to minimize, sorry, data transfers.

A

And the movements that are between the cpu memory and the gpu memory.

A

And then there are other useful analysis here.

A

for instance,. I did talking all the time about the code.

C

[Manuel], while you are typing essentially with these features,, we are exposing.

C

The core of the parallelware technology that classifies every single access.

C

Pattern in to each dimension or every single array in your codes., so there is a lot of opportunities for improvement.

C

On our side on the preciseness, precision of this access pattern description, but we wanted to expose it in this course.

C

Because we think it's a good tool to understand.

C

Or to help in moving data to the gpu.

C

Because you need to know what arrays need to be moved.

C

But somehow you also need to know why or when analyzer or trainer are able to determine.

C

The rate ranges,, you need more information of what array references could not be characterized properly.. So this is the kind of sequence of invocations.

C

To parallelware tools that we are designing to help you in that regard. and the difference between memory, access patterns and memory footprint is that memory access patterns we try to collect, describe precisely your order.

C

Of all of the access to the array. so go major dictates the order at runtime of access to the elements.

C

While memory footprint,, what is interested.

C

Is in what elements have been in touched, read or written.

C

Because, essentially, you don't want to know the order you want to know the subsections of the arrays.

C

That we need to be transferred to the gpu. no,. It doesn't matter the order in which they are processed in the loop, okay?.

C

So this is the first time we expose these to analysis, which we think will be helpful.

C

But just make your work. That is the first time we exposed.

C

We are working to improve the robustness and the precision.

C

Of the access pattern, description that you will find there, okay?

C

just for clarification.

A

[Instructor] okay, right., so what I did in the meantime,.

A

I just involve this code sub analysis of pwloops.

A

For the function mandelbrot., so we could see the code itself.

A

And this case annotated with a p which stands for a parallelization opportunity.

A

In this case for multi threading., so this is the output bright.

A

That we have been talking about.

A

You just seen the information about which ranges.

A

It is written to,, as you can see,.

A

It is not that self evident or so obvious.

A

And also all the data scoping for this look would be seen.

A

In the data scoping use case over there.

A

Sorry, I scroll bit from this a little bit too big.

A

So this is what I was referring and again, the output variable. That was just referential.

A

So, okay,, there are a lot more options,, some more use, cases,.

A

For instance,, going back to the main pwloops analysis,.

A

You can see that there are a couple of loops that are no analyzable.

A

for those cases. You also have a sub analysis.

A

Can be that the loops.

A

So to see, in some cases there are some minor issues.

A

That can be fixed, as in this case.

A

It is that the pointed to extract this cannot be analyzable is our classical limitations.

A

That some cases we can overcome and in other cases without.

A

But we hope to provide some useful messages to these use case to see if you can improve the.

A

Code coverage of paralllelware. okay,, so I know we have seen through other groups.

A

That this one right here may be a good opportunity.

A

For a parallelism and in this case for multi threading.

A

So, let's just give it a try.

A

For that again, we are in a stage two.

A

We want to parallelize the code.. We have our next two, which will be pwdirectives.

A

So pwdirectives you have some options here.

A

That correlate to those that you've seen in trainer..

A

So for openmp, you can parallelize for multi threading.

A

For tasking, usually couple different options.

A

And the same for uploading without teams.

A

And you can also generate directives.

A

For the openacc for the gpu.

A

So in this case,.

A

The look that we are interested in is this one here.

A

Mandelbrot at line thirty.

A

Which is the multi threading opportunity., and it is telling us here that pwdirectives supports it.

A

All right, so we'll try this and invoke pwdirectives, okay.

A

I will use the output file option,.

A

Out-File called mandelbrot opm.c.

A

There's no need to specify openmp will run with the default iterations, okay.

A

Let's see what's happening, file.

A

But they must, like you've seen before in trainer, we have the code with the directives generator for it.

A

So again, we can try to build this with fopenmp.

A

Let's just execute it with a program size of 3000.

A

Well, they have not done we'll do that for now is execute the sequential version, which is the mandelbrot.c.

A

And let's see how long does it take.

A

For the same problem, size,.

A

Right, a little bit more than, than twice as much.

A

So this a default first parallelization seems to be working.

A

For these particular algorithm, which is great., this is similar to what we have been doing. The trainer.

A

In the graphical interface.

A

so, like I said, before, pwdirectives has more options,.

A

We could try some other different options.

A

For instance, we can parallelize for, sorry.

A

I will now pass, generate a new version.

A

In this case, I would say, openmp gpu.

A

So, let's openmp flag and tell you.

A

That we want offloading.

A

So,, you see that in this case, sorry.

A

So the key here is that for the gpu will need to transfer.

A

The output by dimensional array.

A

And this is tricky because there is no deep copy, as we talked about before the presentation.

A

So we have to use enter data then do the computation.

A

On the gpu and then the exit data., so we can copy the continuous segments.

A

Of this non contiguous memory structure to the gpu.

A

So the all the data is probably not back and forth the gpu.

A

And finally,, let's see just a different parallelization.

A

Also for the gpu in this case,, let's go with openacc,.

A

The name of the output file.

A

Okay, so let's take a look.

A

Here you have the openacc pragmas.

A

Okay, for these,, like we were talking before for its technology or platform.

A

A hardware that you target, it is a different recommended compiler.

A

In this case, I will go with nvidia sdk.

A

To use the former pgi compiler.

A

and I will compile this for openacc,.

A

I will get some information about the parallelization process.

A

So here we have the information from info.

A

Telling us what it has parallelized.

A

Let's try it for the gpu. We need to use srun.

A

And you have seen that right now.

A

It was way faster than all the previous versions.

A

Either the sequential one of course,.

A

And the one parallelize openmp.

A

Well, I have changed the environment, but yeah you've seen it before.. So in any case, case, the gpu.

A

We are over less than half second.

A

And this version,, we are about three seconds.

A

So these are the different uses of different tools.

A

Of parallelware analyzer, we have seen the stages one and two. Now you would go to the stage three,.

A

You could run again pw check to see if there are any recommendations regarding optimizations.

A

for instance,. We've got in the gpu data transfers.

A

That will be a typical case, and also check for correctness and say that now do tweak any.

A

Of these directives that pwdirectives inserted for you.

A

And you introduce own mistake for instance, incorrectly sharing a variable.

A

And introduce the data race., so that's where pwcheck can help you again by reporting.

A

That databases to you.

A

okay, manuel, any remarks here?.

A

Do we have time to see some of the advanced features.

A

That analyzer has or shall we.

C

[Manuel] remarked, remember that to come to the stages., you should have completed the stage one to prepare the code of parallelism.. This is what we are assuming in many of these demonstrations.

C

Where you can benefit of parallelware tools of the performance of the different implementation for the compiler, supporting openmp and openacc., so this is this stage number two: where you really don't care about performance.

C

we have shown you cases that speed up you'll have.

C

Cases where, if you're not careful enough.

C

You can generate code that slows down, because you are a stage two and then we will not have today to go through a stage three optimization..

C

So I hope that in the hands on and during this two weeks, we have time to interact with you to help you with the three stages of the code.

C

and just I would say, javi, at least five minutes.

C

So that they can see the tools.

C

The parallelware analyzer running on bigger code bases.

C

I think that that might be useful, at least to show it very,. Very briefly, without going to into many details.

A

[Instructor] okay,, so let me.

A

I will just show a quick option: here, sorry.

A

So I was telling you before that integration is important..

A

I mean, one of the use cases is integrated, for instance,.

A

With jenkins., so you may variable want to get this report in some other form.

A

So for instance, we support json and csv outputs.

A

So you don't have to reliable on a console, reports, okay?.

A

So some other features that manuel was mentioning,.

A

For instance, running over larger code bases,, let's see here,.

A

For instance,, the nas parallel benchmarks.

A

In this case, openmp parallelized version.

A

Which contains some more files.

A

We can analyze this also with the natural first step.

A

Would be that we report.

A

I already know that I need some common folder here.

A

What I'm doing here is something that we have not seen.

A

In the demos before is that we need to pass.

A

And include the directory to pwreport.

A

Because it needs to have access to all the includes header files that are consumed by the source code..

A

So in this case, there are some header files here in common, so we just use gcc and clang style, syntax.

A

To tell it that it should look there when it is analyzing other code we're running short of time, but otherwise I would show that when you do not pass this,, you can get a report with the errors.

A

That you will see that, okay?, you are lacking some header file, so you will get to add this flash yourself.

A

Cause this is more like...

B

[Participant] we can use the thursday time and to show more of the advanced features after your homework. Demo.

A

[Instructor] all right? sure, sure, that makes sense.

B

The other two pictures I was intending to show.

A

Is that you can use cmake built.

A

To get information on these hidden files that I was just talking about, but here are some results that you have, for instance,, we'll detect that there were 10,000 lines of code parallelized over the 25,000 lines.

A

We find a pretty large number of recommendations and opportunities for parallelism.

A

and we can even guarantee not only detect that some groups contained data races that also guarantee.

A

That some loops are data race, free, which is quite a hard problem to solve.

A

We can do that in many cases.

A

So manuel,, do you want to see something about a cmake or multi file or some of these features.

A

Or like she suggested leave that for another day?.

C

[Manuel], I think we should move it to thursday.

C

just mentioned here that we have shown capabilities.

C

To work inside a function, one file.

C

But in big applications you will have to address other technical challenges but these,.

C

How can you analyze code where the functions are spread.

C

Across multiple files?, so we have features for that..

C

How can you interact with build systems.

C

Because analyzer and the parallelware technology need the compilation flags.

C

so, instead of having to type them all,, we can interact with cmake databases, to read those flags without you having to type them.

C

And replicate them for the input of the analyzer tool.

C

So the region would be systems and also the tools are designed.

C

To be integrable with a continuous integration,.

C

Continuous delivery of frame works.

C

so like jenkins, that are usually based on invoking.

C

Scripts at contain commands to common tool., so these common tools can be one of those tools.

C

We need to study, analyze yet ways for tighter integration.

C

With different types of continuous integration,, continuous delivery systems, but we are working in that direction., so if we have time,, we will go demonstrate.

C

Those have advanced features for pi code basis on thursday.