TEST(sort_and_merge, trivial) {
sfv_t v;
v.push_back(make_pair("f4", 1.0));
v.push_back(make_pair("f2", 2.0));
v.push_back(make_pair("f4", 3.0));
sort_and_merge(v);
ASSERT_EQ(2u, v.size());
EXPECT_EQ("f2", v[0].first);
EXPECT_EQ(2.0, v[0].second);
EXPECT_EQ("f4", v[1].first);
EXPECT_EQ(4.0, v[1].second);
}
int classifier_serv::train(std::vector<std::pair<std::string, jubatus::datum> > data) {
check_set_config();
int count = 0;
sfv_t v;
fv_converter::datum d;
for (size_t i = 0; i < data.size(); ++i) {
convert<jubatus::datum, fv_converter::datum>(data[i].second, d);
converter_->convert(d, v);
sort_and_merge(v);
wm_.wm_->update_weight(v);
wm_.wm_->get_weight(v);
clsfer_.classifier_->train(v, data[i].first);
count++;
}
// FIXME: send count incrementation to mixer
return count;
}
TEST(sort_and_merge, empty) {
sfv_t v;
sort_and_merge(v);
EXPECT_TRUE(v.empty());
}
int main(int argc, char** argv)
{
size_t _AmountOfElements, _Count;
size_t* _FirstArray, *_SecondArray, *_ThirdArray, *_FirstCopiedArray, *_SecondCopiedArray, *_LastArray;
array* _FirstStructArray, *_SecondStructArray;
struct timespec _Start, _End;
int _Verbose = 0;
if (argc < 2)
{
_AmountOfElements = 10;
}
else
{
_AmountOfElements = atoi(argv[1]);
if (argc > 2) _Verbose = strcmp(argv[2], "-v") == 0 ? 1 : 0;
}
srand(time(NULL)); /* seed srand to be random */
_FirstStructArray = (array*)malloc(sizeof(array));
_SecondStructArray = (array*)malloc(sizeof(array));
_FirstArray = (size_t*)malloc(sizeof(size_t) * _AmountOfElements);
_SecondArray = (size_t*)malloc(sizeof(size_t) * _AmountOfElements);
_ThirdArray = (size_t*)malloc(sizeof(size_t) * (_AmountOfElements * 2) );
_FirstCopiedArray = (size_t*)malloc(sizeof(size_t) * _AmountOfElements);
_SecondCopiedArray = (size_t*)malloc(sizeof(size_t) * _AmountOfElements);
_LastArray = (size_t*)malloc(sizeof(size_t) * (_AmountOfElements * 2));
initialize_array(_FirstArray, _AmountOfElements);
initialize_array(_SecondArray, _AmountOfElements);
memcpy(_FirstCopiedArray, _FirstArray, _AmountOfElements);
memcpy(_SecondCopiedArray, _SecondArray, _AmountOfElements);
memcpy(_LastArray, _FirstArray, _AmountOfElements);
memcpy(_LastArray + _AmountOfElements, _SecondArray, _AmountOfElements);
_FirstStructArray->m_array = _FirstArray;
_FirstStructArray->m_size = _AmountOfElements;
_SecondStructArray->m_array = _SecondArray;
_SecondStructArray->m_size = _AmountOfElements;
hr_timer_start(&_Start);
sort_and_merge_with_threads(_FirstStructArray, _SecondStructArray, _ThirdArray);
hr_timer_stop(&_End);
_FirstStructArray->m_array = _FirstCopiedArray;
_SecondStructArray->m_array = _SecondCopiedArray;
if (_Verbose) for (_Count = 0; _Count < _AmountOfElements; ++_Count) printf("_FirstArray[%d] = %d, _SecondArray[%d] = %d\n", (int)_Count, (int)_FirstArray[_Count], (int)_Count, (int)_SecondArray[_Count]);
printf("Total time to sort and merge with threads = %f.2 milliseconds\n", duration_as_microseconds(&_Start, &_End));
hr_timer_start(&_Start);
sort_and_merge(_FirstStructArray, _SecondStructArray, _ThirdArray);
hr_timer_stop(&_End);
if (_Verbose) for (_Count = 0; _Count < _AmountOfElements; ++_Count) printf("_FirstArray[%d] = %d, _SecondArray[%d] = %d\n", (int)_Count, (int)_FirstArray[_Count], (int)_Count, (int)_SecondArray[_Count]);
printf("Total time to sort and merge without threads = %f.2 milliseconds\n", duration_as_microseconds(&_Start, &_End));
_FirstStructArray->m_array = _LastArray;
hr_timer_start(&_Start);
sort_without_merge(_FirstStructArray);
hr_timer_stop(&_End);
if (_Verbose) for (_Count = 0; _Count < _AmountOfElements; ++_Count) printf("_FirstArray[%d] = %d, _SecondArray[%d] = %d\n", (int)_Count, (int)_FirstArray[_Count], (int)_Count, (int)_SecondArray[_Count]);
printf("Total time to sort without merging = %f.2 milliseconds\n", duration_as_microseconds(&_Start, &_End));
free(_FirstStructArray);
free(_SecondStructArray);
free(_FirstArray);
free(_SecondArray);
free(_ThirdArray);
free(_FirstCopiedArray);
free(_SecondCopiedArray);
free(_LastArray);
}
