CompactIndex2::~CompactIndex2() {
if (fileHandle < 0)
return;
if (!readOnly) {
if (use_O_DIRECT) {
// if we access the output file directly, we need to close the file handle
// now and re-acquire a new one, because the write operations in the destructor
// are not properly mem-aligned
close(fileHandle);
fileHandle = open(fileName, O_RDWR | O_LARGEFILE, DEFAULT_FILE_PERMISSIONS);
if (fileHandle < 0) {
log(LOG_ERROR, LOG_ID, "Unable to re-open target file.");
perror("~CompactIndex2");
exit(1);
}
}
flushWriteCache();
// write descriptors
lseek(fileHandle, bytesWrittenToFile, SEEK_SET);
bytesWrittenToFile +=
writeRawData(bytesWrittenToFile, compressedDescriptors, usedByDescriptors);
// write header data
header.compressedDescriptorSize = usedByDescriptors;
bytesWrittenToFile +=
writeRawData(bytesWrittenToFile, &header, sizeof(header));
forced_ftruncate(fileHandle, lseek(fileHandle, 0, SEEK_CUR));
realFree(writeCache);
writeCache = NULL;
fsync(fileHandle);
} // end if (!readOnly)
sprintf(errorMessage, "Freeing memory for on-disk index: %s", fileName);
long long pc = header.postingCount;
log(LOG_DEBUG, LOG_ID, errorMessage);
sprintf(errorMessage,
" terms: %lld, segments: %lld, postings: %lld, descriptors: %lld (%d bytes)",
static_cast<long long>(header.termCount),
static_cast<long long>(header.listCount),
static_cast<long long>(header.postingCount),
static_cast<long long>(header.descriptorCount),
usedByDescriptors);
log(LOG_DEBUG, LOG_ID, errorMessage);
FREE_AND_SET_TO_NULL(inMemoryIndex);
FREE_AND_SET_TO_NULL(temporaryPLSH);
FREE_AND_SET_TO_NULL(compressedDescriptors);
FREE_AND_SET_TO_NULL(groupDescriptors);
FREE_AND_SET_TO_NULL(fileName);
if (baseFile != NULL) {
delete baseFile;
baseFile = NULL;
}
close(fileHandle);
fileHandle = -1;
} // end of ~CompactIndex2()
CompactIndex::~CompactIndex() {
if (fileHandle < 0)
return;
if (!readOnly) {
if (use_O_DIRECT) {
// if we access the output file directly, we need to close the file handle
// now and re-acquire a new one, because the write operations in the destructor
// are not properly mem-aligned
close(fileHandle);
fileHandle = open(fileName, O_RDWR | O_LARGEFILE, DEFAULT_FILE_PERMISSIONS);
if (fileHandle < 0) {
log(LOG_ERROR, LOG_ID, "Unable to re-open target file.");
perror("~CompactIndex");
exit(1);
}
}
flushWriteCache();
// write descriptors
long long totalDescriptorSize =
header.descriptorCount * sizeof(CompactIndex_BlockDescriptor);
lseek(fileHandle, bytesWrittenToFile, SEEK_SET);
writeRawData(bytesWrittenToFile, descriptors, totalDescriptorSize);
// write header data
writeRawData(bytesWrittenToFile + totalDescriptorSize, &header, sizeof(header));
forced_ftruncate(fileHandle, lseek(fileHandle, 0, SEEK_CUR));
realFree(writeCache);
writeCache = NULL;
fsync(fileHandle);
}
sprintf(errorMessage, "Freeing memory for %s index: %s",
(inMemoryIndex == NULL ? "on-disk" : "in-memory"), fileName);
long long pc = header.postingCount;
log(LOG_DEBUG, LOG_ID, errorMessage);
sprintf(errorMessage, " termCount = %d, listCount = %d, descriptorCount = %d, postingCount = %lld",
header.termCount, header.listCount, header.descriptorCount, pc);
log(LOG_DEBUG, LOG_ID, errorMessage);
FREE_AND_SET_TO_NULL(fileName);
FREE_AND_SET_TO_NULL(descriptors);
FREE_AND_SET_TO_NULL(inMemoryIndex);
if (baseFile != NULL) {
delete baseFile;
baseFile = NULL;
}
close(fileHandle);
fileHandle = -1;
} // end of ~CompactIndex()
void TAbstractWebSocket::sendPong(const QByteArray &data)
{
TWebSocketFrame frame;
frame.setOpCode(TWebSocketFrame::Pong);
frame.setPayload(data);
writeRawData(frame.toByteArray());
}
void TAbstractWebSocket::sendBinary(const QByteArray &data)
{
TWebSocketFrame frame;
frame.setOpCode(TWebSocketFrame::BinaryFrame);
frame.setPayload(data);
writeRawData(frame.toByteArray());
renewKeepAlive(); // Renew Keep-Alive interval
}
void TAbstractWebSocket::sendText(const QString &message)
{
TWebSocketFrame frame;
frame.setOpCode(TWebSocketFrame::TextFrame);
frame.setPayload(message.toUtf8());
writeRawData(frame.toByteArray());
renewKeepAlive(); // Renew Keep-Alive interval
}
void rawForcesAndMoments::evaluate()
{
List<std::pair<scalar, label> > timeLabel;
vectorField forces, moments;
readForceAndMomentData(timeLabel, forces, moments);
writeRawData(timeLabel, forces, moments);
}
void saveFull( MultiBlock2D& multiBlock, FileName fName, IndexOrdering::OrderingT ordering )
{
global::profiler().start("io");
SparseBlockStructure2D blockStructure(multiBlock.getBoundingBox());
Box2D bbox = multiBlock.getBoundingBox();
if (ordering==IndexOrdering::forward) {
plint nBlocks = std::min(bbox.getNx(), (plint)global::mpi().getSize());
std::vector<std::pair<plint,plint> > ranges;
util::linearRepartition(bbox.x0, bbox.x1, nBlocks, ranges);
for (pluint iRange=0; iRange<ranges.size(); ++iRange) {
blockStructure.addBlock (
Box2D( ranges[iRange].first, ranges[iRange].second,
bbox.y0, bbox.y1 ),
iRange );
}
}
else if (ordering==IndexOrdering::backward) {
plint nBlocks = std::min(bbox.getNy(), (plint)global::mpi().getSize());
std::vector<std::pair<plint,plint> > ranges;
util::linearRepartition(bbox.y0, bbox.y1, nBlocks, ranges);
for (pluint iRange=0; iRange<ranges.size(); ++iRange) {
blockStructure.addBlock (
Box2D( bbox.x0, bbox.x1, ranges[iRange].first, ranges[iRange].second ),
iRange );
}
}
else {
// Sparse ordering not defined.
PLB_ASSERT( false );
}
plint envelopeWidth=1;
MultiBlockManagement2D adjacentMultiBlockManagement (
blockStructure, new OneToOneThreadAttribution, envelopeWidth );
MultiBlock2D* multiAdjacentBlock = multiBlock.clone(adjacentMultiBlockManagement);
std::vector<plint> offset;
std::vector<plint> myBlockIds;
std::vector<std::vector<char> > data;
bool dynamicContent = false;
dumpData(*multiAdjacentBlock, dynamicContent, offset, myBlockIds, data);
if (ordering==IndexOrdering::backward && myBlockIds.size()==1) {
PLB_ASSERT( data.size()==1 );
Box2D domain;
blockStructure.getBulk(myBlockIds[0], domain);
plint sizeOfCell = multiAdjacentBlock->sizeOfCell();
PLB_ASSERT( domain.nCells()*sizeOfCell == (plint)data[0].size() );
transposeToBackward( sizeOfCell, domain, data[0] );
}
plint totalSize = offset[offset.size()-1];
writeOneBlockXmlSpec(*multiAdjacentBlock, fName, totalSize, ordering);
writeRawData(fName, myBlockIds, offset, data);
delete multiAdjacentBlock;
global::profiler().stop("io");
}
void save( MultiBlock2D& multiBlock, FileName fName, bool dynamicContent )
{
global::profiler().start("io");
std::vector<plint> offset;
std::vector<plint> myBlockIds;
std::vector<std::vector<char> > data;
dumpData(multiBlock, dynamicContent, offset, myBlockIds, data);
writeXmlSpec(multiBlock, fName, offset, dynamicContent);
writeRawData(fName, myBlockIds, offset, data);
global::profiler().stop("io");
}
void TAbstractWebSocket::sendClose(int code)
{
if (!closeSent.exchange(true)) {
TWebSocketFrame frame;
frame.setOpCode(TWebSocketFrame::Close);
QDataStream ds(&frame.payload(), QIODevice::WriteOnly);
ds.setByteOrder(QDataStream::BigEndian);
ds << (qint16)code;
writeRawData(frame.toByteArray());
stopKeepAlive();
}
}
void TAbstractWebSocket::sendHandshakeResponse()
{
THttpResponseHeader response;
response.setStatusLine(Tf::SwitchingProtocols, THttpUtility::getResponseReasonPhrase(Tf::SwitchingProtocols));
response.setRawHeader("Upgrade", "websocket");
response.setRawHeader("Connection", "Upgrade");
QByteArray secAccept = QCryptographicHash::hash(reqHeader.rawHeader("Sec-WebSocket-Key").trimmed() + saltToken,
QCryptographicHash::Sha1).toBase64();
response.setRawHeader("Sec-WebSocket-Accept", secAccept);
writeRawData(response.toByteArray());
}
qint64 THttpSocket::write(const THttpHeader *header, QIODevice *body)
{
T_TRACEFUNC("");
if (body && !body->isOpen()) {
if (!body->open(QIODevice::ReadOnly)) {
tWarn("open failed");
return -1;
}
}
// Writes HTTP header
QByteArray hdata = header->toByteArray();
qint64 total = writeRawData(hdata.data(), hdata.size());
if (total < 0) {
return -1;
}
if (body) {
QBuffer *buffer = qobject_cast<QBuffer *>(body);
if (buffer) {
if (writeRawData(buffer->data().data(), buffer->size()) != buffer->size()) {
return -1;
}
total += buffer->size();
} else {
QByteArray buf(WRITE_BUFFER_LENGTH, 0);
qint64 readLen = 0;
while ((readLen = body->read(buf.data(), buf.size())) > 0) {
if (writeRawData(buf.data(), readLen) != readLen) {
return -1;
}
total += readLen;
}
}
}
return total;
}
err_t HttpClient::onReceive(pbuf *buf)
{
if (buf == NULL)
{
// Disconnected, close it
TcpClient::onReceive(buf);
}
else
{
int startPos = 0;
if (waitParse)
{
String http = NetUtils::pbufStrCopy(buf, 0, 4);
http.toUpperCase();
if (http == "HTTP" && code == 0)
{
int codeStart = NetUtils::pbufFindChar(buf, ' ', 4);
int codeEnd = NetUtils::pbufFindChar(buf, ' ', codeStart + 1);
if (codeStart != -1 && codeEnd != -1 && codeEnd - codeStart < 5)
{
String strCode = NetUtils::pbufStrCopy(buf, codeStart, codeEnd);
code = strCode.toInt();
}
else
code = 0;
}
int headerEnd = NetUtils::pbufFindStr(buf, "\r\n\r\n");
if (headerEnd != -1)
{
debugf("Header pos: %d", headerEnd);
startPos = headerEnd + 4;
waitParse = false;
if (headerEnd < NETWORK_MAX_HTTP_PARSING_LEN)
parseHeaders(buf, headerEnd);
}
}
writeRawData(buf, startPos);
// Fire ReadyToSend callback
TcpClient::onReceive(buf);
}
return ERR_OK;
}
qint64 THttpSocket::writeRawData(const QByteArray &data)
{
return writeRawData(data.data(), data.size());
}
void BinaryWriterAppender::writeFooter() const
{
if (layout() && mpWriter)
writeRawData(binaryLayout()->binaryFooter());
}
