Calloc v/s malloc и эффективность времени

Я с интересом прочитал сообщение C разница между malloc и calloc. Я использую malloc в своем коде и хочу узнать, какая разница у меня будет с использованием calloc.

Мой текущий (псевдо) код с malloc:

Сценарий 1

int main()
{  
   allocate large arrays with malloc

   INITIALIZE ALL ARRAY ELEMENTS TO ZERO

   for loop //say 1000 times
    do something and write results to arrays
   end for loop

   FREE ARRAYS with free command

} //end main

Если я использую calloc вместо malloc, тогда у меня будет:

Scenario2

int main()
{  

   for loop //say 1000 times
    ALLOCATION OF ARRAYS WITH CALLOC 

    do something and write results to arrays

    FREE ARRAYS with free command

   end for loop


} //end main

У меня есть три вопроса:

  • Какой из сценариев более эффективен, если массивы очень большие?

  • Какой из сценариев будет более эффективным с точки зрения времени, если массивы очень большие?

  • В обоих сценариях я просто пишу для массивов в том смысле, что для любой заданной итерации в цикле for я записываю каждый массив последовательно от первого элемента до последнего элемента. Важный вопрос: если я использую malloc, как в сценарии 1, то необходимо ли инициализировать элементы до нуля? Скажем с malloc, у меня есть массив z = [garbage1, garbage2, garbage 3]. Для каждой итерации я пишу элементы последовательно, то есть в первой итерации я получаю z = [some_result, garbage2, garbage3], во второй итерации, которую я получаю на первой итерации, я получаю z = [some_result, another_result, garbage3] и так on, то нужно ли мне специально инициализировать мои массивы после malloc?

Ответы

Ответ 1

Предполагая, что общий объем инициализированной памяти в ваших двух примерах одинаковый, выделение памяти с помощью calloc() может быть быстрее, чем выделение памяти с помощью malloc(), а затем обнуление их на отдельном шаге, особенно если в в случае malloc() вы произвольно обнуляете элементы, итерации по ним в цикле. A malloc(), за которым следует a memset(), вероятно, будет примерно так же быстро, как calloc().

Если вам все равно, что элементы массива являются мусором, прежде чем вы фактически сохраните результаты вычислений в них, нет необходимости фактически инициализировать свои массивы после malloc().

Ответ 2

Для 1 и 2 обе делают то же самое: выделяют и нуль, а затем используют массивы.

Для 3, если вам не нужно сначала обнулять массивы, то обнуление не нужно, а выполнение не выполняется быстрее.

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

Ответ 3

Подходы calloc и memset должны быть примерно одинаковыми и, возможно, немного быстрее, чем обнулить его самостоятельно.

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

Ответ 4

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

Выполнение memset() или bzero() (вызываемых calloc() в любом случае) - хороший способ аннулировать огромную часть вашего кеша. Не делайте этого, если вы не уверены, что не будете перезаписывать все, но можете прочитать части буфера, которые не были записаны (как если бы 0 было приемлемым значением по умолчанию). Если вы все равно пишете все, значит, не инициализируйте свою память без необходимости.

Ненужная запись в памяти не только испортит производительность вашего приложения, но и производительность всех приложений, совместно использующих один и тот же процессор.

Ответ 5

malloc отличаются calloc двумя причинами

  • malloc принимает один аргумент, тогда как calloc принимает два аргумента

  • malloc быстрее, чем причина calloc - это то, что malloc обрабатывает одномерный массив в формате указателя, тогда как calloc принимает двумерный массив и перед обработкой преобразует его в одномерный массив, а затем в формат указателя.

Я думаю, что, почему malloc быстрее обрабатывает calloc