void getGlobalCounts()
{
if (container.queryLocalOrGrouped())
return;
CMessageBuffer msg;
if (!receiveMsg(msg, 0, mpTag))
return;
memcpy(totalCounts, msg.readDirect(numSets*sizeof(rowcount_t)), numSets*sizeof(rowcount_t));
memcpy(priorCounts, msg.readDirect(numSets*sizeof(rowcount_t)), numSets*sizeof(rowcount_t));
}
const void *getResult(const void *firstRow)
{
IHThorAggregateArg *helper = (IHThorAggregateArg *)baseHelper.get();
unsigned numPartialResults = container.queryJob().querySlaves();
if (1 == numPartialResults)
return firstRow;
CThorExpandingRowArray partialResults(*this, this, true, stableSort_none, true, numPartialResults);
if (hadElement)
partialResults.setRow(0, firstRow);
--numPartialResults;
size32_t sz;
while (numPartialResults--)
{
CMessageBuffer msg;
rank_t sender;
if (!receiveMsg(msg, RANK_ALL, mpTag, &sender))
return NULL;
if (abortSoon)
return NULL;
msg.read(sz);
if (sz)
{
assertex(NULL == partialResults.query(sender-1));
CThorStreamDeserializerSource mds(sz, msg.readDirect(sz));
RtlDynamicRowBuilder rowBuilder(queryRowAllocator());
size32_t sz = queryRowDeserializer()->deserialize(rowBuilder, mds);
partialResults.setRow(sender-1, rowBuilder.finalizeRowClear(sz));
}
}
RtlDynamicRowBuilder rowBuilder(queryRowAllocator(), false);
bool first = true;
numPartialResults = container.queryJob().querySlaves();
unsigned p=0;
for (;p<numPartialResults; p++)
{
const void *row = partialResults.query(p);
if (row)
{
if (first)
{
first = false;
sz = cloneRow(rowBuilder, row, queryRowMetaData());
}
else
sz = helper->mergeAggregate(rowBuilder, row);
}
}
if (first)
sz = helper->clearAggregate(rowBuilder);
return rowBuilder.finalizeRowClear(sz);
}
const void *getFirst() // for global, not called on 1st slave
{
CMessageBuffer msg;
if (!queryJobChannel().queryJobComm().recv(msg, queryJobChannel().queryMyRank()-1, mpTag)) // previous node
return NULL;
msg.read(count);
size32_t r = msg.remaining();
OwnedConstThorRow firstRow;
if (r)
firstRow.deserialize(inrowif, r, msg.readDirect(r));
return firstRow.getClear();
}
void getTallies() // NB: not called on first node.
{
CMessageBuffer msg;
if (!receiveMsg(msg, queryJobChannel().queryMyRank()-1, mpTag))
return;
memcpy(tallies, msg.readDirect(numSets*sizeof(unsigned)), numSets*sizeof(unsigned));
#if THOR_TRACE_LEVEL >= 5
StringBuffer s;
unsigned idx=0;
for (; idx<numSets; idx++)
s.append("[").append(tallies[idx]).append("]");
ActPrintLog("CHOOSESETS: Incoming count = %s", s.str());
#endif
}
const void *CPartialResultAggregator::getResult()
{
CMessageBuffer mb;
if (activity.receiveMsg(mb, 0, activity.queryMpTag()))
{
if (mb.length())
{
CThorStreamDeserializerSource ds(mb.length(), mb.readDirect(mb.length()));
RtlDynamicRowBuilder rowBuilder(activity.queryRowAllocator());
size32_t sz = activity.queryRowDeserializer()->deserialize(rowBuilder,ds);
return rowBuilder.finalizeRowClear(sz);
}
}
return NULL;
}
const void * getResult()
{
CMessageBuffer mb;
if (receiveMsg(mb, 0, mpTag)) {
size32_t sz;
mb.read(sz);
if (sz) {
CThorStreamDeserializerSource ds(sz,mb.readDirect(sz));
RtlDynamicRowBuilder rowBuilder(queryRowAllocator());
size32_t sz = queryRowDeserializer()->deserialize(rowBuilder,ds);
return rowBuilder.finalizeRowClear(sz);
}
}
return NULL;
}
bool RemoteDataSource::fetchRawRow(MemoryBuffer & out, __int64 offset)
{
CMessageBuffer msg;
msg.setEndian(__BIG_ENDIAN);
msg.append(FVCMDfetchraw);
msg.append(id);
msg.append(offset);
sendReceive(msg);
bool ok;
msg.read(ok);
if (!ok) return false;
size32_t len;
msg.read(len);
out.append(len, msg.readDirect(len));
return true;
}
const void *getAggregate(CActivityBase &activity, unsigned partialResults, IRowInterfaces &rowIf, IHThorCompoundAggregateExtra &aggHelper, mptag_t mpTag)
{
// JCSMORE - pity this isn't common routine with similar one in aggregate, but helper is not common
CThorRowArray slaveResults;
slaveResults.ensure(partialResults);
unsigned _partialResults = partialResults;
while (_partialResults--)
{
CMessageBuffer mb;
rank_t sender;
if (!activity.receiveMsg(mb, RANK_ALL, mpTag, &sender)) return false;
if (activity.queryAbortSoon()) return 0;
if (mb.length())
{
CThorStreamDeserializerSource ds(mb.length(), mb.readDirect(mb.length()));
RtlDynamicRowBuilder rowBuilder(rowIf.queryRowAllocator());
size32_t sz = rowIf.queryRowDeserializer()->deserialize(rowBuilder, ds);
slaveResults.setRow(sender-1, rowBuilder.finalizeRowClear(sz));
}
}
RtlDynamicRowBuilder result(rowIf.queryRowAllocator(), false);
size32_t sz;
bool first = true;
_partialResults = 0;
for (;_partialResults<partialResults; _partialResults++)
{
const void *partialResult = slaveResults.item(_partialResults);
if (partialResult)
{
if (first)
{
first = false;
sz = cloneRow(result, slaveResults.item(_partialResults), rowIf.queryRowMetaData());
}
else
sz = aggHelper.mergeAggregate(result, partialResult);
}
}
if (first)
sz = aggHelper.clearAggregate(result);
return result.finalizeRowClear(sz);
}
void process()
{
CWorkUnitWriteMasterBase::process();
unsigned nslaves = container.queryJob().querySlaves();
CMessageBuffer mb;
unsigned s=0;
for (; s<nslaves; s++)
{
loop
{
if (!container.queryJob().queryJobComm().send(mb, s+1, mpTag)) return;
if (!receiveMsg(mb, s+1, mpTag)) return;
if (0 == mb.length())
break;
unsigned numGot;
mb.read(numGot);
unsigned l=mb.remaining();
if (workunitWriteLimit && totalSize+resultData.length()+l > workunitWriteLimit)
{
StringBuffer errMsg("Dataset too large to output to workunit (limit is set to ");
errMsg.append(workunitWriteLimit/0x100000).append(") megabytes, in result (");
if (resultName.length())
errMsg.append("name=").append(resultName);
else
errMsg.append("sequence=").append(resultSeq);
errMsg.append(")");
throw MakeThorException(TE_WorkUnitWriteLimitExceeded, "%s", errMsg.str());
}
resultData.append(l, mb.readDirect(l));
mb.clear();
numResults += numGot;
if (-1 != flushThreshold && resultData.length() >= (unsigned)flushThreshold)
flushResults();
}
}
flushResults(true);
}
virtual void process()
{
CMasterActivity::process();
bool results = false;
unsigned nslaves = container.queryJob().querySlaves();
while (nslaves--)
{
CMessageBuffer mb;
if (abortSoon || !receiveMsg(mb, RANK_ALL, replyTag, NULL)) break;
StringBuffer str;
mb.getSender().getUrlStr(str);
size32_t sz;
mb.read(sz);
if (sz)
{
if (results)
throw MakeThorException(TE_UnexpectedMultipleSlaveResults, "Received greater than one result from slaves");
IHThorRemoteResultArg *helper = (IHThorRemoteResultArg *)queryHelper();
Owned<IThorRowInterfaces> resultRowIf = createRowInterfaces(helper->queryOutputMeta());
CThorStreamDeserializerSource mds(sz, mb.readDirect(sz));
RtlDynamicRowBuilder rowBuilder(resultRowIf->queryRowAllocator());
size32_t sz = resultRowIf->queryRowDeserializer()->deserialize(rowBuilder, mds);
OwnedConstThorRow result = rowBuilder.finalizeRowClear(sz);
helper->sendResult(result);
results = true;
}
}
if (!results && !abortSoon)
{
ActPrintLog("WARNING: no results");
IHThorRemoteResultArg *helper = (IHThorRemoteResultArg *)queryHelper();
//helper->sendResult(NULL);
// Jake I think this always cores (so raise exception instead)
throw MakeThorException(TE_UnexpectedMultipleSlaveResults, "Received no results from slaves");
}
}
bool SortSlaveMP::marshall(ISortSlaveMP &slave, ICommunicator* comm, mptag_t tag)
{
CMessageBuffer mb;
rank_t sender;
comm->recv(mb,0,tag,&sender); // NB only recv from master
if (mb.length()==0) {
PROGLOG("Stopping SortSlaveMP::marshall");
return false;
}
byte fn;
mb.read(fn);
CMessageBuffer mbout;
mbout.init(mb.getSender(),tag,mb.getReplyTag());
byte okout=1;
mbout.append(okout);
#ifdef FULLTRACE
StringBuffer tmp1;
PROGLOG(">SortSlaveMP::marshall(%d) got %d from %s tag %d replytag %d",(int)fn, mb.length(), mb.getSender().getUrlStr(tmp1).str(),tag,mb.getReplyTag());
#endif
bool replydone = false;
Owned<IException> err;
try {
switch ((MPSlaveFunctions)(int)fn) {
case FN_Connect: {
unsigned _part;
unsigned _numnodes;
mb.read(_part).read(_numnodes);
bool ret = slave.Connect(_part,_numnodes);
mbout.append(ret);
}
break;
case FN_StartGather: {
slave.StartGather();
}
break;
case FN_GetGatherInfo: {
bool hasserializer;
mb.read(hasserializer);
rowcount_t numlocal;
unsigned overflowscale;
offset_t totalsize;
slave.GetGatherInfo(numlocal,totalsize,overflowscale,hasserializer);
mbout.append(numlocal).append(totalsize).append(overflowscale);
}
break;
case FN_GetMinMax: {
size32_t keybuffsize;
void *keybuff;
size32_t avrecsize;
rowcount_t ret = slave.GetMinMax(keybuffsize,keybuff,avrecsize);
serializeblk(mbout,keybuffsize,keybuff).append(avrecsize).append(ret);
free(keybuff);
}
break;
case FN_GetMultiMidPointStart: {
replydone = true;
comm->reply(mbout);
size32_t lkeybuffsize;
void * lkeybuff;
size32_t hkeybuffsize;
void * hkeybuff;
deserializeblk(mb,lkeybuffsize,lkeybuff);
deserializeblk(mb,hkeybuffsize,hkeybuff);
slave.GetMultiMidPointStart(lkeybuffsize,lkeybuff,hkeybuffsize,hkeybuff);
free(lkeybuff);
free(hkeybuff);
}
break;
case FN_MultiBinChopStop: {
unsigned num;
mb.read(num);
void *out = mbout.reserveTruncate(num*sizeof(rowcount_t));
slave.MultiBinChopStop(num,(rowcount_t *)out);
}
break;
case FN_GetMultiMidPointStop: {
size32_t mkeybuffsize=0;
void * mkeybuff = NULL;
slave.GetMultiMidPointStop(mkeybuffsize,mkeybuff);
serializeblk(mbout,mkeybuffsize,mkeybuff);
free(mkeybuff);
}
break;
case FN_MultiBinChopStart: {
replydone = true;
comm->reply(mbout);
size32_t keybuffsize;
void * keybuff;
deserializeblk(mb,keybuffsize,keybuff);
byte cmpfn;
mb.read(cmpfn);
slave.MultiBinChopStart(keybuffsize,(const byte *)keybuff,cmpfn);
free(keybuff);
}
break;
case FN_MultiBinChop: {
size32_t keybuffsize;
void * keybuff;
deserializeblk(mb,keybuffsize,keybuff);
unsigned num;
byte cmpfn;
mb.read(num).read(cmpfn);
void *out = mbout.reserveTruncate(num*sizeof(rowcount_t));
slave.MultiBinChop(keybuffsize,(const byte *)keybuff,num,(rowcount_t *)out,cmpfn);
free(keybuff);
}
break;
case FN_OverflowAdjustMapStart: {
replydone = true;
comm->reply(mbout);
unsigned mapsize;
mb.read(mapsize);
const void * map = mb.readDirect(mapsize*sizeof(rowcount_t));
size32_t keybuffsize;
void * keybuff;
deserializeblk(mb,keybuffsize,keybuff);
byte cmpfn;
mb.read(cmpfn);
bool useaux;
mb.read(useaux);
slave.OverflowAdjustMapStart(mapsize,(rowcount_t *)map,keybuffsize,(const byte *)keybuff,cmpfn,useaux);
free(keybuff);
}
break;
case FN_OverflowAdjustMapStop: {
unsigned mapsize;
mb.read(mapsize);
rowcount_t ret=0;
size32_t retofs = mbout.length();
mbout.append(ret);
void *map=mbout.reserveTruncate(mapsize*sizeof(rowcount_t));
ret = slave.OverflowAdjustMapStop(mapsize,(rowcount_t *)map); // could avoid copy here if passed mb
mbout.writeDirect(retofs,sizeof(ret),&ret);
}
break;
case FN_MultiMerge: {
replydone = true;
comm->reply(mbout);
unsigned mapsize;
mb.read(mapsize);
const void *map = mb.readDirect(mapsize*sizeof(rowcount_t));
unsigned num;
mb.read(num);
SocketEndpointArray epa;
for (unsigned i=0;i<num;i++) {
SocketEndpoint ep;
ep.deserialize(mb);
epa.append(ep);
}
slave.MultiMerge(mapsize,(rowcount_t *)map,num,epa.getArray());
}
break;
case FN_MultiMergeBetween: {
replydone = true;
comm->reply(mbout);
unsigned mapsize;
mb.read(mapsize);
const void *map = mb.readDirect(mapsize*sizeof(rowcount_t));
const void *mapupper = mb.readDirect(mapsize*sizeof(rowcount_t));
unsigned num;
mb.read(num);
SocketEndpointArray epa;
for (unsigned i=0;i<num;i++) {
SocketEndpoint ep;
ep.deserialize(mb);
epa.append(ep);
}
slave.MultiMergeBetween(mapsize,(rowcount_t *)map,(rowcount_t *)mapupper,num,epa.getArray());
}
break;
case FN_SingleMerge: {
replydone = true;
comm->reply(mbout); // async
slave.SingleMerge();
}
break;
case FN_FirstRowOfFile: {
StringAttr filename;
mb.read(filename);
size32_t rowbufsize = 0;
byte *rowbuf = NULL;
bool ret = slave.FirstRowOfFile(filename,rowbufsize,rowbuf);
serializeblk(mbout,rowbufsize,rowbuf);
free(rowbuf);
mbout.append(ret);
}
break;
case FN_GetMultiNthRow: {
unsigned numsplits;
mb.read(numsplits);
size32_t mkeybuffsize = 0;
void * mkeybuf = NULL;
slave.GetMultiNthRow(numsplits,mkeybuffsize,mkeybuf);
serializeblk(mbout,mkeybuffsize,mkeybuf);
free(mkeybuf);
}
break;
case FN_StartMiniSort: {
replydone = true;
rowcount_t totalrows;
mb.read(totalrows);
comm->reply(mbout); // async
slave.StartMiniSort(totalrows);
}
break;
case FN_Close: {
replydone = true;
comm->reply(mbout); // async
slave.Close();
}
break;
case FN_CloseWait: {
slave.CloseWait();
}
break;
case FN_Disconnect: {
comm->reply(mbout); // async
replydone = true;
slave.Disconnect();
}
// fall through
return false;
default:
throw MakeStringException(-1,"unknown function %d",(int)fn);
}
}
catch (IException *e) {
EXCLOG(e,"SortSlaveMP::marshall");
if (!replydone) {
mbout.clear();
okout = 0;
mbout.append(okout);
int err = e->errorCode();
mbout.append(err);
StringBuffer outs;
e->errorMessage(outs);
mbout.append(outs.str());
}
err.setown(e);
}
if (!replydone) {
#ifdef FULLTRACE
StringBuffer tmp1;
PROGLOG("<SortSlaveMP::marshall(%d) send %d to %s tag %d",(int)fn, mbout.length(), mbout.getSender().getUrlStr(tmp1).str(),mbout.getReplyTag());
#endif
comm->reply(mbout);
}
if (err.get())
throw err.getClear();
return true;
}