Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	TESTS/TEST_TENSOR_BLOCK_VEC/main.cpp	Lines:	71	71	100.0 %
Date:	2026-03-27 22:08:32	Branches:	114	114	100.0 %


/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

#include "PTensor.h"

#define USE_VECTOR_SIZE 2lu

///Test the PTensor
/**	@return true on success, false otherwise
*/
bool testPTensorBlock(){
	size_t nbRow(6lu), nbCol(14lu);
	PTensor<int> tensor;
	tensor.resize(AllocMode::NONE, nbRow, nbCol);
	tensor.setNbVecNeighbour(USE_VECTOR_SIZE);
	for(size_t i(0lu); i < nbRow; ++i){
		for(size_t j(0lu); j < nbCol; ++j){
			tensor.setValue(i, j, (int)(i*nbCol + j));
		}
	}
	std::cout << "testPTensorBlock : input tensor : " << std::endl << tensor << std::endl;
	size_t blockSizeRow(2lu), blockSizeCol(6lu);	//The final block will have 2 columns because it has to be a multiple of 2
	std::vector<PBlock<int> > vecBlock;
	tensor.splitBlock(vecBlock, blockSizeRow, blockSizeCol, 0lu);

	std::cout << "testPTensorBlock : create " << vecBlock.size() << " blocks" << std::endl;
	bool b(true);
	b &= vecBlock.size() == 9lu;

	size_t blockIndex(0lu);
	for(std::vector<PBlock<int> >::iterator it(vecBlock.begin()); it != vecBlock.end(); ++it){
		PBlock<int> & block = *it;
		std::cout << "Block " << blockIndex << " ("<<block.getLocationRow()<<", "<<block.getLocationCol()<<") :" << std::endl << block << std::endl;

		for(size_t i(0lu); i < block.getFullNbRow(); ++i){
			for(size_t j(0lu); j < block.getNbCol(); ++j){
				b &= block.getValue(i, j) == (int)((i + block.getLocationRow())*nbCol + (j + block.getLocationCol()));
			}
		}
		std::cout << "testPTensorBlock : Block " << blockIndex << ", b = " << b << std::endl;
		++blockIndex;
	}
	std::cout << "testPTensorBlock : create block b = " << b << std::endl;

	tensor.fill(0);	//Let's clear the tensor and put the block back into it
	tensor.mergeBlock(vecBlock, 0lu);
	std::cout << "testPTensorBlock : merged tensor : " << std::endl << tensor << std::endl;
	for(size_t i(0lu); i < nbRow; ++i){
		for(size_t j(0lu); j < nbCol; ++j){
			b &= tensor.getValue(i, j) == (int)(i*nbCol + j);
		}
	}
	std::cout << "testPTensorBlock : merge block b = " << b << std::endl;
	return b;
}

///Test the PTensor
/**	@return true on success, false otherwise
*/
bool testPTensorBlockNeighbourRing(){
	std::cout << "testPTensorBlockNeighbourRing =================== START ====================" << std::endl;
	size_t nbRow(6lu), nbCol(14lu);
	PTensor<int> tensor;
	tensor.resize(AllocMode::NONE, nbRow, nbCol);
	tensor.setNbVecNeighbour(USE_VECTOR_SIZE);
	for(size_t i(0lu); i < nbRow; ++i){
		for(size_t j(0lu); j < nbCol; ++j){
			tensor.setValue(i, j, (int)(i*nbCol + j));
		}
	}
	std::cout << "testPTensorBlockNeighbourRing : input tensor : " << std::endl << tensor << std::endl;
	size_t blockSizeRow(4lu), blockSizeCol(6lu);
	std::vector<PBlock<int> > vecBlock;
	tensor.splitBlock(vecBlock, blockSizeRow, blockSizeCol, 1lu);

	std::cout << "testPTensorBlockNeighbourRing : create " << vecBlock.size() << " blocks" << std::endl;
	bool b(true);
	b &= vecBlock.size() == 10lu;	//This is 2 rows of 5 blocs inside 2x2 (outside 4x6)

	size_t blockIndex(0lu);
	for(std::vector<PBlock<int> >::iterator it(vecBlock.begin()); it != vecBlock.end(); ++it){
		PBlock<int> & block = *it;
		std::cout << "Block " << blockIndex << " ("<<block.getLocationRow()<<", "<<block.getLocationCol()<<") :" << std::endl << block << std::endl;

		for(size_t i(0lu); i < block.getFullNbRow(); ++i){
			for(size_t j(0lu); j < block.getNbCol(); ++j){
				b &= block.getValue(i, j) == (int)((i + block.getLocationRow())*nbCol + (j + block.getLocationCol()));
			}
		}
		std::cout << "testPTensorBlockNeighbourRing : Block " << blockIndex << ", b = " << b << std::endl;
		++blockIndex;
	}
	std::cout << "testPTensorBlockNeighbourRing : split block b = " << b << std::endl;
	tensor.fill(0);				//Let's reset the tensor to clearly see the padding of 0
	tensor.mergeBlock(vecBlock, 1lu);
	std::cout << "testPTensorBlock : merged tensor : " << std::endl << tensor << std::endl;
	for(size_t i(1lu); i < nbRow - 1lu; ++i){
		for(size_t j(USE_VECTOR_SIZE); j < nbCol - USE_VECTOR_SIZE; ++j){
			b &= tensor.getValue(i, j) == (int)(i*nbCol + j);
		}
	}
	std::cout << "testPTensorBlockNeighbourRing : merge block b = " << b << std::endl;
	return b;
}

int main(int argc, char** argv){
	bool b(testPTensorBlock());
	b &= testPTensorBlockNeighbourRing();
	return b - 1;
}




Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/***************************************
2			Auteur : Pierre Aubert
3			Mail : pierre.aubert@lapp.in2p3.fr
4			Licence : CeCILL-C
5			****************************************/
6
7			#include "PTensor.h"
8
9			#define USE_VECTOR_SIZE 2lu
10
11			///Test the PTensor
12			/** @return true on success, false otherwise
13			*/
14		1	bool testPTensorBlock(){
15		1	size_t nbRow(6lu), nbCol(14lu);
16	✓	2	PTensor<int> tensor;
17	✓	1	tensor.resize(AllocMode::NONE, nbRow, nbCol);
18		1	tensor.setNbVecNeighbour(USE_VECTOR_SIZE);
19	✓✓	7	for(size_t i(0lu); i < nbRow; ++i){
20	✓✓	90	for(size_t j(0lu); j < nbCol; ++j){
21	✓	84	tensor.setValue(i, j, (int)(i*nbCol + j));
22			}
23			}
24	✓✓✓✓	1	std::cout << "testPTensorBlock : input tensor : " << std::endl << tensor << std::endl;
25		1	size_t blockSizeRow(2lu), blockSizeCol(6lu); //The final block will have 2 columns because it has to be a multiple of 2
26		1	std::vector<PBlock<int> > vecBlock;
27	✓	1	tensor.splitBlock(vecBlock, blockSizeRow, blockSizeCol, 0lu);
28
29	✓✓✓✓	1	std::cout << "testPTensorBlock : create " << vecBlock.size() << " blocks" << std::endl;
30		1	bool b(true);
31		1	b &= vecBlock.size() == 9lu;
32
33		1	size_t blockIndex(0lu);
34	✓✓	10	for(std::vector<PBlock<int> >::iterator it(vecBlock.begin()); it != vecBlock.end(); ++it){
35		9	PBlock<int> & block = *it;
36	✓✓✓✓ ✓✓✓✓ ✓✓✓	9	std::cout << "Block " << blockIndex << " ("<<block.getLocationRow()<<", "<<block.getLocationCol()<<") :" << std::endl << block << std::endl;
37
38	✓✓	27	for(size_t i(0lu); i < block.getFullNbRow(); ++i){
39	✓✓	102	for(size_t j(0lu); j < block.getNbCol(); ++j){
40	✓✓	84	b &= block.getValue(i, j) == (int)((i + block.getLocationRow())*nbCol + (j + block.getLocationCol()));
41			}
42			}
43	✓✓✓✓ ✓	9	std::cout << "testPTensorBlock : Block " << blockIndex << ", b = " << b << std::endl;
44		9	++blockIndex;
45			}
46	✓✓✓	1	std::cout << "testPTensorBlock : create block b = " << b << std::endl;
47
48		1	tensor.fill(0); //Let's clear the tensor and put the block back into it
49	✓	1	tensor.mergeBlock(vecBlock, 0lu);
50	✓✓✓✓	1	std::cout << "testPTensorBlock : merged tensor : " << std::endl << tensor << std::endl;
51	✓✓	7	for(size_t i(0lu); i < nbRow; ++i){
52	✓✓	90	for(size_t j(0lu); j < nbCol; ++j){
53	✓	84	b &= tensor.getValue(i, j) == (int)(i*nbCol + j);
54			}
55			}
56	✓✓✓	1	std::cout << "testPTensorBlock : merge block b = " << b << std::endl;
57		2	return b;
58			}
59
60			///Test the PTensor
61			/** @return true on success, false otherwise
62			*/
63		1	bool testPTensorBlockNeighbourRing(){
64	✓✓	1	std::cout << "testPTensorBlockNeighbourRing =================== START ====================" << std::endl;
65		1	size_t nbRow(6lu), nbCol(14lu);
66	✓	2	PTensor<int> tensor;
67	✓	1	tensor.resize(AllocMode::NONE, nbRow, nbCol);
68		1	tensor.setNbVecNeighbour(USE_VECTOR_SIZE);
69	✓✓	7	for(size_t i(0lu); i < nbRow; ++i){
70	✓✓	90	for(size_t j(0lu); j < nbCol; ++j){
71	✓	84	tensor.setValue(i, j, (int)(i*nbCol + j));
72			}
73			}
74	✓✓✓✓	1	std::cout << "testPTensorBlockNeighbourRing : input tensor : " << std::endl << tensor << std::endl;
75		1	size_t blockSizeRow(4lu), blockSizeCol(6lu);
76		1	std::vector<PBlock<int> > vecBlock;
77	✓	1	tensor.splitBlock(vecBlock, blockSizeRow, blockSizeCol, 1lu);
78
79	✓✓✓✓	1	std::cout << "testPTensorBlockNeighbourRing : create " << vecBlock.size() << " blocks" << std::endl;
80		1	bool b(true);
81		1	b &= vecBlock.size() == 10lu; //This is 2 rows of 5 blocs inside 2x2 (outside 4x6)
82
83		1	size_t blockIndex(0lu);
84	✓✓	11	for(std::vector<PBlock<int> >::iterator it(vecBlock.begin()); it != vecBlock.end(); ++it){
85		10	PBlock<int> & block = *it;
86	✓✓✓✓ ✓✓✓✓ ✓✓✓	10	std::cout << "Block " << blockIndex << " ("<<block.getLocationRow()<<", "<<block.getLocationCol()<<") :" << std::endl << block << std::endl;
87
88	✓✓	50	for(size_t i(0lu); i < block.getFullNbRow(); ++i){
89	✓✓	280	for(size_t j(0lu); j < block.getNbCol(); ++j){
90	✓✓	240	b &= block.getValue(i, j) == (int)((i + block.getLocationRow())*nbCol + (j + block.getLocationCol()));
91			}
92			}
93	✓✓✓✓ ✓	10	std::cout << "testPTensorBlockNeighbourRing : Block " << blockIndex << ", b = " << b << std::endl;
94		10	++blockIndex;
95			}
96	✓✓✓	1	std::cout << "testPTensorBlockNeighbourRing : split block b = " << b << std::endl;
97		1	tensor.fill(0); //Let's reset the tensor to clearly see the padding of 0
98	✓	1	tensor.mergeBlock(vecBlock, 1lu);
99	✓✓✓✓	1	std::cout << "testPTensorBlock : merged tensor : " << std::endl << tensor << std::endl;
100	✓✓	5	for(size_t i(1lu); i < nbRow - 1lu; ++i){
101	✓✓	44	for(size_t j(USE_VECTOR_SIZE); j < nbCol - USE_VECTOR_SIZE; ++j){
102	✓	40	b &= tensor.getValue(i, j) == (int)(i*nbCol + j);
103			}
104			}
105	✓✓✓	1	std::cout << "testPTensorBlockNeighbourRing : merge block b = " << b << std::endl;
106		2	return b;
107			}
108
109		1	int main(int argc, char** argv){
110		1	bool b(testPTensorBlock());
111		1	b &= testPTensorBlockNeighbourRing();
112		1	return b - 1;
113			}
114
115