132 lines
2.3 KiB
C++
132 lines
2.3 KiB
C++
#include <iostream>
|
|
#include <exception>
|
|
#include <string>
|
|
#include <algorithm>
|
|
|
|
#include <tbb/parallel_for.h>
|
|
#include <tbb/blocked_range.h>
|
|
|
|
static const size_t N = 23;
|
|
|
|
class SubStringFinder
|
|
{
|
|
const std::string str;
|
|
size_t *max_array;
|
|
size_t *pos_array;
|
|
|
|
public:
|
|
void operator() ( const tbb::blocked_range<size_t>& r ) const
|
|
{
|
|
std::cout << "gs:" << r.grainsize() << " b:" << r.begin() << " e:" << r.end() << std::endl;
|
|
std::cout.flush();
|
|
for ( size_t i = r.begin(); i != r.end(); ++i )
|
|
{
|
|
size_t max_size = 0, max_pos = 0;
|
|
for (size_t j = 0; j < str.size(); ++j)
|
|
if (j != i)
|
|
{
|
|
size_t limit = str.size()-std::max(i,j);
|
|
for (size_t k = 0; k < limit; ++k)
|
|
{
|
|
if (str[i + k] != str[j + k])
|
|
break;
|
|
if (k > max_size)
|
|
{
|
|
max_size = k;
|
|
max_pos = j;
|
|
}
|
|
}
|
|
}
|
|
max_array[i] = max_size;
|
|
pos_array[i] = max_pos;
|
|
}
|
|
}
|
|
|
|
SubStringFinder(std::string &s, size_t *m, size_t *p)
|
|
: str(s), max_array(m), pos_array(p)
|
|
{ }
|
|
};
|
|
|
|
int test()
|
|
{
|
|
std::string str[N] = { std::string("a"), std::string("b") };
|
|
|
|
for (size_t i = 2; i < N; ++i)
|
|
str[i] = str[i-1]+str[i-2];
|
|
std::string &to_scan = str[N-1];
|
|
size_t num_elem = to_scan.size();
|
|
|
|
size_t *max = new size_t[num_elem];
|
|
size_t *pos = new size_t[num_elem];
|
|
|
|
tbb::parallel_for( tbb::blocked_range<size_t>(0, num_elem ),
|
|
SubStringFinder( to_scan, max, pos ) );
|
|
|
|
for (size_t i = 0; i < num_elem; ++i)
|
|
std::cout << " " << max[i] << "(" << pos[i] << ")" << std::endl;
|
|
delete[] pos;
|
|
delete[] max;
|
|
return 0;
|
|
}
|
|
|
|
class copy_tracker
|
|
{
|
|
int v;
|
|
public:
|
|
copy_tracker()
|
|
: v(0)
|
|
{
|
|
std::cout << "copy_tracker::copy_tracker()" << std::endl;
|
|
}
|
|
|
|
copy_tracker( copy_tracker& c )
|
|
: v( c.v )
|
|
{
|
|
std::cout << "copy_tracker::copy_tracker( copy_tracker& c )" << std::endl;
|
|
}
|
|
|
|
void echo()
|
|
{
|
|
std::cout << v << std::endl;
|
|
}
|
|
};
|
|
|
|
copy_tracker copy_tracker_by_value()
|
|
{
|
|
return copy_tracker();
|
|
}
|
|
|
|
copy_tracker copy_tracker_by_value2()
|
|
{
|
|
return copy_tracker_by_value();
|
|
}
|
|
|
|
void test_copy_tracker()
|
|
{
|
|
volatile copy_tracker o = copy_tracker_by_value2();
|
|
|
|
}
|
|
|
|
int test_flowgraph()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int main ( void )
|
|
{try{
|
|
|
|
test();
|
|
|
|
test_copy_tracker();
|
|
return 0;
|
|
}
|
|
catch ( const std::exception& e )
|
|
{
|
|
std::cerr << std::endl
|
|
<< "std::exception(\"" << e.what() << "\")." << std::endl;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
std::cerr << std::endl
|
|
<< "unknown exception." << std::endl;
|
|
}} |