void hexpi(CloudI::API const & api,
int const command,
std::string const & name,
std::string const & pattern,
void const * const /*request_info*/,
uint32_t const /*request_info_size*/,
void const * const request,
uint32_t const request_size,
uint32_t timeout,
int8_t /*priority*/,
char const * const trans_id,
char const * const pid,
uint32_t const pid_size)
{
uint32_t const * const parameters =
reinterpret_cast<uint32_t const * const>(request);
assert(request_size > (sizeof(uint32_t) * 2));
uint32_t const & iteration_count = parameters[0];
uint32_t const & digit_step = parameters[1];
char const * digit_index =
reinterpret_cast<char const * const>(¶meters[2]);
// perform the work
timer t;
std::ostringstream result;
for (uint32_t i = 0; i < iteration_count; ++i)
{
if (m_stop)
{
return;
}
else
{
std::string pi_sequence;
if (! bbp_pi(m_stop, digit_index,
digit_step * i, pi_sequence))
return;
result << pi_sequence;
}
}
std::string pi_result = result.str();
if (! bbp_pi_verify(digit_index, pi_result))
return;
// insert the elapsed time as a 32 bit float
pi_result.insert(0, " ");
float * elapsed_hours = reinterpret_cast<float *>(
const_cast<char *>(pi_result.c_str()));
*elapsed_hours = static_cast<float>(t.elapsed() / 3600.0);
api.return_(command, name, pattern, "", 0,
pi_result.c_str(), pi_result.size(),
timeout, trans_id, pid, pid_size);
std::cout << "execution never gets here" << std::endl;
}
bool do_work(bool const & abortTask,
uint32_t const,
std::string const &,
std::string const & workInstance,
uint32_t const id,
uint32_t const,
boost::scoped_array<uint8_t> const & taskData,
size_t const taskDataSize,
DatabaseQueryVector const &,
DatabaseQueryVector & queriesOut)
{
// uncomment for random failures that would be deterministic
// based on the work code dependencies
//if (returnFalse())
// return false;
// get task data
assert(taskDataSize > (sizeof(uint32_t) * 2));
uint32_t & iterationCount =
*(reinterpret_cast<uint32_t *>(&taskData[0]));
uint32_t & digitStep =
*(reinterpret_cast<uint32_t *>(&taskData[sizeof(uint32_t)]));
char const * digitIndex =
reinterpret_cast<char const *>(&taskData[sizeof(uint32_t) * 2]);
// perform the work
std::ostringstream result;
for (uint32_t i = 0; i < iterationCount; ++i)
{
if (abortTask)
{
return false;
}
else
{
std::string piSequence;
if (! bbp_pi(abortTask, digitIndex, digitStep * i, piSequence))
return false;
result << piSequence;
}
}
std::string const & piResult = result.str();
if (! verify(digitIndex, piResult))
return false;
// create query to store the results of the work
std::ostringstream resultQuery;
resultQuery <<
"INSERT INTO incoming_results_v3 "
"(digit_index, data) "
"VALUES "
"(" << digitIndex << ", '" << piResult << "');";
queriesOut.push_back(
DatabaseQuery("cloud_data_pgsql.cloudi_tests",
resultQuery.str()));
queriesOut.push_back(
DatabaseQuery("cloud_data_mysql.cloudi_tests",
resultQuery.str()));
resultQuery.str("");
resultQuery <<
"{set, \"" << digitIndex << "\", <<\"" << piResult << "\">>}";
queriesOut.push_back(
DatabaseQuery("cloud_data_memcached.cloudi_tests",
resultQuery.str()));
resultQuery.str("");
resultQuery <<
"{put, \"" << digitIndex << "\", <<\"" << piResult << "\">>}";
queriesOut.push_back(
DatabaseQuery("cloud_data_tokyotyrant.cloudi_tests",
resultQuery.str()));
resultQuery.str("");
resultQuery <<
"{update_document, \"pi_state\","
" [{<<\"" << workInstance << "_" << id << "\">>, "
"<<\"" << digitIndex << "\">>}]}";
queriesOut.push_back(
DatabaseQuery("cloud_data_couchdb.cloudi_tests",
resultQuery.str()));
return true;
}
