void operator () () const {
try {
M m1 (N, N), m2 (N, N), m3 (N, N);
(*this) (m1, m2, m3);
#ifdef USE_RANGE
ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
mr3 (m3, ublas::range (0, N), ublas::range (0, N));
(*this) (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
(*this) (ms1, ms2, ms3);
#endif
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
catch (...) {
std::cout << "unknown exception" << std::endl;
}
}
void operator () () const {
{
#ifdef USE_BANDED
M m1 (N, N, 1, 1), m2 (N, N, 1, 1), m3 (N, N, 1, 1);
#endif
#ifdef USE_DIAGONAL
M m1 (N, N), m2 (N, N), m3 (N, N);
#endif
test_with (m1, m2, m3);
#ifdef USE_RANGE
ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
mr3 (m3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
}
}
void operator () (int) const {
#ifdef USE_ADAPTOR
try {
M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::triangular_adaptor<M> tam1 (m1), tam2 (m2), tam3 (m3);
(*this) (tam1, tam2, tam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::triangular_adaptor<M> > mr1 (tam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (tam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (tam3, ublas::range (0, N), ublas::range (0, N));
(*this) (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::triangular_adaptor<M> > ms1 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (tam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (tam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
(*this) (ms1, ms2, ms3);
#endif
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
catch (...) {
std::cout << "unknown exception" << std::endl;
}
#endif
}
void operator () (int) const {
#ifdef USE_ADAPTOR
{
#ifdef USE_BANDED
M m1 (N, N, 1, 1), m2 (N, N, 1, 1), m3 (N, N, 1, 1);
ublas::banded_adaptor<M> bam1 (m1, 1, 1), bam2 (m2, 1, 1), bam3 (m3, 1, 1);
test_with (bam1, bam2, bam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::banded_adaptor<M> > mr1 (bam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (bam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (bam3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::banded_adaptor<M> > ms1 (bam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (bam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (bam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
#endif
#ifdef USE_DIAGONAL
M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::diagonal_adaptor<M> dam1 (m1), dam2 (m2), dam3 (m3);
test_with (dam1, dam2, dam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::diagonal_adaptor<M> > mr1 (dam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (dam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (dam3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::diagonal_adaptor<M> > ms1 (dam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (dam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (dam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
#endif
}
#endif
}
void operator () () const {
{
M m1 (N, N), m2 (N, N), m3 (N, N);
test_with (m1, m2, m3);
#ifdef USE_RANGE
ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
mr3 (m3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
}
#ifdef USE_ADAPTOR
{
M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::triangular_adaptor<M> tam1 (m1), tam2 (m2), tam3 (m3);
test_with (tam1, tam2, tam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::triangular_adaptor<M> > mr1 (tam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (tam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (tam3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::triangular_adaptor<M> > ms1 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (tam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (tam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
}
#endif
}
// @requires UseG1GC
TEST_VM(FreeRegionList, length) {
if (!UseG1GC) {
return;
}
FreeRegionList l("test");
const uint num_regions_in_test = 5;
// Create a fake heap. It does not need to be valid, as the HeapRegion constructor
// does not access it.
MemRegion heap(NULL, num_regions_in_test * HeapRegion::GrainWords);
// Allocate a fake BOT because the HeapRegion constructor initializes
// the BOT.
size_t bot_size = G1BlockOffsetTable::compute_size(heap.word_size());
HeapWord* bot_data = NEW_C_HEAP_ARRAY(HeapWord, bot_size, mtGC);
ReservedSpace bot_rs(G1BlockOffsetTable::compute_size(heap.word_size()));
G1RegionToSpaceMapper* bot_storage =
G1RegionToSpaceMapper::create_mapper(bot_rs,
bot_rs.size(),
os::vm_page_size(),
HeapRegion::GrainBytes,
BOTConstants::N_bytes,
mtGC);
G1BlockOffsetTable bot(heap, bot_storage);
bot_storage->commit_regions(0, num_regions_in_test);
// Set up memory regions for the heap regions.
MemRegion mr0(heap.start(), HeapRegion::GrainWords);
MemRegion mr1(mr0.end(), HeapRegion::GrainWords);
MemRegion mr2(mr1.end(), HeapRegion::GrainWords);
MemRegion mr3(mr2.end(), HeapRegion::GrainWords);
MemRegion mr4(mr3.end(), HeapRegion::GrainWords);
HeapRegion hr0(0, &bot, mr0);
HeapRegion hr1(1, &bot, mr1);
HeapRegion hr2(2, &bot, mr2);
HeapRegion hr3(3, &bot, mr3);
HeapRegion hr4(4, &bot, mr4);
l.add_ordered(&hr1);
l.add_ordered(&hr0);
l.add_ordered(&hr3);
l.add_ordered(&hr4);
l.add_ordered(&hr2);
EXPECT_EQ(l.length(), num_regions_in_test) << "Wrong free region list length";
l.verify_list();
bot_storage->uncommit_regions(0, num_regions_in_test);
delete bot_storage;
FREE_C_HEAP_ARRAY(HeapWord, bot_data);
}
void operator () () const {
M m1 (N, N), m2 (N, N), m3 (N, N);
test_expression_with (m1, m2, m3);
test_container_with (m1);
#ifdef USE_RANGE
ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
mr3 (m3, ublas::range (0, N), ublas::range (0, N));
test_expression_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_expression_with (ms1, ms2, ms3);
#endif
}
void operator () (int runs, fast_tag) const {
try {
static M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
mr3 (m3, ublas::range (0, N), ublas::range (0, N));
initialize_matrix (mr1);
initialize_matrix (mr2);
boost::timer t;
for (int i = 0; i < runs; ++ i) {
mr3.assign (ublas::prod (mr1, mr2));
// sink_matrix (mr3);
}
footer<value_type> () (N * N * N, N * N * (N - 1), runs, t.elapsed ());
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
catch (...) {
std::cout << "unknown exception" << std::endl;
}
}
void operator () (int) const {
#ifdef USE_ADAPTOR
{
M m1 (N, N), m2 (N, N), m3 (N, N);
ublas::symmetric_adaptor<M> sam1 (m1), sam2 (m2), sam3 (m3);
test_with (sam1, sam2, sam3);
#ifdef USE_RANGE
ublas::matrix_range<ublas::symmetric_adaptor<M> > mr1 (sam1, ublas::range (0, N), ublas::range (0, N)),
mr2 (sam2, ublas::range (0, N), ublas::range (0, N)),
mr3 (sam3, ublas::range (0, N), ublas::range (0, N));
test_with (mr1, mr2, mr3);
#endif
#ifdef USE_SLICE
ublas::matrix_slice<ublas::symmetric_adaptor<M> > ms1 (sam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms2 (sam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
ms3 (sam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
test_with (ms1, ms2, ms3);
#endif
}
#endif
}
