Re[8]: 32 bit
От: TailWind  
Дата: 13.03.23 16:37
Оценка:
ЕМ>Вы твердо уверены, что из нас двоих психотерапия нужна именно мне?
Я совершенно по дружески рассказываю вам то что вижу в вашем поведении некую странность
Тут многие пытаются соревносться у кого больше эго, это вообще не про то что я вам говорю
Так что не обижайтесь. Люди вокруг кривые зеркала. Но иногда в них можно увидеть что-то важное для себя

TW>>Сложно сказать: я делал тест производительности с компилятором 32 и 64 бит и на моих задачах не было существенной разницы?

ЕМ>Конечно, делал, и не раз.

ЕМ>Раз Вы в рамках этой дискуссии утверждаете "меньше программы влезет в кэш процессора", значит, считаете этот фактор важным и существенным именно в этом аспекте.


Да считаю
Но просто считать мало
Надо делать тесты
Re[4]: 32 bit
От: icezone  
Дата: 13.03.23 22:34
Оценка:
Здравствуйте, Философ, Вы писали:

Ф>а что, реально больше 3-х гигов отжирает?


сейчас и не помню, но вылетала явно раньше
и это я 4к даже не пробовал
Re[4]: 32 bit
От: icezone  
Дата: 13.03.23 22:41
Оценка:
Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Здравствуйте, icezone, Вы писали:


I>>попробовал собрать AOM AV1 — студия сожрала 50+ GB и вылетела с ошибкой — нехватка памяти


ЕМ>Сама студия, или запущенные ею утилиты (компилятор/линкер и т.п.)?


проверял на 2017 и 2022 Студиях

compiler is out of heap space

сперва пробовал 32-битный компилятор, тот вылетел сразу
потом на ноутбуке с 16Гб оперативки запускал 64-битный компилятор — дошел до 40Гб и выдал ошибку
пересел на десктоп с 32Гб — сожрал примерно 55Гб и тоже упал...

помог только запрет inline функций
Re[4]: 32 bit
От: Aquilaware  
Дата: 13.03.23 23:59
Оценка: -1
Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Для типичного приложения такая ситуация нереальна.


Знаменитые "640 килобайт хватит всем".
Re[5]: 32 bit
От: Философ Ад http://vk.com/id10256428
Дата: 14.03.23 03:20
Оценка:
Здравствуйте, TailWind, Вы писали:

TW>INT64 + INT64

TW>Или INT64 ++

TW>32-bit compiler разложит на несколько инструкций

TW>А 64-bit compiler сделает за одну


Во-первых, AMD64 всё ещё нативно исполняет 32-битный код. Возражение не принято.
Во-вторых, как много у тебя математики на int64? Зачем она нужна? Ну кроме вычисления адреса.

В-третьих, похоже у меня есть повод тебя сильно удивить.
  код на шарпе
       static void Main(string[] args)
        {
            Console.WriteLine("test speed for 32");
            for (int a = 0; a < 10; a++)
            {
                TestSpeedInt32();
            }

            Console.WriteLine("test speed for 64");

            for (int a = 0; a < 10; a++)
            {
                TestSpeedInt64();
            }
        }

        const int iterations = 10 * 1000 * 1000;

        private static unsafe void TestSpeedInt32()
        {
            System.Int32 a, b, c, d, e, f, g, h;
            a = b = c = d = e = f = g = h = 0;
            var sw = Stopwatch.StartNew();
            for (int i = 0; i < iterations; i++)
            {
                a++;
                b++;
                c++;
                d++;
                e++;
                f++;
                g++;
                h++;
            }
            sw.Stop();
            var variablesIncrementTime = sw.ElapsedTicks;

            sw.Restart();
            var smallArray = stackalloc System.Int32[8];
            for (int i = 0; i < iterations; i++)
            {
                ++smallArray[0];
                ++smallArray[1];
                ++smallArray[2];
                ++smallArray[3];
                ++smallArray[4];
                ++smallArray[5];
                ++smallArray[6];
                ++smallArray[7];
            }
            sw.Stop();
            var arrayItemIncrementTime = sw.ElapsedTicks;
            Console.WriteLine("elapsed for variable =  {0:D} \tarray = {1:D}", variablesIncrementTime , arrayItemIncrementTime);
        }
        private static unsafe void TestSpeedInt64()
        {
            System.Int64 a, b, c, d, e, f, g, h;
            a = b = c = d = e = f = g = h = 0;
            var sw = Stopwatch.StartNew();
            for (int i = 0; i < iterations; i++)
            {
                a++;
                b++;
                c++;
                d++;
                e++;
                f++;
                g++;
                h++;
            }
            sw.Stop();
            var variablesIncrementTime = sw.ElapsedTicks;

            sw.Restart();
            var smallArray = stackalloc System.Int64[8];
            for (int i = 0; i < iterations; i++)
            {
                ++smallArray[0];
                ++smallArray[1];
                ++smallArray[2];
                ++smallArray[3];
                ++smallArray[4];
                ++smallArray[5];
                ++smallArray[6];
                ++smallArray[7];
            }
            sw.Stop();
            var arrayItemIncrementTime = sw.ElapsedTicks;
            Console.WriteLine("elapsed for variable =  {0:D} \tarray = {1:D}", variablesIncrementTime , arrayItemIncrementTime);
        }


  результаты теста на .net 4.8
RELEASE x86
test speed for 32
elapsed for variable =  29938   array = 208879
elapsed for variable =  29850   array = 209862
elapsed for variable =  30037   array = 210031
elapsed for variable =  29861   array = 208852
elapsed for variable =  29823   array = 209040
elapsed for variable =  29852   array = 208794
elapsed for variable =  29806   array = 208832
elapsed for variable =  29969   array = 209887
elapsed for variable =  29888   array = 209699
elapsed for variable =  30235   array = 211679
test speed for 64
elapsed for variable =  46366   array = 358094
elapsed for variable =  33484   array = 357904
elapsed for variable =  35593   array = 357942
elapsed for variable =  36421   array = 358376
elapsed for variable =  34880   array = 358300
elapsed for variable =  36807   array = 357978
elapsed for variable =  36902   array = 357956
elapsed for variable =  33078   array = 357680
elapsed for variable =  34724   array = 358055
elapsed for variable =  33380   array = 357987

RELEASE x64
test speed for 32
elapsed for variable =  74742   array = 238943
elapsed for variable =  74613   array = 238674
elapsed for variable =  74580   array = 239054
elapsed for variable =  74504   array = 238877
elapsed for variable =  74759   array = 238828
elapsed for variable =  74518   array = 238862
elapsed for variable =  74883   array = 239424
elapsed for variable =  74698   array = 244281
elapsed for variable =  74820   array = 238945
elapsed for variable =  74495   array = 238827
test speed for 64
elapsed for variable =  90245   array = 238788
elapsed for variable =  93368   array = 238568
elapsed for variable =  96092   array = 239351
elapsed for variable =  89619   array = 238821
elapsed for variable =  100410  array = 239856
elapsed for variable =  93027   array = 238582
elapsed for variable =  90229   array = 238834
elapsed for variable =  89806   array = 238840
elapsed for variable =  97128   array = 238660
elapsed for variable =  94326   array = 238535


Занимательные результаты, правда!? Конечно же инкремент int64 в x86 медленнее чем int32 — это логично. Но, во-первых код под x64 прям заметно медленнее, а во-вторых даже на x64 инкремент int64 в x86 медленнее чем int32. Притом существенно медленнее!!!
Процессор-то не так прост оказывается..

На дизассемблер пока нет времени — чуть-чуть позже выложу (причёсывать и расписывать его долго). Там ничего не обычного.
Всё сказанное выше — личное мнение, если не указано обратное.
Отредактировано 14.03.2023 3:23 Философ . Предыдущая версия .
Re[6]: 32 bit
От: TailWind  
Дата: 14.03.23 07:46
Оценка:
Ф>Занимательные результаты, правда!?
Да
Сделайте кто-нибудь на C++ с оптимизацией, плиз
Я бы сам сделал, но долго разбираться как настроить компилятор на 64-бит

Ф>Во-вторых, как много у тебя математики на int64? Зачем она нужна? Ну кроме вычисления адреса.

У меня лично на каждом шагу. Для вычисления смещений больше 4ГБ
map<INT64, record> часто встречается. А там ещё и операции сравнения вылезают

Кстати хороший тест
Можно сравнить производительность map для ключей ULONG и UINT64, добавляя в него рандомнные значения
Отредактировано 14.03.2023 7:49 TailWind . Предыдущая версия .
Re[7]: 32 bit
От: TailWind  
Дата: 14.03.23 09:03
Оценка:
TW>Кстати хороший тест
TW>Можно сравнить производительность map для ключей ULONG и UINT64, добавляя в него рандомнные значения

template <class T>
void Test()
{
  map<T, ULONG> Map;
  //
  My_Timer Timer;
  //
  for (ULONG i=0; i<50000000; i++)
  Map[rand()] = 1;
  //
  printf(L"Time %d ms\n", Timer.ms());
}



Для 32-bit платформы и компилятора:
Для ULONG 6703 ms
Для UINT64 7641 ms

Интересно, что на 64-бит будет
Отредактировано 14.03.2023 9:07 TailWind . Предыдущая версия . Еще …
Отредактировано 14.03.2023 9:04 TailWind . Предыдущая версия .
Re[8]: 32 bit
От: Философ Ад http://vk.com/id10256428
Дата: 14.03.23 09:31
Оценка:
Здравствуйте, TailWind, Вы писали:

TW>Интересно, что на 64-бит будет


Не знаю — потом посмотрю. Я не плюсовик и настройка проекта для меня не секундное дело — тратить рабочее время на это не буду.
Тест ИМХО не очень: рэндомайзер убивает повторяемость. Если уж рэндомайзер, то надо надо много проходов, вместе с поиском медианы, минимума и стандартной ошибки.
Всё сказанное выше — личное мнение, если не указано обратное.
Re[9]: 32 bit
От: TailWind  
Дата: 14.03.23 09:36
Оценка:
Ф>Тест ИМХО не очень: рэндомайзер убивает повторяемость. Если уж рэндомайзер, то надо надо много проходов, вместе с поиском медианы, минимума и стандартной ошибки.
Не убивает
Он обязан выдавать одни и те же значаения при повторном запуске программы
Re[10]: 32 bit
От: Философ Ад http://vk.com/id10256428
Дата: 14.03.23 09:54
Оценка:
Здравствуйте, TailWind, Вы писали:

Ф>>Тест ИМХО не очень: рэндомайзер убивает повторяемость. Если уж рэндомайзер, то надо надо много проходов, вместе с поиском медианы, минимума и стандартной ошибки.

TW>Не убивает
TW>Он обязан выдавать одни и те же значаения при повторном запуске программы

Может быть, может быть... А сколько времени работал сам рэндомайзер в этом примере?
Всё сказанное выше — личное мнение, если не указано обратное.
Re[11]: 32 bit
От: TailWind  
Дата: 14.03.23 11:55
Оценка:
Ф>А сколько времени работал сам рэндомайзер в этом примере?
Не многим дольше чем i++
Re[5]: 32 bit
От: Евгений Музыченко Франция https://software.muzychenko.net/ru
Дата: 14.03.23 12:33
Оценка:
Здравствуйте, Aquilaware, Вы писали:

A>Знаменитые "640 килобайт хватит всем".


У меня, если что, еще ни один бинарник даже за 300 не перевалил, так что в 16-разрядном коде, при той же функциональности, оно бы и на 640 кб работало.

Всем, конечно, не хватит, но подавляющее большинство современного софта превышает реальные потребности в десятки-сотни раз.
Re[6]: 32 bit
От: rudzuk  
Дата: 14.03.23 18:40
Оценка: +2
Здравствуйте, Философ, Вы писали:

Ф> Занимательные результаты, правда!? Конечно же инкремент int64 в x86 медленнее чем int32 — это логично. Но, во-первых код под x64 прям заметно медленнее, а во-вторых даже на x64 инкремент int64 в x86 медленнее чем int32. Притом существенно медленнее!!!

Ф> Процессор-то не так прост оказывается..

Этот ваш дотнет — ненастоящий. Вот другие результаты:


Код: (увеличил количество итераций в 10 раз, время в миллисекундах)
program Project1;

uses
  SysUtils;

const
  Iterations = 100 * 1000 * 1000;

generic procedure TestSpeedIntX<IntX>;
var
  a,b,c,d,e,f,g,h : IntX;
  SmallArray : array[0..7] of IntX;
  VariablesIncrementTime, ArrayItemIncrementTime : Cardinal;
  i : NativeInt;
begin
  a := 0;
  b := 0;
  c := 0;
  d := 0;
  e := 0;
  f := 0;
  g := 0;
  h := 0;
  VariablesIncrementTime := GetTickCount;
  for i := 1 to Iterations do
    begin
      Inc(a);
      Inc(b);
      Inc(c);
      Inc(d);
      Inc(e);
      Inc(f);
      Inc(g);
      Inc(h);
    end;
  VariablesIncrementTime := GetTickCount - VariablesIncrementTime;

  ArrayItemIncrementTime := GetTickCount;
  for i := 1 to Iterations do
    begin
      Inc(SmallArray[0]);
      Inc(SmallArray[1]);
      Inc(SmallArray[2]);
      Inc(SmallArray[3]);
      Inc(SmallArray[4]);
      Inc(SmallArray[5]);
      Inc(SmallArray[6]);
      Inc(SmallArray[7]);
    end;
  ArrayItemIncrementTime := GetTickCount - ArrayItemIncrementTime;

  WriteLn('elapsed for variable = ', VariablesIncrementTime, ' array = ', ArrayItemIncrementTime);
end;

var
  i : NativeInt;
begin
  WriteLn;
  WriteLn({$INCLUDE %FPCTARGETOS%}, ' ', {$INCLUDE %FPCTARGETCPU%}, ' (Free Pascal ', {$INCLUDE %FPCVERSION%}, ')');
  WriteLn('test speed for 32');
  for i := 1 to 10 do
    specialize TestSpeedIntX<Int32>;

  WriteLn('test speed for 64');
  for i := 1 to 10 do
    specialize TestSpeedIntX<Int64>;
end.
avalon/3.0.2
Re[7]: 32 bit
От: TailWind  
Дата: 14.03.23 18:57
Оценка:
R>Код: (увеличил количество итераций в 10 раз, время в миллисекундах)

Надо бы ещё в 10 раз увеличить
А то больно 16 мс погрешность gettckcount вылезает
Re[8]: 32 bit
От: rudzuk  
Дата: 14.03.23 19:10
Оценка: 2 (1)
Здравствуйте, TailWind, Вы писали:

TW> Надо бы ещё в 10 раз увеличить

TW> А то больно 16 мс погрешность gettckcount вылезает

avalon/3.0.2
Re[9]: 32 bit
От: TailWind  
Дата: 14.03.23 19:34
Оценка:
Класс!
Ну и кто это может объяснить?

Почему 32-бит на 64 медленней?

Хотя у array одинаково
Может паскалевские замарочки?
Отредактировано 14.03.2023 20:04 TailWind . Предыдущая версия .
Re[9]: 32 bit
От: Евгений Музыченко Франция https://software.muzychenko.net/ru
Дата: 14.03.23 20:12
Оценка: 8 (1)
Здравствуйте, Философ, Вы писали:

Ф>Я не плюсовик и настройка проекта для меня не секундное дело


Грешно для такой мелочи создавать проект. Достаточно положить текст в файл .cpp, открыть консоль, вызвать командный файл настройки окружения (например, в VS 2019 это C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvarsall.bat) с параметром x86 или x64, и потом дать команду cl file.cpp. Оно само скомпилирует и соберет в EXE.
Re[10]: 32 bit
От: Marty Пират https://www.youtube.com/channel/UChp5PpQ6T4-93HbNF-8vSYg
Дата: 14.03.23 20:23
Оценка: :)
Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Грешно для такой мелочи создавать проект. Достаточно положить текст в файл .cpp, открыть консоль, вызвать командный файл настройки окружения (например, в VS 2019 это C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvarsall.bat) с параметром x86 или x64, и потом дать команду cl file.cpp. Оно само скомпилирует и соберет в EXE.


Фу, сколько телодвижений. У меня для такого cxx03.bat/cxx11.bat/cxx14.bat/cxx17.bat в путях лежат
Маньяк Робокряк колесит по городу
Re[11]: 32 bit
От: Евгений Музыченко Франция https://software.muzychenko.net/ru
Дата: 14.03.23 20:39
Оценка:
Здравствуйте, Marty, Вы писали:

M>У меня для такого cxx03.bat/cxx11.bat/cxx14.bat/cxx17.bat в путях лежат


У меня таких два десятка лежит. А у того, кому отвечал, таких явно нет.
Re[7]: 32 bit
От: Философ Ад http://vk.com/id10256428
Дата: 14.03.23 21:18
Оценка:
Здравствуйте, rudzuk, Вы писали:

R>Этот ваш дотнет — ненастоящий. Вот другие результаты:

R>Image: KwE4NVU.png

R>Код: (увеличил количество итераций в 10 раз, время в миллисекундах)

R>
program Project1;

R>  VariablesIncrementTime := GetTickCount;


Понятно Наши паскалисты не настоящие.
Не настоящие!
  боже, какой позор
   [__DynamicallyInvokable]
    public long ElapsedTicks
    {
      [__DynamicallyInvokable] get => this.GetRawElapsedTicks();
    }
    [__DynamicallyInvokable]
    public static long GetTimestamp()
    {
      if (!Stopwatch.IsHighResolution)
        return DateTime.UtcNow.Ticks;
      long num = 0;
      SafeNativeMethods.QueryPerformanceCounter(out num);
      return num;
    }

    private long GetRawElapsedTicks()
    {
      long elapsed = this.elapsed;
      if (this.isRunning)
      {
        long num = Stopwatch.GetTimestamp() - this.startTimeStamp;
        elapsed += num;
      }
      return elapsed;
    }

    [DllImport("kernel32.dll")]
    public static extern bool QueryPerformanceCounter(out long value);

Всё сказанное выше — личное мнение, если не указано обратное.
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.