mirror of
https://github.com/boostorg/sort.git
synced 2026-01-19 04:42:11 +00:00
adding support -fno-exception
This commit is contained in:
Francisco Tapia
5
.vscode/settings.json
vendored
Normal file
5
.vscode/settings.json
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
{
|
||||
"githubPullRequests.ignoredPullRequestBranches": [
|
||||
"develop"
|
||||
]
|
||||
}
|
||||
@@ -50,8 +50,7 @@ void Generator_reverse_sorted (void);
|
||||
void Generator_reverse_sorted_end (size_t n_last);
|
||||
void Generator_reverse_sorted_middle (size_t n_last);
|
||||
|
||||
template<class IA, class compare>
|
||||
int Test (std::vector<IA> &B, compare comp = compare ());
|
||||
void Test (std::vector<uint64_t> &B);
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
@@ -66,205 +65,203 @@ int main (int argc, char *argv[])
|
||||
cout << "************************************************************\n";
|
||||
cout << std::endl;
|
||||
|
||||
cout<<"[ 1 ] block_indirect_sort [ 2 ] sample_sort\n";
|
||||
cout<<"[ 3 ] parallel_stable_sort\n\n";
|
||||
cout<<" | | | |\n";
|
||||
cout<<" | [ 1 ]| [ 2 ]| [ 3 ]|\n";
|
||||
cout<<"--------------------+------+------+------+\n";
|
||||
cout << "[ 1 ] block_indirect_sort [ 2 ] sample_sort\n";
|
||||
cout << "[ 3 ] parallel_stable_sort\n\n";
|
||||
cout << " | | | |\n";
|
||||
cout << " | [ 1 ]| [ 2 ]| [ 3 ]|\n";
|
||||
cout << "--------------------+------+------+------+\n";
|
||||
std::string empty_line =
|
||||
" | | | |\n";
|
||||
cout<<"random |";
|
||||
cout << "random |";
|
||||
Generator_random ();
|
||||
cout<<empty_line;
|
||||
cout<<"sorted |";
|
||||
cout << empty_line;
|
||||
cout << "sorted |";
|
||||
Generator_sorted ();
|
||||
|
||||
cout<<"sorted + 0.1% end |";
|
||||
cout << "sorted + 0.1% end |";
|
||||
Generator_sorted_end (NELEM / 1000);
|
||||
|
||||
cout<<"sorted + 1% end |";
|
||||
cout << "sorted + 1% end |";
|
||||
Generator_sorted_end (NELEM / 100);
|
||||
|
||||
cout<<"sorted + 10% end |";
|
||||
cout << "sorted + 10% end |";
|
||||
Generator_sorted_end (NELEM / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted + 0.1% mid |";
|
||||
cout << empty_line;
|
||||
cout << "sorted + 0.1% mid |";
|
||||
Generator_sorted_middle (NELEM / 1000);
|
||||
|
||||
cout<<"sorted + 1% mid |";
|
||||
cout << "sorted + 1% mid |";
|
||||
Generator_sorted_middle (NELEM / 100);
|
||||
|
||||
cout<<"sorted + 10% mid |";
|
||||
cout << "sorted + 10% mid |";
|
||||
Generator_sorted_middle (NELEM / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"reverse sorted |";
|
||||
cout << empty_line;
|
||||
cout << "reverse sorted |";
|
||||
Generator_reverse_sorted ();
|
||||
|
||||
cout<<"rv sorted + 0.1% end|";
|
||||
cout << "rv sorted + 0.1% end|";
|
||||
Generator_reverse_sorted_end (NELEM / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% end|";
|
||||
cout << "rv sorted + 1% end|";
|
||||
Generator_reverse_sorted_end (NELEM / 100);
|
||||
|
||||
cout<<"rv sorted + 10% end|";
|
||||
cout << "rv sorted + 10% end|";
|
||||
Generator_reverse_sorted_end (NELEM / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"rv sorted + 0.1% mid|";
|
||||
cout << empty_line;
|
||||
cout << "rv sorted + 0.1% mid|";
|
||||
Generator_reverse_sorted_middle (NELEM / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% mid|";
|
||||
cout << "rv sorted + 1% mid|";
|
||||
Generator_reverse_sorted_middle (NELEM / 100);
|
||||
|
||||
cout<<"rv sorted + 10% mid|";
|
||||
cout << "rv sorted + 10% mid|";
|
||||
Generator_reverse_sorted_middle (NELEM / 10);
|
||||
cout<<"--------------------+------+------+------+\n";
|
||||
cout<<endl<<endl ;
|
||||
cout << "--------------------+------+------+------+\n";
|
||||
cout << endl << endl ;
|
||||
return 0;
|
||||
}
|
||||
void
|
||||
Generator_random (void)
|
||||
void Generator_random (void)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
vector <uint64_t> A;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
}
|
||||
;
|
||||
void
|
||||
Generator_sorted (void)
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted (void)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
|
||||
std::vector <uint64_t> A;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
for (size_t i = 0; i < NELEM; ++i)
|
||||
for (uint64_t i = 0; i < NELEM; ++i)
|
||||
A.push_back (i);
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
|
||||
}
|
||||
|
||||
void Generator_sorted_end (size_t n_last)
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted_end (uint64_t n_last)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
std::vector <uint64_t> A;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (A.begin (), A.begin () + NELEM);
|
||||
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
|
||||
}
|
||||
;
|
||||
void Generator_sorted_middle (size_t n_last)
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted_middle (uint64_t n_middle)
|
||||
{
|
||||
vector<uint64_t> A, B, C;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0)
|
||||
assert (n_middle > 1 && NELEM >= (n_middle -1));
|
||||
std::vector <uint64_t> A, aux;
|
||||
A.reserve (NELEM + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_middle) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
for (size_t i = NELEM; i < A.size (); ++i)
|
||||
B.push_back (std::move (A[i]));
|
||||
A.resize ( NELEM);
|
||||
for (size_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A[i], A[NELEM - 1 - i]);
|
||||
for (uint64_t i = 0; i < n_middle; ++i) aux.push_back (A [i]);
|
||||
|
||||
std::sort (A.begin (), A.end ());
|
||||
size_t step = NELEM / n_last + 1;
|
||||
size_t pos = 0;
|
||||
std::sort (A.begin () + n_middle, A.end ());
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
uint64_t step = NELEM / (n_middle - 1);
|
||||
A [0] = aux [0];
|
||||
uint64_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
for (size_t i = 0; i < B.size (); ++i, pos += step)
|
||||
for (uint64_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
C.push_back (B[i]);
|
||||
for (size_t k = 0; k < step; ++k)
|
||||
C.push_back (A[pos + k]);
|
||||
for (uint64_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = A [pos_read ++];
|
||||
A [pos_write ++] = aux [i];
|
||||
};
|
||||
while (pos < A.size ())
|
||||
C.push_back (A[pos++]);
|
||||
A = C;
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
}
|
||||
;
|
||||
aux.clear ();
|
||||
aux.reserve (0);
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted (void)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
|
||||
std::vector<uint64_t> A;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
for (size_t i = NELEM; i > 0; --i)
|
||||
for (uint64_t i = NELEM; i > 0; --i)
|
||||
A.push_back (i);
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
}
|
||||
void Generator_reverse_sorted_end (size_t n_last)
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted_end (uint64_t n_last)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
std::vector <uint64_t> A;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (A.begin (), A.begin () + NELEM);
|
||||
for (size_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A[i], A[NELEM - 1 - i]);
|
||||
for (uint64_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A [i], A [NELEM - 1 - i]);
|
||||
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
Test (A);
|
||||
}
|
||||
void Generator_reverse_sorted_middle (size_t n_last)
|
||||
void Generator_reverse_sorted_middle (uint64_t n_middle)
|
||||
{
|
||||
vector<uint64_t> A, B, C;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0)
|
||||
assert (n_middle > 1 && NELEM >= (n_middle -1));
|
||||
std::vector <uint64_t> A, aux;
|
||||
A.reserve (NELEM + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_middle) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
for (size_t i = NELEM; i < A.size (); ++i)
|
||||
B.push_back (std::move (A[i]));
|
||||
A.resize ( NELEM);
|
||||
for (size_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A[i], A[NELEM - 1 - i]);
|
||||
for (uint64_t i = 0; i < n_middle; ++i) aux.push_back (A [i]);
|
||||
|
||||
std::sort (A.begin (), A.end ());
|
||||
size_t step = NELEM / n_last + 1;
|
||||
size_t pos = 0;
|
||||
std::sort (A.begin () + n_middle, A.end ());
|
||||
uint64_t pos1 = n_middle, pos2 = A.size () - 1;
|
||||
for (uint64_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A [pos1 ++], A [pos2 --]);
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
uint64_t step = NELEM / (n_middle - 1);
|
||||
A [0] = aux [0];
|
||||
uint64_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
for (size_t i = 0; i < B.size (); ++i, pos += step)
|
||||
for (uint64_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
C.push_back (B[i]);
|
||||
for (size_t k = 0; k < step; ++k)
|
||||
C.push_back (A[pos + k]);
|
||||
for (uint64_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = A [pos_read ++];
|
||||
A [pos_write ++] = aux [i];
|
||||
};
|
||||
while (pos < A.size ())
|
||||
C.push_back (A[pos++]);
|
||||
A = C;
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
aux.clear ();
|
||||
aux.reserve (0);
|
||||
Test (A);
|
||||
};
|
||||
|
||||
|
||||
template<class IA, class compare>
|
||||
int Test (std::vector<IA> &B, compare comp)
|
||||
{ //---------------------------- begin --------------------------------
|
||||
void Test (std::vector <uint64_t> &B)
|
||||
{
|
||||
//---------------------------- begin --------------------------------
|
||||
std::less <uint64_t> comp ;
|
||||
double duration;
|
||||
time_point start, finish;
|
||||
std::vector<IA> A (B);
|
||||
std::vector<double> V;
|
||||
std::vector <uint64_t> A (B);
|
||||
std::vector <double> V;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
A = B;
|
||||
@@ -291,11 +288,10 @@ int Test (std::vector<IA> &B, compare comp)
|
||||
//-----------------------------------------------------------------------
|
||||
// printing the vector
|
||||
//-----------------------------------------------------------------------
|
||||
std::cout<<std::setprecision(2)<<std::fixed;
|
||||
for ( uint32_t i =0 ; i < V.size() ; ++i)
|
||||
{ std::cout<<std::right<<std::setw(5)<<V[i]<<" |";
|
||||
std::cout << std::setprecision (2) << std::fixed;
|
||||
for (uint32_t i = 0; i < V.size (); ++i)
|
||||
{ std::cout << std::right << std::setw (5) << V [i] << " |";
|
||||
};
|
||||
std::cout<<std::endl;
|
||||
return 0;
|
||||
std::cout << std::endl;
|
||||
};
|
||||
|
||||
|
||||
@@ -26,12 +26,8 @@
|
||||
#include <boost/sort/common/time_measure.hpp>
|
||||
#include <boost/sort/common/file_vector.hpp>
|
||||
#include "boost/sort/common/int_array.hpp"
|
||||
|
||||
#include <boost/sort/sort.hpp>
|
||||
|
||||
#define NELEM 100000000
|
||||
#define NMAXSTRING 10000000
|
||||
|
||||
using namespace std;
|
||||
namespace bsc = boost::sort::common;
|
||||
namespace bsp = boost::sort;
|
||||
@@ -45,52 +41,38 @@ using bsc::int_array;
|
||||
using bsc::H_comp;
|
||||
using bsc::L_comp;
|
||||
|
||||
|
||||
template <class IA>
|
||||
void Generator_random (uint64_t N);
|
||||
|
||||
template <class IA>
|
||||
void Generator_random(uint64_t N);
|
||||
void Generator_sorted (uint64_t N);
|
||||
|
||||
template <class IA>
|
||||
void Generator_sorted(uint64_t N);
|
||||
template <class IA>
|
||||
void Generator_sorted_end(uint64_t N, size_t n_last );
|
||||
void Generator_sorted_end (uint64_t N, size_t n_last);
|
||||
|
||||
template <class IA>
|
||||
void Generator_sorted_middle(uint64_t N, size_t n_last );
|
||||
void Generator_sorted_middle (uint64_t N, size_t n_middle);
|
||||
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted(uint64_t N);
|
||||
void Generator_reverse_sorted (uint64_t N);
|
||||
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_end(uint64_t N, size_t n_last );
|
||||
void Generator_reverse_sorted_end (uint64_t N, size_t n_last);
|
||||
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_middle(uint64_t N, size_t n_last );
|
||||
void Generator_reverse_sorted_middle (uint64_t N, size_t n_middle);
|
||||
|
||||
template < class IA >
|
||||
struct H_rightshift {
|
||||
inline uint64_t operator()(const IA& A1, unsigned offset) {
|
||||
return A1.counter() >> offset;
|
||||
}
|
||||
};
|
||||
|
||||
template < class IA >
|
||||
struct L_rightshift {
|
||||
inline uint64_t operator()(const IA& A1, unsigned offset) {
|
||||
return A1.M[0] >> offset;
|
||||
}
|
||||
};
|
||||
|
||||
template <class IA, class rightshift, class compare>
|
||||
int Test(std::vector<IA> &B, rightshift shift, compare comp, std::vector<double> & V );
|
||||
template <class IA, class compare>
|
||||
void Test (std::vector <IA> &B, compare comp, std::vector <double> & V );
|
||||
|
||||
template <class IA>
|
||||
void Test_size ( uint64_t N);
|
||||
void Test_size (uint64_t N);
|
||||
|
||||
void Print_vectors ( std::vector<double> & V1, std::vector<double> & V2);
|
||||
void Print_vectors (std::vector<double> &V1, std::vector<double> & V2);
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
const uint64_t NELEM = 100000000;
|
||||
cout << "\n\n";
|
||||
cout << "************************************************************\n";
|
||||
cout << "** **\n";
|
||||
@@ -172,320 +154,349 @@ int main(int argc, char *argv[])
|
||||
template <class IA>
|
||||
void Test_size ( uint64_t N)
|
||||
{
|
||||
cout<<"[ 1 ] block_indirect_sort [ 2 ] sample_sort\n";
|
||||
cout<<"[ 3 ] parallel_stable_sort\n\n";
|
||||
cout << "[ 1 ] block_indirect_sort [ 2 ] sample_sort\n";
|
||||
cout << "[ 3 ] parallel_stable_sort\n\n";
|
||||
|
||||
cout << " | [ 1 ] | [ 2 ] | [ 3 ] |\n";
|
||||
cout << " | H L | H L | H L |\n";
|
||||
cout << "--------------------+-----------+-----------+-----------+\n";
|
||||
std::string empty_line = " | | | |\n";
|
||||
|
||||
cout<<"random |";
|
||||
Generator_random<IA>(N);
|
||||
cout << "random |";
|
||||
Generator_random <IA> (N);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted |";
|
||||
Generator_sorted<IA>(N);
|
||||
cout << empty_line;
|
||||
cout << "sorted |";
|
||||
Generator_sorted <IA> (N);
|
||||
|
||||
cout<<"sorted + 0.1% end |";
|
||||
Generator_sorted_end<IA>(N, N / 1000);
|
||||
cout << "sorted + 0.1% end |";
|
||||
Generator_sorted_end <IA> (N, N / 1000);
|
||||
|
||||
cout<<"sorted + 1% end |";
|
||||
Generator_sorted_end<IA>(N, N / 100);
|
||||
cout << "sorted + 1% end |";
|
||||
Generator_sorted_end< IA> (N, N / 100);
|
||||
|
||||
cout<<"sorted + 10% end |";
|
||||
Generator_sorted_end<IA>(N, N / 10);
|
||||
cout << "sorted + 10% end |";
|
||||
Generator_sorted_end <IA> (N, N / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted + 0.1% mid |";
|
||||
Generator_sorted_middle<IA>(N, N / 1000);
|
||||
cout << empty_line;
|
||||
cout << "sorted + 0.1% mid |";
|
||||
Generator_sorted_middle <IA> (N, N / 1000);
|
||||
|
||||
cout<<"sorted + 1% mid |";
|
||||
Generator_sorted_middle<IA>(N, N / 100);
|
||||
cout << "sorted + 1% mid |";
|
||||
Generator_sorted_middle <IA> (N, N / 100);
|
||||
|
||||
cout<<"sorted + 10% mid |";
|
||||
Generator_sorted_middle<IA>(N, N / 10);
|
||||
cout << "sorted + 10% mid |";
|
||||
Generator_sorted_middle <IA> (N, N / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"reverse sorted |";
|
||||
Generator_reverse_sorted<IA>(N);
|
||||
cout << empty_line;
|
||||
cout << "reverse sorted |";
|
||||
Generator_reverse_sorted <IA> (N);
|
||||
|
||||
cout<<"rv sorted + 0.1% end|";
|
||||
Generator_reverse_sorted_end<IA>(N, N / 1000);
|
||||
cout << "rv sorted + 0.1% end|";
|
||||
Generator_reverse_sorted_end <IA> (N, N / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% end|";
|
||||
Generator_reverse_sorted_end<IA>(N, N / 100);
|
||||
cout << "rv sorted + 1% end|";
|
||||
Generator_reverse_sorted_end <IA> (N, N / 100);
|
||||
|
||||
cout<<"rv sorted + 10% end|";
|
||||
Generator_reverse_sorted_end<IA>(N, N / 10);
|
||||
cout << "rv sorted + 10% end|";
|
||||
Generator_reverse_sorted_end <IA> (N, N / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"rv sorted + 0.1% mid|";
|
||||
Generator_reverse_sorted_middle<IA>(N, N / 1000);
|
||||
cout << empty_line;
|
||||
cout << "rv sorted + 0.1% mid|";
|
||||
Generator_reverse_sorted_middle <IA> (N, N / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% mid|";
|
||||
Generator_reverse_sorted_middle<IA>(N, N / 100);
|
||||
cout << "rv sorted + 1% mid|";
|
||||
Generator_reverse_sorted_middle <IA> (N, N / 100);
|
||||
|
||||
cout<<"rv sorted + 10% mid|";
|
||||
Generator_reverse_sorted_middle<IA>(N, N / 10);
|
||||
cout<< "--------------------+-----------+-----------+-----------+\n";
|
||||
cout<<endl<<endl<<endl;
|
||||
cout << "rv sorted + 10% mid|";
|
||||
Generator_reverse_sorted_middle <IA> (N, N / 10);
|
||||
cout << "--------------------+-----------+-----------+-----------+\n";
|
||||
cout << endl << endl << endl;
|
||||
}
|
||||
void Print_vectors ( std::vector<double> & V1, std::vector<double> & V2)
|
||||
{
|
||||
assert ( V1.size() == V2.size());
|
||||
std::cout<<std::setprecision(2)<<std::fixed;
|
||||
std::cout << std::setprecision(2)<<std::fixed;
|
||||
for ( uint32_t i =0 ; i < V1.size() ; ++i)
|
||||
{ std::cout<<std::right<<std::setw(5)<<V1[i]<<" ";
|
||||
std::cout<<std::right<<std::setw(5)<<V2[i]<<"|";
|
||||
{ std::cout << std::right<<std::setw(5)<<V1[i]<<" ";
|
||||
std::cout << std::right<<std::setw(5)<<V2[i]<<"|";
|
||||
};
|
||||
std::cout<<std::endl;
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
||||
template <class IA>
|
||||
void Generator_random(uint64_t N)
|
||||
void Generator_random (uint64_t N)
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen));
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate(gen));
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
Test (A, H_comp <IA> (), V1);
|
||||
Test (A, L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
|
||||
template <class IA>
|
||||
void Generator_sorted(uint64_t N)
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen));
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate (gen));
|
||||
|
||||
std::sort( A.begin() , A.end(),H_comp<IA>() );
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
std::sort (A.begin (), A.end (), H_comp <IA> ());
|
||||
Test (A, H_comp <IA> (), V1);
|
||||
|
||||
std::sort( A.begin() , A.end(),L_comp<IA>() );
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
std::sort (A.begin (), A.end (), L_comp <IA> ());
|
||||
Test (A, L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
|
||||
template <class IA>
|
||||
void Generator_sorted_end(uint64_t N, size_t n_last )
|
||||
void Generator_sorted_end (uint64_t N, size_t n_last )
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
A.emplace_back(IA::generate(gen));
|
||||
std::sort ( A.begin() , A.begin() + N ,H_comp<IA>());
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
std::sort (A.begin (), A.begin () + N, H_comp <IA> ());
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(),V1);
|
||||
std::sort ( A.begin() , A.begin() + N ,L_comp<IA>());
|
||||
Test (A, H_comp <IA> (), V1);
|
||||
std::sort (A.begin (), A.begin () + N, L_comp <IA> ());
|
||||
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
Test (A, L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
template <class IA>
|
||||
void Generator_sorted_middle(uint64_t N, size_t n_last )
|
||||
void Generator_sorted_middle (uint64_t N, size_t n_middle )
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
std::vector<double> V1, V2 ;
|
||||
vector<IA> A;
|
||||
A.reserve(N + n_last);
|
||||
assert (n_middle > 1 && N >= (n_middle -1));
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
|
||||
std::vector <double> V1, V2; // vector with the times used
|
||||
vector <IA> A, aux;
|
||||
A.reserve (N + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// H _ C O M P
|
||||
//-----------------------------------------------------------------------
|
||||
for (uint32_t i = 0; i < (N + n_middle); i++)
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
for (size_t i = 0; i < n_middle; ++i)
|
||||
aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin () + n_middle, A.end (), H_comp <IA> ());
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
size_t step = N / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
size_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
{ A.clear() ;
|
||||
gen.reset();
|
||||
vector<IA> B, C;
|
||||
C.reserve(N + n_last);
|
||||
B.reserve ( n_last);
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
C.emplace_back(IA::generate(gen));
|
||||
|
||||
for ( size_t i = N ; i < C.size() ; ++i)
|
||||
B.push_back ( std::move ( C[i]));
|
||||
|
||||
C.resize ( N);
|
||||
|
||||
std::sort ( C.begin() , C.end() ,H_comp<IA>());
|
||||
size_t step = N /n_last ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i)
|
||||
{ A.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
A.push_back ( C[pos++] );
|
||||
};
|
||||
while ( pos < C.size() )
|
||||
A.push_back ( C[pos++]);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
Test (A, H_comp <IA> (), V1);
|
||||
|
||||
{ A.clear() ;
|
||||
gen.reset();
|
||||
vector<IA> B,C;
|
||||
C.reserve(N + n_last);
|
||||
B.reserve ( n_last);
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
C.emplace_back(IA::generate(gen));
|
||||
//----------------------------------------------------------------------
|
||||
// L _ C O M P
|
||||
//-----------------------------------------------------------------------
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
A.reserve (N + n_middle);
|
||||
aux.clear ();
|
||||
aux.reserve (n_middle);
|
||||
|
||||
for (uint32_t i = 0; i < (N + n_middle); i++)
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
for (size_t i = 0; i < n_middle; ++i)
|
||||
aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin () + n_middle, A.end (), L_comp <IA> ());
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
step = N / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
pos_read = n_middle;
|
||||
pos_write = 1;
|
||||
|
||||
for ( size_t i = N ; i < C.size() ; ++i)
|
||||
B.push_back ( std::move ( C[i]));
|
||||
|
||||
C.resize ( N);
|
||||
|
||||
std::sort ( C.begin() , C.end() ,L_comp<IA>());
|
||||
size_t step = N /n_last ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i)
|
||||
{ A.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
A.push_back ( C[pos++] );
|
||||
};
|
||||
while ( pos < C.size() )
|
||||
A.push_back ( C[pos++]);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
|
||||
Test (A, L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted(uint64_t N)
|
||||
void Generator_reverse_sorted (uint64_t N)
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen));
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate (gen));
|
||||
|
||||
std::sort( A.begin() , A.end(),H_comp<IA>() );
|
||||
for ( size_t i = 0; i < (A.size() >>1) ; ++i)
|
||||
std::swap ( A[i], A[A.size() - i -1 ]);
|
||||
std::sort (A.begin (), A.end (), H_comp <IA> ());
|
||||
for (size_t i = 0; i < (A.size () >>1); ++i)
|
||||
std::swap (A [i], A [A.size () - i - 1]);
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
Test (A, H_comp <IA> (), V1);
|
||||
|
||||
std::sort( A.begin() , A.end(),L_comp<IA>() );
|
||||
for ( size_t i = 0; i < (A.size() >>1) ; ++i)
|
||||
std::swap ( A[i], A[A.size() - i -1 ]);
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
std::sort (A.begin (), A.end (), L_comp <IA> ());
|
||||
for (size_t i = 0; i < (A.size () >> 1); ++i)
|
||||
std::swap (A [i], A [A.size() - i - 1]);
|
||||
|
||||
Test (A, L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_end(uint64_t N, size_t n_last )
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_end (uint64_t N, size_t n_last )
|
||||
{
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
A.emplace_back(IA::generate(gen));
|
||||
std::sort ( A.begin() , A.begin() + N ,H_comp<IA>());
|
||||
for ( size_t i =0 ; i < (N>>1); ++i)
|
||||
std::swap ( A[i], A[N-1-i]);
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
std::sort (A.begin (), A.begin () + N , H_comp <IA> ());
|
||||
for (size_t i =0 ; i < (N >> 1); ++i)
|
||||
std::swap (A [i], A [N - 1 - i]);
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
std::sort ( A.begin() , A.begin() + N ,L_comp<IA>());
|
||||
for ( size_t i =0 ; i < (N>>1); ++i)
|
||||
std::swap ( A[i], A[N-1-i]);
|
||||
Test (A, H_comp <IA> (), V1);
|
||||
std::sort (A.begin (), A.begin () + N, L_comp <IA> ());
|
||||
for (size_t i = 0; i < (N >> 1); ++i)
|
||||
std::swap (A [i], A [N - 1 - i]);
|
||||
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
Test (A, L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_middle(uint64_t N, size_t n_last )
|
||||
void Generator_reverse_sorted_middle (uint64_t N, size_t n_middle )
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
std::vector<double> V1, V2 ;
|
||||
vector<IA> A;
|
||||
A.reserve(N + n_last);
|
||||
assert (n_middle > 1 && N >= (n_middle -1));
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
|
||||
std::vector <double> V1, V2; // vector with the times used
|
||||
vector <IA> A, aux;
|
||||
A.reserve (N + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// H _ C O M P
|
||||
//-----------------------------------------------------------------------
|
||||
for (uint32_t i = 0; i < (N + n_middle); i++)
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
for (size_t i = 0; i < n_middle; ++i)
|
||||
aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin () + n_middle, A.end (), H_comp <IA> ());
|
||||
uint64_t pos1 = n_middle, pos2 = A.size () - 1;
|
||||
for (uint64_t i = 0; i < (N >> 1); ++i)
|
||||
std::swap (A [pos1 ++], A [pos2 --]);
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
size_t step = N / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
size_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
{ A.clear() ;
|
||||
gen.reset();
|
||||
vector<IA> B,C;
|
||||
C.reserve(N + n_last);
|
||||
B.reserve ( n_last);
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
C.emplace_back(IA::generate(gen));
|
||||
|
||||
for ( size_t i = N ; i < C.size() ; ++i)
|
||||
B.push_back ( std::move ( C[i]));
|
||||
|
||||
C.resize ( N);
|
||||
|
||||
std::sort ( C.begin() , C.end() ,H_comp<IA>());
|
||||
|
||||
for ( size_t i =0 ; i < (N>>1); ++i)
|
||||
std::swap ( C[i], C[N-1-i]);
|
||||
|
||||
size_t step = N /n_last ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i)
|
||||
{ A.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
A.push_back ( C[pos++ ] );
|
||||
};
|
||||
while ( pos < C.size() )
|
||||
A.push_back ( C[pos++]);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
Test (A, H_comp <IA> (), V1);
|
||||
|
||||
{ A.clear() ;
|
||||
gen.reset();
|
||||
vector<IA> B,C;
|
||||
C.reserve(N + n_last);
|
||||
B.reserve ( n_last);
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
C.emplace_back(IA::generate(gen));
|
||||
//----------------------------------------------------------------------
|
||||
// L _ C O M P
|
||||
//-----------------------------------------------------------------------
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
A.reserve (N + n_middle);
|
||||
aux.clear ();
|
||||
aux.reserve (n_middle);
|
||||
|
||||
for (uint32_t i = 0; i < (N + n_middle); i++)
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
for (size_t i = 0; i < n_middle; ++i)
|
||||
aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin () + n_middle, A.end (), L_comp <IA> ());
|
||||
pos1 = n_middle;
|
||||
pos2 = A.size () - 1;
|
||||
for (uint64_t i = 0; i < (N >> 1); ++i)
|
||||
std::swap (A [pos1 ++], A [pos2 --]);
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
step = N / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
pos_read = n_middle;
|
||||
pos_write = 1;
|
||||
|
||||
for ( size_t i = N ; i < C.size() ; ++i)
|
||||
B.push_back ( std::move ( C[i]));
|
||||
|
||||
C.resize ( N);
|
||||
|
||||
std::sort ( C.begin() , C.end() ,L_comp<IA>());
|
||||
|
||||
for ( size_t i =0 ; i < (N>>1); ++i)
|
||||
std::swap ( C[i], C[N-1-i]);
|
||||
size_t step = N /n_last ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i)
|
||||
{ A.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
A.push_back ( C[pos++ ] );
|
||||
};
|
||||
while ( pos < C.size() )
|
||||
A.push_back ( C[pos++]);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
Test (A, L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
|
||||
template<class IA, class rightshift, class compare>
|
||||
int Test (std::vector<IA> &B, rightshift shift, compare comp,std::vector<double> &V)
|
||||
template<class IA, class compare>
|
||||
void Test (std::vector <IA> &B, compare comp, std::vector <double> &V)
|
||||
{ //---------------------------- begin --------------------------------
|
||||
double duration;
|
||||
time_point start, finish;
|
||||
@@ -514,52 +525,5 @@ int Test (std::vector<IA> &B, rightshift shift, compare comp,std::vector<double>
|
||||
finish = now ();
|
||||
duration = subtract_time (finish, start);
|
||||
V.push_back (duration);
|
||||
//cout << duration << " secs\n";
|
||||
/*
|
||||
A = B;
|
||||
start = now ();
|
||||
spinsort (A.begin (), A.end (), comp);
|
||||
finish = now ();
|
||||
duration = subtract_time (finish, start);
|
||||
V.push_back (duration);
|
||||
|
||||
A = B;
|
||||
start = now ();
|
||||
timsort (A.begin (), A.end (), comp);
|
||||
finish = now ();
|
||||
duration = subtract_time (finish, start);
|
||||
V.push_back (duration);
|
||||
|
||||
|
||||
A = B;
|
||||
//cout << "Boost spreadsort : ";
|
||||
int sorted_count = 0;
|
||||
for (unsigned i = 0; i + 1 < A.size(); ++i)
|
||||
{
|
||||
if (comp(A[i], A[i+1]))
|
||||
{
|
||||
sorted_count++;
|
||||
};
|
||||
};
|
||||
start = now ();
|
||||
boost::sort::spreadsort::integer_sort (A.begin (), A.end (), shift, comp);
|
||||
finish = now ();
|
||||
duration = subtract_time (finish, start);
|
||||
int identical = 0;
|
||||
for (unsigned i = 0; i + 1 < A.size(); ++i)
|
||||
{
|
||||
if (A[i].counter() != sorted[i].counter())
|
||||
{
|
||||
cout << "incorrect!" << std::endl;
|
||||
}
|
||||
if (!comp(A[i], A[i+1]) && !comp(A[i+1], A[i]))
|
||||
{
|
||||
identical++;
|
||||
};
|
||||
};
|
||||
// cout << "identical: " << identical << " pre-sorted: " << sorted_count << std::endl;
|
||||
V.push_back (duration);
|
||||
//cout << duration << " secs\n";
|
||||
*/
|
||||
return 0;
|
||||
};
|
||||
|
||||
@@ -40,18 +40,17 @@ using bsc::subtract_time;
|
||||
|
||||
|
||||
void Generator_random (void);
|
||||
void Generator_sorted(void);
|
||||
void Generator_sorted_end(size_t n_last);
|
||||
void Generator_sorted_middle (size_t n_last);
|
||||
void Generator_reverse_sorted(void);
|
||||
void Generator_reverse_sorted_end(size_t n_last);
|
||||
void Generator_reverse_sorted_middle(size_t n_last);
|
||||
void Generator_sorted (void);
|
||||
void Generator_sorted_end( size_t n_last);
|
||||
void Generator_sorted_middle (size_t n_middle);
|
||||
void Generator_reverse_sorted (void);
|
||||
void Generator_reverse_sorted_end (size_t n_last);
|
||||
void Generator_reverse_sorted_middle (size_t n_middle);
|
||||
|
||||
template <class IA, class compare>
|
||||
int Test(std::vector<IA> &B, compare comp = compare());
|
||||
void Test (std::vector <std::string> &B);
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
int main(int argc, char *argv [])
|
||||
{
|
||||
cout << "\n\n";
|
||||
cout << "************************************************************\n";
|
||||
@@ -64,212 +63,223 @@ int main(int argc, char *argv[])
|
||||
cout << "************************************************************\n";
|
||||
cout << std::endl;
|
||||
|
||||
cout<<"[ 1 ] block_indirect_sort [ 2 ] sample_sort\n";
|
||||
cout<<"[ 3 ] parallel_stable_sort\n\n";
|
||||
cout<<" | | | |\n";
|
||||
cout<<" | [ 1 ]| [ 2 ]| [ 3 ]|\n";
|
||||
cout<<"--------------------+------+------+------+\n";
|
||||
cout << "[ 1 ] block_indirect_sort [ 2 ] sample_sort\n";
|
||||
cout << "[ 3 ] parallel_stable_sort\n\n";
|
||||
cout << " | | | |\n";
|
||||
cout << " | [ 1 ]| [ 2 ]| [ 3 ]|\n";
|
||||
cout << "--------------------+------+------+------+\n";
|
||||
std::string empty_line =
|
||||
" | | | |\n";
|
||||
|
||||
cout<<"random |";
|
||||
cout << "random |";
|
||||
Generator_random ();
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted |";
|
||||
Generator_sorted();
|
||||
cout << empty_line;
|
||||
cout << "sorted |";
|
||||
Generator_sorted ();
|
||||
|
||||
cout<<"sorted + 0.1% end |";
|
||||
Generator_sorted_end(NMAXSTRING / 1000);
|
||||
cout << "sorted + 0.1% end |";
|
||||
Generator_sorted_end (NMAXSTRING / 1000);
|
||||
|
||||
cout<<"sorted + 1% end |";
|
||||
Generator_sorted_end(NMAXSTRING / 100);
|
||||
cout << "sorted + 1% end |";
|
||||
Generator_sorted_end (NMAXSTRING / 100);
|
||||
|
||||
cout<<"sorted + 10% end |";
|
||||
Generator_sorted_end(NMAXSTRING / 10);
|
||||
cout << "sorted + 10% end |";
|
||||
Generator_sorted_end (NMAXSTRING / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted + 0.1% mid |";
|
||||
cout << empty_line;
|
||||
cout << "sorted + 0.1% mid |";
|
||||
Generator_sorted_middle (NMAXSTRING / 1000);
|
||||
|
||||
cout<<"sorted + 1% mid |";
|
||||
cout << "sorted + 1% mid |";
|
||||
Generator_sorted_middle (NMAXSTRING / 100);
|
||||
|
||||
cout<<"sorted + 10% mid |";
|
||||
cout << "sorted + 10% mid |";
|
||||
Generator_sorted_middle (NMAXSTRING / 10 );
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"reverse sorted |";
|
||||
Generator_reverse_sorted();
|
||||
cout << empty_line;
|
||||
cout << "reverse sorted |";
|
||||
Generator_reverse_sorted ();
|
||||
|
||||
cout<<"rv sorted + 0.1% end|";
|
||||
Generator_reverse_sorted_end(NMAXSTRING / 1000);
|
||||
cout << "rv sorted + 0.1% end|";
|
||||
Generator_reverse_sorted_end (NMAXSTRING / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% end|";
|
||||
Generator_reverse_sorted_end(NMAXSTRING / 100);
|
||||
cout << "rv sorted + 1% end|";
|
||||
Generator_reverse_sorted_end (NMAXSTRING / 100);
|
||||
|
||||
cout<<"rv sorted + 10% end|";
|
||||
Generator_reverse_sorted_end(NMAXSTRING / 10);
|
||||
cout << "rv sorted + 10% end|";
|
||||
Generator_reverse_sorted_end (NMAXSTRING / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"rv sorted + 0.1% mid|";
|
||||
Generator_reverse_sorted_middle(NMAXSTRING / 1000);
|
||||
cout << empty_line;
|
||||
cout << "rv sorted + 0.1% mid|";
|
||||
Generator_reverse_sorted_middle (NMAXSTRING / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% mid|";
|
||||
Generator_reverse_sorted_middle(NMAXSTRING / 100);
|
||||
cout << "rv sorted + 1% mid|";
|
||||
Generator_reverse_sorted_middle (NMAXSTRING / 100);
|
||||
|
||||
cout<<"rv sorted + 10% mid|";
|
||||
Generator_reverse_sorted_middle(NMAXSTRING / 10);
|
||||
cout << "rv sorted + 10% mid|";
|
||||
Generator_reverse_sorted_middle (NMAXSTRING / 10);
|
||||
|
||||
cout<< "--------------------+------+------+------+\n";
|
||||
cout<<endl<<endl ;
|
||||
cout << "--------------------+------+------+------+\n";
|
||||
cout << endl <<endl ;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void Generator_random(void)
|
||||
void Generator_random (void)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0)
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
A.clear ();
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted(void)
|
||||
void Generator_sorted (void)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0)
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
A.clear ();
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort( A.begin() , A.end() );
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
std::sort (A.begin (), A.end ());
|
||||
Test (A);
|
||||
};
|
||||
|
||||
void Generator_sorted_end(size_t n_last)
|
||||
void Generator_sorted_end (size_t n_last)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING+ n_last) != 0)
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
A.clear ();
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING+ n_last) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (A.begin() , A.begin() + NMAXSTRING );
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
std::sort (A.begin (), A.begin () + NMAXSTRING );
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted_middle(size_t n_last)
|
||||
void Generator_sorted_middle (size_t n_middle)
|
||||
{
|
||||
std::vector<std::string> A,B,C;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING + n_last) != 0)
|
||||
assert (n_middle > 1 && NMAXSTRING >= (n_middle -1));
|
||||
vector <std::string> A, aux;
|
||||
A.reserve (NMAXSTRING + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_middle) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
for ( size_t i = NMAXSTRING ; i < A.size() ; ++i)
|
||||
B.push_back ( std::move ( A[i]));
|
||||
A.resize ( NMAXSTRING);
|
||||
std::sort (A.begin() , A.end() );
|
||||
size_t step = NMAXSTRING /n_last +1 ;
|
||||
size_t pos = 0 ;
|
||||
for (size_t i = 0; i < n_middle; ++i) aux.push_back (std::move (A [i]));
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i, pos += step)
|
||||
{ C.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
C.push_back ( A[pos + k] );
|
||||
std::sort (A.begin () + n_middle, A.end ());
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
size_t step = NMAXSTRING / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
size_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
while ( pos < A.size() ) C.push_back ( A[pos++]);
|
||||
A = C ;
|
||||
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
aux.clear ();
|
||||
aux.reserve (0);
|
||||
Test (A);
|
||||
};
|
||||
|
||||
void Generator_reverse_sorted(void)
|
||||
void Generator_reverse_sorted (void)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0)
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
{
|
||||
std::vector <std::string> B;
|
||||
B.reserve (NMAXSTRING);
|
||||
if (bsc::fill_vector_string ("input.bin", B, NMAXSTRING) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (B.begin(), B.end());
|
||||
A.clear ();
|
||||
for (size_t i = 0; i < NMAXSTRING; ++i)
|
||||
A.push_back (B [NMAXSTRING - 1 - i]);
|
||||
};
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted_end (size_t n_last)
|
||||
{
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
A.clear ();
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_last) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort( A.begin() , A.end());
|
||||
size_t nmid = (A.size() >>1), nlast = A.size() -1 ;
|
||||
for (size_t i = 0 ; i < nmid ;++i)
|
||||
std::swap ( A[i], A [nlast -i]);
|
||||
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
std::sort (A.begin (), A.begin () + NMAXSTRING);
|
||||
for (size_t i = 0; i < (NMAXSTRING >> 1); ++i)
|
||||
std::swap (A [i], A [NMAXSTRING - 1 - i]);
|
||||
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted_end(size_t n_last)
|
||||
void Generator_reverse_sorted_middle (size_t n_middle)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING+ n_last) != 0)
|
||||
assert (n_middle > 1 && NMAXSTRING >= (n_middle -1));
|
||||
vector <std::string> A, aux;
|
||||
A.reserve (NMAXSTRING + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_middle) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (A.begin() , A.begin() + NMAXSTRING );
|
||||
for ( size_t i =0 ; i< (NMAXSTRING >>1); ++i)
|
||||
std::swap ( A[i], A[NMAXSTRING - 1 - i]);
|
||||
for (size_t i = 0; i < n_middle; ++i) aux.push_back (std::move (A [i]));
|
||||
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
std::sort (A.begin () + n_middle, A.end ());
|
||||
|
||||
size_t pos1 = n_middle, pos2 = A.size () - 1;
|
||||
for (size_t i = 0; i < (NMAXSTRING >> 1); ++i)
|
||||
std::swap (A [pos1 ++], A [pos2 --]);
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
size_t step = NMAXSTRING / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
size_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
};
|
||||
void Generator_reverse_sorted_middle(size_t n_last)
|
||||
{
|
||||
std::vector<std::string> A,B,C;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING + n_last) != 0)
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
for ( size_t i = NMAXSTRING ; i < A.size() ; ++i)
|
||||
B.push_back ( std::move ( A[i]));
|
||||
A.resize ( NMAXSTRING);
|
||||
|
||||
std::sort (A.begin() , A.end() );
|
||||
for ( size_t i =0 ; i< (NMAXSTRING >>1); ++i)
|
||||
std::swap ( A[i], A[NMAXSTRING - 1 - i]);
|
||||
|
||||
size_t step = NMAXSTRING /n_last +1 ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i, pos += step)
|
||||
{ C.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
C.push_back ( A[pos + k] );
|
||||
};
|
||||
while ( pos < A.size() )
|
||||
C.push_back ( A[pos++]);
|
||||
A = C ;
|
||||
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
aux.clear ();
|
||||
aux.reserve (0);
|
||||
Test (A);
|
||||
};
|
||||
|
||||
|
||||
template<class IA, class compare>
|
||||
int Test (std::vector<IA> &B, compare comp)
|
||||
void Test (std::vector <std::string> &B)
|
||||
{ //---------------------------- begin --------------------------------
|
||||
std::less <std::string> comp;
|
||||
double duration;
|
||||
time_point start, finish;
|
||||
std::vector<IA> A (B);
|
||||
std::vector<double> V;
|
||||
std::vector <std::string> A (B);
|
||||
std::vector <double> V;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
A = B;
|
||||
@@ -296,11 +306,11 @@ int Test (std::vector<IA> &B, compare comp)
|
||||
//-----------------------------------------------------------------------
|
||||
// printing the vector
|
||||
//-----------------------------------------------------------------------
|
||||
std::cout<<std::setprecision(2)<<std::fixed;
|
||||
for ( uint32_t i =0 ; i < V.size() ; ++i)
|
||||
{ std::cout<<std::right<<std::setw(5)<<V[i]<<" |";
|
||||
std::cout << std::setprecision (2) << std::fixed;
|
||||
for (uint32_t i = 0; i < V.size (); ++i)
|
||||
{ std::cout << std::right << std::setw (5) << V [i] << " |";
|
||||
};
|
||||
std::cout<<std::endl;
|
||||
return 0;
|
||||
std::cout << std::endl;
|
||||
|
||||
};
|
||||
|
||||
|
||||
@@ -25,7 +25,7 @@ namespace bsc = boost::sort::common;
|
||||
|
||||
void print_banner();
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
int main(int argc, char *argv [])
|
||||
{ //---------------------------- begin--------------------------------------
|
||||
std::string name;
|
||||
size_t number;
|
||||
@@ -38,13 +38,13 @@ int main(int argc, char *argv[])
|
||||
return 0;
|
||||
};
|
||||
name = argv[1];
|
||||
number = atoi(argv[2]);
|
||||
number = atoi (argv[ 2]);
|
||||
if (number == 0) {
|
||||
cout << "error, the number can't be zero\n";
|
||||
return 0;
|
||||
};
|
||||
|
||||
if (bsc::generate_file(name, number) != 0)
|
||||
if (bsc::generate_file (name, number) != 0)
|
||||
std::cout << "Error in the file creation\n";
|
||||
return 0;
|
||||
};
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
echo "."
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
clang++ ./benchmark_numbers.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -pthread -s -lpthread -o benchmark_numbers
|
||||
clang++ ./benchmark_numbers.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -pthread -s -lpthread -o benchmark_numbers
|
||||
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 10 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
clang++ ./benchmark_objects.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -pthread -s -lpthread -o benchmark_objects
|
||||
clang++ ./benchmark_objects.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -pthread -s -lpthread -o benchmark_objects
|
||||
echo "."
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 60 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
echo "."
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
g++ ./benchmark_strings.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -pthread -s -lpthread -o benchmark_strings
|
||||
g++ ./benchmark_strings.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -pthread -s -lpthread -o benchmark_strings
|
||||
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 10 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
echo "."
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
g++ ./benchmark_numbers.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -pthread -s -lpthread -o benchmark_numbers
|
||||
g++ ./benchmark_numbers.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -pthread -s -lpthread -o benchmark_numbers
|
||||
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 10 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
g++ ./benchmark_objects.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -pthread -s -lpthread -o benchmark_objects
|
||||
g++ ./benchmark_objects.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -pthread -s -lpthread -o benchmark_objects
|
||||
echo "."
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 60 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
echo "."
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
g++ ./benchmark_strings.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -pthread -s -lpthread -o benchmark_strings
|
||||
g++ ./benchmark_strings.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -pthread -s -lpthread -o benchmark_strings
|
||||
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 10 minutes depending of your machine )"
|
||||
|
||||
@@ -48,14 +48,13 @@ using bsort::pdqsort;
|
||||
|
||||
void Generator_random (void);
|
||||
void Generator_sorted (void);
|
||||
void Generator_sorted_end (size_t n_last);
|
||||
void Generator_sorted_middle (size_t n_last);
|
||||
void Generator_sorted_end (uint64_t n_last);
|
||||
void Generator_sorted_middle (uint64_t n_middle);
|
||||
void Generator_reverse_sorted (void);
|
||||
void Generator_reverse_sorted_end (size_t n_last);
|
||||
void Generator_reverse_sorted_middle (size_t n_last);
|
||||
void Generator_reverse_sorted_end (uint64_t n_last);
|
||||
void Generator_reverse_sorted_middle (uint64_t n_middle);
|
||||
|
||||
template<class IA, class compare>
|
||||
int Test (std::vector<IA> &B, compare comp = compare ());
|
||||
void Test (const std::vector <uint64_t> &B);
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
@@ -129,34 +128,28 @@ int main (int argc, char *argv[])
|
||||
cout<<endl<<endl ;
|
||||
return 0;
|
||||
}
|
||||
void
|
||||
Generator_random (void)
|
||||
void Generator_random (void)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
vector <uint64_t> A;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
}
|
||||
;
|
||||
void
|
||||
Generator_sorted (void)
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted (void)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
for (size_t i = 0; i < NELEM; ++i)
|
||||
for (uint64_t i = 0; i < NELEM; ++i)
|
||||
A.push_back (i);
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
|
||||
}
|
||||
|
||||
void Generator_sorted_end (size_t n_last)
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted_end (uint64_t n_last)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
A.reserve (NELEM);
|
||||
@@ -164,112 +157,115 @@ void Generator_sorted_end (size_t n_last)
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (A.begin (), A.begin () + NELEM);
|
||||
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
|
||||
}
|
||||
;
|
||||
void Generator_sorted_middle (size_t n_last)
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted_middle (uint64_t n_middle)
|
||||
{
|
||||
vector<uint64_t> A, B, C;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0)
|
||||
assert (n_middle > 1 && NELEM >= (n_middle -1));
|
||||
vector <uint64_t> A, aux;
|
||||
A.reserve (NELEM + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_middle) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
for (size_t i = NELEM; i < A.size (); ++i)
|
||||
B.push_back (std::move (A[i]));
|
||||
A.resize ( NELEM);
|
||||
for (size_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A[i], A[NELEM - 1 - i]);
|
||||
for (uint64_t i = 0; i < n_middle; ++i) aux.push_back (A [i]);
|
||||
|
||||
std::sort (A.begin (), A.end ());
|
||||
size_t step = NELEM / n_last + 1;
|
||||
size_t pos = 0;
|
||||
std::sort (A.begin () + n_middle, A.end ());
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
uint64_t step = NELEM / (n_middle - 1);
|
||||
A [0] = aux [0];
|
||||
uint64_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
for (size_t i = 0; i < B.size (); ++i, pos += step)
|
||||
for (uint64_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
C.push_back (B[i]);
|
||||
for (size_t k = 0; k < step; ++k)
|
||||
C.push_back (A[pos + k]);
|
||||
for (uint64_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = A [pos_read ++];
|
||||
A [pos_write ++] = aux [i];
|
||||
};
|
||||
while (pos < A.size ())
|
||||
C.push_back (A[pos++]);
|
||||
A = C;
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
}
|
||||
;
|
||||
aux.clear ();
|
||||
aux.reserve (0);
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted (void)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
for (size_t i = NELEM; i > 0; --i)
|
||||
for (uint64_t i = NELEM; i > 0; --i)
|
||||
A.push_back (i);
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
}
|
||||
void Generator_reverse_sorted_end (size_t n_last)
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted_end (uint64_t n_last)
|
||||
{
|
||||
vector<uint64_t> A;
|
||||
vector <uint64_t> A;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (A.begin (), A.begin () + NELEM);
|
||||
for (size_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A[i], A[NELEM - 1 - i]);
|
||||
for (uint64_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A [i], A [NELEM - 1 - i]);
|
||||
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
Test (A);
|
||||
}
|
||||
void Generator_reverse_sorted_middle (size_t n_last)
|
||||
void Generator_reverse_sorted_middle (uint64_t n_middle)
|
||||
{
|
||||
vector<uint64_t> A, B, C;
|
||||
A.reserve (NELEM);
|
||||
A.clear ();
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0)
|
||||
assert (n_middle > 1 && NELEM >= (n_middle -1));
|
||||
vector <uint64_t> A, aux;
|
||||
A.reserve (NELEM + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
if (fill_vector_uint64 ("input.bin", A, NELEM + n_middle) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
for (size_t i = NELEM; i < A.size (); ++i)
|
||||
B.push_back (std::move (A[i]));
|
||||
A.resize ( NELEM);
|
||||
for (size_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A[i], A[NELEM - 1 - i]);
|
||||
for (uint64_t i = 0; i < n_middle; ++i) aux.push_back (A [i]);
|
||||
|
||||
std::sort (A.begin (), A.end ());
|
||||
size_t step = NELEM / n_last + 1;
|
||||
size_t pos = 0;
|
||||
std::sort (A.begin () + n_middle, A.end ());
|
||||
uint64_t pos1 = n_middle, pos2 = A.size () - 1;
|
||||
for (uint64_t i = 0; i < (NELEM >> 1); ++i)
|
||||
std::swap (A [pos1 ++], A [pos2 --]);
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
uint64_t step = NELEM / (n_middle - 1);
|
||||
A [0] = aux [0];
|
||||
uint64_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
for (size_t i = 0; i < B.size (); ++i, pos += step)
|
||||
for (uint64_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
C.push_back (B[i]);
|
||||
for (size_t k = 0; k < step; ++k)
|
||||
C.push_back (A[pos + k]);
|
||||
for (uint64_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = A [pos_read ++];
|
||||
A [pos_write ++] = aux [i];
|
||||
};
|
||||
while (pos < A.size ())
|
||||
C.push_back (A[pos++]);
|
||||
A = C;
|
||||
Test<uint64_t, std::less<uint64_t>> (A);
|
||||
aux.clear ();
|
||||
aux.reserve (0);
|
||||
Test (A);
|
||||
};
|
||||
|
||||
|
||||
template<class IA, class compare>
|
||||
int Test (std::vector<IA> &B, compare comp)
|
||||
{ //---------------------------- begin --------------------------------
|
||||
void Test (const std::vector <uint64_t> &B)
|
||||
{
|
||||
//---------------------------- begin --------------------------------
|
||||
std::less <uint64_t> comp ;
|
||||
double duration;
|
||||
time_point start, finish;
|
||||
std::vector<IA> A (B);
|
||||
std::vector<double> V;
|
||||
std::vector <uint64_t> A (B);
|
||||
std::vector <double> V;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
A = B;
|
||||
@@ -307,7 +303,6 @@ int Test (std::vector<IA> &B, compare comp)
|
||||
duration = subtract_time (finish, start);
|
||||
V.push_back (duration);
|
||||
|
||||
|
||||
A = B;
|
||||
start = now ();
|
||||
spreadsort (A.begin (), A.end ());
|
||||
@@ -318,11 +313,10 @@ int Test (std::vector<IA> &B, compare comp)
|
||||
//-----------------------------------------------------------------------
|
||||
// printing the vector
|
||||
//-----------------------------------------------------------------------
|
||||
std::cout<<std::setprecision(2)<<std::fixed;
|
||||
for ( uint32_t i =0 ; i < V.size() ; ++i)
|
||||
{ std::cout<<std::right<<std::setw(5)<<V[i]<<" |";
|
||||
std::cout<<std::setprecision (2) <<std::fixed;
|
||||
for ( uint32_t i =0 ; i < V.size () ; ++i)
|
||||
{
|
||||
std::cout<<std::right<<std::setw (5)<<V [i]<<" |";
|
||||
};
|
||||
std::cout<<std::endl;
|
||||
return 0;
|
||||
};
|
||||
|
||||
|
||||
@@ -26,13 +26,8 @@
|
||||
#include <boost/sort/common/time_measure.hpp>
|
||||
#include <boost/sort/common/file_vector.hpp>
|
||||
#include "boost/sort/common/int_array.hpp"
|
||||
|
||||
#include <boost/sort/sort.hpp>
|
||||
|
||||
|
||||
#define NELEM 100000000
|
||||
#define NMAXSTRING 10000000
|
||||
|
||||
using namespace std;
|
||||
namespace bsort = boost::sort;
|
||||
namespace bsc = bsort::common;
|
||||
@@ -54,49 +49,55 @@ using bsort::pdqsort;
|
||||
|
||||
|
||||
template <class IA>
|
||||
void Generator_random(uint64_t N);
|
||||
void Generator_random (uint64_t N);
|
||||
|
||||
template <class IA>
|
||||
void Generator_sorted(uint64_t N);
|
||||
void Generator_sorted (uint64_t N);
|
||||
template <class IA>
|
||||
void Generator_sorted_end(uint64_t N, size_t n_last );
|
||||
void Generator_sorted_end (uint64_t N, size_t n_last );
|
||||
|
||||
template <class IA>
|
||||
void Generator_sorted_middle(uint64_t N, size_t n_last );
|
||||
void Generator_sorted_middle (uint64_t N, size_t n_middle );
|
||||
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted(uint64_t N);
|
||||
void Generator_reverse_sorted (uint64_t N);
|
||||
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_end(uint64_t N, size_t n_last );
|
||||
void Generator_reverse_sorted_end (uint64_t N, size_t n_last );
|
||||
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_middle(uint64_t N, size_t n_last );
|
||||
void Generator_reverse_sorted_middle (uint64_t N, size_t n_midlle );
|
||||
|
||||
template < class IA >
|
||||
struct H_rightshift {
|
||||
inline uint64_t operator()(const IA& A1, unsigned offset) {
|
||||
return A1.counter() >> offset;
|
||||
}
|
||||
template <class IA>
|
||||
struct H_rightshift
|
||||
{
|
||||
inline uint64_t operator () (const IA& A1, unsigned offset)
|
||||
{
|
||||
return A1.counter () >> offset;
|
||||
};
|
||||
};
|
||||
|
||||
template < class IA >
|
||||
struct L_rightshift {
|
||||
inline uint64_t operator()(const IA& A1, unsigned offset) {
|
||||
return A1.M[0] >> offset;
|
||||
}
|
||||
template <class IA>
|
||||
struct L_rightshift
|
||||
{
|
||||
inline uint64_t operator () (const IA& A1, unsigned offset)
|
||||
{
|
||||
return A1.M[0] >> offset;
|
||||
};
|
||||
};
|
||||
|
||||
template <class IA, class rightshift, class compare>
|
||||
int Test(std::vector<IA> &B, rightshift shift, compare comp, std::vector<double> & V );
|
||||
int Test (std::vector< IA> &B, rightshift shift,
|
||||
compare comp, std::vector <double> & V );
|
||||
|
||||
template <class IA>
|
||||
void Test_size ( uint64_t N);
|
||||
void Test_size (uint64_t N);
|
||||
|
||||
void Print_vectors ( std::vector<double> & V1, std::vector<double> & V2);
|
||||
void Print_vectors ( std::vector <double> &V1, std::vector <double> &V2);
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
int main(int argc, char *argv [])
|
||||
{
|
||||
const uint64_t NELEM = 100000000;
|
||||
cout << "\n\n";
|
||||
cout << "************************************************************\n";
|
||||
cout << "** **\n";
|
||||
@@ -130,7 +131,7 @@ int main(int argc, char *argv[])
|
||||
cout << "** **\n";
|
||||
cout << "************************************************************\n";
|
||||
|
||||
Test_size<int_array<1> >(NELEM);
|
||||
Test_size <int_array <1> >(NELEM);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// I N T _ A R R A Y < 4 >
|
||||
@@ -140,7 +141,7 @@ int main(int argc, char *argv[])
|
||||
cout << " "<<(NELEM >>2)<<" OBJECTS UINT64_T [4]\n";
|
||||
cout << "** **\n";
|
||||
cout << "************************************************************\n";
|
||||
Test_size<int_array<4> >(NELEM >> 2);
|
||||
Test_size <int_array <4> >(NELEM >> 2);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// I N T _ A R R A Y < 8 >
|
||||
@@ -150,7 +151,7 @@ int main(int argc, char *argv[])
|
||||
cout << " "<<(NELEM >>3)<<" OBJECTS UINT64_T [8]\n";
|
||||
cout << "** **\n";
|
||||
cout << "************************************************************\n";
|
||||
Test_size<int_array<8> >(NELEM >> 3);
|
||||
Test_size <int_array <8> >(NELEM >> 3);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// I N T _ A R R A Y < 1 6 >
|
||||
@@ -160,7 +161,7 @@ int main(int argc, char *argv[])
|
||||
cout << " "<<(NELEM >>4)<<" OBJECTS UINT64_T [16]\n";
|
||||
cout << "** **\n";
|
||||
cout << "************************************************************\n";
|
||||
Test_size<int_array<16> >(NELEM >> 4);
|
||||
Test_size <int_array <16> >(NELEM >> 4);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// I N T _ A R R A Y < 6 4 >
|
||||
@@ -170,13 +171,13 @@ int main(int argc, char *argv[])
|
||||
cout << " "<< (NELEM >>6)<<" OBJECTS UINT64_T [64]\n";
|
||||
cout << "** **\n";
|
||||
cout << "************************************************************\n";
|
||||
Test_size<int_array<64> >(NELEM >> 6);
|
||||
Test_size <int_array <64> >(NELEM >> 6);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <class IA>
|
||||
void Test_size ( uint64_t N)
|
||||
void Test_size (uint64_t N)
|
||||
{
|
||||
cout<<"\n";
|
||||
cout<<"[ 1 ] std::sort [ 2 ] pdqsort [ 3 ] std::stable_sort \n";
|
||||
@@ -197,317 +198,349 @@ void Test_size ( uint64_t N)
|
||||
" | | | |\n";
|
||||
|
||||
cout<<"random |";
|
||||
Generator_random<IA>(N);
|
||||
Generator_random <IA> (N);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted |";
|
||||
Generator_sorted<IA>(N);
|
||||
Generator_sorted <IA> (N);
|
||||
|
||||
cout<<"sorted + 0.1% end |";
|
||||
Generator_sorted_end<IA>(N, N / 1000);
|
||||
Generator_sorted_end <IA> (N, N / 1000);
|
||||
|
||||
cout<<"sorted + 1% end |";
|
||||
Generator_sorted_end<IA>(N, N / 100);
|
||||
Generator_sorted_end <IA> (N, N / 100);
|
||||
|
||||
cout<<"sorted + 10% end |";
|
||||
Generator_sorted_end<IA>(N, N / 10);
|
||||
Generator_sorted_end <IA> (N, N / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted + 0.1% mid |";
|
||||
Generator_sorted_middle<IA>(N, N / 1000);
|
||||
Generator_sorted_middle <IA> (N, N / 1000);
|
||||
|
||||
cout<<"sorted + 1% mid |";
|
||||
Generator_sorted_middle<IA>(N, N / 100);
|
||||
Generator_sorted_middle <IA> (N, N / 100);
|
||||
|
||||
cout<<"sorted + 10% mid |";
|
||||
Generator_sorted_middle<IA>(N, N / 10);
|
||||
Generator_sorted_middle <IA> (N, N / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"reverse sorted |";
|
||||
Generator_reverse_sorted<IA>(N);
|
||||
Generator_reverse_sorted <IA> (N);
|
||||
|
||||
cout<<"rv sorted + 0.1% end|";
|
||||
Generator_reverse_sorted_end<IA>(N, N / 1000);
|
||||
Generator_reverse_sorted_end <IA> (N, N / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% end|";
|
||||
Generator_reverse_sorted_end<IA>(N, N / 100);
|
||||
Generator_reverse_sorted_end <IA> (N, N / 100);
|
||||
|
||||
cout<<"rv sorted + 10% end|";
|
||||
Generator_reverse_sorted_end<IA>(N, N / 10);
|
||||
Generator_reverse_sorted_end <IA> (N, N / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"rv sorted + 0.1% mid|";
|
||||
Generator_reverse_sorted_middle<IA>(N, N / 1000);
|
||||
Generator_reverse_sorted_middle <IA> (N, N / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% mid|";
|
||||
Generator_reverse_sorted_middle<IA>(N, N / 100);
|
||||
Generator_reverse_sorted_middle <IA> (N, N / 100);
|
||||
|
||||
cout<<"rv sorted + 10% mid|";
|
||||
Generator_reverse_sorted_middle<IA>(N, N / 10);
|
||||
cout<< "--------------------+-----------+-----------+-----------+";
|
||||
Generator_reverse_sorted_middle <IA> (N, N / 10);
|
||||
cout << "--------------------+-----------+-----------+-----------+";
|
||||
cout << "-----------+-----------+-----------+\n";
|
||||
cout<<endl<<endl<<endl;
|
||||
}
|
||||
void Print_vectors ( std::vector<double> & V1, std::vector<double> & V2)
|
||||
{
|
||||
assert ( V1.size() == V2.size());
|
||||
std::cout<<std::setprecision(2)<<std::fixed;
|
||||
for ( uint32_t i =0 ; i < V1.size() ; ++i)
|
||||
{ std::cout<<std::right<<std::setw(5)<<V1[i]<<" ";
|
||||
std::cout<<std::right<<std::setw(5)<<V2[i]<<"|";
|
||||
assert ( V1.size () == V2.size ());
|
||||
std::cout << std::setprecision (2) << std::fixed;
|
||||
|
||||
for ( uint32_t i =0 ; i < V1.size () ; ++i)
|
||||
{
|
||||
std::cout << std::right << std::setw (5) << V1 [i] << " ";
|
||||
std::cout << std::right << std::setw (5) << V2 [i] <<"|";
|
||||
};
|
||||
std::cout<<std::endl;
|
||||
}
|
||||
|
||||
template <class IA>
|
||||
void Generator_random(uint64_t N)
|
||||
void Generator_random (uint64_t N)
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen));
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate(gen));
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
Test(A, H_rightshift <IA> (), H_comp <IA> (), V1);
|
||||
Test(A, L_rightshift <IA> (), L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
|
||||
template <class IA>
|
||||
void Generator_sorted(uint64_t N)
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen));
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate (gen));
|
||||
|
||||
std::sort( A.begin() , A.end(),H_comp<IA>() );
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
std::sort (A.begin (), A.end (), H_comp <IA> ());
|
||||
Test (A, H_rightshift <IA> (), H_comp <IA> (), V1);
|
||||
|
||||
std::sort( A.begin() , A.end(),L_comp<IA>() );
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
std::sort (A.begin (), A.end (), L_comp <IA> ());
|
||||
Test (A, L_rightshift <IA> (), L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
|
||||
template <class IA>
|
||||
void Generator_sorted_end(uint64_t N, size_t n_last )
|
||||
void Generator_sorted_end (uint64_t N, size_t n_last )
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
A.emplace_back(IA::generate(gen));
|
||||
std::sort ( A.begin() , A.begin() + N ,H_comp<IA>());
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
std::sort (A.begin (), A.begin () + N, H_comp <IA> ());
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(),V1);
|
||||
std::sort ( A.begin() , A.begin() + N ,L_comp<IA>());
|
||||
Test (A, H_rightshift <IA> (), H_comp <IA> (), V1);
|
||||
std::sort (A.begin (), A.begin () + N, L_comp <IA> ());
|
||||
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
Test (A, L_rightshift <IA> (), L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
template <class IA>
|
||||
void Generator_sorted_middle(uint64_t N, size_t n_last )
|
||||
void Generator_sorted_middle (uint64_t N, size_t n_middle )
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
std::vector<double> V1, V2 ;
|
||||
vector<IA> A;
|
||||
A.reserve(N + n_last);
|
||||
assert (n_middle > 1 && N >= (n_middle -1));
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
|
||||
std::vector <double> V1, V2; // vector with the times used
|
||||
vector <IA> A, aux;
|
||||
A.reserve (N + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// H _ C O M P
|
||||
//-----------------------------------------------------------------------
|
||||
for (uint32_t i = 0; i < (N + n_middle); i++)
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
for (size_t i = 0; i < n_middle; ++i)
|
||||
aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin () + n_middle, A.end (), H_comp <IA> ());
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
size_t step = N / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
size_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
{ A.clear() ;
|
||||
gen.reset();
|
||||
vector<IA> B, C;
|
||||
C.reserve(N + n_last);
|
||||
B.reserve ( n_last);
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
C.emplace_back(IA::generate(gen));
|
||||
|
||||
for ( size_t i = N ; i < C.size() ; ++i)
|
||||
B.push_back ( std::move ( C[i]));
|
||||
|
||||
C.resize ( N);
|
||||
|
||||
std::sort ( C.begin() , C.end() ,H_comp<IA>());
|
||||
size_t step = N /n_last ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i)
|
||||
{ A.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
A.push_back ( C[pos++] );
|
||||
};
|
||||
while ( pos < C.size() )
|
||||
A.push_back ( C[pos++]);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
Test (A, H_rightshift <IA> (), H_comp <IA> (), V1);
|
||||
|
||||
{ A.clear() ;
|
||||
gen.reset();
|
||||
vector<IA> B,C;
|
||||
C.reserve(N + n_last);
|
||||
B.reserve ( n_last);
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
C.emplace_back(IA::generate(gen));
|
||||
//----------------------------------------------------------------------
|
||||
// L _ C O M P
|
||||
//-----------------------------------------------------------------------
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
A.reserve (N + n_middle);
|
||||
aux.clear ();
|
||||
aux.reserve (n_middle);
|
||||
|
||||
for (uint32_t i = 0; i < (N + n_middle); i++)
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
for (size_t i = 0; i < n_middle; ++i)
|
||||
aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin () + n_middle, A.end (), L_comp <IA> ());
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
step = N / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
pos_read = n_middle;
|
||||
pos_write = 1;
|
||||
|
||||
for ( size_t i = N ; i < C.size() ; ++i)
|
||||
B.push_back ( std::move ( C[i]));
|
||||
|
||||
C.resize ( N);
|
||||
|
||||
std::sort ( C.begin() , C.end() ,L_comp<IA>());
|
||||
size_t step = N /n_last ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i)
|
||||
{ A.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
A.push_back ( C[pos++] );
|
||||
};
|
||||
while ( pos < C.size() )
|
||||
A.push_back ( C[pos++]);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
|
||||
Test (A, L_rightshift <IA> (), L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted(uint64_t N)
|
||||
void Generator_reverse_sorted (uint64_t N)
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen));
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate (gen));
|
||||
|
||||
std::sort( A.begin() , A.end(),H_comp<IA>() );
|
||||
for ( size_t i = 0; i < (A.size() >>1) ; ++i)
|
||||
std::swap ( A[i], A[A.size() - i -1 ]);
|
||||
std::sort (A.begin (), A.end (), H_comp <IA> ());
|
||||
for (size_t i = 0; i < (A.size () >>1); ++i)
|
||||
std::swap (A [i], A [A.size () - i - 1]);
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
Test (A, H_rightshift <IA> (), H_comp <IA> (), V1);
|
||||
|
||||
std::sort( A.begin() , A.end(),L_comp<IA>() );
|
||||
for ( size_t i = 0; i < (A.size() >>1) ; ++i)
|
||||
std::swap ( A[i], A[A.size() - i -1 ]);
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
std::sort (A.begin (), A.end (), L_comp <IA> ());
|
||||
for (size_t i = 0; i < (A.size () >> 1); ++i)
|
||||
std::swap (A [i], A [A.size() - i - 1]);
|
||||
|
||||
Test (A, L_rightshift <IA> (), L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_end(uint64_t N, size_t n_last )
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
vector<IA> A;
|
||||
A.reserve(N);
|
||||
std::vector<double> V1, V2 ;
|
||||
|
||||
gen.reset();
|
||||
A.clear();
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_end (uint64_t N, size_t n_last )
|
||||
{
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
vector <IA> A;
|
||||
A.reserve (N);
|
||||
std::vector <double> V1, V2 ;
|
||||
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
A.emplace_back(IA::generate(gen));
|
||||
std::sort ( A.begin() , A.begin() + N ,H_comp<IA>());
|
||||
for ( size_t i =0 ; i < (N>>1); ++i)
|
||||
std::swap ( A[i], A[N-1-i]);
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
std::sort (A.begin (), A.begin () + N , H_comp <IA> ());
|
||||
for (size_t i =0 ; i < (N >> 1); ++i)
|
||||
std::swap (A [i], A [N - 1 - i]);
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
std::sort ( A.begin() , A.begin() + N ,L_comp<IA>());
|
||||
for ( size_t i =0 ; i < (N>>1); ++i)
|
||||
std::swap ( A[i], A[N-1-i]);
|
||||
Test (A, H_rightshift <IA> (), H_comp <IA> (), V1);
|
||||
std::sort (A.begin (), A.begin () + N, L_comp <IA> ());
|
||||
for (size_t i = 0; i < (N >> 1); ++i)
|
||||
std::swap (A [i], A [N - 1 - i]);
|
||||
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
Test (A, L_rightshift <IA> (), L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
|
||||
template <class IA>
|
||||
void Generator_reverse_sorted_middle(uint64_t N, size_t n_last )
|
||||
void Generator_reverse_sorted_middle (uint64_t N, size_t n_middle )
|
||||
{
|
||||
bsc::uint64_file_generator gen("input.bin");
|
||||
std::vector<double> V1, V2 ;
|
||||
vector<IA> A;
|
||||
A.reserve(N + n_last);
|
||||
assert (n_middle > 1 && N >= (n_middle -1));
|
||||
bsc::uint64_file_generator gen ("input.bin");
|
||||
|
||||
std::vector <double> V1, V2; // vector with the times used
|
||||
vector <IA> A, aux;
|
||||
A.reserve (N + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// H _ C O M P
|
||||
//-----------------------------------------------------------------------
|
||||
for (uint32_t i = 0; i < (N + n_middle); i++)
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
for (size_t i = 0; i < n_middle; ++i)
|
||||
aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin () + n_middle, A.end (), H_comp <IA> ());
|
||||
uint64_t pos1 = n_middle, pos2 = A.size () - 1;
|
||||
for (uint64_t i = 0; i < (N >> 1); ++i)
|
||||
std::swap (A [pos1 ++], A [pos2 --]);
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
size_t step = N / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
size_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
{ A.clear() ;
|
||||
gen.reset();
|
||||
vector<IA> B,C;
|
||||
C.reserve(N + n_last);
|
||||
B.reserve ( n_last);
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
C.emplace_back(IA::generate(gen));
|
||||
|
||||
for ( size_t i = N ; i < C.size() ; ++i)
|
||||
B.push_back ( std::move ( C[i]));
|
||||
|
||||
C.resize ( N);
|
||||
|
||||
std::sort ( C.begin() , C.end() ,H_comp<IA>());
|
||||
|
||||
for ( size_t i =0 ; i < (N>>1); ++i)
|
||||
std::swap ( C[i], C[N-1-i]);
|
||||
|
||||
size_t step = N /n_last ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i)
|
||||
{ A.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
A.push_back ( C[pos++ ] );
|
||||
};
|
||||
while ( pos < C.size() )
|
||||
A.push_back ( C[pos++]);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
|
||||
Test(A, H_rightshift<IA>(), H_comp<IA>(), V1);
|
||||
Test (A, H_rightshift <IA> (), H_comp <IA> (), V1);
|
||||
|
||||
{ A.clear() ;
|
||||
gen.reset();
|
||||
vector<IA> B,C;
|
||||
C.reserve(N + n_last);
|
||||
B.reserve ( n_last);
|
||||
for (uint32_t i = 0; i < (N + n_last); i++)
|
||||
C.emplace_back(IA::generate(gen));
|
||||
//----------------------------------------------------------------------
|
||||
// L _ C O M P
|
||||
//-----------------------------------------------------------------------
|
||||
gen.reset ();
|
||||
A.clear ();
|
||||
A.reserve (N + n_middle);
|
||||
aux.clear ();
|
||||
aux.reserve (n_middle);
|
||||
|
||||
for (uint32_t i = 0; i < (N + n_middle); i++)
|
||||
A.emplace_back (IA::generate (gen));
|
||||
|
||||
for (size_t i = 0; i < n_middle; ++i)
|
||||
aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin () + n_middle, A.end (), L_comp <IA> ());
|
||||
pos1 = n_middle;
|
||||
pos2 = A.size () - 1;
|
||||
for (uint64_t i = 0; i < (N >> 1); ++i)
|
||||
std::swap (A [pos1 ++], A [pos2 --]);
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
step = N / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
pos_read = n_middle;
|
||||
pos_write = 1;
|
||||
|
||||
for ( size_t i = N ; i < C.size() ; ++i)
|
||||
B.push_back ( std::move ( C[i]));
|
||||
|
||||
C.resize ( N);
|
||||
|
||||
std::sort ( C.begin() , C.end() ,L_comp<IA>());
|
||||
|
||||
for ( size_t i =0 ; i < (N>>1); ++i)
|
||||
std::swap ( C[i], C[N-1-i]);
|
||||
size_t step = N /n_last ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i)
|
||||
{ A.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
A.push_back ( C[pos++ ] );
|
||||
};
|
||||
while ( pos < C.size() )
|
||||
A.push_back ( C[pos++]);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
|
||||
Test(A, L_rightshift<IA>(), L_comp<IA>(), V2);
|
||||
Print_vectors ( V1, V2 ) ;
|
||||
Test (A, L_rightshift <IA> (), L_comp <IA> (), V2);
|
||||
Print_vectors (V1, V2) ;
|
||||
};
|
||||
|
||||
template<class IA, class rightshift, class compare>
|
||||
int Test (std::vector<IA> &B, rightshift shift, compare comp,std::vector<double> &V)
|
||||
template <class IA, class rightshift, class compare>
|
||||
int Test (std::vector <IA> &B, rightshift shift,
|
||||
compare comp, std::vector <double> &V)
|
||||
{ //---------------------------- begin --------------------------------
|
||||
double duration;
|
||||
time_point start, finish;
|
||||
std::vector<IA> A (B);
|
||||
V.clear() ;
|
||||
std::vector <IA> A (B);
|
||||
V.clear () ;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
A = B;
|
||||
|
||||
@@ -47,18 +47,17 @@ using bsort::spreadsort::spreadsort;
|
||||
using bsort::pdqsort;
|
||||
|
||||
void Generator_random (void);
|
||||
void Generator_sorted(void);
|
||||
void Generator_sorted_end(size_t n_last);
|
||||
void Generator_sorted (void);
|
||||
void Generator_sorted_end (size_t n_last);
|
||||
void Generator_sorted_middle (size_t n_last);
|
||||
void Generator_reverse_sorted(void);
|
||||
void Generator_reverse_sorted_end(size_t n_last);
|
||||
void Generator_reverse_sorted_middle(size_t n_last);
|
||||
void Generator_reverse_sorted (void);
|
||||
void Generator_reverse_sorted_end (size_t n_last);
|
||||
void Generator_reverse_sorted_middle (size_t n_last);
|
||||
|
||||
template <class IA, class compare>
|
||||
int Test(std::vector<IA> &B, compare comp = compare());
|
||||
int Test (std::vector <std::string> &B);
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
int main (int argc, char *argv [])
|
||||
{
|
||||
cout << "\n\n";
|
||||
cout << "************************************************************\n";
|
||||
@@ -72,232 +71,224 @@ int main(int argc, char *argv[])
|
||||
cout << "************************************************************\n";
|
||||
cout << std::endl;
|
||||
|
||||
cout<<"[ 1 ] std::sort [ 2 ] pdqsort [ 3 ] std::stable_sort \n";
|
||||
cout<<"[ 4 ] spinsort [ 5 ] flat_stable_sort [ 6 ] spreadsort\n\n";
|
||||
cout<<" | | | | | | |\n";
|
||||
cout<<" | [ 1 ]| [ 2 ]| [ 3 ]| [ 4 ]| [ 5 ]| [ 6 ]|\n";
|
||||
cout<<"--------------------+------+------+------+------+------+------+\n";
|
||||
cout << "[ 1 ] std::sort [ 2 ] pdqsort [ 3 ] std::stable_sort\n";
|
||||
cout << "[ 4 ] spinsort [ 5 ] flat_stable_sort [ 6 ] spreadsort\n\n";
|
||||
cout << " | | | | | | |\n";
|
||||
cout << " | [ 1 ]| [ 2 ]| [ 3 ]| [ 4 ]| [ 5 ]| [ 6 ]|\n";
|
||||
cout << "--------------------+------+------+------+------+------+------+\n";
|
||||
std::string empty_line =
|
||||
" | | | | | | |\n";
|
||||
|
||||
cout<<"random |";
|
||||
cout << "random |";
|
||||
Generator_random ();
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted |";
|
||||
Generator_sorted();
|
||||
cout << empty_line;
|
||||
cout << "sorted |";
|
||||
Generator_sorted ();
|
||||
|
||||
cout<<"sorted + 0.1% end |";
|
||||
Generator_sorted_end(NMAXSTRING / 1000);
|
||||
cout << "sorted + 0.1% end |";
|
||||
Generator_sorted_end (NMAXSTRING / 1000);
|
||||
|
||||
cout<<"sorted + 1% end |";
|
||||
Generator_sorted_end(NMAXSTRING / 100);
|
||||
cout << "sorted + 1% end |";
|
||||
Generator_sorted_end (NMAXSTRING / 100);
|
||||
|
||||
cout<<"sorted + 10% end |";
|
||||
Generator_sorted_end(NMAXSTRING / 10);
|
||||
cout << "sorted + 10% end |";
|
||||
Generator_sorted_end (NMAXSTRING / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"sorted + 0.1% mid |";
|
||||
cout <<empty_line;
|
||||
cout << "sorted + 0.1% mid |";
|
||||
Generator_sorted_middle (NMAXSTRING / 1000);
|
||||
|
||||
cout<<"sorted + 1% mid |";
|
||||
cout << "sorted + 1% mid |";
|
||||
Generator_sorted_middle (NMAXSTRING / 100);
|
||||
|
||||
cout<<"sorted + 10% mid |";
|
||||
cout << "sorted + 10% mid |";
|
||||
Generator_sorted_middle (NMAXSTRING / 10 );
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"reverse sorted |";
|
||||
Generator_reverse_sorted();
|
||||
cout <<empty_line;
|
||||
cout << "reverse sorted |";
|
||||
Generator_reverse_sorted ();
|
||||
|
||||
cout<<"rv sorted + 0.1% end|";
|
||||
Generator_reverse_sorted_end(NMAXSTRING / 1000);
|
||||
cout << "rv sorted + 0.1% end|";
|
||||
Generator_reverse_sorted_end (NMAXSTRING / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% end|";
|
||||
Generator_reverse_sorted_end(NMAXSTRING / 100);
|
||||
cout << "rv sorted + 1% end|";
|
||||
Generator_reverse_sorted_end (NMAXSTRING / 100);
|
||||
|
||||
cout<<"rv sorted + 10% end|";
|
||||
Generator_reverse_sorted_end(NMAXSTRING / 10);
|
||||
cout << "rv sorted + 10% end|";
|
||||
Generator_reverse_sorted_end (NMAXSTRING / 10);
|
||||
|
||||
cout<<empty_line;
|
||||
cout<<"rv sorted + 0.1% mid|";
|
||||
Generator_reverse_sorted_middle(NMAXSTRING / 1000);
|
||||
cout <<empty_line;
|
||||
cout << "rv sorted + 0.1% mid|";
|
||||
Generator_reverse_sorted_middle (NMAXSTRING / 1000);
|
||||
|
||||
cout<<"rv sorted + 1% mid|";
|
||||
Generator_reverse_sorted_middle(NMAXSTRING / 100);
|
||||
cout << "rv sorted + 1% mid|";
|
||||
Generator_reverse_sorted_middle (NMAXSTRING / 100);
|
||||
|
||||
cout<<"rv sorted + 10% mid|";
|
||||
Generator_reverse_sorted_middle(NMAXSTRING / 10);
|
||||
cout << "rv sorted + 10% mid|";
|
||||
Generator_reverse_sorted_middle (NMAXSTRING / 10);
|
||||
|
||||
cout<<"--------------------+------+------+------+------+------+------+\n";
|
||||
cout<<endl<<endl ;
|
||||
cout << "--------------------+------+------+------+------+------+------+\n";
|
||||
cout << endl<<endl ;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void Generator_random(void)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0)
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
A.clear ();
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted(void)
|
||||
void Generator_sorted (void)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0)
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
A.clear ();
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort( A.begin() , A.end() );
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
std::sort (A.begin (), A.end ());
|
||||
Test (A);
|
||||
};
|
||||
|
||||
void Generator_sorted_end(size_t n_last)
|
||||
void Generator_sorted_end (size_t n_last)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING+ n_last) != 0)
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
A.clear ();
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING+ n_last) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (A.begin() , A.begin() + NMAXSTRING );
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
std::sort (A.begin (), A.begin () + NMAXSTRING );
|
||||
Test (A);
|
||||
};
|
||||
void Generator_sorted_middle(size_t n_last)
|
||||
void Generator_sorted_middle (size_t n_middle)
|
||||
{
|
||||
std::vector<std::string> A,B,C;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING + n_last) != 0)
|
||||
assert (n_middle > 1 && NMAXSTRING >= (n_middle -1));
|
||||
vector <std::string> A, aux;
|
||||
A.reserve (NMAXSTRING + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_middle) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
for ( size_t i = NMAXSTRING ; i < A.size() ; ++i)
|
||||
B.push_back ( std::move ( A[i]));
|
||||
A.resize ( NMAXSTRING);
|
||||
std::sort (A.begin() , A.end() );
|
||||
size_t step = NMAXSTRING /n_last +1 ;
|
||||
size_t pos = 0 ;
|
||||
for (size_t i = 0; i < n_middle; ++i) aux.push_back (std::move (A [i]));
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i, pos += step)
|
||||
{ C.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
C.push_back ( A[pos + k] );
|
||||
};
|
||||
while ( pos < A.size() ) C.push_back ( A[pos++]);
|
||||
A = C ;
|
||||
std::sort (A.begin () + n_middle, A.end ());
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
size_t step = NMAXSTRING / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
size_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
};
|
||||
|
||||
void Generator_reverse_sorted(void)
|
||||
{
|
||||
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
std::vector<std::string> B;
|
||||
B.reserve(NMAXSTRING);
|
||||
if (bsc::fill_vector_string("input.bin", B, NMAXSTRING) != 0)
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
aux.clear ();
|
||||
aux.reserve (0);
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted (void)
|
||||
{
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
{
|
||||
std::vector <std::string> B;
|
||||
B.reserve (NMAXSTRING);
|
||||
if (bsc::fill_vector_string ("input.bin", B, NMAXSTRING) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort(B.begin(), B.end());
|
||||
A.clear();
|
||||
std::sort (B.begin(), B.end());
|
||||
A.clear ();
|
||||
for (size_t i = 0; i < NMAXSTRING; ++i)
|
||||
A.push_back(B[NMAXSTRING - 1 - i]);
|
||||
A.push_back (B [NMAXSTRING - 1 - i]);
|
||||
};
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
|
||||
/*
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
};
|
||||
std::sort( A.begin() , A.end());
|
||||
size_t nmid = (A.size() >>1), nlast = A.size() -1 ;
|
||||
for (size_t i = 0 ; i < nmid ;++i)
|
||||
std::swap ( A[i], A [nlast -i]);
|
||||
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
*/
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted_end(size_t n_last)
|
||||
void Generator_reverse_sorted_end (size_t n_last)
|
||||
{
|
||||
std::vector<std::string> A;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING+ n_last) != 0)
|
||||
std::vector <std::string> A;
|
||||
A.reserve (NMAXSTRING);
|
||||
A.clear ();
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_last) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
std::sort (A.begin() , A.begin() + NMAXSTRING );
|
||||
for ( size_t i =0 ; i< (NMAXSTRING >>1); ++i)
|
||||
std::swap ( A[i], A[NMAXSTRING - 1 - i]);
|
||||
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
std::sort (A.begin (), A.begin () + NMAXSTRING);
|
||||
for (size_t i = 0; i < (NMAXSTRING >> 1); ++i)
|
||||
std::swap (A [i], A [NMAXSTRING - 1 - i]);
|
||||
|
||||
Test (A);
|
||||
};
|
||||
void Generator_reverse_sorted_middle(size_t n_last)
|
||||
void Generator_reverse_sorted_middle (size_t n_middle)
|
||||
{
|
||||
std::vector<std::string> A,B,C;
|
||||
A.reserve(NMAXSTRING);
|
||||
A.clear();
|
||||
if (bsc::fill_vector_string("input.bin", A, NMAXSTRING + n_last) != 0)
|
||||
assert (n_middle > 1 && NMAXSTRING >= (n_middle -1));
|
||||
vector <std::string> A, aux;
|
||||
A.reserve (NMAXSTRING + n_middle);
|
||||
aux.reserve (n_middle);
|
||||
|
||||
if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_middle) != 0)
|
||||
{
|
||||
std::cout << "Error in the input file\n";
|
||||
return;
|
||||
std::exit (EXIT_FAILURE);
|
||||
};
|
||||
for ( size_t i = NMAXSTRING ; i < A.size() ; ++i)
|
||||
B.push_back ( std::move ( A[i]));
|
||||
A.resize ( NMAXSTRING);
|
||||
for (size_t i = 0; i < n_middle; ++i) aux.push_back (std::move (A [i]));
|
||||
|
||||
std::sort (A.begin() , A.end() );
|
||||
for ( size_t i =0 ; i< (NMAXSTRING >>1); ++i)
|
||||
std::swap ( A[i], A[NMAXSTRING - 1 - i]);
|
||||
std::sort (A.begin () + n_middle, A.end ());
|
||||
|
||||
size_t pos1 = n_middle, pos2 = A.size () - 1;
|
||||
for (size_t i = 0; i < (NMAXSTRING >> 1); ++i)
|
||||
std::swap (A [pos1 ++], A [pos2 --]);
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// To insert n_middle elements, must have (n_middle - 1) intervals between
|
||||
// them. The size of the interval is step
|
||||
// The elements after the last element of aux don't need to be moved
|
||||
//-------------------------------------------------------------------------
|
||||
size_t step = NMAXSTRING / (n_middle - 1);
|
||||
A [0] = std::move (aux [0]);
|
||||
size_t pos_read = n_middle, pos_write = 1;
|
||||
|
||||
size_t step = NMAXSTRING /n_last +1 ;
|
||||
size_t pos = 0 ;
|
||||
|
||||
for ( size_t i =0 ; i < B.size() ; ++i, pos += step)
|
||||
{ C.push_back ( B[i]);
|
||||
for ( size_t k = 0 ; k < step ; ++k )
|
||||
C.push_back ( A[pos + k] );
|
||||
for (size_t i = 1; i < n_middle; ++i)
|
||||
{
|
||||
for (size_t k = 0 ; k < step; ++k)
|
||||
A [pos_write ++] = std::move (A [pos_read ++]);
|
||||
A [pos_write ++] = std::move (aux [i]);
|
||||
};
|
||||
while ( pos < A.size() )
|
||||
C.push_back ( A[pos++]);
|
||||
A = C ;
|
||||
|
||||
Test<std::string, std::less<std::string>>(A);
|
||||
aux.clear ();
|
||||
aux.reserve (0);
|
||||
Test (A);
|
||||
};
|
||||
|
||||
|
||||
template<class IA, class compare>
|
||||
int Test (std::vector<IA> &B, compare comp)
|
||||
{ //---------------------------- begin -----------------------------
|
||||
int Test (std::vector <std::string> &B)
|
||||
{
|
||||
//---------------------------- begin -----------------------------
|
||||
std::less <std::string> comp;
|
||||
double duration;
|
||||
time_point start, finish;
|
||||
std::vector<IA> A (B);
|
||||
std::vector<double> V;
|
||||
|
||||
std::vector <std::string> A (B);
|
||||
std::vector <double> V;
|
||||
|
||||
A = B;
|
||||
start = now ();
|
||||
@@ -344,11 +335,12 @@ int Test (std::vector<IA> &B, compare comp)
|
||||
//-----------------------------------------------------------------------
|
||||
// printing the vector
|
||||
//-----------------------------------------------------------------------
|
||||
std::cout<<std::setprecision(2)<<std::fixed;
|
||||
for ( uint32_t i =0 ; i < V.size() ; ++i)
|
||||
{ std::cout<<std::right<<std::setw(5)<<V[i]<<" |";
|
||||
std::cout << std::setprecision (2) << std::fixed;
|
||||
for (uint32_t i = 0; i < V.size () ; ++i)
|
||||
{
|
||||
std::cout << std::right << std::setw (5) << V [i] << " |";
|
||||
};
|
||||
std::cout<<std::endl;
|
||||
std::cout <<std::endl;
|
||||
return 0;
|
||||
};
|
||||
|
||||
|
||||
@@ -25,7 +25,7 @@ namespace bsc = boost::sort::common;
|
||||
|
||||
void print_banner();
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
int main(int argc, char *argv [])
|
||||
{ //---------------------------- begin--------------------------------------
|
||||
std::string name;
|
||||
size_t number;
|
||||
@@ -37,8 +37,8 @@ int main(int argc, char *argv[])
|
||||
cout << " file_generator file_name number_elements\n\n";
|
||||
return 0;
|
||||
};
|
||||
name = argv[1];
|
||||
number = atoi(argv[2]);
|
||||
name = argv [1];
|
||||
number = atoi (argv [2]);
|
||||
if (number == 0) {
|
||||
cout << "error, the number can't be zero\n";
|
||||
return 0;
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
echo "."
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
clang++ ./benchmark_numbers.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o benchmark_numbers
|
||||
clang++ ./benchmark_numbers.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o benchmark_numbers
|
||||
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 10 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
clang++ ./benchmark_objects.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o benchmark_objects
|
||||
clang++ ./benchmark_objects.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o benchmark_objects
|
||||
echo "."
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 45 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
echo "."
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
clang++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
clang++ ./benchmark_strings.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o benchmark_strings
|
||||
clang++ ./benchmark_strings.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o benchmark_strings
|
||||
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 10 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
echo "."
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
g++ ./benchmark_numbers.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o benchmark_numbers
|
||||
g++ ./benchmark_numbers.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o benchmark_numbers
|
||||
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 10 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
g++ ./benchmark_objects.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o benchmark_objects
|
||||
g++ ./benchmark_objects.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o benchmark_objects
|
||||
echo "."
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 45 minutes depending of your machine )"
|
||||
|
||||
@@ -7,9 +7,9 @@ echo "=================================================================="
|
||||
echo "."
|
||||
echo "C O M P I L I N G . . . . . . . . . . ."
|
||||
echo "."
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o file_generator
|
||||
g++ ./file_generator.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o file_generator
|
||||
|
||||
g++ ./benchmark_strings.cpp -std=c++11 -march=native -w -fexceptions -O3 -I../../include -s -o benchmark_strings
|
||||
g++ ./benchmark_strings.cpp -std=c++11 -march=native -w -fno-exceptions -fno-operator-names -O3 -I../../include -s -o benchmark_strings
|
||||
|
||||
echo "R U N N I N G . . . . . . . . . . ."
|
||||
echo "( The time needed is around 10 minutes depending of your machine )"
|
||||
|
||||
@@ -102,7 +102,7 @@ void sort_index(Iter_t global_first, std::vector<Iter_t> &index)
|
||||
|
||||
while (pos_in_vector < nelem)
|
||||
{
|
||||
while (pos_in_vector < nelem and
|
||||
while (pos_in_vector < nelem &&
|
||||
(size_t(index[pos_in_vector] - global_first)) == pos_in_vector)
|
||||
{
|
||||
++pos_in_vector;
|
||||
|
||||
@@ -14,7 +14,6 @@
|
||||
#ifndef __BOOST_SORT_COMMON_MERGE_BLOCK_HPP
|
||||
#define __BOOST_SORT_COMMON_MERGE_BLOCK_HPP
|
||||
|
||||
#include <ciso646>
|
||||
#include <boost/sort/common/range.hpp>
|
||||
#include <boost/sort/common/rearrange.hpp>
|
||||
#include <boost/sort/common/util/merge.hpp>
|
||||
@@ -126,7 +125,7 @@ struct merge_block
|
||||
|
||||
~ merge_block()
|
||||
{
|
||||
if (ptr_circ != nullptr and owned)
|
||||
if (ptr_circ != nullptr && owned)
|
||||
{
|
||||
delete ptr_circ;
|
||||
ptr_circ = nullptr;
|
||||
@@ -171,7 +170,7 @@ struct merge_block
|
||||
//-------------------------------------------------------------------------
|
||||
bool is_tail(size_t pos) const
|
||||
{
|
||||
return (pos == (nblock - 1) and ntail != 0);
|
||||
return (pos == (nblock - 1) && ntail != 0);
|
||||
};
|
||||
//-------------------------------------------------------------------------
|
||||
// function :
|
||||
@@ -223,10 +222,10 @@ template<class Iter_t, class Compare, uint32_t Power2>
|
||||
void merge_block<Iter_t, Compare, Power2>
|
||||
::merge_range_pos(it_index itx_first, it_index itx_mid,it_index itx_last)
|
||||
{
|
||||
assert((itx_last - itx_mid) >= 0 and (itx_mid - itx_first) >= 0);
|
||||
assert((itx_last - itx_mid) >= 0 && (itx_mid - itx_first) >= 0);
|
||||
|
||||
size_t nelemA = (itx_mid - itx_first), nelemB = (itx_last - itx_mid);
|
||||
if (nelemA == 0 or nelemB == 0) return;
|
||||
if (nelemA == 0 || nelemB == 0) return;
|
||||
|
||||
//-------------------------------------------------------------------
|
||||
// Create two index with the position of the blocks to merge
|
||||
@@ -244,17 +243,17 @@ void merge_block<Iter_t, Compare, Power2>
|
||||
Iter_t itA = global_range.first, itB = global_range.first;
|
||||
bool validA = false, validB = false;
|
||||
|
||||
while (itxA != indexA.end() and itxB != indexB.end())
|
||||
while (itxA != indexA.end() && itxB != indexB.end())
|
||||
{ //----------------------------------------------------------------
|
||||
// Load valid ranges from the itxA and ItxB positions
|
||||
//----------------------------------------------------------------
|
||||
if (not validA)
|
||||
if (! validA)
|
||||
{
|
||||
rngA = get_range(*itxA);
|
||||
itA = rngA.first;
|
||||
validA = true;
|
||||
};
|
||||
if (not validB)
|
||||
if (! validB)
|
||||
{
|
||||
rngB = get_range(*itxB);
|
||||
itB = rngB.first;
|
||||
@@ -266,7 +265,7 @@ void merge_block<Iter_t, Compare, Power2>
|
||||
//----------------------------------------------------------------
|
||||
if (ptr_circ->size() == 0)
|
||||
{
|
||||
if (not cmp(*rngB.front(), *rngA.back()))
|
||||
if (! cmp(*rngB.front(), *rngA.back()))
|
||||
{
|
||||
*(itx_out++) = *(itxA++);
|
||||
validA = false;
|
||||
@@ -274,7 +273,7 @@ void merge_block<Iter_t, Compare, Power2>
|
||||
};
|
||||
if (cmp(*rngB.back(), *rngA.front()))
|
||||
{
|
||||
if (not is_tail(*itxB))
|
||||
if (! is_tail(*itxB))
|
||||
*(itx_out++) = *itxB;
|
||||
else ptr_circ->push_move_back(rngB.first, rngB.size());
|
||||
++itxB;
|
||||
@@ -295,7 +294,7 @@ void merge_block<Iter_t, Compare, Power2>
|
||||
}
|
||||
else
|
||||
{ // rngB is finished
|
||||
if (not is_tail(*itxB))
|
||||
if (! is_tail(*itxB))
|
||||
{
|
||||
ptr_circ->pop_move_front(rngB.first, rngB.size());
|
||||
*(itx_out++) = *itxB;
|
||||
@@ -315,7 +314,7 @@ void merge_block<Iter_t, Compare, Power2>
|
||||
else
|
||||
{ // The list B is finished
|
||||
rngA = get_range(*itxA);
|
||||
if (ntail != 0 and indexB.back() == (nblock - 1)) // exist tail
|
||||
if (ntail != 0 && indexB.back() == (nblock - 1)) // exist tail
|
||||
{ // add the tail block to indexA, and shift the element
|
||||
indexA.push_back(indexB.back());
|
||||
size_t numA = size_t(itA - rngA.first);
|
||||
@@ -341,7 +340,7 @@ template<class Iter_t, class Compare, uint32_t Power2>
|
||||
void merge_block<Iter_t, Compare, Power2>
|
||||
::move_range_pos_backward(it_index itx_first, it_index itx_last, size_t npos)
|
||||
{
|
||||
assert((itx_last - itx_first) >= 0 and npos <= BLOCK_SIZE);
|
||||
assert((itx_last - itx_first) >= 0 && npos <= BLOCK_SIZE);
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// Processing the last block. Must be ready fore to accept npos
|
||||
@@ -391,7 +390,7 @@ void merge_block<Iter_t, Compare, Power2>
|
||||
pos_ini = 0;
|
||||
while (pos_ini < nelem)
|
||||
{
|
||||
while (pos_ini < nelem and index[pos_ini] == pos_ini)
|
||||
while (pos_ini < nelem && index[pos_ini] == pos_ini)
|
||||
++pos_ini;
|
||||
if (pos_ini == nelem) return;
|
||||
pos_dest = pos_src = pos_ini;
|
||||
|
||||
@@ -13,7 +13,6 @@
|
||||
#ifndef __BOOST_SORT_PARALLEL_DETAIL_UTIL_RANGE_HPP
|
||||
#define __BOOST_SORT_PARALLEL_DETAIL_UTIL_RANGE_HPP
|
||||
|
||||
#include <ciso646>
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
@@ -235,7 +234,7 @@ inline bool is_mergeable_stable(const range<Iter1_t> &src1,
|
||||
//------------------------------------------------------------------------
|
||||
// Code
|
||||
//------------------------------------------------------------------------
|
||||
return not comp(*(src1.back()), *(src2.front()));
|
||||
return ! comp(*(src1.back()), *(src2.front()));
|
||||
};
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -380,7 +379,7 @@ static void merge_flow(range<Iter1_t> rng1, range<Iter2_t> rbuf,
|
||||
//-------------------------------------------------------------------------
|
||||
range<Iter2_t> rbx(rbuf);
|
||||
range<Iter1_t> rx1(rng1), rx2(rng2);
|
||||
assert(rbx.size() == rx1.size() and rx1.size() == rx2.size());
|
||||
assert(rbx.size() == rx1.size() && rx1.size() == rx2.size());
|
||||
while (rx1.first != rx1.last)
|
||||
{
|
||||
*(rx1.first++) = (cmp(*rbx.first, *rx2.first)) ?
|
||||
|
||||
@@ -13,7 +13,6 @@
|
||||
#ifndef __BOOST_SORT_COMMON_REARRANGE_HPP
|
||||
#define __BOOST_SORT_COMMON_REARRANGE_HPP
|
||||
|
||||
#include <ciso646>
|
||||
#include <functional>
|
||||
#include <iterator>
|
||||
#include <type_traits>
|
||||
@@ -83,7 +82,7 @@ void rearrange(Iter_data global_first, Iter_index itx_first,
|
||||
pos_ini = 0;
|
||||
while (pos_ini < nelem)
|
||||
{
|
||||
while (pos_ini < nelem and pos(index[pos_ini]) == pos_ini)
|
||||
while (pos_ini < nelem && pos(index[pos_ini]) == pos_ini)
|
||||
++pos_ini;
|
||||
if (pos_ini == nelem) return;
|
||||
pos_dest = pos_src = pos_ini;
|
||||
|
||||
@@ -13,7 +13,6 @@
|
||||
#ifndef __BOOST_SORT_COMMON_SORT_BASIC_HPP
|
||||
#define __BOOST_SORT_COMMON_SORT_BASIC_HPP
|
||||
|
||||
#include <ciso646>
|
||||
#include <cstdlib>
|
||||
#include <functional>
|
||||
#include <iterator>
|
||||
@@ -56,7 +55,7 @@ inline Iter_t is_stable_sorted_forward (Iter_t first, Iter_t last,
|
||||
#endif
|
||||
if ((last - first) < 2) return first;
|
||||
Iter_t it2 = first + 1;
|
||||
for (Iter_t it1 = first; it2 != last and not comp(*it2, *it1); it1 = it2++);
|
||||
for (Iter_t it1 = first; it2 != last && ! comp(*it2, *it1); it1 = it2++);
|
||||
return it2;
|
||||
}
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -79,7 +78,7 @@ inline Iter_t is_reverse_stable_sorted_forward(Iter_t first, Iter_t last,
|
||||
#endif
|
||||
if ((last - first) < 2) return first;
|
||||
Iter_t it2 = first + 1;
|
||||
for (Iter_t it1 = first; it2 != last and comp(*it2, *it1); it1 = it2++);
|
||||
for (Iter_t it1 = first; it2 != last && comp(*it2, *it1); it1 = it2++);
|
||||
return it2;
|
||||
};
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -105,14 +104,14 @@ size_t number_stable_sorted_forward (Iter_t first, Iter_t last,
|
||||
|
||||
// sorted elements
|
||||
Iter_t it2 = first + 1;
|
||||
for (Iter_t it1 = first; it2 != last and not comp(*it2, *it1); it1 = it2++);
|
||||
for (Iter_t it1 = first; it2 != last && ! comp(*it2, *it1); it1 = it2++);
|
||||
size_t nsorted = size_t ( it2 - first);
|
||||
if ( nsorted != 1)
|
||||
return (nsorted >= min_process) ? nsorted: 0;
|
||||
|
||||
// reverse sorted elements
|
||||
it2 = first + 1;
|
||||
for (Iter_t it1 = first; it2 != last and comp(*it2, *it1); it1 = it2++);
|
||||
for (Iter_t it1 = first; it2 != last && comp(*it2, *it1); it1 = it2++);
|
||||
nsorted = size_t ( it2 - first);
|
||||
|
||||
if ( nsorted < min_process) return 0 ;
|
||||
@@ -140,7 +139,7 @@ inline Iter_t is_stable_sorted_backward(Iter_t first, Iter_t last,
|
||||
#endif
|
||||
if ((last - first) < 2) return first;
|
||||
Iter_t itaux = last - 1;
|
||||
while (itaux != first and not comp(*itaux, *(itaux - 1))) {--itaux; };
|
||||
while (itaux != first && ! comp(*itaux, *(itaux - 1))) {--itaux; };
|
||||
return itaux;
|
||||
}
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -163,7 +162,7 @@ inline Iter_t is_reverse_stable_sorted_backward (Iter_t first, Iter_t last,
|
||||
#endif
|
||||
if ((last - first) < 2) return first;
|
||||
Iter_t itaux = last - 1;
|
||||
for (; itaux != first and comp(*itaux, *(itaux - 1)); --itaux);
|
||||
for (; itaux != first && comp(*itaux, *(itaux - 1)); --itaux);
|
||||
return itaux;
|
||||
}
|
||||
|
||||
@@ -188,13 +187,13 @@ size_t number_stable_sorted_backward (Iter_t first, Iter_t last,
|
||||
#endif
|
||||
if ((last - first) < 2) return 0;
|
||||
Iter_t itaux = last - 1;
|
||||
while (itaux != first and not comp(*itaux, *(itaux - 1))) {--itaux; };
|
||||
while (itaux != first && ! comp(*itaux, *(itaux - 1))) {--itaux; };
|
||||
size_t nsorted = size_t ( last - itaux);
|
||||
if ( nsorted != 1)
|
||||
return ( nsorted >= min_process)?nsorted: 0 ;
|
||||
|
||||
itaux = last - 1;
|
||||
for (; itaux != first and comp(*itaux, *(itaux - 1)); --itaux);
|
||||
for (; itaux != first && comp(*itaux, *(itaux - 1)); --itaux);
|
||||
nsorted = size_t ( last - itaux);
|
||||
if ( nsorted < min_process) return 0 ;
|
||||
util::reverse ( itaux, last );
|
||||
@@ -238,7 +237,7 @@ inline void internal_sort (const range<Iter1_t> &rng1,
|
||||
range<Iter2_t> rng2_left(rng2.first, rng2.first + nelem),
|
||||
rng2_right(rng2.first + nelem, rng2.last);
|
||||
|
||||
if (nelem <= 32 and (level & 1) == even)
|
||||
if (nelem <= 32 && (level & 1) == even)
|
||||
{
|
||||
insert_sort(rng1_left.first, rng1_left.last, comp);
|
||||
insert_sort(rng1_right.first, rng1_right.last, comp);
|
||||
|
||||
@@ -13,7 +13,6 @@
|
||||
#ifndef __BOOST_SORT_COMMON_UTIL_MERGE_HPP
|
||||
#define __BOOST_SORT_COMMON_UTIL_MERGE_HPP
|
||||
|
||||
#include <ciso646>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include <iterator>
|
||||
@@ -107,7 +106,7 @@ static Iter3_t merge(Iter1_t buf1, const Iter1_t end_buf1, Iter2_t buf2,
|
||||
if (buf1 == end_buf1) return move_forward(buf_out, buf2, end_buf2);
|
||||
if (buf2 == end_buf2) return move_forward(buf_out, buf1, end_buf1);
|
||||
|
||||
if (not comp(*buf2, *(end_buf1 - 1)))
|
||||
if (! comp(*buf2, *(end_buf1 - 1)))
|
||||
{
|
||||
Iter3_t mid = move_forward(buf_out, buf1, end_buf1);
|
||||
return move_forward(mid, buf2, end_buf2);
|
||||
@@ -119,9 +118,9 @@ static Iter3_t merge(Iter1_t buf1, const Iter1_t end_buf1, Iter2_t buf2,
|
||||
return move_forward(mid, buf1, end_buf1);
|
||||
};
|
||||
};
|
||||
while ((buf1 != end_buf1) and (buf2 != end_buf2))
|
||||
while ((buf1 != end_buf1) && (buf2 != end_buf2))
|
||||
{
|
||||
*(buf_out++) = (not comp(*buf2, *buf1)) ?
|
||||
*(buf_out++) = (! comp(*buf2, *buf1)) ?
|
||||
std::move(*(buf1++)) : std::move(*(buf2++));
|
||||
};
|
||||
|
||||
@@ -168,7 +167,7 @@ static Value_t *merge_construct(Iter1_t first1, const Iter1_t last1,
|
||||
if (first1 == last1) return move_construct(it_out, first2, last2);
|
||||
if (first2 == last2) return move_construct(it_out, first1, last1);
|
||||
|
||||
if (not comp(*first2, *(last1 - 1)))
|
||||
if (! comp(*first2, *(last1 - 1)))
|
||||
{
|
||||
Value_t* mid = move_construct(it_out, first1, last1);
|
||||
return move_construct(mid, first2, last2);
|
||||
@@ -180,10 +179,10 @@ static Value_t *merge_construct(Iter1_t first1, const Iter1_t last1,
|
||||
return move_construct(mid, first1, last1);
|
||||
};
|
||||
};
|
||||
while (first1 != last1 and first2 != last2)
|
||||
while (first1 != last1 && first2 != last2)
|
||||
{
|
||||
construct_object((it_out++),
|
||||
(not comp(*first2, *first1)) ?
|
||||
(! comp(*first2, *first1)) ?
|
||||
std::move(*(first1++)) :
|
||||
std::move(*(first2++)));
|
||||
};
|
||||
@@ -232,7 +231,7 @@ static Iter2_t merge_half(Iter1_t buf1, const Iter1_t end_buf1, Iter2_t buf2,
|
||||
if (buf1 == end_buf1) return end_buf2;
|
||||
if (buf2 == end_buf2) return move_forward(buf_out, buf1, end_buf1);
|
||||
|
||||
if (not comp(*buf2, *(end_buf1 - 1)))
|
||||
if (! comp(*buf2, *(end_buf1 - 1)))
|
||||
{
|
||||
move_forward(buf_out, buf1, end_buf1);
|
||||
return end_buf2;
|
||||
@@ -244,9 +243,9 @@ static Iter2_t merge_half(Iter1_t buf1, const Iter1_t end_buf1, Iter2_t buf2,
|
||||
return move_forward(mid, buf1, end_buf1);
|
||||
};
|
||||
};
|
||||
while ((buf1 != end_buf1) and (buf2 != end_buf2))
|
||||
while ((buf1 != end_buf1) && (buf2 != end_buf2))
|
||||
{
|
||||
*(buf_out++) = (not comp(*buf2, *buf1)) ?
|
||||
*(buf_out++) = (! comp(*buf2, *buf1)) ?
|
||||
std::move(*(buf1++)) : std::move(*(buf2++));
|
||||
};
|
||||
return (buf2 == end_buf2)? move_forward(buf_out, buf1, end_buf1) : end_buf2;
|
||||
@@ -295,7 +294,7 @@ static Iter2_t merge_half_backward(Iter1_t buf1, Iter1_t end_buf1, Iter2_t buf2,
|
||||
if (buf1 == end_buf1)
|
||||
return here::move_backward(end_buf_out, buf2, end_buf2);
|
||||
|
||||
if (not comp(*buf2, *(end_buf1 - 1)))
|
||||
if (! comp(*buf2, *(end_buf1 - 1)))
|
||||
{
|
||||
here::move_backward(end_buf_out, buf2, end_buf2);
|
||||
return buf1;
|
||||
@@ -307,10 +306,10 @@ static Iter2_t merge_half_backward(Iter1_t buf1, Iter1_t end_buf1, Iter2_t buf2,
|
||||
return here::move_backward(mid, buf2, end_buf2);
|
||||
};
|
||||
};
|
||||
while ((buf1 != end_buf1) and (buf2 != end_buf2))
|
||||
while ((buf1 != end_buf1) && (buf2 != end_buf2))
|
||||
{
|
||||
*(--end_buf_out) =
|
||||
(not comp(*(end_buf2 - 1), *(end_buf1 - 1))) ?
|
||||
(! comp(*(end_buf2 - 1), *(end_buf1 - 1))) ?
|
||||
std::move(*(--end_buf2)):
|
||||
std::move(*(--end_buf1));
|
||||
};
|
||||
@@ -352,19 +351,19 @@ static bool merge_uncontiguous(Iter1_t src1, const Iter1_t end_src1,
|
||||
//-------------------------------------------------------------------------
|
||||
// Code
|
||||
//-------------------------------------------------------------------------
|
||||
if (src1 == end_src1 or src2 == end_src2
|
||||
or not comp(*src2, *(end_src1 - 1))) return true;
|
||||
if (src1 == end_src1 || src2 == end_src2
|
||||
|| ! comp(*src2, *(end_src1 - 1))) return true;
|
||||
|
||||
while (src1 != end_src1 and not comp(*src2, *src1))
|
||||
while (src1 != end_src1 && ! comp(*src2, *src1))
|
||||
++src1;
|
||||
|
||||
Iter3_t const end_aux = aux + (end_src1 - src1);
|
||||
Iter2_t src2_first = src2;
|
||||
move_forward(aux, src1, end_src1);
|
||||
|
||||
while ((src1 != end_src1) and (src2 != end_src2))
|
||||
while ((src1 != end_src1) && (src2 != end_src2))
|
||||
{
|
||||
*(src1++) = std::move((not comp(*src2, *aux)) ? *(aux++) : *(src2++));
|
||||
*(src1++) = std::move((! comp(*src2, *aux)) ? *(aux++) : *(src2++));
|
||||
}
|
||||
|
||||
if (src2 == end_src2)
|
||||
@@ -409,11 +408,11 @@ static bool merge_contiguous(Iter1_t src1, Iter1_t src2, Iter1_t end_src2,
|
||||
//-------------------------------------------------------------------------
|
||||
// Code
|
||||
//-------------------------------------------------------------------------
|
||||
if (src1 == src2 or src2 == end_src2 or not comp(*src2, *(src2 - 1)))
|
||||
if (src1 == src2 || src2 == end_src2 || ! comp(*src2, *(src2 - 1)))
|
||||
return true;
|
||||
|
||||
Iter1_t end_src1 = src2;
|
||||
while (src1 != end_src1 and not comp(*src2, *src1))
|
||||
while (src1 != end_src1 && ! comp(*src2, *src1))
|
||||
++src1;
|
||||
|
||||
if (src1 == end_src1) return false;
|
||||
@@ -460,7 +459,7 @@ static bool merge_circular(Iter1_t buf1, Iter1_t end_buf1, Iter2_t buf2,
|
||||
assert ( circ.free_size() >= size_t ((end_buf1-buf1) + (end_buf2-buf2)));
|
||||
#endif
|
||||
|
||||
if (not comp(*buf2, *(end_buf1 - 1)))
|
||||
if (! comp(*buf2, *(end_buf1 - 1)))
|
||||
{
|
||||
circ.push_move_back(buf1, (end_buf1 - buf1));
|
||||
it1_out = end_buf1;
|
||||
@@ -474,7 +473,7 @@ static bool merge_circular(Iter1_t buf1, Iter1_t end_buf1, Iter2_t buf2,
|
||||
it2_out = end_buf2;
|
||||
return false;
|
||||
}
|
||||
while (buf1 != end_buf1 and buf2 != end_buf2)
|
||||
while (buf1 != end_buf1 && buf2 != end_buf2)
|
||||
{
|
||||
circ.push_back(comp(*buf2, *buf1) ? std::move(*(buf2++))
|
||||
: std::move(*(buf1++)));
|
||||
|
||||
@@ -13,7 +13,6 @@
|
||||
#ifndef __BOOST_SORT_FLAT_STABLE_SORT_HPP
|
||||
#define __BOOST_SORT_FLAT_STABLE_SORT_HPP
|
||||
|
||||
#include <ciso646>
|
||||
#include <cstdlib>
|
||||
#include <functional>
|
||||
#include <iterator>
|
||||
@@ -110,9 +109,10 @@ public:
|
||||
//----------------------------------------------------------------------------
|
||||
//
|
||||
//------------------------------------------------------------------------
|
||||
// function :
|
||||
/// @brief :
|
||||
/// @param Pos :
|
||||
// @fn divide
|
||||
/// @brief Divide a big list of blocks in two parts to be sorted and merged
|
||||
/// @param itx_first iterator to the first element in the index
|
||||
/// @param itx_last itarator to to the after the last element in the index
|
||||
/// @return
|
||||
//------------------------------------------------------------------------
|
||||
template <class Iter_t, typename Compare, uint32_t Power2>
|
||||
@@ -135,18 +135,17 @@ void flat_stable_sort <Iter_t, Compare, Power2>
|
||||
};
|
||||
//
|
||||
//------------------------------------------------------------------------
|
||||
// function : sort_small
|
||||
/// @brief :
|
||||
/// @param
|
||||
/// @param
|
||||
/// @param
|
||||
// @fn sort_small
|
||||
/// @brief sort an small number of blocks
|
||||
/// @param itx_first iterator to the first element in the index
|
||||
/// @param itx_last itarator to to the after the last element in the index
|
||||
//------------------------------------------------------------------------
|
||||
template <class Iter_t, typename Compare, uint32_t Power2>
|
||||
void flat_stable_sort <Iter_t, Compare, Power2>
|
||||
::sort_small(it_index itx_first, it_index itx_last)
|
||||
{
|
||||
size_t nblock = size_t(itx_last - itx_first);
|
||||
assert(nblock > 0 and nblock < 5);
|
||||
assert(nblock > 0 && nblock < 5);
|
||||
value_t *paux = ptr_circ->get_buffer();
|
||||
range_it rng_data = get_group_range(*itx_first, nblock);
|
||||
|
||||
@@ -172,7 +171,7 @@ void flat_stable_sort <Iter_t, Compare, Power2>
|
||||
};
|
||||
//
|
||||
//------------------------------------------------------------------------
|
||||
// function : is_sorted_forward
|
||||
// @fn is_sorted_forward
|
||||
/// @brief : return if the data are ordered,
|
||||
/// @param itx_first : iterator to the first block in the index
|
||||
/// @param itx_last : iterator to the last block in the index
|
||||
@@ -213,7 +212,7 @@ bool flat_stable_sort <Iter_t, Compare, Power2>
|
||||
};
|
||||
//
|
||||
//------------------------------------------------------------------------
|
||||
// function : is_sorted_backward
|
||||
// @fn is_sorted_backward
|
||||
/// @brief : return if the data are ordered,
|
||||
/// @param itx_first : iterator to the first block in the index
|
||||
/// @param itx_last : iterator to the last block in the index
|
||||
@@ -260,7 +259,7 @@ namespace bscu = boost::sort::common::util;
|
||||
namespace flat = boost::sort::flat_internal;
|
||||
//
|
||||
///---------------------------------------------------------------------------
|
||||
// function flat_stable_sort
|
||||
// @fn flat_stable_sort
|
||||
/// @brief This class is select the block size in the block_indirect_sort
|
||||
/// algorithm depending of the type and size of the data to sort
|
||||
///
|
||||
@@ -285,7 +284,7 @@ struct block_size_fss
|
||||
|
||||
//
|
||||
///---------------------------------------------------------------------------
|
||||
// function flat_stable_sort
|
||||
// @fn flat_stable_sort
|
||||
/// @brief This class is select the block size in the flat_stable_sort
|
||||
/// algorithm depending of the type and size of the data to sort
|
||||
///
|
||||
|
||||
@@ -13,7 +13,6 @@
|
||||
#ifndef __BOOST_SORT_INTROSORT_DETAIL_INSERT_SORT_HPP
|
||||
#define __BOOST_SORT_INTROSORT_DETAIL_INSERT_SORT_HPP
|
||||
|
||||
#include <ciso646>
|
||||
#include <functional>
|
||||
#include <iterator>
|
||||
#include <algorithm>
|
||||
@@ -51,7 +50,7 @@ static void insert_sort (Iter_t first, Iter_t last,
|
||||
value_t Aux = std::move (*it_examine);
|
||||
Iter_t it_insertion = it_examine;
|
||||
|
||||
while (it_insertion != first and comp (Aux, *(it_insertion - 1)))
|
||||
while (it_insertion != first && comp (Aux, *(it_insertion - 1)))
|
||||
{
|
||||
*it_insertion = std::move (*(it_insertion - 1));
|
||||
--it_insertion;
|
||||
|
||||
Reference in New Issue
Block a user