200lines of main function or the main function with many branching functions reducing the number of line to 10-20...
Calling a function is costly. Not only the
clock cycles for executing the jump command.
You have also to consider that maybe the state
of the local variables has to be stored
on the stack before the call and be restored
after return.
Another possibility is to work with
macros, such as #define f(x,y) ...
No function is called, but the code
defined is inserted at every place
where it is used.
Regards,
Joachim
200 lines is not a big code. Go for functions keeping in view of modularity of code only. Therefore, it depends on what is your code. If your code is simply sequential jobs to do without repetition, 200 lines could also be okay.
In your code, if the repeatability is more then it is better to go with functions or else it is better to go with single main function...
200 lines of code isn't so much that you would have serious performance issues. If it's very critical that you have optimal performance and the code runs sequentially, go with the main() function approach. Otherwise, use separate functions to make your code easier to maintain, easier to document, easier to read. Writing well-structured code in many cases is more important, especially if you are planning to revisit this project. If you are uncertain what to do, allow for a couple more days during development to profile your code (remove printf, communications overhead etc and time the execution of your code), test energy consumption on the embedded pc, or run lint/splint tests to find if there are corrections you can make.
Writing separate functions usually gives you more readable code. Never think that this software will run unchanged forever. Eventually, somebody will come back (it might be your future self) and has to change a line of code. Keeping this is mind I would go for the functions instead of a single main.
The only reason to go for a single main is if the execution of the code is very highly performance critical. It is true, like other mentioned, that function calls have an overhead (but sometimes the automatic stack behaviour is exactly what you want). If this really concerns you have a look at the optimization flags of your compiler. There should be a flag for function inlining and sometimes there are even keyword you can put in the source code to force this kind of behaviour for certain functions explicitly. Though, the most important rule is to never optimize something which is not performance-critical. First, profile your code and if there is a problem with performance then try to optimize. Otherwise, just go for readable code.
Calling a function is always an expensive thing in C programming, because you have to branch to some other location, push local variables to stack (requires stack memory) and come back again. This is expensive both in terms of time to execute as well as power that will be consumed in system (as power consumption is an issue in embedded systems).
So conclusion can be if the code is reasonably "OK" i.e. not containing more repetitions and not exceeding memory (again it depends upon the requirements) then you can have redundant instructions, for that you can also use macros or inline functions.
Hope it helps :)
- Badges
- Science topic
- Similar topics
- Computer Science and Engineering
- Programming Languages