void testEndThreadException(CuTest *tc) { const int MAX_DOCS=1500; RAMDirectory ram; WhitespaceAnalyzer an; IndexWriter* writer = _CLNEW IndexWriter(&ram, &an, true); // add some documents Document doc; for (int i = 0; i < MAX_DOCS; i++) { TCHAR * tmp = English::IntToEnglish(i); doc.add(* new Field(_T("content"), tmp, Field::STORE_YES | Field::INDEX_UNTOKENIZED)); writer->addDocument(&doc); doc.clear(); _CLDELETE_ARRAY( tmp ); } CuAssertEquals(tc, MAX_DOCS, writer->docCount()); writer->close(); _CLLDELETE(writer); // this sequence is OK: delete searcher after search thread finish { IndexSearcher * searcher = _CLNEW IndexSearcher(&ram); _LUCENE_THREADID_TYPE thread = _LUCENE_THREAD_CREATE(&searchDocs, searcher); SCOPED_LOCK_MUTEX(searchMutex); CONDITION_WAIT(searchMutex, searchCondition); // _LUCENE_SLEEP(9999); //make sure that deleteMutex is being waited on... CONDITION_NOTIFYALL(deleteCondition); _LUCENE_THREAD_JOIN(thread); searcher->close(); _CLLDELETE(searcher); } // this produces memory exception: delete searcher after search finish but before thread finish { IndexSearcher * searcher = _CLNEW IndexSearcher(&ram); _LUCENE_THREADID_TYPE thread = _LUCENE_THREAD_CREATE(&searchDocs, searcher); SCOPED_LOCK_MUTEX(searchMutex); CONDITION_WAIT(searchMutex, searchCondition); searcher->close(); _CLLDELETE(searcher); CONDITION_NOTIFYALL(deleteCondition); _LUCENE_THREAD_JOIN(thread); } ram.close(); }
void IndexReader::setNorm(int32_t doc, const TCHAR* field, uint8_t value){ SCOPED_LOCK_MUTEX(THIS_LOCK) this->ensureOpen(); this->acquireWriteLock(); this->hasChanges = true; this->doSetNorm(doc, field, value); }
/** IndexInput methods */ void FSDirectory::FSIndexInput::readInternal(uint8_t* b, const int32_t len) { SCOPED_LOCK_MUTEX(handle->THIS_LOCK) CND_PRECONDITION(handle!=NULL,"shared file handle has closed"); CND_PRECONDITION(handle->fhandle>=0,"file is not open"); if ( handle->_fpos != _pos ){ if ( fileSeek(handle->fhandle,_pos,SEEK_SET) != _pos ){ _CLTHROWA( CL_ERR_IO, "File IO Seek error"); } handle->_fpos = _pos; } bufferLength = _read(handle->fhandle,b,len); // 2004.10.31:SF 1037836 if (bufferLength == 0){ _CLTHROWA(CL_ERR_IO, "read past EOF"); } if (bufferLength == -1){ //if (EINTR == errno) we could do something else... but we have //to guarantee some return, or throw EOF _CLTHROWA(CL_ERR_IO, "read error"); } _pos+=bufferLength; handle->_fpos=_pos; }
void SingleInstanceLock::release() { SCOPED_LOCK_MUTEX(*locks_LOCK); LocksType::iterator itr = locks->find( lockName ); if ( itr != locks->end() ) { locks->remove(itr, true); } }
void RAMDirectory::list(vector<string>* names) const{ SCOPED_LOCK_MUTEX(files_mutex); FileMap::const_iterator itr = files.begin(); while (itr != files.end()){ names->push_back(itr->first); ++itr; } }
void ThreadLocalBase::UnregisterCurrentThread(){ _LUCENE_THREADID_TYPE id = _LUCENE_CURRTHREADID; SCOPED_LOCK_MUTEX(ThreadLocalBase_THIS_LOCK) ThreadLocalsType::iterator itr = threadLocals.lower_bound(id); ThreadLocalsType::iterator end = threadLocals.upper_bound(id); while ( itr != end ){ itr->second->setNull(); ++itr; } }
bool RAMDirectory::RAMLock::obtain(){ SCOPED_LOCK_MUTEX(directory->files_mutex); if (!directory->fileExists(fname)) { IndexOutput* tmp = directory->createOutput(fname); tmp->close(); _CLDELETE(tmp); return true; } return false; }
FSDirectory::FSIndexInput::FSIndexInput(const FSIndexInput& other): BufferedIndexInput(other){ //Func - Constructor // Uses clone for its initialization //Pre - clone is a valide instance of FSIndexInput //Post - The instance has been created and initialized by clone if ( other.handle == NULL ) _CLTHROWA(CL_ERR_NullPointer, "other handle is null"); SCOPED_LOCK_MUTEX(other.handle->THIS_LOCK) handle = _CL_POINTER(other.handle); _pos = other.handle->_fpos; //note where we are currently... }
void ThreadLocalBase::shutdown(){ SCOPED_LOCK_MUTEX(ThreadLocalBase_THIS_LOCK) ThreadLocalsType::iterator itr = threadLocals.begin(); while ( itr != threadLocals.end() ){ itr->second->setNull(); ++itr; } ShutdownHooksType::iterator itr2 = shutdownHooks.begin(); while ( itr2 != shutdownHooks.end() ){ ShutdownHook* hook = *itr2; hook(false); } }
_LUCENE_THREAD_FUNC(searchDocs, _searcher) { WhitespaceAnalyzer an; IndexSearcher * searcher = (IndexSearcher *)_searcher; Query * query = QueryParser::parse(_T("one"), _T("content"), &an); Hits * hits = searcher->search(query); // _LUCENE_SLEEP(9999); //make sure that searchMutex is being waited on... CONDITION_NOTIFYALL(searchCondition); SCOPED_LOCK_MUTEX(deleteMutex); _CLLDELETE(hits); _CLLDELETE(query); CONDITION_WAIT(deleteMutex, deleteCondition); // _LUCENE_THREAD_FUNC_RETURN(0); }
_LUCENE_THREAD_FUNC(indexDocs, _data) { ThreadData * data = (ThreadData *)_data; int cnt = 0; TCHAR * text; for (int j=1; j<docsPerThread; j++) { Document doc; text = English::IntToEnglish(data->num*docsPerThread+j); doc.add(*new Field(_T("sizeContent"), text, Field::STORE_YES | Field::INDEX_UNTOKENIZED)); data->writer->addDocument(&doc); _CLDELETE_ARRAY(text); { SCOPED_LOCK_MUTEX(data->dir->THIS_LOCK); CuAssertTrue(data->tc, data->dir->sizeInBytes == data->dir->getRecomputedSizeInBytes()); } } _LUCENE_THREAD_FUNC_RETURN( 0 ); }
ScoreDocComparator* FieldSortedHitQueue::lookup (IndexReader* reader, const TCHAR* field, int32_t type, SortComparatorSource* factory) { ScoreDocComparator* sdc = NULL; FieldCacheImpl::FileEntry* entry = (factory != NULL) ? _CLNEW FieldCacheImpl::FileEntry (field, factory) : _CLNEW FieldCacheImpl::FileEntry (field, type); { SCOPED_LOCK_MUTEX(Comparators.THIS_LOCK) hitqueueCacheReaderType* readerCache = Comparators.get(reader); if (readerCache == NULL){ _CLDELETE(entry); return NULL; } sdc = readerCache->get (entry); _CLDELETE(entry); } return sdc; }
IndexReader* IndexReader::open(Directory* directory, bool closeDirectory) { //Func - Static method. // Returns an IndexReader reading the index in an FSDirectory in the named path. //Pre - directory represents a directory // closeDir indicates if the directory needs to be closed //Post - An IndexReader has been returned that reads the index located at directory // in- & inter-process sync SCOPED_LOCK_MUTEX(directory->THIS_LOCK) //Instantiate an IndexReader::LockWith which can produce an IndexReader LuceneLock* lock = directory->makeLock(QLatin1String("commit.lock")); IndexReader::LockWith with(lock, directory); IndexReader* ret = NULL; try { //Create an IndexReader reading the index ret = with.runAndReturn(); } _CLFINALLY ( _CLDELETE(lock); );
void IndexWriter::_IndexWriter(const bool create) { //Func - Initialises the instances //Pre - create indicates if the indexWriter must create a new index // located at path or just open it similarity = CL_NS(search)::Similarity::getDefault(); useCompoundFile = true; if ( directory->getDirectoryType() == RAMDirectory::DirectoryType() ) useCompoundFile = false; //Create a ramDirectory ramDirectory = _CLNEW TransactionalRAMDirectory; CND_CONDITION(ramDirectory != NULL, "ramDirectory is NULL"); //Initialize the writeLock to writeLock = NULL; //initialise the settings... maxFieldLength = DEFAULT_MAX_FIELD_LENGTH; mergeFactor = DEFAULT_MERGE_FACTOR; maxMergeDocs = DEFAULT_MAX_MERGE_DOCS; writeLockTimeout = WRITE_LOCK_TIMEOUT; commitLockTimeout = COMMIT_LOCK_TIMEOUT; minMergeDocs = DEFAULT_MAX_BUFFERED_DOCS; termIndexInterval = DEFAULT_TERM_INDEX_INTERVAL; //Create a new lock using the name "write.lock" LuceneLock* newLock = directory->makeLock(IndexWriter::WRITE_LOCK_NAME); //Condition check to see if newLock has been allocated properly CND_CONDITION(newLock != NULL, "No memory could be allocated for LuceneLock newLock"); //Try to obtain a write lock if (!newLock->obtain(writeLockTimeout)){ //Write lock could not be obtained so delete it _CLDELETE(newLock); //Reset the instance _finalize(); //throw an exception because no writelock could be created or obtained _CLTHROWA(CL_ERR_IO, "Index locked for write or no write access." ); } //The Write Lock has been obtained so save it for later use this->writeLock = newLock; //Create a new lock using the name "commit.lock" LuceneLock* lock = directory->makeLock(IndexWriter::COMMIT_LOCK_NAME); //Condition check to see if lock has been allocated properly CND_CONDITION(lock != NULL, "No memory could be allocated for LuceneLock lock"); LockWith2 with(lock, commitLockTimeout, this, NULL, create); { SCOPED_LOCK_MUTEX(directory->THIS_LOCK) // in- & inter-process sync with.run(); } //Release the commit lock _CLDELETE(lock); isOpen = true; }
_CLTHROWA(CL_ERR_UnsupportedOperation, "This reader does not support reopen()."); } CL_NS(store)::Directory* IndexReader::directory() { ensureOpen(); if (NULL != _internal->directory) { return _internal->directory; } else { _CLTHROWA(CL_ERR_UnsupportedOperation, "This reader does not support this method."); } } void IndexReader::ensureOpen(){ } void IndexReader::acquireWriteLock(){ SCOPED_LOCK_MUTEX(THIS_LOCK) /* NOOP */ } CL_NS(document)::Document* IndexReader::document(const int32_t n){ CL_NS(document)::Document* ret = _CLNEW CL_NS(document)::Document; if (!document(n,*ret) ) _CLDELETE(ret); return ret; } uint64_t IndexReader::lastModified(const char* directory2) { //Func - Static method // Returns the time the index in the named directory was last modified. //Pre - directory != NULL and contains the path name of the directory to check //Post - The last modified time of the index has been returned
void ThreadLocalBase::registerShutdownHook(ShutdownHook* hook){ SCOPED_LOCK_MUTEX(ThreadLocalBase_THIS_LOCK) shutdownHooks.insert(hook); }
bool SingleInstanceLock::obtain() { SCOPED_LOCK_MUTEX(*locks_LOCK); return locks->insert( lockName ).second; }
bool SingleInstanceLock::isLocked() { SCOPED_LOCK_MUTEX(*locks_LOCK); return locks->find( lockName ) == locks->end(); }