当迭代器是类成员时，为什么 C++ 中的 for 循环更慢

Question

This question was previously asked by myself though not very well. I have reworded and expanded on it and I hope I have clarified a couple of points. This question is very much from a beginners perspective.

Below is a short example code which runs inline and as part of a function.

The code adds 1 to each element of an array and then divides each element by two. This is arbitrary for the moment and is just a place holder for something more complex but very much equivalent.

As background this stems audio processing for real-time applications. This is the reason for

int N = 44.1e3 * 60;

So essentially this will be processing 1 minute of audio sampled at 44.1kHz.

The explicit code written inline runs far fast than the function code. Though a timer has been declared it is not a small difference but rather a question of one method running within 1 second and the other taking around 8 seconds (ymmv).

Functions calls will incur a penalty with overheads. Speed can be improved with changing optimisation flags but no where near to the point that both methods are running in a similar timeframe.

My questions are:

1. Can the function call method be altered, while still keeping as a function in a class, so that it runs at a similar, or the exact same, speed as the inline method.?
2. Are there any compiler flags that can be used which will result in both methods running in similar timeframe? If so, how would they be used within Xcode and preferably, is there a recommended resource detailing usage.

The below code is simplistic, and stylistically not very professional. This is to reduce clutter and hopefully focus on the main problem.

If there are any change to the class definition that can be made that will apply to the above questions, I am all ears. Otherwise, I understand your grievance, but it may not be relevant here.

The the clock print out provided is not a thorough benchmarking tool. It is included as a basic illustration of the a large time difference between the two methods.

#include <iostream>
#include <sys/time.h>

class MyClass
{
    static const int I = 1000;
    int n, i;
    double foo[I] = {0};

public:
    void myFunction(int N)
    {
        for(n = 0; n < N; n++ )
        {
            for(i = 0; i < I; i++ )
            {
                foo[i]+= 1;
                foo[i]*= .5;
            }
        }
    }
};

int main()
{
    
    int N = 44.1e3 * 60; // number of samples
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // The Explicit Approach
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    
    const int I = 1000;
    double bar[I] = {0};
    
    std::clock_t startTime = std::clock();
    
    for(int n = 0; n < N; n++)
    {
        for(int i = 0; i < I; i++)
        {
            bar[i] += 1;
            bar[i] *=.5;
        }
    }
    
    double duration = ( std::clock() - startTime ) / (double) CLOCKS_PER_SEC;
    
    std::cout << "Explicit Approach Time (seconds): " << duration << '\n';
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //  The Class Approach
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    MyClass testClass;
    
    startTime = std::clock();
    
    testClass.myFunction(N);
    
    duration = (std::clock() - startTime) / (double) CLOCKS_PER_SEC;
    
    std::cout << "Class Approach Time (seconds): " << duration << '\n';
    
    return 0;
}

Answer 1

I slightly re-wrote your code like this:

#include <iostream>
#include <chrono>
#include <cmath>

class someClass {
   int n, i;           // internal class loop indeces
   double foo[1000];
   int I = ::std::floor(sizeof(foo)/sizeof(foo[0])); // number of elements in foo
 public:
   void someFunction(int);
};

void someClass::someFunction(int N)
{
   for(n=N; n--; ) {
      for(i=I; i--; ) {
         foo[i] += 1;
         foo[i] *= .5;
      }
   }
}


int main()
{

    // this was initially an audio processing problem
    // Essentially, process a minute of audio

   int N = 44.1e3 * 60;

   {
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      /// The Explicit Method
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      int n, i;             // loop indeces
      double bar[1000];
      int I = floor(sizeof(bar)/sizeof(bar[0]));

      // START CLOCK
      auto start = ::std::chrono::high_resolution_clock::now();


      // Exactly what is defined in the function 'someFunction' above
      for(n=N;n--; ){
         for(i=I;i--; ){
            bar[i]+= 1;
            bar[i]*=.5;
         }
      }

      // END CLOCK
      auto end = ::std::chrono::high_resolution_clock::now();

      std::chrono::duration<double> duration_secs = end - start;

      std::cout<<"Explicit Method Time (seconds): "<< duration_secs.count() <<'\n';
   }

   {
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      //  The Function Method
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      someClass testClass;

      // START CLOCK
      auto start = ::std::chrono::high_resolution_clock::now();

      testClass.someFunction(N);

      // END CLOCK
      auto end = ::std::chrono::high_resolution_clock::now();

      std::chrono::duration<double> duration_secs = end - start;
      std::cout<<"Member Function Time (seconds): "<< duration_secs.count() <<'\n';
   }

    return 0;
}

And I get this output now:

$ /tmp/a.out 
Explicit Method Time (seconds): 3.89e-07
Member Function Time (seconds): 1.46e-07

So, for me the explicit method is a lot slower. Though they are still both so little time that it's barely worth measuring. Both on the order of hundreds of nanoseconds. It's impressive the timer is high resolution enough to measure it.

So, the next question is, which compiler are you using? What platform are you compiling for?

There are still a lot of things about your code that are sub-optimal. I just cleaned up the includes, used ::std::chrono from C++11 for timing, and made explicit scopes for timing your hand-inlined version and the member function version.

I compiled with -O3 on gcc 7.2. It still contains undefined behavior since it uses an uninitialized array. Looking at the code, gcc realized the arrays were never even used and generated no code. So, basically, back-to-back calls to now . The time difference between the hand-inlined version and the member function can be completely attributed to basically roundoff error.

So, the answer is, your code still doesn't show the problem you're talking about, and you still haven't given enough detail. :-) Either that, or the answer lies in the compiler you're using and the options you're giving it.

Answer 2

This question was previously asked by myself though not very well. I have reworded and expanded on it and I hope I have clarified a couple of points. This question is very much from a beginners perspective.

Below is a short example code which runs inline and as part of a function.

The code adds 1 to each element of an array and then divides each element by two. This is arbitrary for the moment and is just a place holder for something more complex but very much equivalent.

As background this stems audio processing for real-time applications. This is the reason for

int N = 44.1e3 * 60;

So essentially this will be processing 1 minute of audio sampled at 44.1kHz.

The explicit code written inline runs far fast than the function code. Though a timer has been declared it is not a small difference but rather a question of one method running within 1 second and the other taking around 8 seconds (ymmv).

Functions calls will incur a penalty with overheads. Speed can be improved with changing optimisation flags but no where near to the point that both methods are running in a similar timeframe.

My questions are:

1. Can the function call method be altered, while still keeping as a function in a class, so that it runs at a similar, or the exact same, speed as the inline method.?
2. Are there any compiler flags that can be used which will result in both methods running in similar timeframe? If so, how would they be used within Xcode and preferably, is there a recommended resource detailing usage.

The below code is simplistic, and stylistically not very professional. This is to reduce clutter and hopefully focus on the main problem.

If there are any change to the class definition that can be made that will apply to the above questions, I am all ears. Otherwise, I understand your grievance, but it may not be relevant here.

The the clock print out provided is not a thorough benchmarking tool. It is included as a basic illustration of the a large time difference between the two methods.

#include <iostream>
#include <sys/time.h>

class MyClass
{
    static const int I = 1000;
    int n, i;
    double foo[I] = {0};

public:
    void myFunction(int N)
    {
        for(n = 0; n < N; n++ )
        {
            for(i = 0; i < I; i++ )
            {
                foo[i]+= 1;
                foo[i]*= .5;
            }
        }
    }
};

int main()
{
    
    int N = 44.1e3 * 60; // number of samples
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // The Explicit Approach
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    
    const int I = 1000;
    double bar[I] = {0};
    
    std::clock_t startTime = std::clock();
    
    for(int n = 0; n < N; n++)
    {
        for(int i = 0; i < I; i++)
        {
            bar[i] += 1;
            bar[i] *=.5;
        }
    }
    
    double duration = ( std::clock() - startTime ) / (double) CLOCKS_PER_SEC;
    
    std::cout << "Explicit Approach Time (seconds): " << duration << '\n';
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //  The Class Approach
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    MyClass testClass;
    
    startTime = std::clock();
    
    testClass.myFunction(N);
    
    duration = (std::clock() - startTime) / (double) CLOCKS_PER_SEC;
    
    std::cout << "Class Approach Time (seconds): " << duration << '\n';
    
    return 0;
}