Provided Basic Support for -l N option on windows platform.

I have implemented basic support for **-l N** on windows platform.

Tested with platform==msvc and platform==mingw.

Values returned from OS are filtered with basic filter, to minimize load variation caused by short time between consecutive calls.

I have tested it on 2 core machine with HT and 4 core one, and CPU load in Task Manager matches one provided in -l option.

Any suggestion and improvements are more than welcome.


Any thoughts on rewriting this as

    static double CalculateProcessorLoad(uint64_t idle_ticks,
                                         uint64_t total_ticks) {
      static uint64_t previous_idle_ticks = idle_ticks;
      static uint64_t previous_total_ticks = total_ticks;
      static double previous_load = 0.0;
      
      uint64_t idle_ticks_since_last_time = idle_ticks - previous_idle_ticks;
      uint64_t total_ticks_since_last_time = total_ticks - previous_total_ticks;
      if (total_ticks_since_last_time == 0)
        return previous_load;
      
      // Calculate load.
      double idle_to_total_ratio =
          ((double)idle_ticks_since_last_time) / total_ticks_since_last_time;
      double load_since_last_call = 1.0 - idle_to_total_ratio;
      
      // Filter/smooth result when possible
      if (previous_load > 0) {
        load = 0.9 * previous_load + 0.1 * load_since_last_call;
      } else {
        load = load_since_last_call;
      }
      
      previous_load = load;
      previous_total_ticks = total_ticks;
      previous_idle_ticks = idle_ticks;
      
      return load;
    }

? That is a bit shorter and does the same, I think. (If you don't like that, it's fine as is too. If you do like it, I can change this after merging.)