Create own functions in CFC, performance question

Dear Experts,

I'm developing my project using CFC, for this project I need to create my own functions with inputs and outputs that I will use repeatedly in the project.

My question is which choice is efficient in terms of perfomance, to create the functions as FC or as FB. It's not a must for some of the blocks that I will create to have instance DBs that's why I can create them as FC. but once compiled to stl which way is efficient.

If I use create them as FB then an instance DB is created for each call insert, which looks like waist of memory resources. On the other hand, when I create as FC and look to the compiled stl version I can see that all input variables are transferred to local memory variables and then are inserted as actual variables of the FC. That looks like a waist of performance. In FB case it seems that actual variables are transferred to the fields of the instance DB just before the UC call of the FB and no insertion of actual variables, it seems more efficient.

I hope I could make my question clear. Prompting for your comments

------------------------------------------------------------------------------------------
Split from CFC create your own blocks.

thank you for your comments,

well, I'm not exactly sure whether FC takes the reference of the parameter or its value to the local memory which is most probably is the stack of the core computer. if we can be sure about this point I think we can be one step further towards the answer of my main issue.

In a specific case where the parameters of the function are constants, but of course of different values for each instance call of the function, using FB for the first glans looks more efficient since I had seen that the CFC compiler stores those parameters as the values of the instance DB. They're written once by the compiler and not transferred cyclically. In the case of FC those constants are transferred cyclically with every call. So for that specific case where we have constant input parameters FB seems a winner.

Still we have two concerns to consider. The first is with variable parameter as inputs of the function, what's the estimate of performance in terms of passing the parameters to FC or FB.

The second concern is related to the code inside the function itself, accessing the IO parameters as instance DB elements or accessing the parameters as local variables of the FC, which is more efficient.

I had a closer look to the generated STL code of the CFC compiler, attached you can see the difference in passing the constant parameters for both FC and FB. That was where I discovered that the constant parameters are not transferred cyclically to the FB but just used as the values of the instance DB parameter values.

smiffy

It is kind of hard to say for definite without knowing the insides of the Siemens CPU hardware and firmware architecture.
However, based of my extensive knowledge and experience of embedded systems I will give you my best guess.

When calling a function the parameters can be passed in one of 2 ways, by value or by reference. The latter is more efficient as each parameter is passed as a pointer (which is nomally 4 bytes in size) regardless of the parameter type to be passed in. The former would need to copy over the whole parameter data from the calling block to the instance DB of the called block. FB's pass by value and FC's pass by reference and therefore, I would expect that FC's would be more efficient.

FC'c also store all there data in local (stack) memory, whereas FB's store their data in instance DB's which are part of the work memory (I think). Now local stack memory is likely to be architectually closer to the program code than work memory, and therefore faster. Again giving FC's the speed advantage.

However all this is guess work on my part, so do not take it as gospel.

 Dear all,

I have very good news. Today I decided to make a benchmark test of a sample program to compare the performance for an FC call or an FB call. As I had mentioned earlier, the function that I'm working on now is a function with constant input parameters and one variable input parameter. It's actually a simplified analog input scaler that shall convert the PIW value to an engineering value. I've decided to write my own optimised and simplified function rather than using the standard simatic function which is a general and multipurpose function.

So what I have done is to make a simple program with with the scaler written both as FC and as FB with exactly the same siplified code.

I've written a simple benchmarking function that will count the total plc main cycles for a period of 10 seconds.

The first test was to run the program with only the FB version called, the second test was FC. The program was tested on a 314C-2DP cpu wich I have in my laboratory. Each version was tested five times and the average performance benchmarks were as follows:

FB call version: 11308 Cycles of cpu per 10 seconds.

FC call version: 8061 Cycles of cpu per 10 seconds.

So as we can see from this test, passing the constant input parameters to the FC by transferring them each call was a major drawback in performance.

In conclusion, the advantage of having the constant parameters as elements of the instance DB without the need to transfer them cyclically was an extreme profit in terms of performance.

Dear all,

Today I've decided to make some changes on the program so that the benchmark is more judging in regard to passing the parameters. As I had mentioned earlier, the function has five input parameters, one is a variable and the other four are constants. On the past day I had tested the FC and FB benchmark separately with one variable and four constants as Inputs. Today I started to think that it might be unfair for the FC since the FB never makes load and transfer of the constant input parameters. So I decided to make two of the parameters be transferred from another data block as if they were variables rather than constants, you can see the attached image. This way both FB and FC are cyclically transferring the input parameters.

The result was still in great favor of FB:

Test with FC 7999 Cycles / 10 seconds.

Test with FB 11136 Cycles / 10 seconds.

So I think that transferring the parameter to the stack and working from the stack might be expensive performance wise.

I hope I can get your comments.

smiffy

It is kind of hard to say for definite without knowing the insides of the Siemens CPU hardware and firmware architecture.
However, based of my extensive knowledge and experience of embedded systems I will give you my best guess.

When calling a function the parameters can be passed in one of 2 ways, by value or by reference. The latter is more efficient as each parameter is passed as a pointer (which is nomally 4 bytes in size) regardless of the parameter type to be passed in. The former would need to copy over the whole parameter data from the calling block to the instance DB of the called block. FB's pass by value and FC's pass by reference and therefore, I would expect that FC's would be more efficient.

FC'c also store all there data in local (stack) memory, whereas FB's store their data in instance DB's which are part of the work memory (I think). Now local stack memory is likely to be architectually closer to the program code than work memory, and therefore faster. Again giving FC's the speed advantage.

However all this is guess work on my part, so do not take it as gospel.

 Dear all,

Today I've done some more tests, I can conclude that passing the IO parameters to FC is blody expensive compared to using elements of instance DB of FB.

Calling a dummy FC or FB without any parameters is almost the same cost in performance. So the main difference is in passing the parameters of the FC (propably to the stack of the core cpu)!