问题

Presentation :

I am working on a piece of code that can compare two javascript Object by looping into the first one (called A) to perform a key lookup in the second one called B (I put value as key and occurence as value).

But when I am measuring the performance of the subkey key lookup of Object A (10 times per amount of data, with data as changing parameters for each 10 times the program runs (100 per row, 200...) I get high timing for the smallest amount of data (so potentially less key in the dict B)

Objects layout :

Object A looks like below:

{
 SQL_TABLE_1:
 {
     column_1:
      [ 
        '2jmj7l5rSfeb/vlWAYkK/YBwIDk=',
        '3MaRDFGBKvsLLhrLUdplz3wUiOI=',
        'PEvUFHDR4HbOYXcj7danOvyRJqs='
        'XHvERAKZ4AqU+iWlx2scZXdem80=',
        'nSG0lvwlkIe5YxZGTo5binr3pAw=',
        'Swuc/7YCU9Ptfrff+KHaJJ1+b7U=',
        'N28qqdfezfZbPmK7CaGmj7m7IOQ=',
        'ffc7skeffegT1ZytAqjco3EpwUE=',
        '2XldayBefzBxsUuu6tMFYHVZEEY=',
        '5rC2y6IzadQ1aEy7CvNyr30JJ2k='
      ]
 },
 SQL_TABLE_2:
   {
      column_1:[......]
   }
}

Object B field have various size but this size never change in our tests And Object B looks like:

[
field_1:
 { 
  '2jmj7l5rSfeb/vlWAYkK/YBwIDk=': 1,
  '3MaRDFGBKvsLLhrLUdplz3wUiOI=': 1,
  'PEvUFHDR4HbOYXcj7danOvyRJqs=': 1,
  'XHvERAKZ4AqU+iWlx2scZXdem80=': 4,
  'nSG0lvwlkIe5YxZGTo5binr3pAw=': 1,
  'Swuc/7YCU9Ptfrff+KHaJJ1+b7U=': 1,
  'N28qqdfezfZbPmK7CaGmj7m7IOQ=': 27,
  'ffc7skeffegT1ZytAqjco3EpwUE=': 1,
  '2XldayBefzBxsUuu6tMFYHVZEEY=': 18,
  '5rC2y6IzadQ1aEy7CvNyr30JJ2k=': 1 },
field_2:{......}
]

Timing measurement in the code is structured like this:


    sql_field_1:
    {
       mongo_field_1: 0.003269665241241455, mongo_field_2: 0.0015446391105651855, mongo_field_3: 0.0009834918975830079, mongo_field_4: 0.0004488091468811035,
    },
    sql_field_2:
    {
        ....
    }

Goal

The goal is to perform for each sub-subkey of Object A a key lookup on the Object B subkeys.

Code

Here's the code that cause this behavior: Object A is called sql_dict_array Object B is called hash_mongo_dict

    for(var field_name in hash_mongo_dict)
        {       
            performance_by_mongo_field[field_name] = {};
            result_by_mongo_field[field_name] = {};
            // LOOP ON OBJECT A KEYS
            for(var table_name in sql_dict_array)
            {
                // Start of time measurement
                var start_time = performance.now();


                // there is only one column in our test data
                for(var column_name in sql_dict_array[table_name])
                {   
                    found_count = 0;

                    for(var value of sql_dict_array[table_name][column_name])
                    {   
                        // **SUBKEY LOOPKUP HERE WITH VALUE**
                        var results = hash_mongo_dict[field_name][value];
                        // IF NOT UNDEFINED THEN IT HAS BEEN FOUND
                        // THIS CHECK IS NOT THE BOTTLENECK
                        if(results != undefined)
                        { 
                            found_count+=results;
                        }
                    }
                    if(found_count > limit_parameter)
                    {
                        console.log("error: too many match between hashes")
                        process.exit(0)
                    }
                    // PERFORMANCE CALCULATION
                    performance_by_mongo_field[field_name][table_name] = (performance.now() - start_time)/1000;
                    result_by_mongo_field[field_name][table_name+'.'+column_name] = (found_count/verif_hash_count*100);

                }
            }
         return some results...
        }

Testing:

With this code, I expect to have almost constant time whatever the size of the Object B (amount of subkey) but in my code I have higher time when I have only 10 subkeys in the nested object A, and it become stable when reaching 100 keys or more (tested with 6000 keys)

Here's 10 runs for the key lookup code of one key of Object A containing 10 subkeys with 300.000+ data from Object B:

0.2824700818061829 0.2532380700111389 0.2455208191871643 0.2610406551361084 0.2840422649383545 0.2344329071044922 0.2375670108795166 0.23545906591415405 0.23111085414886476 0.2363566837310791

Here's the same comparison but with 4000+ subkeys:

0.0027927708625793456 0.0018292622566223144 0.015235211849212647 0.0036304402351379395 0.002919149875640869 0.004972007751464844 0.014655702114105225 0.003572652339935303 0.0032280778884887697 0.003232938766479492

I will appreciate every advice you can provide me,

来源：https://stackoverflow.com/questions/57226320/weird-comparison-performance-on-javascript-object-key-lookup

标签

javascript