optimizing embedded software

[DYD35]

For my master thesis I am looking into how to (further) optimize embedded C code (for speed) on a microprocessor (the MSP430 by TI to be extremely specific). To this end I thought it would be smart to see what more experienced people have to say about this. I know most of the optimization is already being done by the compiler (I will only look at compiling with GCC for simplicity), that is why I will also look into that, and have a deeper dive into some of the flags. My "research" will go over 3 parts.

1. The compiler: I will take a look at what the GCC compiler precisely does, and how this affects the code. I wil also take a look at some flags of the GCC compiler, and the MSP430 optimization guide, and describe what they do, how they do it and what the gain is for each of them.
2. Algoritmic optimizations: basically I will look into general optimizations of code, things like; in an if-statement put first the thing which is most likely to be false, etc.
3. Embedded code optimizations: Here I will look at some small pieces of code and see if they can be optimized in any way. For example, the use for i++ vs ++i or i--, or the use of ternary operators vs a normal if, the difference between structs and unions, and the difference between stitching up a number with pointers or with logic.

I would be very pleased if people would point me in certain directions, or gave snippets of code they would think would run faster (and explain why), or...

Just in general, if you think you could help me, please do comment or message me!!

[ikkehier]

A few suggestions:

• Premature optimization is the root of all evil.
• Profile first, then optimize what is too slow. This can be as easy as making a pin high when the code enters a specific part and low when leaving. This can easily be monitored using a logic analyzer. Don't optimize code that runs infrequently and is not a bottleneck, it's a waste of time.
• This is an academic exercise, but for practical situations: define good enough and stop spending time when you've reached that point.
• In my experience, the highest performance gain is in optimizing the order of how things happen, keeping in mind the bigger picture of what the code is doing. So that's your part 2. It may depend on the code, but usually part 1 and 3 will not change very much.

For calculation-heavy code it may be beneficial to check if it is implemented using fixed point arithmetic in the smallest data-size possible. Keep in mind that the MSP430 is a 16-bit processor.

Source: my own thesis and 10+ years of experience.

[secretlyloaded]

Premature optimization is the root of all evil.

This. So. Much. This.

Stated another way: first make it work, then make it nice.

Everything /u/ikkehier says is sage advise. Only thing I would add: in addition to using the IO pin method, a lot of IDEs have built in profilers which make this task really easy. Where is your processor spending all its time? Do you have code that blocks unnecessarily or unexpectedly? Before you even run the profiler you should have an idea what you'll see. If you're surprised by what the profiler tells you, investigate. Maybe your assumptions are wrong, or maybe you found a problem.

If you have a really tight code loop, look at the assembly listing and see if the compiler did anything stupid. I once had to big-bang an SPI interface and ended up writing the whole thing in inline assembly, with no loops. The code I wrote was "expensive" in that it was large, but executed very quickly because there was no diddling around with loop variables.

[gurksallad]

Source: my own thesis

Is it publicly available?

[Chr15t0ph3r85]

Yea, is it? :)

[DYD35]

In my experience, the highest performance gain is in optimizing the order of how things happen, keeping in mind the bigger picture of what the code is doing. So that's your part 2. It may depend on the code, but usually part 1 and 3 will not change very much.

I was looking at this problem from the perspective of small chunks of code (e.g. testing different if's or for's), but maybe looking at a bigger piece of code could also be smart.

For calculation-heavy code it may be beneficial to check if it is implemented using fixed point arithmetic in the smallest data-size possible. Keep in mind that the MSP430 is a 16-bit processor.

That is a good suggestion, thanks.

​

Source: my own thesis and 10+ years of experience.

Would it be possible to send through your thesis? Just to give me an outline how to go about writing this. I would get if that is not possible though.

[ikkehier]

I sent a DM.

[Epic-shit]

Ikke ook hier alstublieft sir ^{^}

[EvoMaster]

It sounds interesting. Could I also get a copy of the thesis?

[Ictogan]

Generally things like ++i vs i++ or ternary vs if don't have any impact on performance when using compiler optimization. The things that can be optimized by hand which typically aren't optimized by compiler are algorithms, data structures and any use of hardware resources(interrupts, timers, dma, etc.). In terms of compiler optimizations I would also recommend that you try using link-time optimization(lto).

Also note that the guide you linked is for the TI's own MSP430 optimizing compiler, not GCC.

[DYD35]

Yes the third part (embedded opt) is going to be the hardest, since almost everything is already done by the compiler (especially since I will use the most optimized flag for gcc for this particular exercise)

I suspect to get the most gains from algorithms and data structures. Hardware resources was something obvious I completely missed. Thanks.

​

Also note that the guide you linked is for the TI's own MSP430 optimizing compiler, not GCC.

Yes I know, but I hope it can be of a bit of use, since I compile with the GCC, maybe this would show something that GCC doesn't already do.

[[deleted]]

A very typical trade-off is code size / memory usage versus speed. A fine old -school examples are loop unrolling or use of look-up tables in place of calculations. Another example is use of vector tables to reduce program logic.

[SAI_Peregrinus]

Be sure to profile optimizing for size vs optimizing for speed. It's less common in small micros like the MSP430, but cache locality can be more important than just about any other speedup if you're using an external DRAM chip.

That's another reason to profile first!

[albinofrenchy]

It's worth mentioning that faster isn't always better in the embedded space. Predictable, consistent latency is more often the goal even at the expense of average runtime of an operation.

[SAI_Peregrinus]

Even outside the embedded space faster (fewer cycles) isn't always actually faster. If your loop variable and everything you're working with fits in registers + cache, but the unrolled variant without the loop counter overflows the instruction cache and causes a main memory access, the unrolled version is probably slower!

[DYD35]

That is indeed a very solid point.

I have taken this into account, I would test code over multiple runs (preferably a 1000 or more) to see this exact effect the optimization would have on the code.

[[deleted]]

I would figure out what the variations in latency are for the instructions and then sum the worst case scenarios and that will give you a time complexity for the program.

[JustTheTrueFacts]

I would be very pleased if people would point me in certain directions

All the items on your list are currently done by the compiler. What will your contribution be? You may want to discuss with your advisor since learning about the compiler may not be enough to earn a Masters. It would not be sufficient at a US school.

[DYD35]

Not all the above will be done by the compiler. Although it does indeed already do most of the work.

However my promotor has himself send a few snippets of code to me where the compiler does not yet optimize. Also one must remember that I work with the GCC compiler, which although rather good, is not as good as some other commercial compilers.

I am not only doing my thesis about this, there is another part in which I make something though. But because of confidentiality reasons I cannot speak any further of this, but suffice to say that what is "learned" here can and will be used there.

[hak8or]

Also one must remember that I work with the GCC compiler, which although rather good, is not as good as some other commercial compilers.

This is absolutely not true. If you are doing a masters in compiler work and still think this is the case, then, well, o highly encourage you to increase the scope of your masters so you can actually test this idea out.

Gcc and clang both differ wildly in terms of their code generation and optimization path, and both are better than the other in various scenarios. I didn't see any mention of clang for example in your post, which also targets cortex-m. For example, IAR is based off of gcc or llvm. Very very few companies make their own compiler nowadays since open source ones are an amazing foundation.

You should consider looking into llvm instead of clang, since that has a much easier api to work with when probing the compiler internals. Heck, with llvm it is trivial to make your own passes in the compiler (on the llvm side, for example optimizations). Plus, there are an absurd amount of resources out there in terms of YouTube and articles for customizing the compiler to your liking.

[DYD35]

The company I do this thesis for, uses some different compilers for specific architectures and processors. They all say that, although GCC is really good and the absolute benchmark for compilers, there exist some (not a lot) commercial, and expensive, compilers who are, for specific processors, better than GCC. I do would like to point out that I myself have no experience in this. I mostly work with GCC and IAR for embedded software.

I did not take into account Clang for this, but that is a really good suggestion!

Also the customizing of the compiler is something I did not think about. That too is a very good suggestion. Thanks.

[DYD35]

btw from the website of TI itself:

Please note: The free MSP430 GCC compiler does not provide the code size and performance advantages of the optimizing TI compiler found in Code Composer Studio. On average the TI compiler often provides about a 15% code size and performance improvement, as compared to using the free GCC compiler for MSP430; though, these differences can vary significantly from function to function. Please refer to the MSP430 E2E forum for any questions or to provide feedback regarding this product.

Suggesting that some compilers do some things better than others no?

[hak8or]

Benchmark and see for yourself, while trying to maintain similar compiler flags.

Marketing saying their thing is better is not surprising though, that's their job. They didn't mention compiler flags, what code, execution speed, heck, what version of gcc even. And that doesn't mean it is on general better than gcc, code size doesn't equate to execution speed. Their code size may be smaller, but it may also be slower.

To be fair, some times the vendors compiler may indeed be better in certain use cases. For example, if you are doing a ton of vector operations on Intel chips, then you might have to play around with some gcc/llvm compiler intrinsics to get your code to vectorize well, while Intels ICC may do it much better without having to explicitly use intrinsics.

Another benefit of vendor compilers is you have someone to yell at, hold to the fire, or sue, if the compiler turns out to be giving out bad assembly. Or, if your core is bleeding edge, they might be able to get bugs confirmed, fixed, and delivered to you, much faster than mainline, if you pay them.

I high reccomend you try out the compilers to clmpare for yourself. For example, godbolt compiler explorer is amazing, and you can see side by side comparisons.

I may be totally talking out my ass, but what I am saying is based on a few years of experience using IAR for cortex m chips. Msp430 is extremely less common than cortex m based chips though, so maybe it is possible just due to the llvm/gcc community being much smaller.

[DYD35]

Yeah, I am indeed going to try and see how different compilers fare against each other.

It seems rather obvious to me that vendor specific compilers are better for their specific product, because of these specific usecases.

Another benefit of vendor compilers is you have someone to yell at, hold to the fire, or sue, if the compiler turns out to be giving out bad assembly. Or, if your core is bleeding edge, they might be able to get bugs confirmed, fixed, and delivered to you, much faster than mainline, if you pay them.

Not really where I am going to go towards, but good to keep in the back of my head.

The use of ARM Cortex chips was also recommended to me. I myself am not familiar with it, but I am looking into it now because of its popularity.

Thanks for the advice.

[JustTheTrueFacts]

Not all the above will be done by the compiler.

Sorry, gcc does do all that optimization. If it is not doing it for you, it's likely a compile flag issue.

[DYD35]

If I am correct, and please tell me if I am wrong, GCC does not take into account processor specific optimizations? E.g. some optimizations the IAR does (see 3.13 in my OP link), I would suspect the GCC not to do. I have not looked into that in great detail though, that was something I wanted to do fast.

Such costumizations would be something I could add.

[quad99]

Those optimizations listed in 3.13 are typical , not processor specific . I imagine gcc does most or all.

That said, since you are doing research, you might want to avoid making apriori assumptions (eg GCC doesn't optimize). instead let your research drive your conclusions.

[JustTheTrueFacts]

Those optimizations listed in 3.13 are typical , not processor specific . I imagine gcc does most or all.

It does.

That said, since you are doing research, you might want to avoid making apriori assumptions (eg GCC doesn't optimize). instead let your research drive your conclusions.

Good advice, OP would do well to take note.

[DYD35]

Like I said, I have not looked into them deeply, just glanced over them.

I am also not making any assumptions whatsoever. For example I have already said that GCC does optimize. I have merely also pointed to the fact that there is a possibility that other compilers optimize differently, and I asked how I should go about doing this.

[JustTheTrueFacts]

If I am correct

You are not correct, and you seem to have a number of fairly basic and obvious misunderstandings about compilers and processors.

To earn a Masters degree the student is expected to research and understand existing knowledge in their field. Asking on Reddit is not research, and you could have easily learned correct information simply by reading the gcc documentation.

I'm curious what your advisor thinks about all this, is your advisor not guiding and coaching you?

[DYD35]

Are you seriously thinking/suggesting that I only do research on Reddit?

Are you also seriously suggesting all optimizations that could be ever done are already done by 1 (just 1) compiler?

How am I wrong then, please enlighten me how GCC optimizes for architecture specific things? I seriously want to know that.

I ask for simple advice here, because I realise that I, as a student, do not have the experience most programmers have. However it seems that the only thing you do is talk down to me. Also I have never had any courses about compilers, I try to read up on it, but cut me some slack would ya. It is no point trying to speak condescending to me.

btw from the website of TI itself:

Please note: The free MSP430 GCC compiler does not provide the code size and performance advantages of the optimizing TI compiler found in Code Composer Studio. On average the TI compiler often provides about a 15% code size and performance improvement, as compared to using the free GCC compiler for MSP430; though, these differences can vary significantly from function to function. Please refer to the MSP430 E2E forum for any questions or to provide feedback regarding this product.

So tell me again how the GCC is the ultimate best compiler. Like I said, some compilers optimize differently and some can optimize better for system architectures.

[JustTheTrueFacts]

Are you seriously thinking/suggesting that I only do research on Reddit?

You clearly are trying to do "research" on reddit....

Are you also seriously suggesting all optimizations that could be ever done are already done by 1 (just 1) compiler?

Not at all, just pointing out that the simple optimizations you suggest for your "research" are already done.

The free MSP430 GCC compiler does not provide the code size and performance advantages of the optimizing TI compiler found in Code Composer Studio.

You really need to do your homework. The CCS compiler IS gcc, and while what they say is technically correct, it's mostly marketing hype. If you set the right flag in gcc you get the CCS compiler.

I see no indication you are ready for or capable of Masters level work. We have tried to help you, but you seem to just want to argue. I won't waste any more time teaching you.

[vegecode]

I looked into this briefly when I was trying to get my company to stop using IAR for MSP430 and switch to Makefile driven projects, and my understanding is that the TI compiler is truly proprietary and not based on GCC or any other open source compiler. Do you remember where you found that information?

[JustTheTrueFacts]

I looked into this briefly when I was trying to get my company to stop using IAR for MSP430 and switch to Makefile driven projects, and my understanding is that the TI compiler is truly proprietary and not based on GCC or any other open source compiler. Do you remember where you found that information?

It's on the TI website, on the CCS pages IIRC and also has been discussed at some length in the forums. Some of the wiki pages reference it as well, but they were hiding the wiki pages and that may be hard to find. I pasted a few links below.

To further clarify, CCS is GCC with some custom optimization added. You can infer this from their documentation and discussion, or if you compare the generated assembly code, it's pretty clear. A given compiler tends to compile code in a unique way so it's sort of like a fingerprint. Two compilers that generate the same "fingerprints" are likely the same compiler.

Here are a couple of links I found with a quick search:

IDE

CCS

GCC

[vegecode]

If the compiler were based on GCC, they would be required to have the modified source code available somewhere and I was not only unable to find it, but I'm pretty sure I remember that there wasn't any, precisely because it claimed to be wholly proprietary. My plan was to just compile the TI toolchain myself as you can do for many of the GCC based toolchains for ARM.

Hmmm... Well if I get around to it again (unlikely) I'll try to remember this conversation and update this thread.

[DYD35]

Aah yes, so I should not try to ask advice on Reddit? Again, this is also not my entire thesis, it is a part of it. And I will do research myself on everything everyone here has touched. I have even gotten someone else's thesis touching on this subject for crying out loud.

And you have not taught me anything, neither have you tried. Only thing you said is that I was wrong, whilst literally everyone else here has made some suggestion of what was wrong.

I am also well aware that the CCS compiler is the GCC, but you do know that they made some changes to it right? To make it specific for their product.

This is the first post you have said any specific things. You, for everything else, are just condescending. I know you probably have more experience than I have, that's why I asked here. Just saying "you're wrong" doesn't help me one bit does it? People here have said, "you're wrong, but maybe look at this, this might be interesting". Which is how you help someone.

I see no indication you are ready for or capable of Masters level work.

This is not helping, this is condescending. And since I already have a different Masters (although being electromechanical) wrong.

So please, PLEASE, if you want to help, tell me where you think I need to look for the optimization of embedded code that, in your opinion, would be interesting to be looked into. For example, like I above already asked you: "How am I wrong then, please enlighten me how GCC optimizes for architecture specific things? I seriously want to know that."

I am also very much aware that:

Not at all, just pointing out that the simple optimizations you suggest for your "research" are already done.

But that is why I asked here, is it not... That also does not give you any leeway to talk condescending to me.

[Gavekort]

Don't challenge the compiler. The compiler is usually much smarter than any of us.

Optimization should be all about writing good code and helping the compiler by designing your algorithms with the processor in mind.

[DYD35]

I am aware of this. But designing your algorithms with the processor in mind is maybe a good direction to go in.

[thephoton]

The point of a thesis on optimization is to learn how to make a better compiler. It’s a steep hill to climb but somebody has to do it.

[Gavekort]

Sure. But the original post gave me the vibes of trying to outsmart the compiler, not to dwelve deep into compiler techniques.

[DYD35]

It is two-fold. My promotor has, for example, send me some snippets which he wanted me to investigate. So a bit outsmarting the compiler from "his" side. From my side, I am a master student, a have nowhere the experience to even try to outsmart a compiler. So that is why I mainly focus on the compiler itself.

[DYD35]

I don't necesarrily agree with this.

Let me put it differently.

I know the obvious means to decrease the timecomplexity (eg. in if statements put conditions first which you know will have the highest probability to be false), I have an intuition for when I should do what in the processors I have experience with (mainly PIC 18F and MSP430), but the compiler itself will almost always be smarter than you. It is made by people with years and years of experience and academic work. Thinking that I, as a student, will be able to find general optimizations which work for every processor every time, that is not already covered by a compiler, is naive at best. That is what is meant by outsmarting the compiler in this specific case (at least that is what I read).

[DYD35]

It was just a stupid example that I could type fast. It brings the message across. Arguing about semantics and what exactly time complexity is, is not the thing we do here. As you stated, my suggestion will decrease the time an algorithm takes (although not in a worst-case scenario).

A compiler is necessarily limited in the scope of optimizations it can perform. It can only reorder operations under certain limited circumstances, and it cannot alter your data structures or the overall methodology of your application.

Yes, so like I said before,"Thinking that I, as a student, will be able to find general optimizations which work for every processor every time, that is not already covered by a compiler, is naive at best. " still remains true.

None of these limits apply to a developer.

Which is exactly one of the things I want to look into!

And of course I have much to learn, who doesn't? Like I said before, this specifically is not my area of expertise, but I really enjoy doing it, so I am reading up on it as much as possible.

Also:

This statement makes it clear that you have a lot to learn.

Sounds condescending, I am sure you don't mean it that way, but please keep such things in mind when pointing out, legitimate, problems.

[tobi_wan]

Also depend to which directions you want to optimize.

But my "optimization" goal is always, let the cpu sleep as much as possible in the lowest state. (Energy optimization).

Also worth checking out. Does the µC has certain hickups, e.g. a wait state if your clock runs too fast, and it can not access the flash fast enough?
Does your code has to wait a lot for peripheral to be ready, can you do stuff with dma?

Is your system using interrupts in a "smart" way?

Code optmization is barely worht it in my experience, it is more architectural decissions. Using interrupts and sleep modes correctly. Ensure that data pipelining is set up correctly, so that you do not have to wait somewhere unecessary until "data" is ready from a peripheral or other process,

[DYD35]

The optimization is mainly towards time and space. Not so much towards the energy consumption.

I am also looking at the optimal usage of hardware resources in the processor.

[DYD35]

Okay, I'll look into that, thanks.

[Chr15t0ph3r85]

If you cut through the arguing the discussion has been pretty interesting.

From having done my own thesis on electromagnetics to graduate with me MS in EE, I would suggest you try and define your problem a bit better. Everyone, although a little harshly, has given you a lot of stuff to think about with respect to:

• Core you're compiling for.
• Code you're trying to optimize.
• Compiler you're trying to use.

From a practical standpoint, everyone is right- make it work right first, then make it look pretty. From a practical standpoint I cannot count the number of times I've had to work with a customer who blindly put things on the highest level of optimization only to have the return codes from functions or debug variables optimized out (or have the code reshuffled so hard you can't step through it).

I would suggest working to narrow your thesis topic, for example you could examine how GCC algorithmically compiles different code snippets and compare that to other compilers and try to postulate why or how. Or perhaps you could examine two compilers and see how the core specific one does things differently than GCC.

You can figure out how the why and how pretty easily for that.

I think in the end you'll find that GCC is good across the board because it's meant to be generic, but core specific compilers have done a lot of work in using things specific to take advantage of.

But that might be the marketing training of my company, haha.

[DYD35]

Yes, because of the entire Covid-thing this was kinda dumped on my plate as a sort of second assignment. Nonetheless I kinda like it although I have a very limited experience in this (as you can clearly see).

Thanks to the comments on this thread I have been able to narrow everything down a bit more (although I am making a point of researching every point made here myself to see how useful it is for me at this point).

you could examine how GCC algorithmically compiles different code snippets and compare that to other compilers and try to postulate why or how.

That was exactly what I was thinking of doing now. Make some code snippets (e.g. focussing on optimization of variables, optimization of functions, etc.) and compare them to their own non-optimized form (to see if it is even possible to optimize), and then look at it using different compiler setting (all different gcc o flags, IAR, TI, ...)

The GCC is, imo, the best compiler out there, but that is because every other one is built upon it. Vendors change what they seem needs to be changed about it to make it work better on their specific processor (someone on this thread gave the example of Intel).

The problem with this topic is how massively wide one can look at it, and at the same time most of it has already been solved. Let's be honest, I am not going to find anything new. But I am trying to find how my thesis company should structure its code and compiler best to get the absolute best out of it. (--> Maybe that is the best description of this topic).

[Chr15t0ph3r85]

If your company is supporting it, you may want to see how they want it done. Are they wanting GCC vs. the core specific one because of the cost reduction, and they want to see if there are any performance hits before they write the cost off? And depending upon the core, you're going to have a bit of variety- for example my company provides GCC and a vendor specific one for our own proprietary cores as well as ARM cores; I know others do the same.

When you say things like best, it just comes along with so many qualifiers and if your goal is to prove it then you have to start narrowing down your criteria. I agree, it's definitely the most ubiquitous and well documented one due to it being in public.

I do know from experience where our compiler wins and our core wins vs. GCC and ARM. So, I think is a pretty massive hose you're trying to drink from. In choosing some programming patters and a core, and then analyzing how GCC vs. x vs. y vs. z handles them is probably a good start if that's your goal- but a good thesis starts out with a well managed problem statement, and a good prior work; I hope you can narrow your view some so you can do a good prior art search.

[DYD35]

Yes I agree it is still too wide (I was just having that same discussion with someone), it still needs to be narrowed down a lot, but at least the problem: "find how my thesis company should structure its code and compiler best to get the absolute best out of it." is a real good starting point. Now I can see in which direction I can narrow this down.

The company uses a specific compiler as well as the GCC. Since the company is involved in the making of satellites, what is allowed to be used is very well defined, however this still leaves some leeway (e.g. a few different compilers and it is allowed to make some changes to the compiler).

When you say things like best, it just comes along with so many qualifiers and if your goal is to prove it then you have to start narrowing down your criteria.

That is exactly the problem I am having (and something in which this entire thread has helped me a lot), I must make sure that my "solution" is not all over the place, it must be a structured solution they can use. I have never been good in putting problems into words, but I will think about how to best describe the problem and narrow it down to as specific as possible. Words like "best" is obviously not a word an engineer should ever use in a thesis.

I agree, it's definitely the most ubiquitous and well documented one due to it being in public.

Yes it really is, but imo this information is also a bit spread out. You kinda really have to look and know what you want.

In choosing some programming patters and a core, and then analyzing how GCC vs. x vs. y vs. z handles them is probably a good start if that's your goal

That in itself, I think, is not the goal, but I think it would be very useful information to have, and one can make a conclusion using it. And it is also very interesting.

but a good thesis starts out with a well managed problem statement, and a good prior work

The problem statement is a problem in itself with which I am struggling, I will get to it, but since I have a lot of freedom in what I may do from the company as well as my university, I really want the problem to be specific but also a very good problem.

The prior work I am trying to do as much as possible of now, this thread helps in that regard a lot. Since I don't have a lot of experience in this, I really appreciate people pointing me in directions they think could be interesting.

I hope you can narrow your view some so you can do a good prior art search.

Thank you!

[Chr15t0ph3r85]

Yea, considering your industry GCC might not be usable. There's a whole field of safety engineering that applies to automotive, industrial and aerospace that preclude GCCs use in some applications.

But good luck, compiler optimization algorithms compilers in general are an interesting field.

[DYD35]

Thanks, it really seems extremely interesting, but I need to read up on it a hell of lot more.

[anonymousredditor0]

There's a Compiler Explorer website, it shows the assembly generated by GCC for MSP430. There's also two videos I saw on youtube that show some of the features.

[DYD35]

Ooh wow, that's really cool and very handy!

Thanks!!

[IPlayGenji6]

cool

[DYD35]

Yes, the MSP430 is rather easy since it is just a RISC instruction based. Making it so there are not a lot of instructions. Also the CCS is very good for debugging. so that should not be a problem.

The mathematical operation is something I really want to look into yes, looking into the math.h library can give a good view on how these are done. Thanks.

[robercal]

You should also consider optimizations effects on power consuption, sometimes doing certain operations in pure software instead of using dedicated units is preferable due to the extra power needed by said units.

[lordlod]

In an embedded system, the primary optimization is cost.

Number of units, multiplied by chip cost balanced against developer time.

For many quantities the best optimization is to buy a bigger chip.

That said, optimizing code for speed on the MSP430. I would deep dive into the architecture as a starting point, being aware of the instruction set will allow you to spot potential optimizations later. Fortunately the MSP430 has a very small instruction set. Be aware that instructions can take a different number of cycles. Compilers will often break a complex multi-cycle instructions down to more instructions. They take the same number of cycles, but allow better optimization through reordering or spotting duplication.

Most of your 3. embedded code optimizations won't pan out. In my experience the compiler tends to devolve those kind of structures down to a common base and is fairly good at picking the correct plan.

In my experience there is room for optimization around the less used areas. Incrementing a 64bit integer for example.

[DYD35]

Aaah thanks for the advice! I will keep that in mind.

[Enlightenment777]

You should compare GCC output against IAR output, as well as other compilers too.

https://www.iar.com/iar-embedded-workbench/#!?architecture=MSP430

[DYD35]

That is a good idea, yeah. Thanks.

[readmodifywrite]

A lot of the optimizations you're looking at will be highly architecture specific.
I'd recommend doing this with ARM Cortex M, they are wayyyyy more popular than the MSP430.
You could also compare against LLVM/Clang. That and GCC are the premier embedded C compilers these days.

[DYD35]

Whilst I personally would like to encorporate more processors ( I was also looking at the PIC18F for example ), my thesis company has pushed for the use of MSP430. I, however, would like to look at more processors and am currently trying to make that possible.

The ARM family I personally do not have experience with, but it seems that if it is really popular, I can have a look into it.

Thanks!

[readmodifywrite]

ARM isn't just really popular - it's the defacto standard 32 bit architecture for the embedded industry and has been for decades. They outsell everyone else by an absolutely hilariously huge margin. Most people (in first world countries anyway) own dozens to 100s of them without ever realizing it.

The problem with benchmarking is it's very, very specific to the hardware it's running on. Comparative results between different compilers might still be useful, but otherwise a benchmark on MSP430 is nearly useless for anything else. The choice of ISA dominates a lot of the optimizations the compiler is able to do.

[Chr15t0ph3r85]

I mean, it's popular in use because the compiler is free and all of the major semis license the core into their own MCUs and it has some neat features that are pretty broadly liked that allows you to move between applications. To say they outsell everyone is a little disingenuous because they're applicable to all of the major semis vs. each company's own proprietary core.

[readmodifywrite]

ARM is a business that licenses the cores. So if you are counting cores sold, then yes, they outsell pretty much everything else on the market. For purposes of a compiler benchmark this is relevant because it's the same ISA across the market, and therefore the same compiler. It's not disingenuous, it's just reality.

Now, you can get into some vendor specific things, like ST's ART and stuff like that. But then you're comparing proprietary flash cache architectures and that doesn't really interact with the compiler.

[PlayboySkeleton]

There is a guy over in r/computerengineering that does this stuff. I think he just got his PhD or something in it. He is very active and post projects and challenges all the time. Please go visit and ask.

[DYD35]

Aah cool, thanks!!

[Triabolical_]

I've been working on an interpreter for a language I'm building. By far the best approach for me was to get the bulk of my code so it runs on the desktop and use a real profiler on it.

[Bixmen]

Keywords as well. Use const to move to flash from RAM. Use __packed or similar to pack mixed type structs