嵌套for循环的性能问题

Question

I have a nested for loop that performs some calculations and the math has been simplified to a great extent, however I still have a performance issue that I'm not sure I can resolve. I don't believe it can be resolved due to the sheer number of times these for loops execute. Now I'm not familiar with using any analytical tools to help determine where the slow downs occur within these but I am fairly certain that it's just the number of times these loops execute.

I would greatly appreciate any help in helping trim this down and increase the performance of this code. I'm trying to stay away from a HPC or highly parallelized solution, but if that's the only way to make this truly effective then I'll look into going down that road.

Here's the code with X= 20,000 and N_zero= 45,420 (values pulled from actual tests):

Dictionary<decimal, int> n_alpha = new Dictionary<decimal, int>();
Random rand = new Random();
decimal r = 0m;
decimal check=0m;

for (int i = 0; i < X; i++)
{
    B = N_0 = N_1 = N0_ = N1_ = 0;
    for (int j = 0; j < N_zero; j++)
    {
        // need a random decimal value between 0 and 1
        r = (decimal)rand.Next() / int.MaxValue;
        if (r <= r1)
        {
            N0_ += 1;
            N_0 += 1;
        }
        else if (r1 < r && r <= r2)
        {
            B += 1;
            N0_ += 1;
            N_1 += 1;
        }
        else if (r2 < r && r <= r3)
        {
            B += 1;
            N_0 += 1;
            N1_ += 1;
        }
        else if (r > r3)
        {
            N1_ += 1;
            N_1 += 1;
        }

    }
    check = N_0 * N_1 * N0_ * N1_;
    if (check != 0)
    {
        decimal a = 1 - (B * N_zero) / ((N_0 *N1_) + (N0_ *  N_1 ));
        // technically only tracking 4 decimal points, so key should reflect this
        decimal key = Math.Round(a, 4);
        if (n_alpha.ContainsKey(key))
        {
            n_alpha[key] += 1;
        }
        else
        {
            n_alpha.Add(key, 1);
        }
    }
}

Answer 1

1. The use of rand.Next() is a bit of a performance problem. If you can live with a home-brewed, quick and dirty Linear Congruential Generator you will be much better off.

2. The use of decimal is also a major performance problem. Do not use decimal if you can avoid it. Use double instead.

3. The use of Dictionary can also be a bit of a problem, especially if the distribution of your data is such that it causes lots of hash collisions. I do not know what the range of your numeric data is, nor how it is distributed in that range, but if you can replace the dictionary with an array, by all means, do it.

4. You may be able to completely eliminate your inner nested loop. Since rand.Next() supposedly yields numbers with a uniform distribution, and since r1 , r2 and r3 are known in advance and do not change in the loops, you can simply calculate how many r s would be issued that are below r1 , how many many r s would fall between r1 and r2 , etc. without actually issuing any r s. So, just add the corresponding quantities to your N0 , N_1 , etc instead of adding 1 each time.

EDIT Clarification about #4:

So, judging by the way you issue r , it can have values from 0.0 to 1.0 . (Inclusively or exclusively doesn't really matter.) So, I presume that r1 , r2 , and r3 are also between 0.0 and 1.0 . Therefore, assuming a perfectly uniform distribution, your r s should be as follows:

• r < r1 will occur N_Zero * r1 times

• r1 < r < r2 will occur N_Zero * (r2 - r1) times

• r2 < r < r3 will occur N_Zero * (r3 - r2) times

• r3 < r will occur N_Zero * (1 - r3) times.