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

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

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

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

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

6 13
optimization malloc calloc

6 ответов:

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

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

10

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

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

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

1

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

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

0

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

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

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

Malloc быстрее, чем Calloc, потому что причина в том, что malloc возвращает память, как она есть из операционной системы. Но когда вы вызываете Calloc, он получает память от ядра или операционной системы и инициализирует ее с нулем, а затем возвращает ее вам. таким образом, инициализация требует времени. вот почему Мэллок быстрее, чем Каллок

-1

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

  1. Мэллок принимает один аргумент, в то время как Каллок принимает два аргумента

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

Я думаю, что именно поэтому обработка malloc быстрее, чем calloc

-8