the begginning

utils/testbc/iomanager.cpp

@@ -0,0 +1,309 @@
+/* Copyright (C) 2014 InfiniDB, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; version 2 of
+   the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+   MA 02110-1301, USA. */
+
+// $Id: iomanager.cpp 724 2008-09-26 16:16:05Z jrodriguez $
+//
+// C++ Implementation: iomanager
+//
+// Description: 
+//
+//
+// Author: Jason Rodriguez <jrodriguez@calpont.com>
+//
+//
+//
+
+#define _FILE_OFFSET_BITS 64
+#define _LARGEFILE64_SOURCE
+#include <stdexcept>
+#include <iostream>
+#include <iomanip>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string>
+#include <sstream>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <boost/shared_ptr.hpp>
+#include <boost/scoped_array.hpp>
+#define NDEBUG
+#include <cassert>
+
+using namespace std;
+
+#include "configcpp.h"
+using namespace config;
+
+#include "iomanager.h"
+namespace {
+
+using namespace dbbc;
+using namespace std;
+
+void timespec_sub(const struct timespec &tv1,
+				const struct timespec &tv2,
+				double &tm) 
+{
+	tm = (double)(tv2.tv_sec - tv1.tv_sec) + 1.e-9*(tv2.tv_nsec - tv1.tv_nsec);
+}
+
+struct IOMThreadArg {
+	ioManager* iom;
+	int32_t thdId;
+};
+
+typedef IOMThreadArg IOMThreadArg_t;
+
+void* thr_popper(void* arg) {
+	ioManager* iom = ((IOMThreadArg*)arg)->iom;
+	int32_t iomThdId = ((IOMThreadArg*)arg)->thdId;
+	FileBufferMgr* fbm;
+	int totalRqst=0;
+	fileRequest* fr=0;
+	BRM::LBID_t lbid=0;
+	BRM::OID_t oid=0;
+	BRM::VER_t ver=0; 
+	int blocksLoaded=0;
+	int blocksRead=0;
+	const unsigned pageSize = 4096;
+	fbm = &iom->fileBufferManager();
+	char fileName[WriteEngine::FILE_NAME_SIZE];
+	const uint64_t fileBlockSize = BLOCK_SIZE;
+	uint32_t offset=0;
+	bool flg=false;
+	char* fileNamePtr=fileName;
+	uint64_t longSeekOffset=0;
+	int err;
+	uint32_t dlen = 0, acc, readSize, blocksThisRead, j;
+	uint32_t blocksRequested=0;
+	ssize_t i;
+	uint32_t sz=0;
+	char* alignedbuff=0;
+ 	boost::scoped_array<char> realbuff;	
+	pthread_t threadId=0;
+	ostringstream iomLogFileName;
+	ofstream lFile;
+
+	threadId=pthread_self();
+
+	uint32_t readBufferSz=iom->blocksPerRead * BLOCK_SIZE+pageSize;
+
+	realbuff.reset(new char[readBufferSz]);
+	if (realbuff.get() == 0) {
+		cerr << "thr_popper: Can't allocate space for a whole extent in memory" << endl;
+		return 0;
+	}
+
+#if __WORDSIZE > 32
+	//alignedbuff=(char*)((((ptrdiff_t)&realbuff[0] + pageSize - 1) / pageSize) * pageSize);
+	// pagesize == (1 << 12)
+	alignedbuff=(char*)((((ptrdiff_t)realbuff.get() >> 12) << 12) + pageSize);
+#else
+	//alignedbuff=(char*)(((((ptrdiff_t)&realbuff[0] & 0xffffffff) + pageSize - 1) / pageSize) * pageSize);
+	alignedbuff=(char*)(((((ptrdiff_t)realbuff.get() >> 12) << 12) & 0xffffffff) + pageSize);
+#endif
+
+	idbassert(((ptrdiff_t)alignedbuff - (ptrdiff_t)realbuff.get()) < (ptrdiff_t)pageSize);
+	idbassert(((ptrdiff_t)alignedbuff % pageSize) == 0);
+
+	for ( ; ; ) {
+
+		fr = iom->getNextRequest();
+		lbid = fr->Lbid();
+		ver = fr->Ver();
+		flg = fr->Flg();
+		blocksLoaded=0;
+		blocksRead=0;
+		dlen = fr->BlocksRequested();
+		blocksRequested = fr->BlocksRequested();
+		
+		err = iom->lbidLookup(lbid, ver, flg, oid, offset);
+		if (err < 0) {
+			cerr << "lbid=" << lbid << " ver=" << ver << " flg=" << (flg ? 1 : 0) << endl;
+			throw runtime_error("thr_popper: BRM lookup failure");
+		}
+
+		longSeekOffset=(uint64_t)offset * (uint64_t)fileBlockSize;
+		totalRqst++;
+		sz=0; 
+
+		uint32_t readCount=0;
+		uint32_t bytesRead=0;
+		uint32_t jend = blocksRequested/iom->blocksPerRead;
+		for (j = 0; j <= jend; j++) {
+
+			blocksThisRead = std::min(dlen, iom->blocksPerRead);
+			readSize = blocksThisRead * BLOCK_SIZE;
+
+			acc = 0;
+			while (acc < readSize) {
+				i = readSize; //pread(fd, &alignedbuff[acc], readSize - acc, longSeekOffset);
+				/* XXXPAT: Need to decide how to handle errors here */
+				if (i < 0 && errno == EINTR) {
+					continue;
+				}
+				else if (i < 0) {
+					perror("thr_popper::read");
+					return 0;			// shuts down this thread, 
+									// probably not the right thing to do
+				}
+				else if (i == 0) {
+					try {
+						
+					} catch (exception& exc) {
+						cerr << "FileName Err:" << exc.what() << endl;
+					}
+					cerr << "thr_popper: Early EOF in file " << fileNamePtr << endl;
+					return 0;
+				}
+				acc += i;
+				longSeekOffset += (uint64_t)i;
+				readCount++;
+				bytesRead+=i;	
+			} // while(acc...
+			blocksRead+=blocksThisRead;
+
+			for (i = 0; (unsigned)i < blocksThisRead; ++i) {
+				if (fbm->insert( (lbid+i) + (j*iom->blocksPerRead), ver, (uint8_t*)&alignedbuff[i*BLOCK_SIZE]))
+					++blocksLoaded;
+			}
+
+			dlen -= blocksThisRead;
+		} // for (j...
+
+		fr->BlocksRead(blocksRead);
+		fr->BlocksLoaded(blocksLoaded);
+
+		if (fr->data != 0 && blocksRequested == 1)
+			memcpy(fr->data, alignedbuff, BLOCK_SIZE);
+
+		pthread_mutex_lock(&fr->frMutex());
+		fr->SetPredicate(fileRequest::COMPLETE);
+		pthread_cond_signal(&fr->frCond());
+		pthread_mutex_unlock(&fr->frMutex());
+
+	} // for(;;)
+
+	lFile.close();
+
+	return 0;
+} // end thr_popper
+
+} // anonymous namespace
+
+namespace dbbc {
+
+ioManager::ioManager(FileBufferMgr& fbm,
+					fileBlockRequestQueue& fbrq,
+					int thrCount,
+					int bsPerRead):
+		blocksPerRead(bsPerRead),
+		fIOMfbMgr(fbm),
+		fIOMRequestQueue(fbrq)
+{
+
+	if (thrCount<=0)
+		thrCount=1;
+	
+	if (thrCount > 256)
+		thrCount=256;
+	
+	fConfig = Config::makeConfig();
+    string val = fConfig->getConfig("DBBC", "IOMTracing");
+	int temp=0;
+    if (val.length()>0) temp=static_cast<int>(Config::fromText(val));
+        
+    if (temp > 0)
+		fIOTrace=true;
+	else
+		fIOTrace=false;
+
+	fThreadCount=thrCount;
+	go();
+
+} // ioManager
+
+void ioManager::buildOidFileName(const BRM::OID_t oid, char* file_name) {
+
+	if (fFileOp.getFileName(oid, file_name) != WriteEngine::NO_ERROR) {
+		file_name[0]=0;
+		throw std::runtime_error("fileOp.getFileName failed");
+	}
+}
+
+
+BRM::LBID_t ioManager::lbidLookup(BRM::LBID_t lbid,
+							BRM::VER_t verid,
+							bool vbFlag,
+							BRM::OID_t& oid,
+							uint32_t& offset)
+{
+ int rc =  fdbrm.lookup(lbid, verid, vbFlag, oid, offset);
+ return rc;
+}
+
+int ioManager::createReaders() {
+	int realCnt=0;
+	IOMThreadArg_t fThdArgArr[256];
+	for (int idx=0; idx<fThreadCount; idx++){
+		fThdArgArr[realCnt].iom = this;
+		fThdArgArr[realCnt].thdId = realCnt;
+		int ret = pthread_create(&fThreadArr[realCnt], 0, thr_popper, &fThdArgArr[realCnt]);
+ 		if (ret!=0)
+ 			perror("createReaders::pthread_create");
+		else
+			realCnt++;
+	}
+	fThreadCount=realCnt;
+	return fThreadCount;
+}
+
+
+ioManager::~ioManager()
+{
+	stop();
+}
+
+void ioManager::go(void) {
+	createReaders();
+}
+
+
+void ioManager::stop() {
+	for(int idx=0; idx <fThreadCount; idx++) {
+		pthread_detach(fThreadArr[idx]);
+	}
+}
+
+
+fileRequest* ioManager::getNextRequest() {
+	fileRequest* blk = 0;
+	try {
+		blk = fIOMRequestQueue.pop();
+		return blk;
+	} catch (exception& e) {
+		cerr << "ioManager::getNextRequest() ERROR " << endl;
+	}
+
+	return blk;
+	
+}
+
+}
+// vim:ts=4 sw=4: