На главную Наши проекты:
Журнал   ·   Discuz!ML   ·   Wiki   ·   DRKB   ·   Помощь проекту
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS
msm.ru
! Правила раздела *nix / gcc / Eclipse / Qt / wxWidgets / GTK+
  • При создании темы ОБЯЗАТЕЛЬНО указывайте версию тулкита / библиотеки / компилятора.
  • Перед тем как задать вопрос, сформулируйте его правильно, чтобы вас могли понять.
  • Нарушение Правил может повлечь наказание со стороны модераторов.


Полезные ссылки:
user posted image Boost по-русски
user posted image Qt по-русски
Модераторы: archimed7592
Страницы: (2) [1] 2  все  ( Перейти к последнему сообщению )  
> Qt v.5.5.1. Существует ли простой путь узнать, сколько оперативной
    .памяти свободно?
      Кроссплатформенного варианта в Qt пока нет, в стандарте С++ - тем более.
      Но, по сути, это тривиальный вопрос, если замутить получение через API конкретной ОС.
        Поднятый в теме вопрос лично для меня очень актуальный: как определить максимальный размер оперативки (да еще и желательно непрерывный), чтобы программа не лезла в SWAP.
        Вот такой выход пока для себя нашел в кроссплатформенном коде Linux/Windows:
        ExpandedWrap disabled
          // Определение ОС (спасибо участнику нашей конференции)
          #if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
          #define WINDOWS
          #elif defined(__linux__)
          #define Linux
          #elif defined(__APPLE__) || defined(__MACH__)
          #define MacOS
          #elif defined(__FreeBSD__)
          #define FreeBSD
          #elif defined(__ANDROID__)
          #define Android
          #elif defined(sun) || defined(__sun)
          #if defined(__SVR4) || defined(__svr4__)
          #define SOLARIS
          #else
          #define SunOS
          #endif
          #elif defined(__QNX__) || defined(__QNXNTO__)
          #define QNX
          #else
          #error Unknown OS
          #endif
           
          #include <stdlib.h>
          #include <stdio.h>
          #include <time.h>
          #include <string.h>
           
          // Подключение структур, в т.ч. и для работы с памятью
          #ifndef WINDOWS
          #include <sys/sysinfo.h>
          #else
          #define UNICODE
          #include <sysinfoapi.h>
          #endif
           
          // А это чтобы русские символы универсально выводить в Linux/Windows
          #include <locale.h>
          #include <iconv.h>
           
          // Информация об основных параметрах ОС (главным образом - RAM)
          #ifndef WINDOWS
          struct sysinfo osInfo;
          char cSl = '/';
          #else
          MEMORYSTATUSEX osInfo;
          char cSl = '\\';
          #endif
           
          // Ниже - фрагмент кода работы с RAM. С пояснениями по типу переменных
               // Чтение информации о состоянии операционной системы
          #ifndef WINDOWS
               sysinfo(&osInfo);
               // unsigned long long int iMemMax, iDMem;
               iMemMax = osInfo.freeram - (osInfo.freeram / 100) * 4; // 4% от свободной памяти
               iDMem   = osInfo.totalram / 1000 + 1;
          #else
               osInfo.dwLength = sizeof(osInfo);
               if (!GlobalMemoryStatusEx(&osInfo)) { // osInfo.freeram;
                   PrintCons("Не могу определить размер динамической памяти!\n");
                   return -1;
               }
               iMemMax = osInfo.ullAvailPhys;
               iDMem   = osInfo.ullTotalPhys / 1000 + 1;
          #endif
           
               // signed char *pByte; - Указатель, "нарезающий" выделяемую память для массивов данных
               pByte = (signed char*)calloc(iMemMax, sizeof(signed char));
               while (!pByte && (iMemMax > iDMem)) {
                   iMemMax -= iDMem;
                   pByte = (signed char*)calloc(iMemMax, sizeof(signed char));
               }
               if (!pByte) {
                   PrintCons("Не могу выделить динамическую память!\n");
                   return -1;
               }
           
          // Итоговая информация - сколько RAM удалось выделить.
          // Моему возмущению нет предела - модификаторы long long int разные в Linux и в Windows
          #ifndef WINDOWS
               PrintCons("Динамической памяти "); printf("RAM = %lld Mbyte\n", iMemMax / 1048576);  // 1048576   = 1024 *1024
          #else
               PrintCons("Динамической памяти "); printf("RAM = %I64d Mbyte\n", iMemMax / 1048576); // 1048576   = 1024 *1024
          #endif


        Пока выделаю RAM именно таким способом.
        Был бы рад, если будет сделан более эффективный код.
        Мне важно, чтобы огромные массивы данных строго лежали в RAM и не сбрасывались в SWAP - идет расчет труднорешаемых комбинаторных задач типа Задачи Коммивояжера.

        P.S. Я примерно такую же тему поднимал на форуме раньше. Мне были даны весьма дельные советы, но пока руки не дошли их проверить на практике.
          Цитата mkudritsky @

          Хороший исходник. Заглотил, буду тестить #скоро.
            Цитата Сергей85 @
            Заглотил, буду тестить

            Интересно было бы почитать Ваше мнение!
            Но сначала, раз есть заинтересованность, дополню свой код выше.
            А именно, как я использую ссылку на начало области динамической памяти pByte для нарезания реальных данных:
            ExpandedWrap disabled
              // Максимальный объем динамической памяти суммарный задействованный объем динамической памяти. В байтах.
              unsigned long long int    iMemMax, iMem;
              // Указатель на начало максимального выделенного объема динамической памяти
              signed char *pByte;    
               
              // Ну и пример выделяемой структуры динамической памяти
              short iNg, *iOpt;    // Длина массива двухбайтных чисел и ссылка на его начало
               
              // Пока ни одного байта динамической памяти не выделено
              iMem = 0;
               
              // Собственно, выделение памяти:
              iNg = 5000;
               
              iOpt = (short *)(pByte + iMem);  // calloc(iNg, sizeof(short)); - так бы память выделялась "по классике"
              iMem += iNg * sizeof(short);
              if (iMem > iMemMax) {
                  PrintCons("Не могу выделить память!\n"); return -1;
              }
               
              // Ну и так далее. Именно таким способом выделяю память для массивов, записей, всяких там связанных списков и других переменных структур
               
              // Ну а освобождается вся выделенная память одним элегантным движением:
              free(pByte);


            Далее.
            Вот мои предварительные замечания по работе с максимальным объемом памяти в Windows 7 и в Debian 9, 11.
            1. Windows 7.
            К моему удивлению здесь память выделяется аккуратно и массивы данных не сливаются в SWAP. Это удивительно, т.к. в свое время к Win XP SP2 у меня тут были большие претензии.
            Минус один - сама по себе Windows занимает много RAM (от 2Гб и более) и на прикладную задачу остается мало RAM.
            Особенно это чувствуется на 32-bit системах. Максимум, что тут удалось добиться - 1.8Гб RAM для расчетов из 3.8Гб в наличии.

            2. Linux (Debian 9, 11 с самой легкой графической оболочкой OpenBox).
            Тут система занимает совсем немного (32bit около 150Мб и 64bit около 250Мб) и почти вся RAM доступна для прикладной задачи.
            Но есть в Linux один жирный минус - неконтролируемое сливание массивов данных в SWAP.
            Код, который я привел в предыдущем сообщении, смягчает эту проблему, но полностью ее не решает!
            Дело дошло до того, что я просто удалил раздел для файла подкачки!
            Но от ручного контроля за RAM это не освободило - часто Linux, обнаружив, что прикладная программа жрет слишком много памяти, попросту выкидывает ее из списка исполняемых задач!
            Например, я заметил, что на 32bit системе с 2Гб физической RAM задаче можно позволить выделить не более 1.6Гб RAM - иначе система снимет ее со счета!

            3. С каждым новым запуском программы RAM выделяется все больше и больше.
            Это понятно - Windows неиспользуемые (но запущенные!) программы сбрасывает в SWAP, а Linux (поскольку SWAP я отключил) просто выгружает лишнее из памяти.
            Весь вопрос в том, чтобы как-то нащупать тот самый золотой предел - чтобы после очередного выделения максимального куска RAM и задача не снималась со счета, и чтобы система вела себя устойчиво.
            Как я уже сказал выше, в этом аспекте мне пока Win нравится больше, чем Linux.

            Кстати, раньше (а я Linux использую с 1998 года) в Linux при загрузке ОС можно было послать сигнал single ядру системы.
            При этом Linux грузился без графики в командной строке чуть ли не в однозадачном режиме.
            Но при этом все ресурсы ПК, включая максимальную RAM и почти 100% времени процессора, были доступны одной-единственной прикладной задаче.
            Сейчас я это не проверял...
              Цитата mkudritsky @

              Давайте добивать эту <sensored> тему. Где-то близко уже. У меня мозги вытекли - орпечатки могут быть. Скрины - в след сообщении понатыкаю.

              С вашим кодом что-то не так, примерное описание (в Qt 5.5.1 переделывал в винде):
              - по дефайнам: лучше не "если не винда, то линукс", а "если не линукс - то винда". По крайней мере, в этой среде работает только так. Соответственно, убираются большинство дефайнов типа MACOS. И код в результате упрощается по чтению и становится много меньше;
              - по функциям: у вас GlobalMemoryStatusEx принадлежит линуксу - когда такая функция есть в винде в инклудах, например, билдера 6-го в winbase.h, а в Qt - в "sysinfoapi.h". Я подозреваю, ваш код работал лишь потому, что дефайн Windows отрабатывал ложно - и путаница в функциях распутывалась в обратную сторону;
              - "// Моему возмущению нет предела - модификаторы long long int разные в Linux и в Windows". Используйте qint64 в Qt или __int64 в любой другой среде.

              С ОС Windows XP x32 что-то не так:
              - при отключенном файле подкачки, диспетчер задач показывает размер "файла подкачки";
              - при сравнении скринов просто программы и программы, подмявшей под себя гиг, - диспетчер видит этот гиг в поле "файла подкачки", а в структуре изменения неоднозначные (сравните числа);
              - ни с файлом подкачки, ни без него, Qt не дает возможности выделить больше памяти, чем есть свободной RAM.

              С моими мозгами что-то не так:
              - как понимаю: нужно как-то получить число ярко-зеленое - и вычесть его из размера планок памяти в ПК (по крайней мере, это 100% рабочий способ был бы);
              - или смотреть поле структуры AvailVirtual или AvailPagefile. Но какое из них правильное - непонятно, ввиду их малого различия. Возможно, это "доступно" и "системный кеш" на рисунке;
              - сделал разницу двух структур при выделении 1 гибибайта - получил что на скрине. Возможно, кто-то сожрал 4КБ между операциями выделения и удаления массива. Интересно то, что запуская код в разное время - условие ошибки никогда не срабатывает: равенство на скрине сохраняется;
              - выгрузил Notepad++ при включенном и выключенном файле подкачки - количество в ullAvailVirtual НЕ изменилось (кеширование какое-нибудь?). Но количество Доступно в диспетчере задач изменилось! То есть, ullAvailVirtual не равно "Доступно". Прям видно, как число "Доступно" меняется в диспетчере задач, когда график меняется. НО одновременно с этим "Доступно" не меняется, если сожрать 1ГБ и подержать несколько секунд! То есть, непонятно, кто из этих двоих врет;
              - в Linux не пробовал, прошу проработать этот вопрос вами лично, т.к. сам плаваю (какие h-файлы и функции использовать и т.д.);
              - самый главный вопрос. Предположим, ullAvailVirtual - количество свободной RAM. А выделять-то сколько можно? 99%? Кто-то же влез и сожрал 4К посторонний.

              ExpandedWrap disabled
                //Основное.
                #include "mainwindow.h"
                #include "ui_mainwindow.h"
                 
                //Получение объема свободной RAM.
                #ifdef Q_OS_LINUX
                    //
                #else
                    #include "sysinfoapi.h"
                #endif
                 
                qint64 qi64Free_RAM(void)
                {
                    qint64 qi64Result = -1;
                 
                    #ifdef Q_OS_LINUX
                        //struct sysinfo memstatus;
                        //sysinfo(&memstatus);
                    #else
                        //Для понимания, какую именно часть структуры использовать для получения свободной именно RAM, а не файла подкачки или чего-либо еще, - нужно ввести несколько структур и анализировать их от машины к машине, что покажет корректность алгоритма.
                        MEMORYSTATUSEX memstatus_Nominal, memstatus_Plus_1GB, memstatus_Different;
                 
                        memstatus_Nominal.dwLength = sizeof(memstatus_Nominal);
                        memstatus_Plus_1GB.dwLength = sizeof(memstatus_Plus_1GB);
                        memstatus_Different.dwLength = sizeof(memstatus_Different);
                 
                        GlobalMemoryStatusEx(&memstatus_Nominal);
                        qint64 *qi64Array_Memory = new qint64[134217728]; //+1 гибибайт.
                        GlobalMemoryStatusEx(&memstatus_Plus_1GB);
                        for (qint64 ttt=0; ttt<134217728*15; ttt++){} //Тут видно, что "файл подкачки" увеличился, а "Доступно" не уменьшилось.
                        delete []qi64Array_Memory;
                 
                        memstatus_Different.dwLength = memstatus_Nominal.dwLength - memstatus_Plus_1GB.dwLength;
                        memstatus_Different.dwMemoryLoad = memstatus_Nominal.dwMemoryLoad - memstatus_Plus_1GB.dwMemoryLoad;
                        memstatus_Different.ullAvailExtendedVirtual = memstatus_Nominal.ullAvailExtendedVirtual - memstatus_Plus_1GB.ullAvailExtendedVirtual;
                        memstatus_Different.ullAvailPageFile = memstatus_Nominal.ullAvailPageFile - memstatus_Plus_1GB.ullAvailPageFile;
                        memstatus_Different.ullAvailPhys = memstatus_Nominal.ullAvailPhys - memstatus_Plus_1GB.ullAvailPhys;
                        memstatus_Different.ullAvailVirtual = memstatus_Nominal.ullAvailVirtual - memstatus_Plus_1GB.ullAvailVirtual;
                        memstatus_Different.ullTotalPageFile = memstatus_Nominal.ullTotalPageFile - memstatus_Plus_1GB.ullTotalPageFile;
                        memstatus_Different.ullTotalPhys = memstatus_Nominal.ullTotalPhys - memstatus_Plus_1GB.ullTotalPhys;
                        memstatus_Different.ullTotalVirtual = memstatus_Nominal.ullTotalVirtual - memstatus_Plus_1GB.ullTotalVirtual;
                 
                        //Во время выделения и удаления памяти может кто-то вмешаться и сожрать/освободить немного - выделяемый 1ГБ будет разницей ullAvailVirtual и ullAvailPhys.
                        if (memstatus_Different.ullAvailVirtual-memstatus_Different.ullAvailPhys != 1073741824)
                        {
                            //Ошибка при работе с оперативной памятью.
                        }
                        else qi64Result = memstatus_Nominal.ullAvailVirtual;
                    #endif
                 
                    return qi64Result;
                }
                1 - выделено 1ГБ под массив.JPG
                Прикреплённая картинка
                Прикреплённая картинка


                2 - высвобождено.JPG
                Прикреплённая картинка
                Прикреплённая картинка


                3 - проблема отображения и поведения чисел.JPG
                Прикреплённая картинка
                Прикреплённая картинка


                4 - математика структуры.JPG
                Прикреплённая картинка
                Прикреплённая картинка
                Сообщение отредактировано: Сергей85 -
                  Сергей85, в эту тему не заглядывал?
                    Цитата Qraizer @

                    В вашей теме еще сложнее. Как понял, оперативка выделяется долго по времени. Мне же нужно, по факту, проверить до 32ГБ RAM за 16сек. Такой алгоритм я написал, но в задаче есть слово "до". Отсюда и все проблемы. То есть, мне размер свободной RAM надо узнать мгновенно.
                    Сообщение отредактировано: Сергей85 -
                      Видишь ли, Сергей85, в нынешних реалиях понятие "свободная RAM" отсутствует как формальный термин. У него много значений. Мгновенно, всего за один вызов API, ты можешь получить цифру, и это будет свободная RAM вот прям на текущий момент. Проблема в том, что эта цифра, во-первых, так же мгновенно станет неактуальной, во-вторых, не учитывает потребностей фоновых и системных процессов. В той теме была немного другая задача: получить максимум памяти, когда ещё поведение системы не деградирует. Как по мне, это более приближённая к реальности задача, опирающаяся на другое определение термина "свободная RAM".
                      Сообщение отредактировано: Qraizer -
                        Цитата Qraizer @

                        Это все понятно. Я говорю о том пока, что я получаю цифру свободной RAM - только она странная. Значение в структуре противоречит числу в диспетчере задач. А число в диспетчере задач само ведет себя странно, когда либо вообще не изменяется после выделения памяти и ее высвобождении, либо не до конца назад увеличивается.

                        Сейчас заметил, что если Qt и программу закрыть - память очищается почти до конца. А вот если просто все delete отработали и прога висит в состоянии покоя - число в диспетчере задач не меняется. Вот и думай, почему это.
                        Сообщение отредактировано: Сергей85 -
                          Если ты попытаешься поработать со своим понятием этого термина, то скорее всего на старте получишь ещё более дикие тормоза, которые в дальнейшем не исчезнут, потому что свопиться будет всё остальное. Помимо прочего, ты можешь вообще не получить такого объёма памяти, если совсем "обнаглеешь". Разве что тебя устроит фрагментированная на куски "свободная RAM". Пример из той темы лишён этих недостатков. Да, выделяет меньше, но и система при этом живёт и здравствует, и память не свопится. К тому же, это ж только шаблон, вполне может быть изменён под твои нужды.

                          Добавлено
                          Сейчас вот повторил эксперимент. Win10Pro 64, 21H2. 16Гб RAM. Вчера ребуталась после наката обновлений. Активны три интерактивные учётные записи под Fast User Switch. Утилизация памяти 34%. Запуск первого экземпляра.
                          ExpandedWrap disabled
                            Allocated 45812984488 bytes
                            Residented 11453246120 bytes
                            Locked 7635497393 bytes
                          Время до чекпоинта 27 секунд, утилизация памяти 72%. Запуск второго экземпляра.
                          ExpandedWrap disabled
                            Allocated 34359738365 bytes
                            Residented 2863311528 bytes
                            Locked 1908874333 bytes
                          Здесь и далее время замерять нет смысла, по сути это практически мгновенно. Утилизация памяти 82%. Запуск третьего экземпляра.
                          ExpandedWrap disabled
                            Allocated 34359738365 bytes
                            Residented 715827880 bytes
                            Locked 477218569 bytes
                          Утилизация 88%. Запуск четвёртого экземпляра.
                          ExpandedWrap disabled
                            Allocated 34359738365 bytes
                            Residented 89478483 bytes
                            Locked 59652312 bytes
                          Утилизация, внезапно, 87%. Запуск пятого экземпляра.
                          ExpandedWrap disabled
                            Allocated 34359738365 bytes
                            Residented 25165821 bytes
                            Locked 16777211 bytes
                          Утилизация снова 88%.
                          Этот пост я пишу в Vivaldi при всё ещё активных всех пяти экземпляров. После запуска первого экземпляра Vivaldi приходил в себя те же полминуты и мышь ездила с трудом, и это был единственный шоковый для системы момент. Далее утилизация не меняется ан-нет, под момент отправки поста достигла 90%, свопов нет, система не деградирует, работает как будто у неё не откусывали 10Гб из 16, причём ещё 4 занято фоновыми процессами. При этом я дополнительно открыл калькулятор, ещё один Far Manager, новую вкладку в Vivaldi и попростил гугл посчитать в ней сумму 7635497393+1908874333+477218569 +59652312 + 16777211.
                          Тормоза и шок при запуске первого экземпляра 100пудово из-за того, что система заюзала ту самую "свободную RAM", потому что она никем не использовалась. И начала активно её освобождать как только на неё нашёлся охотник. Вот и думай, а была ли она в натуре свободной. С одной стороны да, ведь она так или иначе была передана по первому требованию, с другой же, ...хм... "я тут посижу, пока никого нет и сразу же уйду, как только кто-то придёт с билетом на это место" не везде прокатывает.

                          Добавлено
                          Ну т.е. я к чему. Твоё понятие свободной RAM почти наверняка не соответствует твоим ожиданиям от результата овладения ею. Если у тебя чётко поставленная задача, то имеет смысл озаботиться её оптимизацией, но нужно быть готовым к огромной куче частных решений, зависящих от ОС. Даже от версии ОС, не только её семейства. Вроде бы Qt прямо для противоположного, но тебе виднее. Тогда, возможно, ты найдёшь наиоптимальнейшее решение, превосходящее качеством системное. Иначе же положись на саму ОС. Ей виднее, как рулить ресурсами в подавляющем большинстве общих сценариев. Хотя бы потому, что у неё есть статистика по всем процессам, а у тебя только по твоему.

                          Добавлено
                          Цитата Сергей85 @
                          Сейчас заметил, что если Qt и программу закрыть - память очищается почти до конца. А вот если просто все delete отработали и прога висит в состоянии покоя - число в диспетчере задач не меняется. Вот и думай, почему это.
                          Та чё тут думать-то. У Qt свой менеджер хипа. Кушает память у ОС по мере необходимости и очень неохотно отдаёт обратно. Если вообще отдаёт.
                          Сообщение отредактировано: Qraizer -
                            Пока получается так.

                            Для доказательства, какая именно переменная структуры GlobalMemoryStatusEx(&osInfo) отвечает за свободную память, пришлось выяснить:
                            - предполагаемое число "Доступно" в диспетчере задач создает иллюзию показа динамически изменяющегося числа RAM - но это число не изменяется при высвобождении RAM исходным кодом. Число изменяется только с выходом из ПО. А в структуре это число всегда динамически меняется сразу и после выледения, и после высвобождения;
                            - предполагаемое число ullAvailVirtual в структуре было очень схожим с ullAvailPageFile - даже при отключенном файле подкачки;
                            - в диспетчере задач абсолютно четко видно изменение яркого зеленого числа "Файл подкачки" и при выделении, и при высвобождении RAM;
                            - полный размер оперативной памяти содержится в ullTotalPhys: физический размер RAM минус RAM, выделенная для встроенной видеокарте в BIOS;
                            - разница между ullTotalPhys и ullAvailVirtual практически равна яркому зеленому числу "Файл подкачки" диспетчера задач;
                            - в итоге, делается акцент на ullAvailVirtual;
                            - остается вопрос, что делать с разницей ullAvailPhys: почему практически всегда изменяется на 4КиБ, ведь он должен быть константой. В XP всегда 4КиБ. В вин7 ullAvailPhys=0, но ullAvailVirtual все равно = 1ГиБ +4КиБ;
                            - в т.ч. отсюда порождается и конечный вопрос: насколько правомерно забивать 100% ullAvailVirtual, если может кто-то влезть. Возможно, нужно забивать 99%.


                            Однако известное количество свободной RAM не значит, что ОС/среда позволит всю ее использовать.
                            Закомментированный пример показывает, что не удалось использовать даже 90% RAM: критическая ошибка и закрытие ПО.
                            qint64 *qi64Array_All_RAM = new qint64[int(qi64Result/8 *9/10)];
                            delete []qi64Array_All_RAM; qi64Array_All_RAM = NULL;

                            ВыЯснилось, что в XP, 7 x32, 7 x64 на одном и том же ПК проблема одна и та же: не получается использовать больше 70% RAM. И только в 7 x64 среда разработки бзднула в вывод приложения и показала ошибку. Очень большая вероятность, что именно Qt и именно версии 5.5.1 есть порождение этой ошибки. Тот же самый код позволил в Linux выделить 7.5ГиБ из физических 8 на другом системнике без проблем - но там Qt 5.11.

                            Прикреплённая картинка
                            Прикреплённая картинка


                            Диспетчер задач 7-ки тоже глючный, но по-своему: неправильно показывает Свободно, Память. Правильно - Выделение памяти в Мониторе ресурсов.

                            Прикреплённая картинка
                            Прикреплённая картинка


                            Прикреплённая картинка
                            Прикреплённая картинка
                            Сообщение отредактировано: Сергей85 -
                              Макетирование на том же самом компе, но с Астрой и Qt v.5.11 позволило выделить без проблем 2.5ГиБ одной строкой. Linux установлен без раздела SWAP. Не догадался начать заполнять массив и посмотреть на лампочку харда.

                              Осталось методом от противного в XP поставить Builder 2002 года и попробовать выделить 1.5ГиБ там - что окажется больше, чем в Qt 5.5.1 в XP. И доказать, что Qt прошлых версий - отстой.

                              Прикреплённая картинка
                              Прикреплённая картинка
                                В Astra + Qt v.5.11 оказалось все много проще. Количество свободной памяти показывает правильно. Память заполняется только тогда, когда начинаешь данные в массив помещать. Хард не задействуется, файл подкачки тоже (в структуре это видно). Заполнил пока не на 100%. Обратил внимание, что память пытается освобождаться по мере возможности в Astra: то было 2.6ГБ свободно - а после манипуляций забивания 2.2ГБ - стало 2.9ГБ. Компилятор высвобождает память сразу после delete, в отличие от Qt v.5.5.1.

                                Прикреплённая картинка
                                Прикреплённая картинка


                                Прикреплённая картинка
                                Прикреплённая картинка


                                Прикреплённая картинка
                                Прикреплённая картинка


                                Прикреплённая картинка
                                Прикреплённая картинка


                                Прикреплённая картинка
                                Прикреплённая картинка


                                Зависимостей между цифрами структуры не увидел.

                                Прикреплённая картинка
                                Прикреплённая картинка


                                Где исправить настройки, чтобы можно было рисунки >200КБ заливать? Это ад какой-то с уменьшением размеров, затирая "лишнее".

                                С билдером выделил 2ГБ - что больше ~1.3ГБ в Qt. Дальше пока пробовать не стал. То есть, Qt v.5.5.1 - лютое гнище, и для данной задачи не подходит.

                                Прикреплённая картинка
                                Прикреплённая картинка



                                Пока резюме такое. Astra v.2.12.43 + Qt v.5.11 в ее составе - способны решить задачу обнаружение именно правильного количества RAM и ее забития чем-то. То есть, определение свободной RAM и работа с ней - не тривиальная задача, зависящая напрямую от ОС и среды программирования. Пока создается впечатление, что больше от среды.
                                0 пользователей читают эту тему (0 гостей и 0 скрытых пользователей)
                                0 пользователей:


                                Рейтинг@Mail.ru
                                [ Script execution time: 0,2178 ]   [ 24 queries used ]   [ Generated: 10.12.22, 04:23 GMT ]