Serialization - Special Considerations

Boost , ,

Object Tracking

Class Information

Helper Support

Archive Portability

Numerics

Traits

Binary Archives

XML Archives

Exporting Class Serialization

Static Libraries and Serialization

DLLS - Serialization and Runtime Linking

Plugins

Multi-Threading

Optimizations

Archive Exceptions

Exception Safety

Object Tracking

Это может вызвать проблемы в прогамах, где копии разных объектов сохраняются с одного адреса.<

template<class Archive>
void save(boost::basic_oarchive  & ar, const unsigned int version) const
{
    for(int i = 0; i < 10; ++i){
        A x = a[i];
        ar << x;
    }
}

Чтобы помочь обнаружить такие случаи, операторы выходных архивов ожидают, что будут переданы<const>справочные аргументы.

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

template<class Archive>
void save(boost::basic_oarchive & ar, const unsigned int version) const
{
    for(int i = 0; i < 10; ++i){
        ar << a[i];
    }
}

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

Аналогичная проблема может возникнуть, когда различные объекты загружаются по адресу, отличному от конечного местоположения:<

template<class Archive>
void load(boost::basic_oarchive  & ar, const unsigned int version) const
{
    for(int i = 0; i < 10; ++i){
        A x;
        ar >> x;
        std::m_set.insert(x);
    }
}

template<class Archive>
void load(boost::basic_iarchive  & ar, const unsigned int version) const
{
    for(int i = 0; i < 10; ++i){
        A x;
        ar >> x;
        std::pair<std::set::const_iterator, bool> result;
        result = std::m_set.insert(x);
        ar.reset_object_address(& (*result.first), &x);
    }
}

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

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

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

BOOST_CLASS_TRACKING(my_virtual_base_class, boost::serialization::track_always)

Помощь

Для реализации этой возможности объявляетсявспомогательный объект, связанный с текущим архивом, который может использоваться для хранения контекстной информации, относящейся к конкретному алгоритму сериализации типа.<

template
class shared_ptr
{
   ...
};
BOOST_SERIALIZATION_SPLIT_FREE(shared_ptr)
class shared_ptr_serialization_helper
{
  // table of previously loaded shared_ptr
  // lookup a shared_ptr from the object address
  shared_ptrlookup(const T *);
  // insert a new shared_ptr
  void insert>(const shared_ptr*);
};
namespace boost {
namespace serialization {
template<class Archive>
void save(Archive & ar, const shared_ptr & x, const unsigned int /* version */)
{
    // save shared ptr
    ...
}
template<class Archive>
void load(Archive & ar, shared_ptr & x, const unsigned int /* version */)
{
    // get a unique identifier.  Using a constant means that all shared pointers
    // are held in the same set.  Thus we detect handle multiple pointers to the
    // same value instances in the archive.
    const void * shared_ptr_helper_id = 0;
    shared_ptr_serialization_helper & hlp =
        ar.template get_helper<shared_ptr_serialization_helper>(helper_instance_id);
    // load shared pointer object
    ...
    shared_ptr_serialization_helper & hlp =
        ar.template get_helper<shared_ptr_serialization_helper>(shared_ptr_helper_id);
    // look up object in helper object
    T * shared_object hlp.lookup(...);
    // if found, return the one from the table
    // load the shared_ptr data
    shared_ptrsp = ...
    // and add it to the table
    hlp.insert(sp);
    // implement shared_ptr_serialization_helper load algorithm with the aid of hlp
}
} // namespace serialization
} // namespace boost

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

Информация о классе

.Отключение отслеживания и сериализации информации о классе приведет к чистому встроенному коду шаблона, который в принципе может быть оптимизирован до простой записи / чтения потока.Устранение всех накладных расходов на сериализацию таким образом обходится дорого. После того, как архивы будут выпущены для пользователей, признаки сериализации класса не могут быть изменены без признания старых архивов недействительными. Включение информации о классе в архив гарантирует, что она будет читаемой в будущем, даже если определение класса будет пересмотрено. Легковесная структура, такая как пиксель дисплея, может быть объявлена в заголовке, таком как:<

#include <boost/serialization/serialization.hpp>
#include <boost/serialization/level.hpp>
#include <boost/serialization/tracking.hpp>
// a pixel is a light weight struct which is used in great numbers.
struct pixel
{
    unsigned char red, green, blue;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int /* version */){
        ar << red << green << blue;
    }
};
// elminate serialization overhead at the cost of
// never being able to increase the version.
BOOST_CLASS_IMPLEMENTATION(pixel, boost::serialization::object_serializable);
// eliminate object tracking (even if serialized through a pointer)
// at the risk of a programming error creating duplicate objects.
BOOST_CLASS_TRACKING(pixel, boost::serialization::track_never)

Переносимость архива

Числа

Специальный интегральный тип<std::size_t>, который является типдефом интегральных типов, гарантированно достаточно большим, чтобы удерживать размер любой коллекции, но его фактический размер может отличаться в зависимости от платформы. Обертка<collection_size_type>существует для обеспечения возможности переносной сериализации размеров коллекций архивом. Рекомендуемые варианты для портативной сериализации размеров коллекции должны использовать либо 64-битное, либо целочисленное представление переменной длины.

Черты

template<class T>
struct my_wrapper {
    template<class Archive>
    Archive & serialize ...
};
...
class my_class {
    wchar_t a;
    short unsigned b;
    template<class Archive>
    Archive & serialize(Archive & ar, unsigned int version){
        ar & my_wrapper(a);
        ar & my_wrapper(b);
    }
};

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

Еще один способ избежать этой проблемы — присвоить всем специализациям шаблона<my_wrapper>черты сериализации для всех примитивных типов, чтобы информация о классе никогда не сохранялась. Это то, что было сделано для реализации сериализации коллекций STL.

Бинарные архивы

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

XML Архивы

Сериализация экспортного класса

• Обосновывает код, который не упоминается иначе.
• Связывает внешний идентификатор с классом, подлежащим сериализации. Тот факт, что класс явно не упоминается, подразумевает это требование.

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

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

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
... // other archives
#include "a.hpp" // header declaration for class a
BOOST_CLASS_EXPORT(a)
... // other class headers and exports

Включение<BOOST_CLASS_EXPORT>в сам заголовок a.hpp, как это было бы с другими чертами сериализации, затруднит или сделает невозможным соблюдение вышеупомянутого правила относительно включения заголовков архива до того, как будет использован<BOOST_CLASS_EXPORT>. Для этого лучше всего использовать<BOOST_CLASS_EXPORT_KEY>в объявлениях заголовка и<BOOST_CLASS_EXPORT_IMPLEMENT>в файле определения класса.

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

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

Обратите внимание, что реализация этой функциональности зависит от конкретных расширений поставщика языка C++. Таким образом, нет гарантированной переносимости программ, которые используют этот объект. Тем не менее, все компиляторы C++, которые тестируются с ускорением, обеспечивают необходимые расширения. Библиотека содержит дополнительные декларации, требуемые каждым из этих составителей. Разумно ожидать, что будущие компиляторы C++ будут поддерживать эти расширения.

Статические библиотеки и сериализация

• Только компилируйте определения сериализации в библиотеке.
• Явно инстанцируйте код сериализации для ВСЕХ классов архивов, которые вы собираетесь использовать в библиотеке.
• Для экспортируемых типов используйте только<BOOST_CLASS_EXPORT_KEY>в заголовках.
• Для экспортируемых типов используют только<BOOST_CLASS_EXPORT_IMPLEMENT>в определениях, составленных в библиотеке. Для любого конкретного типа должен быть только один файл, который содержит<BOOST_CLASS_EXPORT_IMPLEMENT>для этого типа. Это гарантирует, что в программе будет существовать только одна копия кода сериализации. Это позволяет избежать потери пространства и возможности иметь разные версии кода сериализации в одной программе. Включение<BOOST_CLASS_EXPORT_IMPLEMENT>в несколько файлов может привести к отказу ссылки из-за дублированных символов или к исключению времени выполнения.
• Код для сериализации должен быть только в библиотеке,
• Ознакомьтесь с идиомойPIMPL.

DLLS - Сериализация и соединение времени выполнения

<test_dll_simple>и<dll_a.cpp>, где реализация последовательностей также полностью отделена от основной программы, но код загружается во время выполнения. В этом примере этот код загружается автоматически при запуске программы, которая его использует, но он также может быть загружен и выгружен с помощью вызова API, зависящего от ОС.

Также включены<test_dll_exported.cpp>и<polymorphic_derived2.cpp>, которые аналогичны вышеперечисленным, но включают испытания экспортных и неторти-объектов в контексте DLLS.

Для достижения наилучших результатов напишите свой код в соответствии со следующими рекомендациями:

• Не включайте код<inline>в классы, используемые в DLLS. Это будет генерировать дублированный код в DLLS и магистрали. Это просто дублирует код. Хуже того, это позволяет одновременно существовать различным версиям одного и того же кода. Этот тип ошибки оказывается мучительно трудно отладить. Наконец, это открывает возможность того, что упомянутый модуль может быть эксплицитно разгружен, что приведет (надеюсь) к ошибке времени выполнения. Это еще один баг, который не всегда воспроизводим или легко найти. Для шаблонов членов класса используют что-то вроде<

  
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version);
  

  >в заголовке и<

  
  template<class Archive>
  void myclass::serialize(Archive & ar, const unsigned int version){
  	...
  }
  BOOST_EXPORT_CLASS_IMPLEMENT(my_class)
  #include <boost/archive/text_oarchive>
  #include <boost/archive/text_iarchive<
  template myclass::serialize(boost::archive::text_oarchive & ar, const unsigned int version);
  template myclass::serialize(boost::archive::text_iarchive & ar, const unsigned int version);
  ... // repeat for each archive class to be used.
  

  >в файле реализации. Это приведет к генерации всего кода, необходимого только в одном месте. Библиотека не обнаруживает такого рода ошибки.
• Если DLLS должны загружаться и выгружаться явно (например, используя<dlopen>в *nix или<LoadLibrary>в Windows). Постарайтесь устроить так, чтобы они разгружались в обратной последовательности. Это должно гарантировать, что проблемы будут устранены, даже если вышеприведенное руководство не было выполнено.

Плагины

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
... // other archives
#include "a.hpp" // header declaration for class a
// this class has a default constructor
BOOST_SERIALIZATION_FACTORY_0(a)
// as well as one that takes one integer argument
BOOST_SERIALIZATION_FACTORY_1(a, int)
// specify the GUID for this class
BOOST_CLASS_EXPORT(a)
... // other class headers and exports

Многопоточность

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

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

• Доступ к одному и тому же экземпляру архива из разных задач.
• Загрузка/выгрузка DLLS или общих библиотек, в то время как любые экземпляры архива открыты.

Оптимизация

Архивные исключения

Безопасность исключения

& копия; Авторское правоРоберт Рэми2002-2004. Распространяется под лицензией Boost Software License, версия 1.0. (См. сопроводительный файл LICENSE_1_0.txt или копию по адресу http://www.boost.org/LICENSE_1_0.txt)

Статья Serialization - Special Considerations раздела может быть полезна для разработчиков на c++ и boost.

:: Главная :: ::