Re: [boost] [Serialization] Bizarre bug

Subject: Re: [boost] [Serialization] Bizarre bug
From: Jarl Lindrud (jarl.lindrud_at_[hidden])
Date: 2009-08-10 04:01:49

Robert Ramey <ramey <at> rrsd.com> writes:

> > -----------------------------------------
> >
> > * If one program writes archives like this:
> >
> >    ar & vec; // vec is a std::vector<char>
> >
> > , it is then impossible to reliably load that archive in another
> > program, unless one is aware of the entire compile-time content of
> > the first program.
> 
> Nope.  The only time a problem can occur if one does
> 
>     ar & vec; // vec is a std::vector<char>
> 
> In the saving program and
> 
>     ar & p_vec; // vec is a * std::vector<char>
> 
> in the loading progam. 

Robert, that's manifestly incorrect. I have appended 3 well-formed programs, 
A1, A2, and B, to this post. B can read archives from A1, but it *cannot* read 
archives from A2. If you don't believe me, then please run the programs 
yourself. The only difference between A1 and A2 is compile-time instantiation, 
of code that is never executed.

> 
> Making matters worse, the archive
> 
> > format change is compatibility- breaking.
> 
> Only for collections of primitives.
> 

So we do agree that compatibility does break, due to compile-time instantiation.

> 
> I would use "concievable" rather than "likely".  In fact, I can't think
> of any real program where this could occur without there being
> some other error that would also prevent this program from
> functioning.
> 

Do you consider there to be any errors in either A1, A2 or B?

If you were to implement a generic IPC marshalling layer, you would end up with 
the kind of code that A1, A2, and B contain. IPC serialization is a bit 
different from file-based serialization, in that serialization and 
deserialization generally take place in different programs.

Another wrinkle in IPC serialization, is that one program may contain only 
serialization code for a type T (and not deserialization), while another 
program may contain only deserialization code for type T (and not 
serialization). If that makes the programs ill-formed in your view, then I 
guess one would have to conclude that B.Ser. is not an appropriate choice for 
IPC applications.

Regards,
Jarl

----------------------------------
// A1

#include <fstream>

#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>

int main()
{
        std::vector<char> vec(25, 'A');
        std::ofstream fout("A.txt");
        boost::archive::text_oarchive(fout) & vec;
        return 0;
}

----------------------------------
// A2

#include <fstream>

#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>

template<typename Archive>
struct X
{
        template<typename T> 
        void operator<<(const T &t)
        { 
                Archive &archive = (*(Archive *) NULL);
                archive << t; 
        }

        template<typename T> 
        void operator>>(T &t)
        { 
                Archive &archive = (*(Archive *) NULL);
                archive >> t; 
        }
};

// This function is instantiated by the compiler, but never executed.
void dummy()
{
        typedef boost::archive::text_iarchive IArchive;
        typedef boost::archive::text_oarchive OArchive;
        std::vector<char> *pt = NULL;

        X<OArchive> & oar = * (X<OArchive> *) NULL;
        oar << pt;
                
        X<IArchive> & iar = * (X<IArchive> *) NULL;
        iar >> pt;
}

int main()
{
        std::vector<char> vec(25, 'A');
        std::ofstream fout("A.txt");
        boost::archive::text_oarchive(fout) & vec;
        return 0;
}

----------------------------------
// B

#include <fstream>

#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>

int main()
{
        std::vector<char> vec;
        std::ifstream fin("A.txt");
        
        // If A1 produced the archive, this line succeeds.
        // If A2 produced the archive, this line will silently fail.
        boost::archive::text_iarchive(fin) & vec; 
        
        return 0;
}

----------------------------------