void TestRingBuffer::Do()
{
char_t ch = '\0';
int32_t num = 0;
RingBuffer rbuff(16);
rbuff.PutInt32(1);
rbuff.GetInt32(num);
assertEquals(1, num);
rbuff.PutInt32(2);
rbuff.PutInt32(3);
rbuff.PutByte('n');
rbuff.PutInt32(5);
rbuff.PutInt32(6);
rbuff.GetInt32(num);
assertEquals(2, num);
rbuff.GetInt32(num);
assertEquals(3, num);
rbuff.GetByte(ch);
assertEquals('n', ch);
rbuff.GetInt32(num);
assertEquals(5, num);
}
void mpi::ostream:: put( const void *buff, size_t size, size_t &done)
{
assert(!(0==buff&&size>0));
done=0;
if(fp)
{
assert(MPI.IsFirst);
//-- master writes its buffer
fp->save(buff, size);
MPI_Status status;
// then append other buffers
for(int r=1; r < MPI.CommWorldSize; ++r)
{
//-- recv authentication
if( MPI.Recv<io_key_t>(r, tag, MPI_COMM_WORLD, status) != key )
throw yocto::exception("MPI I/O: invalid key during put buffer");
//-- recv length
const size_t rsize = MPI.Recv<size_t>(r,tag,MPI_COMM_WORLD,status);
//-- recv buffer
memory::buffer_of<char, memory::global> rbuff( rsize ); assert( rbuff.length() == rsize);
MPI.Recv( rbuff.rw(), rsize, MPI_BYTE, r, tag, MPI_COMM_WORLD, status);
//-- write it !
*fp << rbuff;
}
// all done
done = size;
}
else
{
//-- send authentication
MPI.Send<io_key_t>(key,0,tag,MPI_COMM_WORLD);
//-- send buffer length
MPI.Send<size_t>(size,0,tag,MPI_COMM_WORLD);
//-- send buffer
MPI.Send(buff, size, MPI_BYTE, 0, tag, MPI_COMM_WORLD);
done = size;
}
}
ibis::table*
ibis::jRange::select(const ibis::table::stringArray& colnames) const {
ibis::table *res = 0;
if (nrows < 0) {
int64_t ierr = count();
if (ierr < 0) {
LOGGER(ibis::gVerbose > 0)
<< "Warning -- jRange::count failed with error code"
<< ierr;
return res;
}
}
if (valr_ == 0 || orderr_ == 0 || vals_ == 0 || orders_ == 0 ||
orderr_->size() != maskr_.cnt() || orders_->size() != masks_.cnt()) {
LOGGER(ibis::gVerbose > 0)
<< "Warning -- jRange::select failed to evaluate the join";
return res;
}
if (colnames.empty() || nrows == 0) {
std::string nm = ibis::util::shortName(desc_);
res = new ibis::tabula(nm.c_str(), desc_.c_str(), nrows);
return res;
}
const uint32_t ncols = colnames.size();
std::string evt;
evt = "select ";
evt += colnames[0];
for (uint32_t j = 1; j < ncols; ++ j) {
evt += ", ";
evt += colnames[j];
}
if ((desc_[0] != 'F' && desc_[0] != 'f') ||
(desc_[1] != 'R' && desc_[1] != 'r') ||
(desc_[2] != 'O' && desc_[2] != 'o') ||
(desc_[3] != 'M' && desc_[3] != 'm'))
evt += " for ";
else
evt += ' ';
evt += desc_;
ibis::util::timer mytimer(evt.c_str());
std::map<const char*, uint32_t, ibis::lessi> namesToPos;
std::vector<uint32_t> ipToPos(colnames.size());
std::vector<const ibis::column*> ircol, iscol;
std::vector<const ibis::dictionary*> cats(colnames.size(), 0);
// identify the names from the two data partitions
for (uint32_t j = 0; j < ncols; ++ j) {
ipToPos[j] = ncols+1;
const char* cn = colnames[j];
std::string tname;
while (*cn != 0 && *cn != '.') {
tname += *cn;
++ cn;
}
if (*cn == '.') {
++ cn;
}
else { // did not find '.'
tname.erase();
cn = colnames[j];
}
int match = -1; // 0 ==> partr_, 1 ==> parts_
if (! tname.empty()) {
match = frm_->position(tname.c_str());
if (match >= static_cast<long>(frm_->size())) {
if (stricmp(tname.c_str(), partr_.name()) == 0) {
match = 0;
}
else if (stricmp(tname.c_str(), parts_.name()) == 0) {
match = 1;
}
}
}
if (match == 0) {
const ibis::column *col = partr_.getColumn(cn);
if (col != 0) {
namesToPos[colnames[j]] = j;
ipToPos[j] = ircol.size();
ircol.push_back(col);
if (col->type() == ibis::CATEGORY) {
const ibis::category *cat =
static_cast<const ibis::category*>(col);
cats[j] = cat->getDictionary();
}
else if (col->type() == ibis::UINT) {
const ibis::bord::column *bc =
dynamic_cast<const ibis::bord::column*>(col);
if (bc != 0) {
cats[j] = bc->getDictionary();
}
}
}
else {
LOGGER(ibis::gVerbose > 0)
<< "Warning -- " << evt << " can not find column named \""
<< colnames[j] << "\" in data partition \"" << partr_.name()
<< "\"";
return res;
}
}
else if (match == 1) {
const ibis::column *col = parts_.getColumn(cn);
if (col != 0) {
namesToPos[colnames[j]] = j;
ipToPos[j] = ncols - iscol.size();
iscol.push_back(col);
if (col->type() == ibis::CATEGORY) {
const ibis::category *cat =
static_cast<const ibis::category*>(col);
cats[j] = cat->getDictionary();
}
else if (col->type() == ibis::UINT) {
const ibis::bord::column *bc =
dynamic_cast<const ibis::bord::column*>(col);
if (bc != 0) {
cats[j] = bc->getDictionary();
}
}
}
else {
LOGGER(ibis::gVerbose > 0)
<< "Warning -- " << evt << " can not find column named \""
<< colnames[j] << "\" in data partition \""
<< parts_.name() << "\"";
return res;
}
}
else { // not prefixed with a data partition name
cn = colnames[j];
const ibis::column* col = partr_.getColumn(cn);
if (col != 0) {
ipToPos[j] = ircol.size();
ircol.push_back(col);
if (col->type() == ibis::CATEGORY) {
const ibis::category *cat =
static_cast<const ibis::category*>(col);
cats[j] = cat->getDictionary();
}
else if (col->type() == ibis::UINT) {
const ibis::bord::column *bc =
dynamic_cast<const ibis::bord::column*>(col);
if (bc != 0) {
cats[j] = bc->getDictionary();
}
}
LOGGER(ibis::gVerbose > 3)
<< evt << " encountered a column name ("
<< colnames[j] << ") that does not start with a data "
"partition name, assume it is for \"" << partr_.name()
<< "\"";
}
else {
col = parts_.getColumn(cn);
if (col != 0) {
ipToPos[j] = ncols - iscol.size();
iscol.push_back(col);
if (col->type() == ibis::CATEGORY) {
const ibis::category *cat =
static_cast<const ibis::category*>(col);
cats[j] = cat->getDictionary();
}
else if (col->type() == ibis::UINT) {
const ibis::bord::column *bc =
dynamic_cast<const ibis::bord::column*>(col);
if (bc != 0) {
cats[j] = bc->getDictionary();
}
}
LOGGER(ibis::gVerbose > 1)
<< evt << " encountered a column name (" << colnames[j]
<< ") that does not start with a data partition name, "
"assume it is for \"" << parts_.name() << "\"";
}
else {
LOGGER(ibis::gVerbose > 0)
<< "Warning -- " << evt << " encountered a name ("
<< colnames[j] << ") that does not start with a data "
"partition name";
return res;
}
}
}
} // for (uint32_t j = 0; j < ncols;
LOGGER(ibis::gVerbose > 3)
<< evt << " -- found " << ircol.size()
<< " column" << (ircol.size() > 1 ? "s" : "") << " from "
<< partr_.name() << " and " << iscol.size() << " column"
<< (iscol.size() > 1 ? "s" : "") << " from " << parts_.name();
// change Pos values for columns in S to have offset ircol.size()
for (uint32_t j = 0; j < ncols; ++j) {
if (ipToPos[j] <= ncols && ipToPos[j] >= ircol.size())
ipToPos[j] = (ncols - ipToPos[j]) + ircol.size();
}
ibis::table::typeArray rtypes(ircol.size(), ibis::UNKNOWN_TYPE);
ibis::table::bufferArray rbuff(ircol.size(), 0);
IBIS_BLOCK_GUARD(ibis::table::freeBuffers, ibis::util::ref(rbuff),
ibis::util::ref(rtypes));
ibis::table::typeArray stypes(iscol.size(), ibis::UNKNOWN_TYPE);
ibis::table::bufferArray sbuff(iscol.size(), 0);
IBIS_BLOCK_GUARD(ibis::table::freeBuffers, ibis::util::ref(sbuff),
ibis::util::ref(stypes));
bool sane = true;
// retrieve values from r_
for (uint32_t j = 0; sane && j < ircol.size(); ++ j) {
rtypes[j] = ircol[j]->type();
switch (ircol[j]->type()) {
case ibis::BYTE:
rbuff[j] = ircol[j]->selectBytes(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<signed char>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::UBYTE:
rbuff[j] = ircol[j]->selectUBytes(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<unsigned char>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::SHORT:
rbuff[j] = ircol[j]->selectShorts(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<int16_t>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::USHORT:
rbuff[j] = ircol[j]->selectUShorts(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<uint16_t>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::INT:
rbuff[j] = ircol[j]->selectInts(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<int32_t>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::UINT:
rbuff[j] = ircol[j]->selectUInts(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<uint32_t>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::LONG:
rbuff[j] = ircol[j]->selectLongs(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<int64_t>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::ULONG:
rbuff[j] = ircol[j]->selectULongs(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<uint64_t>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::FLOAT:
rbuff[j] = ircol[j]->selectFloats(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<float>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::DOUBLE:
rbuff[j] = ircol[j]->selectDoubles(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<double>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
case ibis::TEXT:
case ibis::CATEGORY:
rbuff[j] = ircol[j]->selectStrings(maskr_);
if (rbuff[j] != 0)
ibis::util::reorder
(*static_cast<std::vector<std::string>*>(rbuff[j]),
*orderr_);
else
sane = false;
break;
default:
sane = false;
rbuff[j] = 0;
LOGGER(ibis::gVerbose > 1)
<< "Warning -- jRange::select does not support column "
"type " << ibis::TYPESTRING[(int)ircol[j]->type()]
<< " (name = " << partr_.name() << "." << ircol[j]->name()
<< ")";
break;
}
}
if (! sane) {
return res;
}
// retrieve values from parts_
for (uint32_t j = 0; sane && j < iscol.size(); ++ j) {
stypes[j] = iscol[j]->type();
switch (iscol[j]->type()) {
case ibis::BYTE:
sbuff[j] = iscol[j]->selectBytes(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<signed char>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::UBYTE:
sbuff[j] = iscol[j]->selectUBytes(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<unsigned char>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::SHORT:
sbuff[j] = iscol[j]->selectShorts(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<int16_t>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::USHORT:
sbuff[j] = iscol[j]->selectUShorts(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<uint16_t>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::INT:
sbuff[j] = iscol[j]->selectInts(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<int32_t>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::UINT:
sbuff[j] = iscol[j]->selectUInts(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<uint32_t>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::LONG:
sbuff[j] = iscol[j]->selectLongs(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<int64_t>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::ULONG:
sbuff[j] = iscol[j]->selectULongs(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<uint64_t>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::FLOAT:
sbuff[j] = iscol[j]->selectFloats(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<float>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::DOUBLE:
sbuff[j] = iscol[j]->selectDoubles(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<array_t<double>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
case ibis::TEXT:
case ibis::CATEGORY:
sbuff[j] = iscol[j]->selectStrings(masks_);
if (sbuff[j] != 0)
ibis::util::reorder
(*static_cast<std::vector<std::string>*>(sbuff[j]),
*orders_);
else
sane = false;
break;
default:
sane = false;
sbuff[j] = 0;
LOGGER(ibis::gVerbose > 1)
<< "Warning -- jRange::select does not support column "
"type " << ibis::TYPESTRING[(int)iscol[j]->type()]
<< " (name = " << parts_.name() << "." << iscol[j]->name()
<< ")";
break;
}
}
if (! sane) {
return res;
}
/// fill the in-memory buffer
switch (colr_.type()) {
case ibis::BYTE:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<signed char>*>(valr_), rtypes, rbuff,
*static_cast<array_t<signed char>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::UBYTE:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<unsigned char>*>(valr_), rtypes, rbuff,
*static_cast<array_t<unsigned char>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::SHORT:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<int16_t>*>(valr_), rtypes, rbuff,
*static_cast<array_t<int16_t>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::USHORT:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<uint16_t>*>(valr_), rtypes, rbuff,
*static_cast<array_t<uint16_t>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::INT:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<int32_t>*>(valr_), rtypes, rbuff,
*static_cast<array_t<int32_t>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::UINT:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<uint32_t>*>(valr_), rtypes, rbuff,
*static_cast<array_t<uint32_t>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::LONG:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<int64_t>*>(valr_), rtypes, rbuff,
*static_cast<array_t<int64_t>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::ULONG:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<uint64_t>*>(valr_), rtypes, rbuff,
*static_cast<array_t<uint64_t>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::FLOAT:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<float>*>(valr_), rtypes, rbuff,
*static_cast<array_t<float>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
case ibis::DOUBLE:
res = fillResult
(nrows, delta1_, delta2_, evt,
*static_cast<array_t<double>*>(valr_), rtypes, rbuff,
*static_cast<array_t<double>*>(vals_), stypes, sbuff,
colnames, ipToPos);
break;
default:
LOGGER(ibis::gVerbose > 0)
<< "Warning -- " << evt << " can not handle join column of type "
<< ibis::TYPESTRING[(int)colr_.type()];
}
for (unsigned j = 0; j < cats.size(); ++ j) {
if (cats[j] != 0) {
ibis::bord::column *bc = dynamic_cast<ibis::bord::column*>
(static_cast<ibis::bord*>(res)->getColumn(j));
if (bc != 0)
bc->setDictionary(cats[j]);
}
}
return res;
} // ibis::jRange::select
