anchor.diff:      end;
   
   linux_which_cpuinfo(other) ->
  -    %% Check for x86 (Intel or AMD or ...)
  +    %% Check for x86 (Intel or AMD)
       CPU =
  -        case linux_cpuinfo_lookup("model name") of
  +        case linux_cpuinfo_model_name() of
               "-" ->
                   %% ARM (at least some distros...)
  -                case linux_cpuinfo_lookup("Processor") of
  +                case linux_cpuinfo_processor() of
                       "-" ->
                           %% Ok, we give up
                           throw(noinfo);
  
positive.code:         _:_:_ -> "-"
      end.
  
      
  analyze_and_print_linux_host_info(Version) ->
      Distro =
          case file:read_file_info("/etc/issue") of
              {ok, _} ->
                  DistroStr = string:trim(os:cmd("cat /etc/issue")),
                  io:format("Linux: ~s"
                            "~n   ~s"
                            "~n",
                            [Version, DistroStr]),
                  case DistroStr of
                      "Wind River Linux" ++ _ ->
                          wind_river;
                      _ ->
                          other
                  end;
              _ ->
                  io:format("Linux: ~s"
                            "~n", [Version]),
                  other
          end,
      Factor =
          case (catch linux_which_cpuinfo(Distro)) of
              {ok, {CPU, BogoMIPS}} ->
                  io:format("CPU: "
                            "~n   Model:          ~s"
                            "~n   BogoMIPS:       ~s"
                            "~n   Num Schedulers: ~s"
                            "~n", [CPU, BogoMIPS, str_num_schedulers()]),
                  %% We first assume its a float, and if not try integer
                  try list_to_float(string:trim(BogoMIPS)) of
                      F when F > 5000 ->
                          1;
                      F when F > 2000 ->
                          2;
                      F when F > 1000 ->
                          3;
                      _ ->
                          5
                  catch
                      _:_:_ ->
                          try list_to_integer(string:trim(BogoMIPS)) of
                              I when I > 5000 ->
                                  1;
                              I when I > 2000 ->
                                  2;
                              I when I > 1000 ->
                                  3;
                              _ ->
                                  5
                          catch
                              _:_:_ ->
                                  5 % Be a "bit" conservative...
                          end
                  end;
              {ok, CPU} ->
                  io:format("CPU: "
                            "~n   Model:          ~s"
                            "~n   Num Schedulers: ~s"
                            "~n", [CPU, str_num_schedulers()]),
                  2; % Be a "bit" conservative...
              _X ->
                  %% io:format("X: ~p~n", [_X]),
                  5 % Be a "bit" (more) conservative...
          end,
      %% Check if we need to adjust the factor because of the memory
      try linux_which_meminfo() of
  
negative.code:            (V) when (V =:= {2,6,32}) ->
                  case string:trim(os:cmd("cat /etc/issue")) of
                      "Debian GNU/Linux 6.0 " ++ _ -> % Stone age Debian => Skip
                          true;
                      _ ->
                          false
                  end;
             (V) when (V =:= {2,6,10}) ->
                  case string:trim(os:cmd("cat /etc/issue")) of
                      "MontaVista" ++ _ -> % Stone age MontaVista => Skip
                          %% The real problem is that the machine is *very* slow
                          true;
                      _ ->
                          false
  