CQMultiple Class Reference

#include <CQMultiple.h>

Inheritance diagram for CQMultiple:

List of all members.

Public Member Functions
	CQMultiple ()
	~CQMultiple ()
	CQMultiple (CAccessorAdminCollection &inAccessorAdminCollection, CAlgorithm &inAlgorithm)
virtual CIDRelevanceLevelPairList *	fastQuery (const CXMLElement &inQuery, int inNumberOfInterestingImages, double inDifferenceToBest)
virtual CXMLElement *	query (const CXMLElement &inQuery)
virtual bool	setAlgorithm (CAlgorithm &inAlgorithm)
Static Public Member Functions
static void *	doFastQueryThread (void *)
static void *	doQueryThread (void *)
Protected Member Functions
void	init ()
Protected Attributes
bool	mUsesResultURLs

---

Detailed Description

This is going to be one of our main building blocks. It is a structure which contains a couple of CQuery structures, hands a query through to them, and then unifies the result. In fact this is the center of all this query tree business.

Probably we will put another layer into the class tree: The CQTreeNode, but let's first start.

Important: The basic assumption here is, that all children operate on the same collections. If this is not the case we have to be more careful, and most of all: we have to operate using URLs.

[in the following I am talking about things I WANT to do, so the two modes stuff is not yet implemented]

CQMultiple has two minor modes:

Merge-by-ID or Merge-by-URL

In the first case, we need information on how to translate image IDs to image URLs. We dispatche a fastQuery() to each child node, and then we merge the results (by imageID). The resulting list of ID-relevancelevel pairs is translated back to URLs using an URL2FTS accessor.

Please note that I am aware that this needs refactoring: we should have an ULRToID accessor superclass, which provides the necessary translation services, without being fixed on a given data representation.

In the second case, we do not need any additional information: we dispatch a query() (as opposed to fastQuery()) to the child nodes, and then we merge the results. This means we have to merge plenty of XML.

: Wolfgang Müller

Definition at line 118 of file CQMultiple.h.

---

Constructor & Destructor Documentation

CQMultiple::CQMultiple

(

)

default constructor

Definition at line 61 of file CQMultiple.cc.

                      {
  assert(0);
};

CQMultiple::~CQMultiple

(

)

we need to unregister the accessors used

destructor: at present empty

Definition at line 90 of file CQMultiple.cc.

                       {

  cout << "destroying this "
       << __FILE__
       << __LINE__
       << flush
       << endl;

  //i thought i will need this, but at present I do not have this impression
  //it does not hurt, so we leave it in
};

CQMultiple::CQMultiple	(	CAccessorAdminCollection &	inAccessorAdminCollection,
		CAlgorithm &	inAlgorithm
	)

In fact, what we are doing here is to get ourselves an accessor ACURL2FTS to do a proper fastQuery

constructor see CQuery

Definition at line 68 of file CQMultiple.cc.

References CXMLElement::boolReadAttribute(), CQuery::mAccessor, CQuery::mAccessorAdmin, mUsesResultURLs, and CAccessorAdmin::openAccessor().

00069                                             :
00070   CQuery(inAccessorAdminCollection,
00071    inAlgorithm){
00072   {
00073 
00074     pair<bool,bool> lUsesURLs(inAlgorithm.boolReadAttribute("cui-uses-result-urls"));
00075 
00076     mUsesResultURLs=(lUsesURLs.first && lUsesURLs.second);
00077 
00078     // mproxy has been filled in a reasonable way 
00079     // by CQuery::CQuery
00080     mAccessor=mAccessorAdmin->openAccessor("url2fts");
00081     assert(mAccessor);
00082   }
00083 };
    

---

Member Function Documentation

void CQMultiple::init

(

)

[protected, virtual]

Do we merge the results by their URL or by their image ID?

We read the algorithm to find out

how we will dispatch the queries to the child nodes

in which way we will merge the results coming from the child nodes

Implements CQuery.

Definition at line 49 of file CQMultiple.cc.

                     {
  

  

};

void * CQMultiple::doFastQueryThread

(

void *

inParameter

)

[static]

This function processes is in the inner loop of fastQuery. If multithreading is possible on the system on which GIFT was compiled, then this function will run in a thread, and fastQuery will wait for it

Definition at line 344 of file CQMultiple.cc.

References CQuery::fastQuery(), CQMThread::mDifferenceToBest, CQMThread::mFastResult, CQMThread::mQuery, CQMThread::mQueryProcessor, CQMThread::mResult, and CQMThread::mResultSize.

Referenced by CQMThread::runFastThread().

                                                    {
  class CQMThread* lParam((CQMThread*) inParameter);
  lParam->mFastResult=lParam->mQueryProcessor.fastQuery(*(lParam->mQuery),
                lParam->mResultSize,
                lParam->mDifferenceToBest);
  cout << "I AM FINISHED HERE " << lParam << "result" << lParam->mResult << endl;
  return 0;
}

CIDRelevanceLevelPairList * CQMultiple::fastQuery	(	const CXMLElement &	inQuery,
		int	inNumberOfInterestingImages,
		double	inDifferenceToBest
	)			[virtual]

calls fastQuery for every child, merges the results

calls fastQuery for every child, merges the results and translates them back into URLs

NEW, MORE EFFICIENT VERSION

Implements CQuery.

Definition at line 369 of file CQMultiple.cc.

References CQMThread::CQMThread(), CQuery::mAccessor, CQuery::mChildren, and CAccessor::size().

                                       {

  cout << "CMultiple Number of children:"
       << mChildren.size()
       << endl;


  //list<CWeightedResult> lTemporary;
  double lWeightSum(0);

  map<TID,CIDRelevanceLevelPair> lResultMap;


  // no mutex protection needed as this is not called except by main thread

  //
  // rip this into two parts
  // in order to 
  // make it possible to run the querying in one thread
  // and do the merging after having waited for each thread
  //

  list<CQMThread> lListOfThreads;

  lCChildren::const_iterator lLast=mChildren.end();
  lLast--;
  for(lCChildren::const_iterator i=mChildren.begin();
      i!=mChildren.end();
      i++){
    lWeightSum+=i->mWeight;
    
    //lTemporary.push_back(CWeightedResult());
    
    cout << "çç---------------------this CMultiple:fastQuery" << this 
   << ", i->mQuery:" << i->mQuery 
   << ", i->mWeight:" << i->mWeight 
   << endl;
    
    
    lListOfThreads.push_back(CQMThread(*(i->mQuery),          // The Query processor to choose
               inQuery,            // the query to be processed
               i->mWeight,         // the weight the result will receive
               mAccessor->size(),  // the size of the accessor (to get all potential results)
               inDifferenceToBest));// the difference to the best which is allowed for a result
    /* EX-LEAK
       the following was a special branch for reducing the
       number of spawned threads by one. Apparently this did 
       not work and caused a memory leak. Now it seems to work.
       
     if(1==0 
     && (i==lLast)){
     lListOfThreads.back().callFunction();//something to do for the main thread
     }else*/
      
    {
      cout << "Running thread" 
     << endl;
      lListOfThreads.back().runFastThread();//run the thread
      cout << "loop" 
     << endl;
    }
    cout << "endloop" 
   << endl;
  }
  // here we would join all threads

  for(list<CQMThread>::iterator lThread=lListOfThreads.begin();
      lThread!=lListOfThreads.end();
      lThread++){

    cout << "joining..." << endl;

    lThread->join();

    cout << "before merging " << endl;

    if(!lThread->mFastResult){
      cout << "THE THE RESULT OF THIS THREAD WAS NIL " 
     << endl;
    }
    if(lThread->mFastResult){
      for(CIDRelevanceLevelPairList::iterator i=lThread->mFastResult->begin();
    i!=lThread->mFastResult->end();
    i++){
  
  map<TID,CIDRelevanceLevelPair>::const_iterator lFound=lResultMap.find(i->getID());

  i->setRelevanceLevel(i->getRelevanceLevel()*lThread->getWeight());
  
  if(lFound==lResultMap.end()){

    lResultMap.insert(make_pair(i->getID(),
              *i));
  }else{
    
    lResultMap[i->getID()].setRelevanceLevel(lResultMap[i->getID()].getRelevanceLevel()
               +i->getRelevanceLevel()
               );
  }
      }
      delete lThread->mFastResult;
    }

    
    cout << "after merging " << endl;
  }
  
  CIDRelevanceLevelPairList* lReturnValue=new CIDRelevanceLevelPairList();

  cout << "<pushing>"
       << endl;

  for(map<TID,CIDRelevanceLevelPair>::const_iterator i=lResultMap.begin();
      i!=lResultMap.end();
      i++){
    lReturnValue->push_back(i->second);
  }

  cout << "</pushing>\n<sorting>"
       << endl;

  lReturnValue->sort();
  lReturnValue->reverse();
  cout << "Size of the result "
       << lReturnValue->size()
       << endl;
  cout << "</sorting>"
       << endl;

  cout << "<cutting>"
       << endl;
  {
    CIDRelevanceLevelPairList::iterator iSkip=lReturnValue->begin();
    for(int i=0;
  i<inNumberOfInterestingImages && i<lReturnValue->size();
  i++){
      iSkip->setRelevanceLevel(iSkip->getRelevanceLevel()/lWeightSum);
      iSkip++;
    }
    lReturnValue->erase(iSkip,lReturnValue->end());
  }
  cout << "</cutting>"
       << endl;
  return lReturnValue;
};

void * CQMultiple::doQueryThread

(

void *

inParameter

)

[static]

This function processes is in the inner loop of query. If multithreading is possible on the system on which GIFT was compiled, then this function will run in a thread, and fastQuery will wait for it

do the query thread, but starting query

Definition at line 355 of file CQMultiple.cc.

References CQMThread::mQuery, CQMThread::mQueryProcessor, CQMThread::mResult, and CQuery::query().

Referenced by CQMThread::runThread().

                                                {
  class CQMThread* lParam((CQMThread*) inParameter);
  lParam->mResult=lParam->mQueryProcessor.query(*(lParam->mQuery));
  cout << "I AM FINISHED HERE " << lParam << "result" << lParam->mResult << endl;
  return 0;
}

CXMLElement * CQMultiple::query

(

const CXMLElement &

inQuery

)

[virtual]

calls query for every child, merges the results by URLs

calls fastQuery for every child, merges the results and translates them back into URLs

NEW, MORE EFFICIENT VERSION

Reimplemented from CQuery.

Definition at line 592 of file CQMultiple.cc.

References CXMLElement::addAttribute(), CXMLElement::addChild(), mrml_const::calculated_similarity, CXMLElement::child_list_begin(), CXMLElement::child_list_end(), CXMLElement::clone(), mrml_const::error, CQuery::getRandomImages(), mrml_const::image_location, CXMLElement::longReadAttribute(), CQuery::mAccessor, CQuery::mChildren, mrml_const::message, CXMLElement::moveUp(), mUsesResultURLs, CQuery::query(), mrml_const::query_result, mrml_const::query_result_element, mrml_const::query_result_element_list, mrml_const::result_cutoff, mrml_const::result_size, CAccessor::size(), and mrml_const::thumbnail_location.

                                                        {

  if(!mUsesResultURLs){
    // if the mUsesReusltURLs is not set,
    // just call fastquery, and assemble from that a result,
    // as CQuery does.
    return CQuery::query(inQuery);
  }
  
  pair<bool,long> lNumberOfInterestingImages=
    inQuery.longReadAttribute(mrml_const::result_size);
  
  int inNumberOfInterestingImages=
    lNumberOfInterestingImages.second;

  pair<bool,long> lCutoff=
    inQuery.longReadAttribute(mrml_const::result_cutoff);
  
  int inCutoff=
    lCutoff.second;

  // do a deep clone of the query (for const cast)
  CXMLElement* lQuery=inQuery.clone(1);

  if(lQuery->child_list_begin()!=lQuery->child_list_end()){

    //
    // set the result size to a multiple of the 
    // number of the images requested 
    // to get a higher probability that
    // the combination reflects the real score
    // you want more explanation?
    // you get it at help-gift@gnu.org
    //
    lQuery->addAttribute(mrml_const::result_size,
       long(inNumberOfInterestingImages*5));
    
    cout << "CMultiple::query Number of children:"
   << mChildren.size()
   << endl;
    
    
    //list<CWeightedResult> lTemporary;
    double lWeightSum(0);
    
    map<string,CMergeTriplet> lResultMap;
    
    // no mutex protection needed as this is not called except by main thread
    
    //
    // rip this into two parts
    // in order to 
    // make it possible to run the querying in one thread
    // and do the merging after having waited for each thread
    //
    
    list<CQMThread> lListOfThreads;

    lCChildren::const_iterator lLast=mChildren.end();
    lLast--;
    for(lCChildren::const_iterator i=mChildren.begin();
  i!=mChildren.end();
  i++){
      lWeightSum+=i->mWeight;
    
      //lTemporary.push_back(CWeightedResult());
    
      cout << "**-------------------------------this CMultiple QUERY:" << this 
     << ", i->mQuery:" << i->mQuery 
     << ", i->mWeight:" << i->mWeight 
     << endl;
    
    
      lListOfThreads.push_back(CQMThread(*(i->mQuery),          // The Query processor to choose
           *lQuery,            // the query to be processed
           i->mWeight,         // the weight the result will receive
           mAccessor->size(),  // the size of the accessor (to get all potential results)
           inCutoff));// the difference to the best which is allowed for a result
      /* EX-LEAK
   the following was a special branch for reducing the
   number of spawned threads by one. Apparently this did 
   not work and caused a memory leak. Now it seems to work.
       
   if(1==0 
   && (i==lLast)){
   lListOfThreads.back().callFunction();//something to do for the main thread
   }else*/
      
      {
  cout << "Running thread" 
       << endl;
  lListOfThreads.back().runThread();//run the thread
  cout << "loop" 
       << endl;
      }
      cout << "endloop" 
     << endl;
    }
    // here we would join all threads

    for(list<CQMThread>::iterator lThread=lListOfThreads.begin();
  lThread!=lListOfThreads.end();
  lThread++){

      cout << "joining..." << endl;

      lThread->join();

      cout << "before merging " << endl;

      if(!lThread->mResult){
  cout << "THE THE RESULT OF THIS THREAD WAS NIL " 
       << endl;
      }
      if(lThread->mResult){
  /*
    OK. At this point we got back a query-result XML element.
    now we want the result-element-list
  */
  cout << "H" << flush;
  for(CXMLElement::lCChildren::const_iterator i=lThread->mResult->child_list_begin();
      i!=lThread->mResult->child_list_end();
      i++){
    cout << "I" << flush;
    if((*i)->getName() == mrml_const::query_result_element_list){
      for(CXMLElement::lCChildren::const_iterator j=(*i)->child_list_begin();
    j!=(*i)->child_list_end();
    j++){
        cout << "J" << flush;
        if((*j)->getName() == mrml_const::query_result_element){
    cout << "K" << flush;
    /* 
       inside this, *j points now to an XML element which
       is a query-result-element. from this we will read now
       the calculated-relevance,
       as well as the image and thumbnail location.
    */
    pair<bool,double> lCalculatedRelevance=
      (*j)->doubleReadAttribute(mrml_const::calculated_similarity);
    pair<bool,string> lImageLocation=
      (*j)->stringReadAttribute(mrml_const::image_location);
    pair<bool,string> lThumbnailLocation=
      (*j)->stringReadAttribute(mrml_const::thumbnail_location);

    cout << "L" << flush;

    // no relevance corresponds to relevance 0
    if(! lCalculatedRelevance.first){
      lCalculatedRelevance=make_pair(bool(0),
             double(0));
    }

    cout << "L" << flush;
    // if there is a thumbnail and no image,
    // we take the thumbnail location as image location
    if((lThumbnailLocation.first)
       && (!lImageLocation.first)){
      lImageLocation=lThumbnailLocation;
    }
    cout << "L" << flush;
    // if there is an image and no thumbnail,
    // we take the image location as thumbnail location
    if((!lThumbnailLocation.first)
       && (lImageLocation.first)){
      lThumbnailLocation=lImageLocation;
    }
    cout << "L" << flush;
        
    // now we are guaranteed to have a well-initialised
    // image location
    if(lImageLocation.first){
      map<string,CMergeTriplet>::iterator lFound(lResultMap.find(lImageLocation.second));
      
      if(lFound!=lResultMap.end()){
        cout << "A" << flush;
        lFound->second.addToRelevance(lCalculatedRelevance.second);
        cout << "[" << lFound->second.getCalculatedSimilarity() << "]" << flush;
      }else{
        // this result is not yet in the result map
        lFound=lResultMap.insert(make_pair(lImageLocation.second,CMergeTriplet(lImageLocation.second,
                        lThumbnailLocation.second))).first;
        lFound->second.addToRelevance(lCalculatedRelevance.second);
      }
    cout << "M" << flush;

    }
        }
      }
    }
  }
  delete lThread->mFastResult;
      }

    
    
      cout << "after thread " << endl;
    }
    cout << "ALL THREADS FINISHED " << endl;
  
    {
      // now we build a list of merge triplets
      // that is sorted by score in descending order
      list<CMergeTriplet> lResultList;
      for(map<string,CMergeTriplet>::const_iterator i=lResultMap.begin();
    i!=lResultMap.end();
    i++){
  lResultList.push_back(i->second);
      }
      cout << "DELETING " << endl;
      lResultList.sort(CSortDescendingByRelevance_MT());
      cout << "DELETING " << endl;
    
      {
  list<CMergeTriplet>::iterator iSkip=lResultList.begin();
  for(int i=0;
      i<inNumberOfInterestingImages && i<lResultList.size();
      i++){
    iSkip->setSimilarity(iSkip->getCalculatedSimilarity()/lWeightSum);
    iSkip++;
  }
  lResultList.erase(iSkip,lResultList.end());
      }

      // now let's build a result element tree
      CXMLElement* lReturnValue(new CXMLElement(mrml_const::query_result,0));
      CXMLElement* lReturnList(new CXMLElement(mrml_const::query_result_element_list,0));
      lReturnValue->addChild(lReturnList);
    
      assert(mAccessor);
    
      for(list<CMergeTriplet>::const_iterator i=lResultList.begin();
    i!=lResultList.end();
    i++){
      
  CXMLElement* lReturnElement(new CXMLElement(mrml_const::query_result_element,
                0));
  {
    double lRelevanceLevel(i->getCalculatedSimilarity());
    string lString(mrml_const::calculated_similarity);
    lReturnElement->addAttribute(lString,
               lRelevanceLevel);
  }
      
      
      
  {
    string lURL(i->getImageLocation());
    string lString(mrml_const::image_location);
    lReturnElement->addAttribute(lString,
               lURL);
  }

  {
    string lURL(i->getThumbnailLocation());
    string lString(mrml_const::thumbnail_location);
    lReturnElement->addAttribute(lString,
               lURL);
  }
      
  lReturnValue->addChild(lReturnElement);
      
  lReturnValue->moveUp();
      
      }
      //gMutex->unlock();//debugging
      return lReturnValue;
    }
  }else{
    //gMutex->unlock();//debugging
    return getRandomImages(inNumberOfInterestingImages);
  }

  //gMutex->unlock();//debugging
  // missing sort and output
  list<pair<string,string> > lAttributes;
  lAttributes.push_back(make_pair(mrml_const::message,
          string("empty query result, i seem to have missed all ifs and elses!")));
  return new CXMLElement(mrml_const::error,lAttributes);
};

bool CQMultiple::setAlgorithm

(

CAlgorithm &

inAlgorithm

)

[virtual]

set the Algorithm. same scheme as in setCollection

everything happening in the children

Reimplemented from CQuery.

Definition at line 113 of file CQMultiple.cc.

References CAccessorAdmin::closeAccessor(), CAlgorithm::getCollectionID(), CAccessorAdminCollection::getProxy(), CQuery::mAccessor, CQuery::mAccessorAdmin, CQuery::mAccessorAdminCollection, CQuery::mAlgorithm, CAccessorAdmin::openAccessor(), and CQuery::setAlgorithm().

                                                     {
  if(mAlgorithm && mAlgorithm->getCollectionID()==inAlgorithm.getCollectionID()){
    
    return true;
    
  }else{
    //close the old collection, if exsisting
    if(mAccessorAdmin)
      mAccessorAdmin->closeAccessor("url2fts");
    //
    mAccessorAdmin=&mAccessorAdminCollection->getProxy(inAlgorithm.getCollectionID());
    mAccessor=mAccessorAdmin->openAccessor("url2fts");

    assert(mAccessor);
    //
    return (CQuery::setAlgorithm(inAlgorithm) && mAccessor);
  }
};

---

Member Data Documentation

bool CQMultiple::mUsesResultURLs [protected]

do we merge result URLs or result IDs?

Definition at line 129 of file CQMultiple.h.

Referenced by CQMultiple(), and query().

---

The documentation for this class was generated from the following files:

• gift/libMRML/include/CQMultiple.h
• gift/libMRML/cc/CQMultiple.cc