Letysite.ru

IT Новости с интернет пространства
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Система сборки c

Сборки

Какой бы язык .NET не выбирался для программирования, важно понимать, что хотя двоичные .NET-единицы имеют такое же файловое расширение, как и двоичные единицы СОМ-серверов и неуправляемых программ Win32 (* . dll или * . ехе), внутренне они устроены абсолютно по-другому. Например, двоичные .NET-единицы * .dll не экспортируют методы для упрощения взаимодействия с исполняющей средой СОМ (поскольку .NET — это не СОМ). Более того, они не описываются с помощью библиотек СОМ-типов и не регистрируются в системном реестре. Пожалуй, самым важным является то, что они содержат не специфические, а наоборот, не зависящие от платформы инструкции на промежуточном языке (Intermediate Language — IL), а также метаданные типов. На следующей схеме показано, как все это выглядит:

Отсюда следует, что сборка (assembly) — это логическая единица, содержащая скомпилированный код для .NET Framework, т.е. это полностью самодостаточный и скорее логический, нежели физический элемент. Это значит, что он может быть сохранен в более чем одном файле (хотя динамические сборки хранятся в памяти, а вовсе не в файлах). Если сборка хранится в более чем одном файле, то должен существовать один главный файл, содержащий точку входа и описывающий остальные файлы.

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

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

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

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

Сборки бывают двух видов: разделяемые и приватные.

Приватные сборки

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

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

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

Поскольку приватная сборка полностью самодостаточна, процесс ее развертывания весьма прост. Вы просто помещаете соответствующий файл (или файлы) в соответствующую папку системы (никаких записей вносить в реестр не потребуется). Этот процесс известен как установка с нулевым воздействием или установка с помощью хсору (zero impact (хсору) installation).

Разделяемые сборки

Назначение разделяемых сборок — служить библиотеками общего применения, которые могут использоваться любым другим приложением. Поскольку любое другое приложение может получить доступ к разделяемой сборке, возникает необходимость в некоторых предосторожностях, чтобы исключить описанные ниже риски.

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

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

Решение этих проблем включает размещение разделенных сборок в специальном поддереве каталогов файловой системы, известном под названием глобальный кэш сборок (global assembly cache — GAC). В отличие от приватных сборок, это не может быть сделано простым копированием сборки в определенную папку — сборку понадобится специальным образом установить в кэше GAC. Данный процесс может быть реализован с помощью множества утилит .NET и включает в себя выполнение необходимых проверок устанавливаемой сборки, а также создание небольшой иерархии папок в пределах GAC, используемых для обеспечения целостности сборок.

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

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

Однофайловые и многофайловые сборки

В большом количестве случаев между сборками .NET и файлами двоичного кода (*.dll или *.ехе) соблюдается простое соответствие «один к одному». Следовательно, получается, что при построении *.dll-библиотеки .NET, можно спокойно полагать, что файл двоичного кода и сборка представляют собой одно и то же, и что, аналогичным образом, при построении исполняемого приложения для настольной системы на файл *.ехе можно ссылаться как на саму сборку. Однако это не совсем так. С технической точки зрения, сборка, состоящая из одного единственного модуля *.dll или *.ехе, называется однофайловой сборкой . В однофайловых сборках все необходимые CIL-инструкции, метаданные и манифесты содержатся в одном автономном четко определенном пакете.

Многофайловые сборки , в свою очередь, состоят из множества файлов двоичного кода .NET, каждый из которых называется модулем (module). При построении многофайловой сборки в одном из ее модулей (называемом первичным или главным (primary) модулем) содержится манифест всей самой сборки (и, возможно, СIL-инструкции и метаданные по различным типам), а во всех остальных — манифест, CIL-инструкции и метаданные типов, охватывающие уровень только соответствующего модуля. Как нетрудно догадаться, в главном модуле содержится описание набора требуемых дополнительных модулей внутри манифеста сборки.

Системы сборки С++

20 flo [2010-05-17 11:58:00]

Я запустил новый проект на С++ (возможно, некоторые компоненты C тоже), и я ищу современную, промышленную (не бета) систему сборки. Программное обеспечение будет создано несколькими разработчиками через 3-5 лет и будет работать на Linux (Mac OS X и Windows могут поддерживаться позже). Я ищу что-то, что имеет лучшую понятность, простоту использования и ремонтопригодность, чем, например, make , но по-прежнему достаточно силен для обработки сложного проекта. Предпочтительным является программное обеспечение с открытым исходным кодом.

Я начал изучать Boost.Build , CMake , Maven и SCons до сих пор и любил функции и концепции всех этих, но мне не хватает опыта для принятия решения для большого проекта.

9 ответов

6 Решение Matthieu M. [2010-05-17 21:18:00]

Я использовал SCons уже более года, и это действительно здорово. Это полная система сборки, а не генератор скриптов сборки.

Он основан на Python, и вы пишете SConstruct и SConscript (эквивалент Makefile) в Python, который позволяет вам вызывать любую доступную библиотеку, которую вы можете пожелать, и более четкий синтаксис, который разрешает авторизация Makefile.

Поскольку Python является кроссплатформенным, то есть SCons, без проблем.

Он поставляется в комплекте с большим количеством целей:

  • обнаруживает доступный двоичный файл и автоматически отображает ряд расширений в сторону правильных двоичных файлов
  • обнаруживает правильные расширения для ваших объектов/библиотек в зависимости от ОС, хотя вы можете переопределить его
  • предоставляет средства для общих операций (задержка после сборки), таких как Move, Copy, Tar, и вы можете предоставить свои собственные скрипты python и подключить их.
  • работает из коробки и при этом обеспечивает множество перехватов настроек на каждом уровне.

Он действительно эффективен и даже предлагает расширенные функции (например, сохранение хэша предварительно обработанного файла в sqlite db вместо использования метки времени), даже если вы решите свою стратегию в конце.

Он также предлагает бесплатное обнаружение циклов зависимостей (что определенно не связано с Make файлами), и интерфейс обычно лучше/автоматизирован.

Я сказал, что это эффективно? Ну, это, очевидно, позволяет выполнять несколько заданий параллельно;)

И это также бесплатно, как и в бесплатном напитке, не стесняйтесь вносить свой вклад;)

Я могу только рекомендовать его.

У меня нет опыта работы с остальными, но если вы ищете кросс-платформенную систему построения кросс-цепей, используйте CMake. CMake на самом деле не является системой сборки, это генератор сборки script — он генерирует сценарии сборки для многих систем сборки и (и это, на мой взгляд, сила) генерирует файлы проектов для основных IDE, таких как Visual Studio и KDevelop. Недавние версии KDevelop, кстати, имеют файлы Intellisense для CMake.

Читать еще:  Сборщик мусора c

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

Недостатком CMake является то, что на самом деле он не поставляется с множеством встроенных инструментов или простым способом его расширения (по сравнению, например, с MSBuild, который, конечно же, представляет собой только систему сборки, а не генератор), Наши разработчики Linux имеют тенденцию вызывать инструменты командной строки Unix, чтобы делать такие вещи, как сжатие/декомпрессия, которые недоступны при обычной установке Windows, в то время как MSBuild имеет тысячи дополнительных команд, доступных из проектов сообщества, поэтому вам не нужно использовать в командной строке, и очень легко создать новую задачу для MSBuild. В настоящее время я изучаю, как обойти эти ограничения для CMake, поскольку в настоящее время это означает, что мы не можем полностью строить на Windows, даже несмотря на то, что сам код будет хорошо создан.

Написание файлов CMake не является прекрасным опытом, но все в порядке. Язык имеет некоторые странные причуды (например, нужно точно повторять if-условие в else и endif, что сбивает вас с ума, особенно при экспериментировании), и вы действительно будете очень ненавидеть наличие файла под названием CMakeLists.txt в каждом и каждый каталог, который имеет пользовательские правила сборки (и это может быть много, в большом проекте), и все они отображаются только с именем в вашей IDE;)

Через несколько лет в будущем.

  • SCons отмирает от популярности, от того, что я видел. Мне это совсем не нравится.
  • Waf является удивительным (на мой взгляд). Если вы изучаете SCons, сначала попробуйте Waf. Однако параллельные сборки всегда показывают вам все ошибки, которые произошли. поэтому ожидайте, что ваш экран будет заполнен сообщениями об ошибках. Кроме того, это может немного осложниться.
  • Boost.Build является одним из моих любимых, но имеет худшую документацию на земле. Помимо этого, он очень гибкий и позволяет делать практически все. Тем не менее, это может быть немного медленнее.
  • CMake хорош только для создания сценариев ниндзя; все остальное — мусор (4000 строк make файлов для 1-исходного 1-исполняемого проекта)
  • Tup хорошо, но для конфигурации ничего не требуется.
  • Autoconf по-прежнему autocrap.

Другие, не упомянутые:

  • Kbuild немного странно, но выглядит красиво. Это все, что я знаю.
  • mk-configure отлично подходит для любителей.
  • Shake с shake-language-c является гибким и позволяет вам делать что-либо. если вы знаете Haskell и не возражаете отказаться от поддержки VS.
  • Jamplus любит перетаскивать -m32 в конце каждой неудачной команды компилятора, которая отсасывает 64-битную систему.
  • Tundra может быть чересчур повторяющимся, но все еще очень быстрым и точным.
  • Bam. Тундра лучше. Он быстро, не жертвуя точностью.
  • Gyp (используется для Google Chrome/Chromium) недооценивается, но является отличной альтернативой CMake.
  • Premake отлично, если вы цените простоту, но он может раздражать, когда он приходит, делая кажущиеся простыми вещи.
  • Bakefile очень ограничительный, но отличный для простых проектов.
  • fbuild — мой любимый (вместе с Boost.Build). Он довольно недооценен, но имеет множество примеров и очень читаемый исходный код. Строковые скрипты тоже короткие. Он использовался для создания (и был разработан для Felix. Он также очень, очень быстрый, и он почти всегда абсолютно точен и имеет автоматический parallelism, который НЕ наводняет ваш экран. Когда-либо. Я использую его для создания JRE-механизма регулярного выражения и очень, очень счастлив. Это также очень легко расширить. Тем не менее, это по-прежнему технически в бета-версии, хотя я никогда не испытывал никаких реальных проблем.

Я бы рекомендовал fbuild или Boost.Build. или Gyp, если вам нравятся генераторы makefile.

Если вы хотите расширить базовую функциональность, определенно используйте fbuild. Если у вас есть БОЛЬШИЕ флагов/опций платформы и множество беспорядков, используйте Boost.Build. Если вам нужен генератор makefile или у вас много настроек, попробуйте Gyp.

5 Anatoli [2011-05-28 11:18:00]

У меня была возможность сравнить все из них. Сначала мы использовали make. Это уродливо. Вы должны быть экспертом, чтобы действительно понять, что происходит. Я больше не буду принимать боль.

Затем мы перешли к SCons. Это синтаксис в порядке, вы все равно можете делать уродливые вещи, потому что вы можете писать свои собственные скрипты, которые, как правило, являются программами. Это дает вам большую гибкость. Но мы пнули SCons, потому что нам пришлось ждать около 20 секунд для сканирования проекта и еще 20 для сборки каждый раз. Затем мои колледжи писали код python, чтобы кэшировать результаты сканирования в файлы и почти удвоить производительность. Вам все равно пришлось подождать около 20 секунд для сборки, когда вы добавили файл или удалили его из проекта, который вам нужно было перезапустить с помощью параметра -fill-cache.

Затем я переместил проект в CMake, что, безусловно, является моим инструментом выбора. Его структура и синтаксис очень хорошо читаются и также документируются. Он генерирует ваши проекты практически для всех IDE, а также для ранней поддержки новых IDE на рынке. Процесс сборки выполняется так же быстро, как и IDE, и вам нужно вернуться в CMake только при добавлении новых проектов или изменении свойств проекта, чтобы оставаться с CMake

Поэтому я бы предложил CMake

Другим инструментом является TUP. Мой опыт хорош с этим инструментом. Tup

  • Автоматически обрабатывает зависимости (нет необходимости вызывать gcc -M).
  • Работает с графами с частичной зависимостью, поэтому очень быстро.
  • Он поддерживает рекурсивные структуры каталогов блестящим способом (Tuprules.tup)
  • Поддерживает git выдающимся образом: может автоматически создавать файлы .gitignore на основе целевого списка.
  • Чрезвычайно прост в использовании и синтаксис для Tupfiles очень прост.
  • Он поддерживает последовательную сборку исходных файлов, даже если вы переименовали файл или удалили его. Поэтому построенные двоичные файлы всегда отражают текущее состояние источника. Это также означает, что вам никогда не понадобится очищать ваш проект.

После использования его для двух довольно сложных проектов я могу сказать только одну плохую вещь:

  • Сложно использовать вместе с динамическими представлениями ClearCase.

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

2 bobah [2010-05-17 12:30:00]

Из того, что вы упомянули, я пробовал Maven — он слишком строгий, не масштабируется и предназначен для Java, поэтому я бы не стал его рассматривать. Я также слышал от людей, которые использовали «Automake», которые они в шутку называют «Autobreak»

ИМХО, проект с долгой надежностью предпочтет чисто Make, GNU Make, если быть точным. Существует несколько мощных функций Make, обычно не используемых, которые помогают избежать кода шаблона (например, использование eval/call, нерекурсивная сборка). Он совместим с любой другой системой сборки (например, в наших проектах мы успешно объединяем его с Ant, используемым для сборки Java). Он имеет отличную документацию и знаком большинству разработчиков.

Из моего опыта всегда можно выделить makeystem из проекта в той степени, в которой большинство make файлов проекта содержат 2 строки: имя целевой и «include $/makesystem.mk.

Другой взгляд на Bakefile.

Его основная сила заключается в том, что требуется относительно простой входной файл (простой, как XML получает, во всяком случае) и выставляющий много разных исходных системных файлов: Makefile.in в системах на основе autoconf (Linux, OS X command line, BSD. ), Visual С++ решение и файлы проекта, проекты Xcode, MinGW и общие Unix Make файлы и т.д.

Тем не менее, я не знаю, что с самого начала я бы использовал такую ​​систему. Поскольку исходной целью является Linux, а остальные — «майбы», подумайте о начале работы с automake и поместите Bakefile (или что-то еще), пока вы не портируете. Всегда нужно строить вещи, прежде чем они вам понадобятся. В этом случае всегда есть компромисс — самый низкий синдром общего знаменателя — и если вам не нужно платить штраф сегодня, отложите его, пока вам не придется платить; вам, возможно, никогда не придется платить. Если вы пойдете с automake и соедините свои файлы, переход не будет слишком болезненным.

Системы сборки C++ [закрыто]

Я скоро начну новый проект C++ (он может иметь и некоторые компоненты C), и я ищу современную, промышленную (т. е. не бета-версию) систему сборки. Программное обеспечение будет создано несколькими разработчиками через 3-5 лет и будет работать на Linux (Mac OS X и Windows могут быть поддержаны позже). Я ищу что-то, что имеет лучшую понятность, простоту использования и ремонтопригодность, чем, например, make , но все еще достаточно мощное, чтобы справиться со сложным проектом. Открытый исходный код программное обеспечение предпочтительнее.

Я начал смотреть в Boost.Build , CMake , Maven и SCons до сих пор и понравились особенности и концепции всех этих, но мне не хватает опыта, чтобы принять решение для большого проекта.

9 ответов:

Я использую SCons уже больше года, и это действительно круто. Это полная система сборки, а не генератор сценариев сборки.

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

Поскольку Python является кроссплатформенным, то и SCons-нет проблем.

Он поставляется в комплекте с большим количеством цели:

  • обнаруживает доступные двоичные файлы и автоматически сопоставляет ряд расширений с правильными двоичными файлами
  • определяет правильные расширения для ваших объектов / библиотек в зависимости от операционной системы, хотя вы можете переопределить его
  • предоставляет средства для общих операций (которые будут отложены после сборки), таких как перемещение, копирование, Tar, и вы можете предоставить свои собственные скрипты python и подключить их
  • работает из коробки и все же предоставляет много крючков настройки на каждый уровень

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

Он также предлагает обнаружение циклов зависимостей бесплатно (что определенно не входит в комплект Makefile), а интерфейс, как правило, просто лучше / автоматизирован.

Читать еще:  Lenovo ideapad 330 загрузка с флешки

Разве я сказал, что это эффективно ? Ну это очевидно позволяет для нескольких рабочих мест, чтобы выполняться параллельно;)

И это также бесплатно, как в бесплатном напитке, не стесняйтесь вносить свой вклад 😉

Я могу только рекомендовать его.

У меня нет опыта работы с другими, но если вы ищете кросс-платформенную, кросс-инструментальную систему сборки, используйте CMake. CMake на самом деле не является системой сборки, это генератор сценариев сборки — он генерирует фактические сценарии сборки для многих систем сборки и (и это, на мой взгляд, сила) генерирует файлы проектов для основных IDE, таких как Visual Studio и KDevelop. Последние версии KDevelop, кстати, имеют Intellisense для CMake файлов.

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

Недостатком CMake является то, что он на самом деле не поставляется с большим количеством встроенных инструментов или простым способом расширения (по сравнению, например, с MSBuild, который, конечно, является просто системой сборки, а не генератором). Наши разработчики Linux, как правило, вызывают средства командной строки Unix для выполнения таких операций, как сжатие / распаковка, которые недоступны на типичная установка Windows, в то время как MSBuild имеет тысячи дополнительных команд, доступных из проектов сообщества, так что вам не нужно использовать командную строку, и это действительно легко создать новую задачу для MSBuild. В настоящее время я изучаю, как обойти эти ограничения для CMake, потому что в настоящее время это означает, что мы не можем полностью строить на Windows, даже если сам код будет строить нормально.

Написание файлов CMake-это не очень красивый опыт, но это нормально. То язык имеет некоторые странные причуды (например, необходимость точно повторять условие if в else и endif, что сведет вас с ума, особенно при экспериментировании), и вы действительно, действительно ненавидите иметь файл под названием CMakeLists.txt в каждом каталоге, который имеет пользовательские правила сборки (и это, возможно, много, в большом проекте), и все они появляются только с именем в вашей IDE;)

Несколько лет в будущее.

  • SCons умирает в популярности, судя по тому, что я видел. Мне это совсем не нравится.
  • Waf потрясающе (на мой взгляд). Если вы ищете SCons, попробуйте сначала Waf. Однако параллельные сборки всегда показывают вам все ошибки, которые occurred. so ожидайте, что ваш экран будет заполнен сообщениями об ошибках. Кроме того, он может стать немного сложным для расширения.
  • повышение.Build является одним из моих любимых, но имеет худшие документация на земле. Кроме того, он очень гибкий и позволяет вам делать почти все, что угодно. Хотя временами он может быть немного медленным.
  • CMake хорош только для генерации скриптов Ninja; все остальное-мусор (4000 строк Makefile для 1-исходного 1-исполняемого проекта)
  • Tup хорош, но ему не хватает ничего для конфигурации.
  • Autoconf по-прежнемуautocrap .

Другие не упомянутые:

  • Kbuild Немного странный но выглядит неплохо. Это все, что я знаю.
  • mk-configure отлично подходит для любителей make.
  • Shake with shake-language-c является гибким и позволяет делать все, что угодно. если вы знаете Хаскелла и не возражаете отказаться от поддержки VS.
  • Jamplus любит запихивать -m32 в конец каждой долбаной команды компилятора, которая засасывает 64-битную систему.
  • Тундра может быть немного повторяющейся, но все еще очень быстрой и точный.
  • БАМ . Тундра лучше. Это быстро, не жертвуя точностью.
  • Gyp (используется для Google Chrome/Chromium) недокументирован, но является отличной альтернативой CMake.
  • Премейк отлично подходит, если вы цените простоту, но он может раздражать, когда речь заходит о выполнении, казалось бы, простых вещей.
  • Bakefile очень ограничен, но отлично подходит для простых проектов.
  • fbuild — мой любимый (наряду с Повышать.Строить). Он довольно недокументирован, но имеет множество примеров и очень читаемый исходный код. Сценарии сборки тоже короткие. Он используется для построения (и был разработан для) Феликса. Он также очень, очень быстр, и почти всегда идеально точен и имеет автоматический параллелизм, который не заполняет ваш экран. Когда-либо. Я использую его для создания JIT-движка regex и очень, очень счастлив. Его также очень легко расширить. Тем не менее, технически он все еще находится в бета-версии, хотя я никогда не испытывал никаких реальных проблем.

Я бы рекомендовал fbuild или Boost.Строить. или Gyp, если вам нравятся генераторы файлов makefile.

Если вы хотите расширить базовую функциональность, обязательно используйте fbuild. Если у вас есть много специфичных для платформы флагов/опций и много беспорядка, используйте Boost.Строить. Если вам нужен генератор файлов makefile или у вас много конфигураций, попробуйте Gyp.

Также другим инструментом является TUP. Мой опыт довольно хорош с этим инструментом. Tup

  • обрабатывает зависимости автоматически (нет необходимости вызывать gcc-M).
  • работает с графами частичных зависимостей, поэтому это очень быстро.
  • он поддерживает рекурсивные структуры каталогов, блестящим образом (Tuprules.tup)
  • поддерживает git выдающимся образом: может создавать свои .gitignore файлы автоматически, на основе целевого списка.
  • чрезвычайно легко использование и синтаксис Tupfiles очень просты. Он поддерживает последовательную сборку исходных файлов, даже если вы переименовали файл или удалили его. Поэтому построенные двоичные файлы всегда отражают текущее состояние источника. Это также означает, что вам никогда не нужно чистить свой проект.

После использования его для двух довольно сложных проектов я могу сказать только одну плохую вещь об этом:

  • его сложно использовать вместе с ClearCase dynamic Просмотры.

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

Затем мы перешли кSCons . Это синтаксис в порядке, вы все еще можете делать уродливые вещи, потому что вы можете писать свои собственные сценарии, которые, как правило, являются программами. Это дает вам большую гибкость. Но мы пнули SCons, потому что нам пришлось ждать около 20 секунд для сканирования проекта и еще 20 для сборки каждый раз. Затем мои колледжи написали код python для кэширования результатов сканирования в файлы и почти удвоили производительность. Вам все еще приходилось ждать около 20 секунд для сборки, когда вы добавляли файл или удаляли его из проекта, вы должны были повторно запустить сборку с параметром —fill-cache.

Затем я переместил проект в CMake , который определенно является моим инструментом выбора. Его структура и синтаксис очень хорошо читаются, а также документируются. Он генерирует вам проекты для почти каждая IDE, а также ранние версии поддерживают новые IDE на рынке. Процесс сборки выполняется так же быстро, как и IDE, и вам нужно только вернуться к CMake, когда вы добавляете новые проекты или изменяете свойства проекта, чтобы остаться с CMake

Поэтому я бы предложил CMake

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

Из того, что вы упомянули, я попробовал Maven — он слишком строгий, не масштабируется и предназначен для Java, поэтому я бы не рассматривал его. Я также слышал от людей, которые использовали «Automake», который они в шутку называют «Autobreak»

ИМХО, проект с ожиданием долгой жизни предпочтет чистый Make, GNU Make, если быть точным. Есть несколько мощных функций Make, обычно не используемых, которые помогают избежать шаблонного кода (например, использование eval/call, нерекурсивная сборка). Он совместим с любым другая система сборки (например, в наших проектах мы успешно комбинируем ее с Ant, используемой для сборки Java). Он имеет отличную документацию и знаком большинству разработчиков.

По моему опыту всегда можно изолировать makesystem от проекта до такой степени, что большинство файлов Makefile проекта содержат 2 строки: имя цели и «include $/makesystem.mk».

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

Waf выглядит хорошо, но я обнаружил, что борюсь с тем, как правильно делать некоторые вещи, особенно вложенные проекты.

Autotools действительно надежен, хотя он не работает, если вы хотите поддерживать windows. Перекрестная компиляция действительно надежна в autotools.

CMake:я думаю, что вы должны пойти на это. Это довольно быстро, он обрабатывает конфигурацию так же, как autotools, но работает в windows, он создает проекты для xcode, visual studio, make и других. Это хорошая функция, если у вас есть мультиплатформенный проект, так как вы можете генерировать проекты для выбранных IDE. Но должен сказать, что синтаксис мне не слишком нравится. Во всяком случае, он хорошо справляется с большими проектами. Я бы пошел на cmake, если бы хотел получить решение «промышленной прочности». Даже если я лично немного ненавижу его, это единственный жизнеспособный вариант.

Tup: я думаю, что он больше ориентирован на unix. Но я должен сказать, что для меня это самое приятное, и это безумно быстро и просто. Я люблю это. Но то, что вам нужно, это cmake.

Еще один пример-это Bakefile .

Его главная сила заключается в том, что он берет относительно простой входной файл (во всяком случае, простой, как XML) и выпускает множество различных системных файлов собственной сборки: Makefile.in на системах, основанных на autoconf (Linux, OS X command line, BSD. ), Файлы решений и проектов Visual C++, проекты Xcode, MinGW и generic Unix Makefile и т. д.

Тем не менее, я не знаю, буду ли я использовать такую систему с самого начала. Так как начальная цель-Linux а остальные-это «может быть», подумайте о том, чтобы начать с automake, и отложите файл Bakefile (или что-то еще), пока вы не сделаете свой перенос. Это всегда ошибка-строить вещи до того, как они вам действительно понадобятся. Всегда есть компромисс-синдром наименьшего общего знаменателя в этом случае — и если вам не нужно платить штраф Сегодня, отложите его до тех пор, пока вам не придется платить; вы можете Никогда не платить. Если вы идете с automake и создаете свои файлы разумно, миграция не будет слишком сложной. болезненный.

Читать еще:  Как поменять флеш плеер

Системы сборки — make

Поговорим на тему сборки проекта. В данной статье рассмотрим как писать простенькие Make-файлы, для сборки проектов на языках C или C++. Конкретно мы будем компилировать проект на gcc стандарта C99.

Что такое и зачем нужен make? Это специальная утилита для автоматической компиляции кода в объектные модули и сборки из данных модулей исполняемого файла. Используется много где в операционных системах *nix, как я понимаю. Но конкретно мы будем работать на Linux, в библиотеках которых данная утилита крайне широко распространена.

Суть в том, что в процессе разработки ПО появляется необходимость тестирования. Но компилировать постоянно весь проект (а если он очень большой и над ним работает много программистов) не очень удобно. Поэтому make снова в этой ситуации нам поможет. То есть, не удалять результаты объектных файлов прошлых компиляций, а перекомпилировать лишь нужный модуль, что явно быстрее, чем весь проект.

Для начала рассмотрим простой пример сборки. Допустим, у нас есть небольшая программа, которая пишет 5 раз фразу «Hello make» в консоль. Напишем Makefile для нашей простой программы с таким содержанием:

В первой строке нашего Makefile написана цель сборки «all:». Названия целей можно писать любое. Но, обычно для имени конечной цели (главная сборка проекта) пишут именно «all». Я читал, что при вызове make без явного указания цели, то автоматически выполняется цель «all» (но мои эксперименты показали, что в Makefile без цели «all» выполняется первая цель в списке). Через двоеточие указываются зависимости для цели. То есть, прежде чем выполнится цель «all», сперва будут выполняться ее зависимости, в нашем случае это «BinDir». На второй строке идет команда для выполнения. Команды обязательно отделяются табуляцией! Таков синтаксис, без табуляции команды будут игнорироваться утилитой и ничего не выполнится. В качестве команд можно писать все, что необходимо. В нашем случае, мы просто компилируем нашу программу в директорию ./bin (которая создается в цели «BinDir») с помощью компилятора gcc. Последняя цель «clean» чистит результаты сборки проекта — то есть мы просто удалили каталог проекта bin. Это запись является традиционная для Makefile’ов, поэтому писать подобные цели — хороший тон.

Вызов утилиты происходит в каталоге, где находится Makefile с помощью команды в консоли make [цель]. Указание цели при вызове make может быть пустой, как я уже выше писал, тогда просто выполнится первая цель в списке. Процесс сборки и выполнения показан на картинке ниже.

Для более сложной задачи, допустим, у нас есть дистрибутив Ubuntu 14.04, есть небольшой проект на C99 — надо написать Makefile. Пускай сам проект лежит в директории /home/tetraquark/Bomberta. Тут находится файл конфига приложения — settings и сам файл Makefile для утилиты make. Все заголовочные файлы лежат тут: /home/tetraquark/Bomberta/include, файлы с исходным кодом тут: /home/tetraquark/Bomberta/src. В Makefile’ах есть возможность использовать переменные и всю мощь bash скриптов. Вообще, стоит поискать и посмотреть примеры реализаций в разных библиотеках под Linux на C, в которых чаще всего используется именно make. Например, zlib, ncurses и другие. Вот так выглядит реализация Makefile для нашего проекта:

Система сборки для встроенного проекта C/C++

Я ищу высокоуровневую систему сборки / инструмент, который может помочь организовать мой встроенный проект C в «modules» и «components». Обратите внимание, что эти два термина очень субъективны, поэтому мои определения даны ниже.

  • Модуль-это связная коллекция файлов c и h, но только с одним открытым файлом h, который виден другим модулям.
  • Компонент (или слой), с другой стороны, представляет собой набор модулей (например, слой приложений, слой библиотек, слой драйверов, слой RTOS и т. д.).).

Система сборки / инструмент должны —

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

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

2 Ответа

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

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

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

Автоматическое предотвращение циклических зависимостей не является тривиальным. Проблема заключается в том, что вы можете только установить наличие циклической зависимости, просматривая несколько исходных файлов одновременно, а компилятор просматривает только один за один раз.

Рассмотрим пару модулей ModuleA и ModuleB, а также программу Program1, использующую оба модуля.

При компиляции Program1.c он вполне правомерно включает в себя как ModuleA.h, так и ModuleB.h, если использует сервисы обоих модулей. Таким образом, ModuleA.h не может жаловаться, если ModuleB.h включено в ту же самую единицу перевода (TU), и ни один из ModuleB.h не может жаловаться, если ModuleA.h включено в ту же самую TU.

Предположим, что для ModuleA законно использовать средства ModuleB. Поэтому при компиляции ModuleA1.c или ModuleA2.c не может быть никаких проблем с включением как ModuleA.h, так и ModuleB.h.

Однако для предотвращения циклических зависимостей необходимо иметь возможность запретить коду в ModuleB1.c и ModuleB2.c использовать ModuleA.h.

Насколько я могу видеть, единственный способ сделать это-это некоторая техника, которая требует частного заголовка для ModuleB, который говорит «ModuleA is already included», даже если это не так, и это включается до того, как будет включен ModuleA.h.

Скелет ModuleA.h будет иметь стандартный формат (и ModuleB.h будет похожим):

Теперь, если код в ModuleB1.c содержит:

Это далеко не автоматически.

Вы можете выполнить анализ включенных файлов и потребовать, чтобы в зависимостях был топологический вид без цикла. Когда-то существовала программа tsort на системах UNIX (и сопутствующая программа lorder ), которая вместе предоставляла необходимые услуги для создания статической библиотеки ( .a ), содержащей объектные файлы в порядке, не требующем повторного сканирования архива. Программа ranlib , а затем ar и ld взяли на себя обязанности по управлению повторным сканированием одной библиотеки, тем самым сделав lorder в частности избыточным. Но tsort имеет более широкое применение; он доступен в некоторых системах (например, MacOS X; RHEL 5 Linux тоже).

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

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

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

Упакуйте каждый модуль в пакет Debian (что делается очень быстро, когда он уже autoconf’d), объявите Build-Depends правильно и постройте пакеты внутри среды pbuilder. Это гарантирует, что доступны только открытые заголовки каждого модуля (потому что только они находятся в пакетах .deb, установленных pbuilder для сборки других пакетов), и есть отличные инструменты для просмотра деревьев пакетов Debian и проверки их отсутствия циклов.

Тем не менее, это, вероятно, чрезмерное убийство. Просто заявив Это для полноты картины и дела, вам определенно нужно автоматизированное решение.

Похожие вопросы:

У нас есть проект Visual Studio 2010, который состоит из группы исходных файлов C. Эти файлы должны быть скомпилированы, а затем связаны с помощью специальной цепочки инструментов для встроенного.

Привет кто-нибудь знает, почему у меня нет настроек сборки C/C++ и общей настройки C/C++ в моих свойствах проекта на ADT?

Я начинаю новый проект, и один из членов команды решил использовать C# в качестве языка реализации. У меня нет большого опыта в C#,, но краткое чтение показывает, что он очень способен быть.

Может ли кто-нибудь привести пример сценария NAnt для автоматизации сборки проекта C++? Спасибо!

При использовании Visual Stdio 2008 можно создать сборку проекта C++ с помощью внутреннего инструмента, а не напрямую вызывать IDE MSVC. Это улучшает согласованность построений между платформами.

Это вопрос о суперпользователе, но я думаю, что он лучше подходит для SO. Я работаю в shell большую часть времени, поэтому IDE не соответствует моему рабочему процессу. И все же я предпочитаю.

Привет, я немного испортил систему сборки C++ в Sublime Text 3, и теперь я не могу запустить какую-либо программу. Вот моя система сборки : < cmd: g++ $ -o $/$.

Я работаю с python в рамках проекта opengl и пишу свою собственную библиотеку gl с языком C. Я использую Sublime Text 2 и нуждаюсь в системе сборки для создания .so с помощью нажатия crtl-b.

Я ищу хорошую и простую в обслуживании портативную систему сборки для проектов C++. Основные платформы должны включать Windows (Visual Studio 8+) и Linux (gcc); Cygwin может быть преимуществом. Мы.

Мне нужно использовать плагин frama-c value analysis для анализа некоторых проектов. Эти проекты используют инфраструктуру сборки CMake в качестве своей системы сборки. Я использовал frama-c для.

Ссылка на основную публикацию
Adblock
detector