1    Overview / Problem Statement

As complexity in automotive is increasing day by day, the software code is also increasing and the overall time to build the project also is increasing.

It is a common phrase by the developers “Why does the Build take so much long time” OR “Lets go for a coffee break till our software builds” OR “Where can I test my changes quickly, this is soo stupid ?” OR “Why is my system so slow”

One of our client had a requirement that their build time is quite high and if we could help them reduce the overall build time as the project was getting quite complex with huge number of variants, 3 core system and many third party integrations.

 Even though Continuous integration was available, they wanted a way which could help developers build their code quickly and have quick releases along with having a maintainable build system as currently it was very difficult to make any changes due to lot of integrations

2    Project Complexity

The project included classic AUTOSAR code and generators using Electrobit toolchain, handwritten source code, MATLAB code and Third Party libraries. It included all generation of SystemModel Db files, code importers , ECU extract creation and the code generators during the build generation.

Many things of the project were happening in blackbox and less visibility on the project side. (Eg. AUTOSAR Code generators, Pugins of third Party, Internally developed Development Environment which had jar files) .

The project had a Pool of Engineers from German, India and Romania accounting to about 300 Engineers.

It was an ASIL D level project with safety as highes priority.

3    Solutioning Approach by A-DevOps

At A-DevOps we have huge expertise with the Build systems. With our expertise in working with huge number of build system, knowledge about different Tool chains , compilers , scripting and moreover our deep knowledge in Automotive software development in the tooling world, we were able to provide a systematic approach to solve this problem.

3.1    Analysis Phase by A-DevOps

We had an analysis phase, where our goal was to understand the system and identify the culprits which were causing lot of time.

This involved with a deep check with our checklist where we had deep look on below influencers and measured each step:

  • Software development Process and Project structure if can be optimized
  • Code generation process and configuration of stack if can be optimized
  • Build Tools (Are they correctly configured and certain process or steps can be improved with modern systems)
  • Tooling environment and dependency check if correct and required dependencies are configured
  • Mark down Repetitive steps
  • Compiler, Assembler, Linker optimizations and header includes check
  • Configuration of any other checks and code quality tools
  • Continuous Integration Environment and Release steps
  • Parallel executors check
  • Hardware utilization
  • Anti-Virus settings check
  • CPU utilization
  • Timing for each step and if Black boxes can be broken into granular steps

3.2    . Post Analysis and Implementation by A-DevOps

After going through the above-mentioned checks and observations, we found root causes in many of the areas. Our observations include:

  • Project structure and build system structure could be optimized
  • Code generation process was a big black box which code be divided into several conditions and invoked only when needed.
  • Build tools dependency checks missed speed parallel executions in certain areas
  • Mc-Afee antivirus settings also impacted developer side timings
  • Continuous Integration system missed Artifactory and better download mechanisms which would help developers greatly

Together with Electrobit configuration, we were able to optimize the configuration and divide the single big block that was executed into several different steps.

We implemented the dependency check to execute only the required step rather than complete big block.

We implemented a speed optimized builds during compilation, to speed up the process and implemented 2 layers for configuration and one for execution of file with speed including various build systems and some wrapper scripts.

Continuous Integration framework was also extended to generate various checksum algorithms and to store and reuse data.

Refactoring the build environment was done following KISS rule (Keep it simple stupid) so as to have a better maintainability and integrating different variants.

The implementation was tested on several nodes and finally integrated in the entire project.

3.3    Results

Implementing the overall factors resulting in a whopping 100% time saving which made the developers life happy as well as a high overall customer satisfaction. The results helped massive engineers and the solution will be used as a standard.

If you are interested to know more about the project or facing the same problem and need our support , then book our consultation here

Follow on our LinkedIn profile for more updates