Восстановление после отказа динамического выделения памяти

Существует много хороших вещей в других ответах, но я действительно думал это стоящий добавления что, если все потоки войдут в подобный цикл, то программа будет заведена в тупик.

"Корректный" ответ на эту ситуацию должен, вероятно, иметь строгие пределы для различных частей программы, чтобы гарантировать, чтобы они не переделывали, используют память. Это, вероятно, потребовало бы переписывающих главных разделов через все части программы.

Следующее лучшее решение состояло бы в том, чтобы иметь некоторый обратный вызов, где неудавшаяся попытка выделения может сказать остальной части программы, что больше памяти необходимо. Возможно, другие части программы могут выпускать некоторые буферы более настойчиво, чем они обычно были бы, или освобождать память, используемую для кэширования результатов поиска или чего-то. Это потребовало бы нового кода для других частей программы. Однако это могло быть сделано инкрементно, вместо того, чтобы требовать переписывания через всю программу.

Другое решение состояло бы в том, чтобы иметь программу, защищают большие (временные) запросы памяти со взаимным исключением. Это кажется, что Вы уверены, что память будет скоро освобождена, если можно просто попробовать еще раз позже. Я предлагаю, чтобы Вы использовали взаимное исключение для операций, которые могли бы использовать большую память, это позволит потоку быть разбуженным сразу, когда другой поток освободил память, которая необходима. Иначе Ваш поток будет спать в течение одной десятой секунды, даже если память освободит сразу.

Вы могли бы также попробовать сон (0), который просто вручит от управления любому другому потоку, который готов работать. Это позволит Вашему потоку сразу восстановить управление, если все другие потоки заснут, вместо того, чтобы иметь необходимость переждать его 100 предложений миллисекунды. Но если по крайней мере один поток все еще хочет работать, необходимо будет все еще ожидать, пока он не бросает управление. Это обычно - 10 миллисекунд на машинах Linux, в последний раз я проверил. Я не знаю о других платформах. Ваш поток может также иметь более низкий приоритет в планировщике, если он добровольно заснул.

Вы пытаетесь решить глобальную проблему посредством локального обоснования. Глобальная проблема состоит в том, что все устройство имеет ограниченную сумму RAM (и возможно запоминающее устройство) для операционной системы и всех приложений. Для проверки эта сумма RAM не превышена, у Вас есть несколько опций:

• Каждый процесс работает в установленной сумме RAM, которая будет определена для каждого процесса во время запуска; программист делает обоснование, чтобы удостовериться, что все соответствует. Так, да, возможно выделить все статически. Это - просто большая работа, и каждый раз, когда Вы изменяете конфигурацию своей системы, необходимо пересмотреть выделения.

• Процессы знают о своем собственном использовании памяти и потребностях и постоянно сообщают друг другу о том, в каком количестве памяти они нуждаются. Они сотрудничают так, у них не заканчивается память. Это предполагает, что по крайней мере некоторые процессы в системе могут скорректировать свои собственные требования к памяти (например, путем изменения размера внутреннего кэша). Alonso и Appel написали работу об этом подходе.

• Каждый процесс знает, что память может стать исчерпанной и может заменить к состоянию, в котором это использует минимальный объем памяти. Часто эта стратегия реализована при наличии исключения из памяти. Исключение обработано в или почти основное (), и событие из памяти по существу перезапускает программу с нуля. Этот режим обработки отказа может работать, если память растет в ответ на пользовательские запросы; если требования к памяти программы становятся независимыми от того, что делает пользователь, это может привести к перегрузке.

Ваше предложение выше не соответствует ни одному из сценариев. Вместо этого Вы надеетесь, что некоторый другой процесс решит проблему и память, в которой Вы нуждаетесь, в конечном счете появится. Вы могли бы стать удачливыми. Вы не могли бы.

Если бы Вы хотите, чтобы Ваша система работала надежно, Вы преуспели бы для пересмотра дизайна каждого процесса, работающего на системе в свете потребности совместно использовать ограниченную память. Это могло бы быть большее задание, чем Вы ожидали, но если Вы понимаете проблему, можно сделать это.Удачи!

На основе Вашего вопроса я предполагаю, что Ваша "куча" совместно используется несколькими потоками.

Если это не будет затем код выше, то не будет работать, потому что ничто не будет освобождено от "кучи", в то время как цикл работает.

Если бы "куча" совместно используется, то вышеупомянутое, вероятно, работало бы. Однако, если у Вас будет общая "куча", то затем называние "новым", вероятно, приведет к любому спин-блокировка (подобный цикл к тому, который Вы имеете, но использование инструкции CAS), или это заблокируется на основе некоторых ресурсов ядра.

В обоих случаях цикл, который Вы имеете, уменьшит пропускную способность Вашей системы. Это вызвано тем, что Вы или подвергнетесь большему количеству контекстных переключений затем, Вы должны или займете больше времени для ответа на "память, теперь доступное" событие.

Я рассмотрел бы переопределение "нового" и "удалил" бы операторы. Когда новые сбои, которые можно заблокировать (или спин-блокировка на какой-то переменной счетчика) ожидающий другого потока к свободной памяти и затем удалить, могут или сигнализировать о заблокированном "новом" потоке или увеличить переменную счетчика с помощью CAS.

Это должно дать Вам лучшую пропускную способность и быть немного большим количеством efficent

Несколько точек:

• Встроенные программы часто выделяют всю память при запуске или используют только статическое ЗУ для предотвращения таких ситуаций.
• Если нет что-то еще работающее на устройстве, которое освобождает память регулярно, Ваше решение, вероятно, не будет эффективным.
• У Гадюки, которую я имею, есть 64 МБ RAM, я не думаю, что они идут меньше чем с 32 МБ, сколько памяти Ваше приложение использует?

Я второй, что самая разумная вещь сделать состоит в том, чтобы использовать статическое выделение памяти, таким образом, у Вас есть некоторая идея того, что продолжается. Динамическое выделение памяти является дурной привычкой от рабочего стола, программируя, который не подходит на машинах ограниченного ресурса (если Вы не проводите немного времени и усилия, создающего хорошую управляемую и управляемую систему управления памятью).

Кроме того, проверьте, какие функции ОС в Вашем устройстве (принимающий это имеет один, высокопроизводительные устройства ARM как этот, имеет тенденцию выполнять, ОС) имеет для обработки памяти.

Вы используете C++. Таким образом, можно использовать некоторые утилиты C++ для создания жизни легче. Например, почему бы не использовать new_handler?

void my_new_handler() {
    // make room for memory, then return, or throw bad_alloc if
    // nothing can be freed.
}

int main() {
    std::set_new_handler(&my_new_handler);

    // every allocation done will ask my_new_handler if there is
    // no memory for use anymore. This answer tells you what the
    // standard allocator function does: 
    // https://stackoverflow.com/questions/377178
}

В new_handler Вы могли послать все заявления сигнал так, чтобы они знали, что память необходима для некоторого приложения, и затем ожидайте немного, чтобы дать другим приложениям время для обрабатывания запроса для памяти. Важный то, что Вы делаете что-то и не тихо надеетесь на доступную память. Новый оператор назовет Ваш обработчик снова, если все еще достаточно памяти не будет доступно, таким образом, Вы не должны волноваться о том, имеют ли все приложения уже free'ed необходимая память. Можно также перегрузить оператор, новый, если необходимо знать размер памяти, которая необходима в new_handler. См. мой другой ответ о том, как сделать это. Таким образом, у Вас есть одно центральное место для решения проблем памяти вместо многих мест, касавшихся этого.

Конечно, это зависело бы от того, есть ли у Вас разумное ожидание памяти, становящейся доступными в 100 (миллисекунда?) сон? Конечно, необходимо ограничить количество раз, которого это делает попытку.

Мне что-то не пахнет прямо здесь. Хм...

Встроенные системы обычно должны быть чрезвычайно детерминированы - возможно, необходимо рассмотреть всю систему и главу потенциала для этого для сбоя впереди; и затем просто приводят к сбою трудно его, это на самом деле происходит на практике.

Как другие упомянули, идеально, Вы избежали бы этой проблемы первичным дизайном и программной архитектурой, но я принимаю в этой точке, которая действительно не является опцией.

Как другое сообщение упоминает, было бы хорошо перенести логику в некоторые служебные функции так, чтобы Вы не заканчивали тем, что писали код из памяти все место.

Для получения до настоящей проблемы Вы пытаетесь использовать совместно используемый ресурс, память, но неспособны к тому, потому что тот совместно используемый ресурс используется другим потоком в системе. Идеально то, что требуется сделать, является ожиданием одного из других потоков в системе для выпуска ресурса, в котором Вы нуждаетесь и затем получаете тот ресурс. Если бы у Вас был способ прервать все выделение и бесплатные вызовы, то Вы могли бы установить что-то так, чтобы поток выделения, заблокированный до памяти, был доступен, и освобождение сигнализировало о потоке выделения, когда память была доступна. Но я собираюсь предположить, что это - просто слишком много работы.

Учитывая ограничения неспособности к полностью повторно проектируют систему или переписывают средство выделения памяти, затем я думаю, что Ваше решение является самым практичным, пока Вы (и другие в Вашей команде), поймите ограничения и проблемы, это вызовет вниз дорожку.

Теперь для улучшения определенного подхода можно хотеть измерить рабочие нагрузки для наблюдения, как часто память выделена и освобождена. Это дало бы Вам лучшее да вычисления, каков интервал повторной попытки должен быть.

Во-вторых, Вы путь хотите попытаться увеличить тайм-аут для каждого повторения для сокращения загрузки того потока в системе.

Наконец, у Вас определенно должно быть некоторое время случая ошибки/паники, если поток не может сделать успехи после некоторого количества повторений. Это позволит Вам, по крайней мере, видеть потенциальный случай динамической взаимоблокировки, с которым можно встретиться, если все потоки ожидают другого потока в системе к свободной памяти. Вы могли просто выбрать много повторений на основе того, что, как опытным путем показывают, работает, или Вы могли стать более умными об этом и отслеживать то, сколько потоков застревает, ожидая памяти, и если это заканчивает тем, что было всей паникой потоков.

Примечание: Это - очевидно, не идеальное решение и поскольку другие плакаты упомянули, что более глобальное представление приложения в целом необходимо для решения проблемы правильно, но вышеупомянутое является практической техникой, которая должна работать в ближайшей перспективе.