Будет Собрал "мусор" C быть Быстрее, Чем C++?
Это потому, что this в функции обратного вызова из objLoader.load относится к функции onload, а не к экземпляру класса.
Один из способов решить эту проблему - создать экземпляр this в переменной в функции createScene, а затем использовать эту переменную вместо этой в функции загрузки:
createScene(elementId: string): void {
let me = this;
...
objLoader.load(
// resource URL
'helicopter.obj',
// called when resource is loaded
function ( object ) {
console.log(object);
object.position.y -= 60;
me.scene.add( object );
},
...
);
}
Другой способ будет использовать функцию стрелки, где this будет ссылаться на класс ItemsCatalogComponent:
objLoader.load(
// resource URL
'helicopter.obj',
// called when resource is loaded
( object ) => {
console.log(object);
object.position.y -= 60;
this.scene.add( object );
},
// called when loading is in progresses
( xhr ) => {
console.log( ( xhr.loaded / xhr.total * 100 ) + '% loaded' );
},
// called when loading has errors
( error ) => {
console.log( 'An error happened' );
}
);
Надеюсь, что поможет.
11 ответов
Все это зависит! Это - довольно нерешенный вопрос. Этому нужно эссе для ответа на это!
Эй.. вот тот, который кто-то подготовил ранее:
http://lambda-the-ultimate.org/node/2552
http://www.hpl.hp.com/personal/Hans_Boehm/gc/issues.html
Это зависит, насколько большой Ваши объекты, сколько из них существует, как быстро они выделяются и отбрасываются, сколько времени Вы хотите инвестировать оптимизацию и тонкую настройку для создания оптимизации. Если Вы знаете пределы того, в каком количестве памяти Вы нуждаетесь для высокой производительности, я думал бы, что Вы не можете действительно победить захват всей памяти, в которой Вы нуждаетесь от ОС впереди и затем управления им сами.
Причина это может быть медленная память выделения от ОС, состоит в том, что это имеет дело с большим количеством процессов и памяти на диске и в поршне, так для получения памяти, которую это получено, чтобы решить, существует ли достаточно. Возможно, этому, возможно, придется разбить на страницы другую память процессов из поршня к диску, таким образом, это может дать Вам достаточно. Существует продолжение партий. Так управление ею самостоятельно (или с GC собрал "кучу") может быть намного более быстрым, чем движение к ОС для каждого запроса. Кроме того, ОС обычно имеет дело с большими блоками памяти, таким образом, она могла бы окружить размер запросов, Вы делаете значение, что Вы могли потратить впустую память.
Вы получили очень твердое требование для движения супер быстрого? Для большого количества приложений DSL не нужна необработанная производительность. Я предложил бы идти с тем, что является самым простым кодировать. Вы могли провести время жизни, пишущий системы управления памятью и волнуясь, который является лучшим.
То, почему был бы, собрало "мусор" C быть быстрее, чем C++? Единственные сборщики "мусора", доступные для C, являются довольно неэффективными вещами, более разработанными для включения утечек памяти, чем на самом деле улучшить качество кода.
В любом случае C++ имеет потенциал для достижения лучшей производительности с меньшим количеством кода (обратите внимание, что это - только потенциал. Также очень возможно написать код C++, который намного медленнее, чем эквивалент C).
Рассматривание текущего состояния обоих языков, GC в настоящее время не собирается улучшать производительность в Вашем коде. GC может быть сделан очень эффективным на языках, разработанных для него. C/C++ не среди тех.;)
Кроме этого, невозможно сказать. Языки не имеют скорости. Не имеет смысла спрашивать, какой язык быстрее. Это зависит от 1) определенного кода, 2) компилятора, который компилирует его и 3) системы, на которой это работает (аппаратные средства, а также ОС).
malloc является довольно медленной операцией, намного медленнее, чем эквиваленты.NET, таким образом, да, при выполнении большого количества маленьких выделений можно быть более обеспеченным выделением большого бассейна памяти однажды, и затем использование блоков этого.
Причина состоит в том, что ОС должна найти свободный блок памяти, в основном следующим связанный список всех свободных областей памяти. В.NET новое () вызов является в основном не чем иным как перемещением указателя "кучи" столько же байтов как требуется выделением.
мм... Это зависит, как Вы пишете систему сборки "мусора" для своего DSL. Ни один C или C++ идут со встроенным средством сборки "мусора", но или могли использоваться для записи очень эффективного или очень неэффективного сборщика "мусора". Запись такой вещи, между прочим, является нетривиальной задачей.
DSLs часто пишутся на высокоуровневых языках, таких как Ruby или Python конкретно, потому что устройство записи языка может усилить сборку "мусора" и другие средства языка. C и C++ являются большими для записи полных, промышленных языков силы, но, конечно, необходимо знать то, что Вы делаете для использования их - знание yacc и закона особенно полезно здесь, но хорошее понимание управления динамической памятью важно также, как Вы говорите. Вы могли также проверить keykit, музыка с открытым исходным кодом DSL, записанный в C, если Вам все еще нравится идея DSL в C/C++.
С большинством реализаций сборки "мусора" выделение видит улучшение скорости, но затем у Вас есть дополнительная стоимость фазы набора, которая может быть инициирована в любой точке в осуществлении Вашей программы, ведя к внезапной (на вид случайной) задержке.
Что касается Вашего второго вопроса, это зависит от Ваших алгоритмов управления памятью. Вы были бы в безопасности липкий со значением по умолчанию Вашей библиотеки malloc реализация, но существуют альтернативы, которые имеют лучшую производительность.
Связанный вопрос о стороне. malloc/free будет медленнее, чем выделение большого зажима в начале программы и выполнения моего собственного диспетчера памяти по нему?.NET, кажется, делает это. Но я смущен, почему мы не можем рассчитывать на ОС, чтобы сделать это задание лучше и быстрее, чем, что мы можем сделать нас.
Проблема с разрешением ОС обработать выделение памяти состоит в том, что это представляет indeterministic поведение. Нет никакого способа для программиста знать, сколько времени ОС возьмет для возврата нового блока памяти - выделение может быть довольно дорогостоящим, если память должна быть разбита на страницы к диску.
Предварительное выделение поэтому могло бы быть хорошей идеей, особенно при использовании сборщика "мусора" копирования. Это увеличит потребление памяти, но выделение будет быстро, потому что в большинстве случаев это просто будет инкремент указателя.
Проблема имеет много переменных, но если Ваше приложение записано со сборкой "мусора" в памяти, и если Вы используете специальные функции коллектора Boehm, такие как другое выделение призывает к блокам, которые не содержат указатели, затем как правило Ваше приложение - будет иметь более простые интерфейсы - будет работать несколько быстрее - потребует от 1.2x до 2x пространство, чем подобное приложение с помощью явного управления памятью.
Для документации и доказательства, поддерживающего эти требования, Вы видите информацию на веб-сайте Boehm и также нескольких статьях Ben Zorn об измеренной стоимости консервативной сборки "мусора".
Самое главное Вы сохраните тонну усилия и не должны будете волноваться о значительном классе ошибок управления памятью.
Проблема C по сравнению с C++ является ортогональной, но GC определенно будет быстрее, чем подсчет ссылок, особенно когда не будет никакой поддержки компилятора подсчета ссылок.
Как люди указали - GC быстрее для выделения (потому что он просто дает Вам следующий блок в своем списке), но медленнее полный (потому что он должен регулярно уплотнять "кучу" для выделений, чтобы быть быстрым).
таким образом - идут для компромиссного решения (который на самом деле довольно чертовски хорош):
Вы создаете свою собственную "кучу", один для каждого размера объекта, который Вы обычно выделяете (или 4 байта, 8 байтов, 16 байтов, 32 байта, и т.д.) затем, когда Вы хотите новую часть памяти, Вы захватываете последний 'блок' на соответствующей "куче". Поскольку Вы предварительно выделяете от этой "кучи", все, что необходимо сделать, когда выделение является захватом следующий свободный блок. Это работает лучше, чем стандартное средство выделения, потому что Вы счастливо тратите впустую память - если Вы захотите выделить 12 байтов, то Вы бросите целый 16-байтовый блок от 16-байтовой "кучи". Вы сохраняете битовый массив используемых v свободных блоков, таким образом, можно выделить быстро, не тратя впустую загрузки памяти или будучи должен уплотнить.
Кроме того, потому что Вы выполняете несколько "кучи", высоко параллельные системы работают намного лучше, поскольку Вы не должны блокировать так часто (т.е. у Вас есть несколько блокировок для каждой "кучи", таким образом, Вы не получаете конкуренцию почти так же),
Попробуйте его - мы использовали его для замены стандарта, сваливают очень интенсивное приложение в кучу, производительность повысилась довольно много.
BTW., которым причина, стандартные средства выделения являются медленными, состоит в том, что они пытаются не потратить впустую память - поэтому при выделении 5 байтов, 7 байтов и 32 байтов от стандартной "кучи", это сохранит те 'границы'. В следующий раз, когда необходимо выделить, это будет идти через тех, которые ищут достаточно пространства, чтобы дать Вам, что Вы попросили. Это работало хорошо на низкие системы памяти, но только необходимо посмотреть на то, сколько памяти большинство приложений использует сегодня, чтобы видеть, что системы GC идут другим путем и пытаются сделать выделения максимально быстро, ни о чем не заботясь для того, сколько памяти потрачено впустую.
Ни C, ни C++ не дадут Вам мусора бесплатно. То, что они дадут Вам, является библиотеками выделения памяти (которые обеспечивают malloc/free, и т.д.). Существует много ресурсов онлайн к алгоритмам для записи библиотек сборки "мусора". Хорошее начало является текстом ссылки
Большинство не языки GC выделит и освободит память по мере необходимости и больше не необходимый. Языки GC'd обычно выделяют большие блоки памяти прежде ручной и только освобождают память, когда неактивный а не посреди интенсивной задачи, таким образом, я иду в да, если GC умирает в корректное время.
Язык программирования D является собравшим "мусор" языком и ABI, совместимым с C и частично ABI, совместимым с C++. Эта Страница показывает некоторые сравнительные тесты между строковой производительностью в C++ и D.
Если Вы не хотите явно управлять памятью, не используйте C/C++. Существует много языков или с подсчетом ссылок или с поддерживаемыми компилятором сборщиками "мусора", которые будут, вероятно, работать намного лучше на Вас.
C/C++ разработан в среде, где программист управляет их собственной памятью. Попытка модифицировать GC или касательно подсчета на них может помочь некоторым, но Вы найдете Вы, любой должен поставить под угрозу производительность GC (потому что это не имеет никакого компилятора, подсказывающего как, туда, где указатели могли бы быть), или нахождение новых и захватывающих способов, которыми можно завинтить подсчеты ссылок или GC или что бы то ни было.
Я знаю, что это походит на хорошую идею, но действительно, необходимо просто захватить язык больше подходящее для задачи.
Я предлагаю, чтобы, если Вы записали программу, где выделение памяти и освобождение (явно или GC'ed) являются узким местом, затем Вы заново продумали свою архитектуру, разработку и реализацию.