void generation::print()
{
lprintf(" total capacity: %d\n", capacity());
lprintf(" used: %d bytes for oops, %d bytes for bytes, total %d\n",
oops_used() * oopSize, bytes_used(), used());
lprintf(" address boundaries: 0x%x, 0x%x\n",
low_boundary, high_boundary);
}
oop space::get_allocation_vector() {
oop vec= Memory->objVectorObj->cloneSize(3, CANFAIL);
if (vec != failedAllocationOop) {
vec->obj_at_put(0, as_smiOop(oops_used() * oopSize));
vec->obj_at_put(1, as_smiOop(bytes_used()));
vec->obj_at_put(2, as_smiOop(capacity()));
}
return vec;
}
int main()
{
// Set the number of symbols (i.e. the generation size in RLNC
// terminology) and the size of a symbol in bytes
uint32_t max_symbols = 42;
uint32_t max_symbol_size = 64;
std::string encode_filename = "encode-file.bin";
// Create a test file for encoding.
std::ofstream encode_file;
encode_file.open (encode_filename, std::ios::binary);
uint32_t file_size = 50000;
std::vector<char> encode_data(file_size);
std::vector<char> decode_data;
// Just write some bytes to the file
for(uint32_t i = 0; i < file_size; ++i)
{
encode_data[i] = rand() % 255;
}
encode_file.write(&encode_data[0], file_size);
encode_file.close();
// Select the encoding and decoding algorithms
typedef kodo::full_rlnc_encoder<fifi::binary>
encoder_t;
typedef kodo::full_rlnc_decoder<fifi::binary>
decoder_t;
// Now for the encoder we use a file_encoder with the chosen
// encoding algorithm
typedef kodo::file_encoder<encoder_t>
file_encoder_t;
// For decoding we use an object_decoder with the chosen
// decoding algorithm
typedef kodo::object_decoder<decoder_t>
object_decoder_t;
// Create the encoder factory - builds the individual encoders used
file_encoder_t::factory encoder_factory(max_symbols, max_symbol_size);
// Create the actual file encoder using the encoder factory and
// the filename of the file to be encoded
file_encoder_t file_encoder(encoder_factory, encode_filename);
// Create the decoder factory - build the individual decoders used
object_decoder_t::factory decoder_factory(max_symbols, max_symbol_size);
// Create the object decoder using the decoder factory and the
// size of the file to be decoded
object_decoder_t object_decoder(decoder_factory, file_size);
// Now in the following loop we go through all the encoders
// needed to encode the entire file. We the build the corresponding
// decoder and decode the chunk immediately. In practice where
// encoders and decoders are on different devices e.g. connected
// over a network, we would have to pass also the encoder and decoder
// index between the source and sink to allow the correct data would
// passed from encoder to corresponding decoder.
for(uint32_t i = 0; i < file_encoder.encoders(); ++i)
{
auto encoder = file_encoder.build(i);
auto decoder = object_decoder.build(i);
// Set the encoder non-systematic
if(kodo::has_systematic_encoder<encoder_t>::value)
kodo::set_systematic_off(encoder);
std::vector<uint8_t> payload(encoder->payload_size());
while( !decoder->is_complete() )
{
// Encode a packet into the payload buffer
encoder->encode( &payload[0] );
// In practice send the payload over a network, save it to
// a file etc. Then when needed build and pass it to the decoder
// Pass that packet to the decoder
decoder->decode( &payload[0] );
}
std::vector<uint8_t> data_out(decoder->block_size());
decoder->copy_symbols(sak::storage(data_out));
data_out.resize(decoder->bytes_used());
decode_data.insert(decode_data.end(),
data_out.begin(),
data_out.end());
}
// Check we properly decoded the data
if (std::equal(decode_data.begin(),
decode_data.end(), encode_data.begin()))
{
std::cout << "Data decoded correctly" << std::endl;
}
else
{
std::cout << "Unexpected failure to decode "
<< "please file a bug report :)" << std::endl;
}
}
void run_test_random_annex_partial(uint32_t max_symbols,
uint32_t max_symbol_size,
uint32_t multiplier)
{
uint32_t object_size = max_symbols * max_symbol_size * multiplier;
object_size -= (rand() % object_size);
uint32_t annex_size = kodo::max_annex_size(
max_symbols, max_symbol_size, object_size);
if(annex_size > 0)
{
// Randomize the actual annex size
annex_size -= (rand() % annex_size);
}
typedef kodo::random_annex_encoder<Encoder, Partitioning>
random_annex_encoder;
typedef kodo::random_annex_decoder<Decoder, Partitioning>
random_annex_decoder;
std::vector<uint8_t> data_in = random_vector(object_size);
std::vector<uint8_t> data_out(object_size, '\0');
typename Encoder::factory encoder_factory(max_symbols, max_symbol_size);
typename Decoder::factory decoder_factory(max_symbols, max_symbol_size);
random_annex_encoder obj_encoder(
annex_size, encoder_factory, sak::storage(data_in));
random_annex_decoder obj_decoder(
annex_size, decoder_factory, obj_encoder.object_size());
EXPECT_TRUE(obj_encoder.encoders() >= 1);
EXPECT_TRUE(obj_decoder.decoders() >= 1);
EXPECT_TRUE(obj_encoder.encoders() == obj_decoder.decoders());
uint32_t bytes_used = 0;
for(uint32_t i = 0; i < obj_encoder.encoders(); ++i)
{
auto encoder = obj_encoder.build(i);
typename random_annex_decoder::pointer_type decoder =
obj_decoder.build(i);
if(kodo::has_systematic_encoder<Encoder>::value)
kodo::set_systematic_off(encoder);
EXPECT_TRUE(encoder->block_size() >= encoder->bytes_used());
EXPECT_TRUE(decoder->block_size() >= decoder->bytes_used());
EXPECT_TRUE(encoder->block_size() == decoder->block_size());
EXPECT_TRUE(encoder->bytes_used() == decoder->bytes_used());
EXPECT_TRUE(encoder->payload_size() == decoder->payload_size());
std::vector<uint8_t> payload(encoder->payload_size());
while(!decoder->is_complete())
{
encoder->encode( &payload[0] );
decoder->decode( &payload[0] );
}
sak::mutable_storage storage = sak::storage(
&data_out[0] + bytes_used, decoder->bytes_used());
decoder.unwrap()->copy_symbols(storage);
bytes_used += decoder->bytes_used();
}
EXPECT_EQ(bytes_used, object_size);
EXPECT_TRUE(std::equal(data_in.begin(),
data_in.end(),
data_out.begin()));
}
// Tests that encoding and decoding a file withe the file encoder
// works.
TEST(TestFileEncoder, test_file_encoder)
{
{
std::string encode_filename = "encode-file";
std::string decode_filename = "decode-file";
// Write a test file
std::ofstream encode_file;
encode_file.open (encode_filename, std::ios::binary);
uint32_t size = 500;
for(uint32_t i = 0; i < size; ++i)
{
char c = rand() % 255;
encode_file.write(&c, 1);
}
encode_file.close();
typedef kodo::full_rlnc_encoder<fifi::binary>
encoder_t;
typedef kodo::full_rlnc_decoder<fifi::binary>
decoder_t;
typedef kodo::file_encoder<encoder_t>
file_encoder_t;
typedef kodo::object_decoder<decoder_t>
object_decoder_t;
uint32_t max_symbols = 10;
uint32_t max_symbol_size = 10;
file_encoder_t::factory encoder_factory(
max_symbols, max_symbol_size);
file_encoder_t file_encoder(encoder_factory, encode_filename);
object_decoder_t::factory decoder_factory(
max_symbols, max_symbol_size);
object_decoder_t object_decoder(decoder_factory, size);
EXPECT_EQ(object_decoder.decoders(), file_encoder.encoders());
// Open the decode file
std::ofstream decode_file;
decode_file.open (decode_filename, std::ios::binary);
for(uint32_t i = 0; i < file_encoder.encoders(); ++i)
{
auto encoder = file_encoder.build(i);
auto decoder = object_decoder.build(i);
EXPECT_EQ(encoder->symbols(), decoder->symbols());
EXPECT_EQ(encoder->symbol_size(), decoder->symbol_size());
EXPECT_EQ(encoder->bytes_used(), decoder->bytes_used());
// Set the encoder non-systematic
if(kodo::is_systematic_encoder(encoder))
kodo::set_systematic_off(encoder);
std::vector<uint8_t> payload(encoder->payload_size());
while( !decoder->is_complete() )
{
// Encode a packet into the payload buffer
encoder->encode( &payload[0] );
// Pass that packet to the decoder
decoder->decode( &payload[0] );
}
std::vector<uint8_t> data_out(decoder->block_size());
decoder->copy_symbols(sak::storage(data_out));
decode_file.write(
reinterpret_cast<char*>(&data_out[0]), decoder->bytes_used());
}
decode_file.close();
}
}
