Implement a new compression inspired from simple-9.
* src/misc/intvcmp2.cc, src/misc/intvcmp2.hh: New files. * src/misc/Makefile.am: Add them. * src/tgbatest/intvcmp2.cc: New test. * src/tgbatest/Makefile.am: Add it. * src/tgbatest/intvcomp.test: Call it.
This commit is contained in:
Alexandre Duret-Lutz
parent
1d1872ab90
commit
a832eab156
7 changed files with 680 additions and 0 deletions
10
ChangeLog
10
ChangeLog
|
|
@ -1,3 +1,13 @@
|
|||
2011-05-01 Alexandre Duret-Lutz <adl@lrde.epita.fr>
|
||||
|
||||
Implement a new compression inspired from simple-9.
|
||||
|
||||
* src/misc/intvcmp2.cc, src/misc/intvcmp2.hh: New files.
|
||||
* src/misc/Makefile.am: Add them.
|
||||
* src/tgbatest/intvcmp2.cc: New test.
|
||||
* src/tgbatest/Makefile.am: Add it.
|
||||
* src/tgbatest/intvcomp.test: Call it.
|
||||
|
||||
2011-04-15 Alexandre Duret-Lutz <adl@lrde.epita.fr>
|
||||
|
||||
* src/misc/intvcomp.cc: Low-level fine-tuning.
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ misc_HEADERS = \
|
|||
hash.hh \
|
||||
hashfunc.hh \
|
||||
intvcomp.hh \
|
||||
intvcmp2.hh \
|
||||
ltstr.hh \
|
||||
minato.hh \
|
||||
memusage.hh \
|
||||
|
|
@ -56,6 +57,7 @@ libmisc_la_SOURCES = \
|
|||
escape.cc \
|
||||
freelist.cc \
|
||||
intvcomp.cc \
|
||||
intvcmp2.cc \
|
||||
memusage.cc \
|
||||
minato.cc \
|
||||
modgray.cc \
|
||||
|
|
|
|||
482
src/misc/intvcmp2.cc
Normal file
482
src/misc/intvcmp2.cc
Normal file
|
|
@ -0,0 +1,482 @@
|
|||
// Copyright (C) 2011 Laboratoire de Recherche et Developpement de
|
||||
// l'Epita (LRDE).
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
// Spot is free software; you can redistribute it and/or modify it
|
||||
// under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Spot is distributed in the hope that it will be useful, but WITHOUT
|
||||
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
||||
// License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Spot; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
||||
// 02111-1307, USA.
|
||||
|
||||
#include <cstddef>
|
||||
#include <cassert>
|
||||
#include "intvcmp2.hh"
|
||||
|
||||
#if __GNUC__ >= 3
|
||||
# define likely(expr) __builtin_expect(!!(expr), 1)
|
||||
# define unlikely(expr) __builtin_expect(!!(expr), 0)
|
||||
#else
|
||||
# define likely(expr) (expr)
|
||||
# define unlikely(expr) (expr)
|
||||
#endif
|
||||
|
||||
namespace spot
|
||||
{
|
||||
namespace
|
||||
{
|
||||
// This implements integer compression inspired from "Simple-9".
|
||||
//
|
||||
// The first bits of an integer tell how the rest of the integer is coded:
|
||||
// 00: 30 1-bit values
|
||||
// 01: 10 3-bit values
|
||||
// 10: 6 5-bit values
|
||||
// 1100: 4 7-bit values
|
||||
// 1101: 3 9-bit values (1 bit lost)
|
||||
// 1110: 2 14-bit values
|
||||
// 1111: 1 28-bit value
|
||||
|
||||
template <class Self>
|
||||
class stream_compression_base
|
||||
{
|
||||
public:
|
||||
stream_compression_base(size_t size)
|
||||
: size_(size)
|
||||
{
|
||||
}
|
||||
|
||||
void run()
|
||||
{
|
||||
static const unsigned bits_width[7] = { 1, 3, 5, 7, 9, 14, 28 };
|
||||
static const unsigned max_count[8] = { 30, 10, 6, 4, 3, 2, 1, 0 };
|
||||
static const unsigned max_allowed[8] = { 1,
|
||||
(1 << 3) - 1,
|
||||
(1 << 5) - 1,
|
||||
(1 << 7) - 1,
|
||||
(1 << 9) - 1,
|
||||
(1 << 14) - 1,
|
||||
(1 << 28) - 1,
|
||||
-1U };
|
||||
// If we have only X data to compress and they fit with the
|
||||
// current bit width, the following table tells us we should
|
||||
// use bits_width[count_to_level[X - 1]] to limit the number
|
||||
// of trailing zeros we encode. E.g. count_to_level[5 - 1]
|
||||
// is 2, which mean that 5 values should be encoded with
|
||||
// bits_width[2] == 5 bits.
|
||||
static const unsigned count_to_level[30] =
|
||||
{
|
||||
6, // 1
|
||||
5, // 2
|
||||
4, // 3
|
||||
3, // 4
|
||||
2, // 5
|
||||
2, // 6
|
||||
1, // 7
|
||||
1, // 8
|
||||
1, // 9
|
||||
1, // 10
|
||||
0,0,0,0,0, // 11-15
|
||||
0,0,0,0,0, // 16-20
|
||||
0,0,0,0,0, // 21-25
|
||||
0,0,0,0,0, // 26-30
|
||||
};
|
||||
|
||||
unsigned int pos = 0;
|
||||
while (pos < size_)
|
||||
{
|
||||
unsigned id = 0; // Current level in the above two tables.
|
||||
unsigned curmax_allowed = max_allowed[id];
|
||||
unsigned compressable = 0; // Number of integer ready to pack.
|
||||
do
|
||||
{
|
||||
unsigned int val = self().data_at(pos + compressable);
|
||||
++compressable;
|
||||
while (val > curmax_allowed)
|
||||
{
|
||||
curmax_allowed = max_allowed[++id];
|
||||
|
||||
if (compressable >= max_count[id])
|
||||
goto fast_encode;
|
||||
}
|
||||
}
|
||||
while (likely(compressable < max_count[id]
|
||||
&& (pos + compressable) < size_));
|
||||
|
||||
assert(compressable <= max_count[id]);
|
||||
|
||||
// Since we have less data than the current "id" allows,
|
||||
// try to use more bits so we can encode faster.
|
||||
id = count_to_level[compressable - 1];
|
||||
|
||||
if (compressable == max_count[id])
|
||||
goto fast_encode;
|
||||
|
||||
// Slow compression for situations where we have
|
||||
// compressable < max_count[id]. We can only be in
|
||||
// one of the 3 first "id" (1, 3, or 5 bits);
|
||||
{
|
||||
assert(id <= 2);
|
||||
unsigned bits = bits_width[id];
|
||||
unsigned finalshifts = (max_count[id] - compressable) * bits;
|
||||
unsigned output = self().data_at(pos);
|
||||
while (--compressable)
|
||||
{
|
||||
output <<= bits;
|
||||
output |= self().data_at(++pos);
|
||||
}
|
||||
output <<= finalshifts;
|
||||
output |= id << 30;
|
||||
self().push_data(output);
|
||||
return;
|
||||
}
|
||||
|
||||
fast_encode:
|
||||
switch (id)
|
||||
{
|
||||
case 0: // 30 1-bit values
|
||||
{
|
||||
unsigned int output = 0x00 << 30; // 00
|
||||
output |= self().data_at(pos + 0) << 29;
|
||||
output |= self().data_at(pos + 1) << 28;
|
||||
output |= self().data_at(pos + 2) << 27;
|
||||
output |= self().data_at(pos + 3) << 26;
|
||||
output |= self().data_at(pos + 4) << 25;
|
||||
output |= self().data_at(pos + 5) << 24;
|
||||
output |= self().data_at(pos + 6) << 23;
|
||||
output |= self().data_at(pos + 7) << 20;
|
||||
output |= self().data_at(pos + 8) << 21;
|
||||
output |= self().data_at(pos + 9) << 20;
|
||||
output |= self().data_at(pos + 10) << 19;
|
||||
output |= self().data_at(pos + 11) << 18;
|
||||
output |= self().data_at(pos + 12) << 17;
|
||||
output |= self().data_at(pos + 13) << 16;
|
||||
output |= self().data_at(pos + 14) << 15;
|
||||
output |= self().data_at(pos + 15) << 14;
|
||||
output |= self().data_at(pos + 16) << 13;
|
||||
output |= self().data_at(pos + 17) << 12;
|
||||
output |= self().data_at(pos + 18) << 11;
|
||||
output |= self().data_at(pos + 19) << 10;
|
||||
output |= self().data_at(pos + 20) << 9;
|
||||
output |= self().data_at(pos + 21) << 8;
|
||||
output |= self().data_at(pos + 22) << 7;
|
||||
output |= self().data_at(pos + 23) << 6;
|
||||
output |= self().data_at(pos + 24) << 5;
|
||||
output |= self().data_at(pos + 25) << 4;
|
||||
output |= self().data_at(pos + 26) << 3;
|
||||
output |= self().data_at(pos + 27) << 2;
|
||||
output |= self().data_at(pos + 28) << 1;
|
||||
output |= self().data_at(pos + 29);
|
||||
self().push_data(output);
|
||||
}
|
||||
break;
|
||||
case 1: // 10 3-bit values
|
||||
{
|
||||
unsigned int output = 0x01 << 30; // 01
|
||||
output |= self().data_at(pos + 0) << 27;
|
||||
output |= self().data_at(pos + 1) << 24;
|
||||
output |= self().data_at(pos + 2) << 21;
|
||||
output |= self().data_at(pos + 3) << 18;
|
||||
output |= self().data_at(pos + 4) << 15;
|
||||
output |= self().data_at(pos + 5) << 12;
|
||||
output |= self().data_at(pos + 6) << 9;
|
||||
output |= self().data_at(pos + 7) << 6;
|
||||
output |= self().data_at(pos + 8) << 3;
|
||||
output |= self().data_at(pos + 9);
|
||||
self().push_data(output);
|
||||
}
|
||||
break;
|
||||
case 2: // 6 5-bit values
|
||||
{
|
||||
unsigned int output = 0x02 << 30; // 10
|
||||
output |= self().data_at(pos + 0) << 25;
|
||||
output |= self().data_at(pos + 1) << 20;
|
||||
output |= self().data_at(pos + 2) << 15;
|
||||
output |= self().data_at(pos + 3) << 10;
|
||||
output |= self().data_at(pos + 4) << 5;
|
||||
output |= self().data_at(pos + 5);
|
||||
self().push_data(output);
|
||||
}
|
||||
break;
|
||||
case 3: // 4 7-bit values
|
||||
{
|
||||
unsigned int output = 0x0C << 28; // 1100
|
||||
output |= self().data_at(pos + 0) << 21;
|
||||
output |= self().data_at(pos + 1) << 14;
|
||||
output |= self().data_at(pos + 2) << 7;
|
||||
output |= self().data_at(pos + 3);
|
||||
self().push_data(output);
|
||||
}
|
||||
break;
|
||||
case 4: // 3 9-bit values
|
||||
{
|
||||
unsigned int output = 0x0D << 28; // 1101x (1 bit lost)
|
||||
output |= self().data_at(pos + 0) << 18;
|
||||
output |= self().data_at(pos + 1) << 9;
|
||||
output |= self().data_at(pos + 2);
|
||||
self().push_data(output);
|
||||
}
|
||||
break;
|
||||
case 5: // 2 14-bit values
|
||||
{
|
||||
unsigned int output = 0x0E << 28; // 1110
|
||||
output |= self().data_at(pos + 0) << 14;
|
||||
output |= self().data_at(pos + 1);
|
||||
self().push_data(output);
|
||||
}
|
||||
break;
|
||||
case 6: // one 28-bit value
|
||||
{
|
||||
unsigned int output = 0x0F << 28; // 1111
|
||||
output |= self().data_at(pos + 0);
|
||||
self().push_data(output);
|
||||
}
|
||||
break;
|
||||
}
|
||||
pos += max_count[id];
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
size_t size_;
|
||||
|
||||
Self& self()
|
||||
{
|
||||
return static_cast<Self&>(*this);
|
||||
}
|
||||
|
||||
const Self& self() const
|
||||
{
|
||||
return static_cast<const Self&>(*this);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
class int_array_array_compression:
|
||||
public stream_compression_base<int_array_array_compression>
|
||||
{
|
||||
public:
|
||||
int_array_array_compression(const int* array, size_t n,
|
||||
int* dest, size_t& dest_n)
|
||||
: stream_compression_base(n),
|
||||
array_(array), result_size_(dest_n),
|
||||
result_(dest), result_end_(dest + dest_n)
|
||||
{
|
||||
result_size_ = 0; // this resets dest_n.
|
||||
}
|
||||
|
||||
void push_data(unsigned int i)
|
||||
{
|
||||
assert(result_ < result_end_);
|
||||
++result_size_;
|
||||
*result_++ = static_cast<int>(i);
|
||||
}
|
||||
|
||||
unsigned int data_at(unsigned int offset)
|
||||
{
|
||||
return static_cast<unsigned int>(array_[offset]);
|
||||
}
|
||||
|
||||
protected:
|
||||
const int* array_;
|
||||
size_t& result_size_;
|
||||
int* result_;
|
||||
int* result_end_;
|
||||
};
|
||||
|
||||
} // anonymous
|
||||
|
||||
|
||||
void
|
||||
int_array_array_compress2(const int* array, size_t n,
|
||||
int* dest, size_t& dest_size)
|
||||
{
|
||||
int_array_array_compression c(array, n, dest, dest_size);
|
||||
c.run();
|
||||
}
|
||||
|
||||
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
template<class Self>
|
||||
class stream_decompression_base
|
||||
{
|
||||
public:
|
||||
|
||||
void run()
|
||||
{
|
||||
while (likely(self().have_comp_data()))
|
||||
{
|
||||
unsigned val = self().next_comp_data();
|
||||
|
||||
unsigned id = val >> 28;
|
||||
switch (id)
|
||||
{
|
||||
case 0x00: // 00xx - 30 1-bit values.
|
||||
case 0x01:
|
||||
case 0x02:
|
||||
case 0x03:
|
||||
self().write_data_at(0, !!(val & (1 << 29)));
|
||||
self().write_data_at(1, !!(val & (1 << 28)));
|
||||
self().write_data_at(2, !!(val & (1 << 27)));
|
||||
self().write_data_at(3, !!(val & (1 << 26)));
|
||||
self().write_data_at(4, !!(val & (1 << 25)));
|
||||
self().write_data_at(5, !!(val & (1 << 24)));
|
||||
self().write_data_at(6, !!(val & (1 << 23)));
|
||||
self().write_data_at(7, !!(val & (1 << 22)));
|
||||
self().write_data_at(8, !!(val & (1 << 21)));
|
||||
self().write_data_at(9, !!(val & (1 << 20)));
|
||||
self().write_data_at(10, !!(val & (1 << 19)));
|
||||
self().write_data_at(11, !!(val & (1 << 18)));
|
||||
self().write_data_at(12, !!(val & (1 << 17)));
|
||||
self().write_data_at(13, !!(val & (1 << 16)));
|
||||
self().write_data_at(14, !!(val & (1 << 15)));
|
||||
self().write_data_at(15, !!(val & (1 << 14)));
|
||||
self().write_data_at(16, !!(val & (1 << 13)));
|
||||
self().write_data_at(17, !!(val & (1 << 12)));
|
||||
self().write_data_at(18, !!(val & (1 << 11)));
|
||||
self().write_data_at(19, !!(val & (1 << 10)));
|
||||
self().write_data_at(20, !!(val & (1 << 9)));
|
||||
self().write_data_at(21, !!(val & (1 << 8)));
|
||||
self().write_data_at(22, !!(val & (1 << 7)));
|
||||
self().write_data_at(23, !!(val & (1 << 6)));
|
||||
self().write_data_at(24, !!(val & (1 << 5)));
|
||||
self().write_data_at(25, !!(val & (1 << 4)));
|
||||
self().write_data_at(26, !!(val & (1 << 3)));
|
||||
self().write_data_at(27, !!(val & (1 << 2)));
|
||||
self().write_data_at(28, !!(val & (1 << 1)));
|
||||
self().write_data_at(29, !!(val & (1 << 0)));
|
||||
self().forward(30);
|
||||
break;
|
||||
case 0x04: // 01xx - 10 3-bit values.
|
||||
case 0x05:
|
||||
case 0x06:
|
||||
case 0x07:
|
||||
self().write_data_at(0, (val >> 27) & 0x07);
|
||||
self().write_data_at(1, (val >> 24) & 0x07);
|
||||
self().write_data_at(2, (val >> 21) & 0x07);
|
||||
self().write_data_at(3, (val >> 18) & 0x07);
|
||||
self().write_data_at(4, (val >> 15) & 0x07);
|
||||
self().write_data_at(5, (val >> 12) & 0x07);
|
||||
self().write_data_at(6, (val >> 9) & 0x07);
|
||||
self().write_data_at(7, (val >> 6) & 0x07);
|
||||
self().write_data_at(8, (val >> 3) & 0x07);
|
||||
self().write_data_at(9, (val >> 0) & 0x07);
|
||||
self().forward(10);
|
||||
break;
|
||||
case 0x08: // 10xx - 6 5-bit values.
|
||||
case 0x09:
|
||||
case 0x0A:
|
||||
case 0x0B:
|
||||
self().write_data_at(0, (val >> 25) & 0x1F);
|
||||
self().write_data_at(1, (val >> 20) & 0x1F);
|
||||
self().write_data_at(2, (val >> 15) & 0x1F);
|
||||
self().write_data_at(3, (val >> 10) & 0x1F);
|
||||
self().write_data_at(4, (val >> 5) & 0x1F);
|
||||
self().write_data_at(5, (val >> 0) & 0x1F);
|
||||
self().forward(6);
|
||||
break;
|
||||
case 0x0C: // 1100 - 4 7-bit values
|
||||
self().write_data_at(0, (val >> 21) & 0x7F);
|
||||
self().write_data_at(1, (val >> 14) & 0x7F);
|
||||
self().write_data_at(2, (val >> 7) & 0x7F);
|
||||
self().write_data_at(3, (val >> 0) & 0x7F);
|
||||
self().forward(4);
|
||||
break;
|
||||
case 0x0D: // 1101x - 3 9-bit values.
|
||||
self().write_data_at(0, (val >> 18) & 0x1FF);
|
||||
self().write_data_at(1, (val >> 9) & 0x1FF);
|
||||
self().write_data_at(2, (val >> 0) & 0x1FF);
|
||||
self().forward(3);
|
||||
break;
|
||||
case 0x0E: // 110x - 2 14-bit values.
|
||||
self().write_data_at(0, (val >> 14) & 0x3FFF);
|
||||
self().write_data_at(1, (val >> 0) & 0x3FFF);
|
||||
self().forward(2);
|
||||
break;
|
||||
case 0x0F: // 1100 - 1 28-bit value.
|
||||
self().write_data_at(0, val & 0xFFFFFFF);
|
||||
self().forward(1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
Self& self()
|
||||
{
|
||||
return static_cast<Self&>(*this);
|
||||
}
|
||||
|
||||
const Self& self() const
|
||||
{
|
||||
return static_cast<const Self&>(*this);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class int_array_array_decompression:
|
||||
public stream_decompression_base<int_array_array_decompression>
|
||||
{
|
||||
public:
|
||||
int_array_array_decompression(const int* array,
|
||||
size_t array_size,
|
||||
int* res)
|
||||
: array_(array), n_(array_size), pos_(0), result_(res)
|
||||
{
|
||||
}
|
||||
|
||||
void write_data_at(unsigned int pos, int i)
|
||||
{
|
||||
result_[pos] = i;
|
||||
}
|
||||
|
||||
void forward(unsigned int i)
|
||||
{
|
||||
result_ += i;
|
||||
}
|
||||
|
||||
bool have_comp_data() const
|
||||
{
|
||||
return pos_ < n_;
|
||||
}
|
||||
|
||||
unsigned int next_comp_data()
|
||||
{
|
||||
return array_[pos_++];
|
||||
}
|
||||
|
||||
protected:
|
||||
const int* array_;
|
||||
size_t n_;
|
||||
size_t pos_;
|
||||
int* result_;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
int_array_array_decompress2(const int* array, size_t array_size, int* res,
|
||||
size_t)
|
||||
{
|
||||
int_array_array_decompression c(array, array_size, res);
|
||||
c.run();
|
||||
}
|
||||
|
||||
|
||||
|
||||
} // spot
|
||||
52
src/misc/intvcmp2.hh
Normal file
52
src/misc/intvcmp2.hh
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
// Copyright (C) 2011 Laboratoire de Recherche et Developpement de
|
||||
// l'Epita (LRDE).
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
// Spot is free software; you can redistribute it and/or modify it
|
||||
// under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Spot is distributed in the hope that it will be useful, but WITHOUT
|
||||
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
||||
// License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Spot; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
||||
// 02111-1307, USA.
|
||||
|
||||
#ifndef SPOT_MISC_INTVCMP2_HH
|
||||
# define SPOT_MISC_INTVCMP2_HH
|
||||
|
||||
#include <vector>
|
||||
|
||||
namespace spot
|
||||
{
|
||||
/// \addtogroup misc_tools
|
||||
/// @{
|
||||
|
||||
/// \brief Compress an int array of size \a n into a int array.
|
||||
///
|
||||
/// The destination array should be at least \a dest_size large An
|
||||
/// assert will be triggered if \a dest_size is too small. On
|
||||
/// return, \a dest_size will be set to the actually number of int
|
||||
/// filled in \a dest
|
||||
void
|
||||
int_array_array_compress2(const int* array, size_t n,
|
||||
int* dest, size_t& dest_size);
|
||||
|
||||
/// \brief Uncompress an int array of size \a array_size into a int
|
||||
/// array of size \a size.
|
||||
///
|
||||
/// \a size must be the exact expected size of uncompressed array.
|
||||
void
|
||||
int_array_array_decompress2(const int* array, size_t array_size,
|
||||
int* res, size_t size);
|
||||
|
||||
/// @}
|
||||
}
|
||||
|
||||
#endif // SPOT_MISC_INTVCMP2_HH
|
||||
|
|
@ -38,6 +38,7 @@ check_PROGRAMS = \
|
|||
expldot \
|
||||
explprod \
|
||||
intvcomp \
|
||||
intvcmp2 \
|
||||
ltlprod \
|
||||
mixprod \
|
||||
powerset \
|
||||
|
|
@ -56,6 +57,7 @@ expldot_SOURCES = powerset.cc
|
|||
expldot_CXXFLAGS = -DDOTTY
|
||||
explprod_SOURCES = explprod.cc
|
||||
intvcomp_SOURCES = intvcomp.cc
|
||||
intvcmp2_SOURCES = intvcmp2.cc
|
||||
ltl2tgba_SOURCES = ltl2tgba.cc
|
||||
ltlprod_SOURCES = ltlprod.cc
|
||||
mixprod_SOURCES = mixprod.cc
|
||||
|
|
|
|||
131
src/tgbatest/intvcmp2.cc
Normal file
131
src/tgbatest/intvcmp2.cc
Normal file
|
|
@ -0,0 +1,131 @@
|
|||
// Copyright (C) 2011 Laboratoire de Recherche et Developpement de
|
||||
// l'Epita (LRDE).
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
// Spot is free software; you can redistribute it and/or modify it
|
||||
// under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// Spot is distributed in the hope that it will be useful, but WITHOUT
|
||||
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
||||
// License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Spot; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
||||
// 02111-1307, USA.
|
||||
|
||||
#include <iostream>
|
||||
#include "misc/intvcmp2.hh"
|
||||
#include <cstring>
|
||||
|
||||
|
||||
int check_aa(int* data, int size, unsigned expected = 0)
|
||||
{
|
||||
int* comp = new int[size * 2];
|
||||
size_t csize = size * 2;
|
||||
spot::int_array_array_compress2(data, size, comp, csize);
|
||||
|
||||
std::cout << "AC[" << csize << "] ";
|
||||
for (size_t i = 0; i < csize; ++i)
|
||||
std::cout << comp[i] << " ";
|
||||
std::cout << std::endl;
|
||||
|
||||
int* decomp = new int[size + 30];
|
||||
spot::int_array_array_decompress2(comp, csize, decomp, size);
|
||||
|
||||
std::cout << "AD[" << size << "] ";
|
||||
for (int i = 0; i < size; ++i)
|
||||
std::cout << decomp[i] << " ";
|
||||
std::cout << std::endl;
|
||||
|
||||
int res = memcmp(data, decomp, size * sizeof(int));
|
||||
|
||||
if (res)
|
||||
{
|
||||
std::cout << "*** cmp error *** " << res << std::endl;
|
||||
std::cout << "AE[" << size << "] ";
|
||||
for (int i = 0; i < size; ++i)
|
||||
std::cout << data[i] << " ";
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
||||
if (expected && (csize * sizeof(int) != expected))
|
||||
{
|
||||
std::cout << "*** size error *** (expected "
|
||||
<< expected << " bytes, got " << csize * sizeof(int)
|
||||
<< " bytes)" << std::endl;
|
||||
res = 1;
|
||||
}
|
||||
|
||||
std::cout << std::endl;
|
||||
|
||||
delete[] comp;
|
||||
delete[] decomp;
|
||||
return !!res;
|
||||
}
|
||||
|
||||
int check(int* comp, int size, unsigned expected = 0)
|
||||
{
|
||||
return
|
||||
//check_vv(comp, size, expected) +
|
||||
//check_av(comp, size, expected) +
|
||||
check_aa(comp, size, expected);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int errors = 0;
|
||||
|
||||
int comp1[] = { 1, 0, 0, 0, 0, 0, 3, 3, 4, 0, 0, 0 };
|
||||
errors += check(comp1, sizeof(comp1) / sizeof(*comp1));
|
||||
|
||||
int comp2[] = { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 1 };
|
||||
errors += check(comp2, sizeof(comp2) / sizeof(*comp2));
|
||||
|
||||
int comp3[] = { 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1,
|
||||
0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0,
|
||||
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1,
|
||||
0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
||||
0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1,
|
||||
0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0 };
|
||||
errors += check(comp3, sizeof(comp3) / sizeof(*comp3));
|
||||
|
||||
int comp4[] = { 1, 2, 1, 2, 1, 2, 2, 0 }; // 32 bits
|
||||
errors += check(comp4, sizeof(comp4) / sizeof(*comp4), 4);
|
||||
|
||||
int comp5[] = { 1, 2, 1, 2, 1, 2, 2, 0, 1, 2, 1, 2, 1, 2, 2, 0 }; // 64 bits
|
||||
errors += check(comp5, sizeof(comp5) / sizeof(*comp5), 8);
|
||||
|
||||
int comp6[] = { 1, 2, 1, 2, 1, 2, 2, 0, 1, 2, 1, 2, 1, 2, 2, 0,
|
||||
1, 2, 1, 2, 1, 2, 2, 0, 1, 2, 1, 2, 1, 2, 2, 0 }; // 128 bits
|
||||
errors += check(comp6, sizeof(comp6) / sizeof(*comp6), 16);
|
||||
|
||||
int comp7[] = { 4, 8, 10, 3, 49, 50, 0, 20, 13 };
|
||||
errors += check(comp7, sizeof(comp7) / sizeof(*comp7));
|
||||
|
||||
int comp8[] = { 4959, 6754, 8133, 10985, 11121, 14413, 17335, 20754,
|
||||
21317, 30008, 30381, 33494, 34935, 41210, 41417 };
|
||||
errors += check(comp8, sizeof(comp8) / sizeof(*comp8));
|
||||
|
||||
int comp9[] = { 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
errors += check(comp9, sizeof(comp9) / sizeof(*comp9));
|
||||
|
||||
int comp10[] = { 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0,
|
||||
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,
|
||||
9, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 10,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 9 };
|
||||
errors += check(comp10, sizeof(comp10) / sizeof(*comp10));
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
|
@ -25,3 +25,4 @@
|
|||
set -e
|
||||
|
||||
run 0 ../intvcomp
|
||||
run 0 ../intvcmp2
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue