comparison query.cpp @ 455:93ce12fe2f76 api-inversion

Begin pushing adb_t *adb into index_query_loop and query_loop_points

   }
   
   // Test for index (again) here
   if((qspec.refine.flags & ADB_REFINE_RADIUS) && index_exists(adb->path, qspec.refine.radius, qspec.qid.sequence_length)){ 
     VERB_LOG(1, "Calling indexed query on database %s, radius=%f, sequence_length=%d\n", adb->path, qspec.refine.radius, qspec.qid.sequence_length);
-    index_query_loop(&qspec, dbName, query_from_key_index);
+    index_query_loop(adb, &qspec);
   }
   else{
     VERB_LOG(1, "Calling brute-force query on database %s\n", dbName);
     if(query_loop(adb, &qspec)) {
       error("query_loop failed");

 // A reporter has been allocated
 //
 // Postconditions:
 // reporter contains the points and distances that meet the reporter constraints 
 
-void audioDB::query_loop_points(adb_query_spec_t *spec, double* query, adb_qpointers_internal_t *qpointers) {
+void audioDB::query_loop_points(adb_t *adb, adb_query_spec_t *spec, double* query, adb_qpointers_internal_t *qpointers) {
   adb_qpointers_internal_t dbpointers = {0};
 
   uint32_t sequence_length = spec->qid.sequence_length;
   bool power_refine = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
 
-  // check pre-conditions
-  assert(exact_evaluation_queue&&reporter);
-  if(!exact_evaluation_queue->size()) // Exit if no points to evaluate
+  if(exact_evaluation_queue->size() == 0) {
     return;
-
-  // Compute database info
-  // FIXME: we more than likely don't need very much of the database
-  // so make a new method to build these values per-track or, even better, per-point
-  if( !( dbH->flags & O2_FLAG_LARGE_ADB) )
+  }
+
+  // Compute database info.  FIXME: we more than likely don't need
+  // very much of the database so write a new function to build these
+  // values per-track or, even better, per-point
+  if(!(adb->header->flags & O2_FLAG_LARGE_ADB)) {
     if(audiodb_set_up_dbpointers(adb, spec, &dbpointers)) {
-      error("failed to set up db");
-    }
+      error("failed to set up dbpointers");
+    }
+  }
 
   // We are guaranteed that the order of points is sorted by:
-  // trackID, spos, qpos
-  // so we can be relatively efficient in initialization of track data.
-  // Here we assume that points don't overlap, so we will use exhaustive dot
-  // product evaluation instead of memoization of partial sums which is used
-  // for exhaustive brute-force evaluation from smaller databases: e.g. query_loop()
+  // {trackID, spos, qpos} so we can be relatively efficient in
+  // initialization of track data.  We assume that points usually
+  // don't overlap, so we will use exhaustive dot product evaluation
+  // instead of memoization of partial sums which is used for
+  // exhaustive brute-force evaluation from smaller databases in
+  // query_loop()
   double dist;
   size_t data_buffer_size = 0;
   double *data_buffer = 0;
   Uns32T trackOffset = 0;
   Uns32T trackIndexOffset = 0;
   Uns32T currentTrack = 0x80000000; // Initialize with a value outside of track index range
   Uns32T npairs = exact_evaluation_queue->size();
   while(npairs--){
     PointPair pp = exact_evaluation_queue->top();
     // Large ADB track data must be loaded here for sPower
-    if(dbH->flags & O2_FLAG_LARGE_ADB){
+    if(adb->header->flags & O2_FLAG_LARGE_ADB) {
       trackOffset=0;
       trackIndexOffset=0;
       if(currentTrack!=pp.trackID){
 	char* prefixedString = new char[O2_MAXFILESTR];
 	char* tmpStr = prefixedString;

       }
     }
     else{
       // These offsets are w.r.t. the entire database of feature vectors and auxillary variables
       trackOffset = (*adb->track_offsets)[pp.trackID];
-      trackIndexOffset = trackOffset/(dbH->dim * sizeof(double)); // num vectors offset
+      trackIndexOffset = trackOffset/(adb->header->dim * sizeof(double)); // num vectors offset
     }    
     Uns32T qPos = usingQueryPoint?0:pp.qpos;// index for query point
     Uns32T sPos = trackIndexOffset+pp.spos; // index into l2norm table
     // Test power thresholds before computing distance
     if( ( (!power_refine) || audiodb_powers_acceptable(&spec->refine, qpointers->power[qPos], dbpointers.power[sPos])) &&
 	( qPos<qpointers->nvectors-sequence_length+1 && pp.spos<(*adb->track_lengths)[pp.trackID]-sequence_length+1 ) ){
       // Non-large ADB track data is loaded inside power test for efficiency
-      if( !(dbH->flags & O2_FLAG_LARGE_ADB) && (currentTrack!=pp.trackID) ){
+      if(!(adb->header->flags & O2_FLAG_LARGE_ADB) && (currentTrack!=pp.trackID) ){
 	// On currentTrack change, allocate and load track data
 	currentTrack=pp.trackID;
-	lseek(dbfid, dbH->dataOffset + trackOffset, SEEK_SET);
+	lseek(dbfid, adb->header->dataOffset + trackOffset, SEEK_SET);
 	if(audiodb_read_data(adb, dbfid, currentTrack, &data_buffer, &data_buffer_size))
           error("failed to read data");
       }
       // Compute distance
-      dist = audiodb_dot_product(query+qPos*dbH->dim, data_buffer+pp.spos*dbH->dim, dbH->dim*sequence_length);
+      dist = audiodb_dot_product(query + qPos*adb->header->dim, data_buffer + pp.spos*adb->header->dim, adb->header->dim*sequence_length);
       double qn = qpointers->l2norm[qPos];
       double sn = dbpointers.l2norm[sPos];
       switch(spec->params.distance) {
       case ADB_DISTANCE_EUCLIDEAN_NORMED:
 	dist = 2 - (2/(qn*sn))*dist;