CMM Automation Speed C# versus VB6

Hi,

I am currently converting an application that automated PC-DMIS in VB6 over to C#. Our application does the following:

1) Ask the user what PC-DMIS program (i.e. a PRG file) they want to run
2) Launch PC-DMIS passing in the name of the program file selected
3) Get PC-DMIS to run a series of measurements on a Scirocco machine
4) Import the measurements from PC-DMIS into the application for processing
5) Process the results (basically we compare the measurements to a baseline, then insert the deviation into a database)

What I observed is that for any program (we've tried quite a few and this seems to be consistently happening), the VB6 application takes approximately 30 seconds to perform step 4, whereas the C# application takes around 2.5 minutes.

Can anyone help with the following questions please?

1) We directly ported the code from the legacy VB6 application to C# so the new program isn't doing anything different from what the old VB6 one used to do, so why does C# take so much longer than VB6 to perform the import?
2) Is there any way to speed it up, e.g. I think I read something on a forum that VB.NET may be faster, but I can't find anything technical from Microsoft to support that so I can't really justify burning a lot of hours to convert from C# to VB.NET in case it is the same speed?

Thanks!

Parents

ewe0006 over 10 years ago

Thanks to y'all the time to produce the text file has gone from approx. 2.5 minutes to a little over 1 minute. This is the final code in case it helps anyone else or if anyone has further suggestions to make it even faster...

I've got another idea... You currently have your loop evaluating every command to know if it is a trace field, and then if it is a dimension even if you already know it's a trace field. The simplest edit I can think of would be throwing a 'continue' inside the first 'if' block:

for (int i = 1; i < cmdCnt; i++)
                {
                    cmd = pcd.Commands.Item(i);
                    if (cmd != null)
                    {
                        if (cmd.IsTraceField)
                        {
                            //handle trace field...
                            [COLOR="#FF0000"]continue;[/COLOR]
                        }
                        if (cmd.IsDimension)
                        {
                            //handle dimension...
                        }
                        //etc...
                    }
                }

That way, once you already know the command is a trace field, you don't bother checking to see if it is a dimension.

Alternatively, you could use an 'else if', though there are weird cases where all parts of 'if' statements are evaluated and it *might* not help anything...

for (int i = 1; i < cmdCnt; i++)
                {
                    cmd = pcd.Commands.Item(i);
                    if (cmd != null)
                    {
                        if (cmd.IsTraceField)
                        {
                            //handle trace field...
                        }
                        else if (cmd.IsDimension)
                        {
                            //handle dimension...
                        }
                        //etc...
                    }
                }

Lastly, I would move whichever command type your CMM programs have more of to be evaluated first. So, if you have more dimensions than trace fields, evaluate the dimension first. If you do this in combination with either the 'continue' or 'if...else if', you'll have more times where the loop can iterate early and reduce your calls on the PC-DMIS command objects:

for (int i = 1; i < cmdCnt; i++)
                {
                    cmd = pcd.Commands.Item(i);
                    if (cmd != null)
                    {
                        if (cmd.IsDimension)
                        {
                            //handle dimension...
                            continue;
                        }
                        if (cmd.IsTraceField)
                        {
                            //handle trace field...
                        }
                        //etc...
                    }
                }

That should shave off a little bit more of your execution time.

Reply

ewe0006 over 10 years ago

Thanks to y'all the time to produce the text file has gone from approx. 2.5 minutes to a little over 1 minute. This is the final code in case it helps anyone else or if anyone has further suggestions to make it even faster...

for (int i = 1; i < cmdCnt; i++)
                {
                    cmd = pcd.Commands.Item(i);
                    if (cmd != null)
                    {
                        if (cmd.IsTraceField)
                        {
                            //handle trace field...
                            [COLOR="#FF0000"]continue;[/COLOR]
                        }
                        if (cmd.IsDimension)
                        {
                            //handle dimension...
                        }
                        //etc...
                    }
                }

for (int i = 1; i < cmdCnt; i++)
                {
                    cmd = pcd.Commands.Item(i);
                    if (cmd != null)
                    {
                        if (cmd.IsTraceField)
                        {
                            //handle trace field...
                        }
                        else if (cmd.IsDimension)
                        {
                            //handle dimension...
                        }
                        //etc...
                    }
                }

for (int i = 1; i < cmdCnt; i++)
                {
                    cmd = pcd.Commands.Item(i);
                    if (cmd != null)
                    {
                        if (cmd.IsDimension)
                        {
                            //handle dimension...
                            continue;
                        }
                        if (cmd.IsTraceField)
                        {
                            //handle trace field...
                        }
                        //etc...
                    }
                }

That should shave off a little bit more of your execution time.

Children

No Data