comparison query.cpp @ 438:8c1d8a40db91 api-inversion

audioDB::set_up_db can use an adb_qpointers_internal_t...

... make it so.

 
 
 // FIXME: this is not the right name; we're not actually setting up
 // the database, but copying various bits of it out of mmap()ed tables
 // in order to reduce seeks.
-static int audiodb_set_up_db(adb_t *adb, adb_query_spec_t *spec, double **snp, double **vsnp, double **spp, double **vspp, double **mddp, unsigned int *dvp) {
+static int audiodb_set_up_db(adb_t *adb, adb_query_spec_t *spec, adb_qpointers_internal_t *dbpointers) {
+  uint32_t nvectors = adb->header->length / (adb->header->dim * sizeof(double));
   uint32_t sequence_length = spec->qid.sequence_length;
+
   bool using_power = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
   bool using_times = spec->refine.flags & ADB_REFINE_DURATION_RATIO;
   double *times_table = NULL;
 
-  *dvp = adb->header->length / (adb->header->dim * sizeof(double));
-  *snp = new double[*dvp];
-
-  double *snpp = *snp, *sppp = 0;
+
+  dbpointers->nvectors = nvectors;
+  dbpointers->l2norm_data = new double[nvectors];
+
+  double *snpp = dbpointers->l2norm_data, *sppp = 0;
   lseek(adb->fd, adb->header->l2normTableOffset, SEEK_SET);
-  read_or_goto_error(adb->fd, *snp, *dvp * sizeof(double));
+  read_or_goto_error(adb->fd, dbpointers->l2norm_data, nvectors * sizeof(double));
 
   if (using_power) {
     if (!(adb->header->flags & O2_FLAG_POWER)) {
       goto error;
     }
-    *spp = new double[*dvp];
-    sppp = *spp;
+    dbpointers->power_data = new double[nvectors];
+    sppp = dbpointers->power_data;
     lseek(adb->fd, adb->header->powerTableOffset, SEEK_SET);
-    read_or_goto_error(adb->fd, *spp, *dvp * sizeof(double));
+    read_or_goto_error(adb->fd, dbpointers->power_data, nvectors * sizeof(double));
   }
 
   for(unsigned int i = 0; i < adb->header->numFiles; i++){
     size_t track_length = (*adb->track_lengths)[i];
     if(track_length >= sequence_length) {

   if (using_times) {
     if(!(adb->header->flags & O2_FLAG_TIMES)) {
       goto error;
     }
 
-    *mddp = new double[adb->header->numFiles];
-
-    times_table = (double *) malloc(2 * *dvp * sizeof(double));
+    dbpointers->mean_duration = new double[adb->header->numFiles];
+
+    times_table = (double *) malloc(2 * nvectors * sizeof(double));
     if(!times_table) {
       goto error;
     }
     lseek(adb->fd, adb->header->timesTableOffset, SEEK_SET);
-    read_or_goto_error(adb->fd, times_table, 2 * *dvp * sizeof(double));
+    read_or_goto_error(adb->fd, times_table, 2 * nvectors * sizeof(double));
     for(unsigned int k = 0; k < adb->header->numFiles; k++) {
       size_t track_length = (*adb->track_lengths)[k];
       unsigned int j;
-      (*mddp)[k] = 0.0;
+      dbpointers->mean_duration[k] = 0.0;
       for(j = 0; j < track_length; j++) {
-	(*mddp)[k] += times_table[2*j+1] - times_table[2*j];
-      }
-      (*mddp)[k] /= j;
+	dbpointers->mean_duration[k] += times_table[2*j+1] - times_table[2*j];
+      }
+      dbpointers->mean_duration[k] /= j;
     }
 
     free(times_table);
     times_table = NULL;
   }
 
-  *vsnp = *snp;
-  *vspp = *spp;
+  dbpointers->l2norm = dbpointers->l2norm_data;
+  dbpointers->power = dbpointers->power_data;
   return 0;
 
  error:
-  if(*snp) {
-    delete [] *snp;
-  }
-  if(*spp) {
-    delete [] *spp;
-  }
-  if(*mddp) {
-    delete [] *mddp;
+  if(dbpointers->l2norm_data) {
+    delete [] dbpointers->l2norm_data;
+  }
+  if(dbpointers->power_data) {
+    delete [] dbpointers->power_data;
+  }
+  if(dbpointers->mean_duration) {
+    delete [] dbpointers->mean_duration;
   }
   if(times_table) {
     free(times_table);
   }
   return 1;

 //
 // 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) {
-  unsigned int dbVectors;
-  double *sNorm = 0, *snPtr, *sPower = 0, *spPtr = 0;
-  double *meanDBdur = 0;
+  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

 
   // 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) )
-    if(audiodb_set_up_db(adb, spec, &sNorm, &snPtr, &sPower, &spPtr, &meanDBdur, &dbVectors)) {
+    if(audiodb_set_up_db(adb, spec, &dbpointers)) {
       error("failed to set up db");
     }
 
   VERB_LOG(1, "matching points...");
 

       if(currentTrack!=pp.trackID){
 	char* prefixedString = new char[O2_MAXFILESTR];
 	char* tmpStr = prefixedString;
 	// On currentTrack change, allocate and load track data
 	currentTrack=pp.trackID;
-	SAFE_DELETE_ARRAY(sNorm);
-	SAFE_DELETE_ARRAY(sPower);
+	SAFE_DELETE_ARRAY(dbpointers.l2norm_data);
+	SAFE_DELETE_ARRAY(dbpointers.power_data);
 	if(infid>0)
 	  close(infid);
 	// Open and check dimensions of feature file
 	strncpy(prefixedString, featureFileNameTable+pp.trackID*O2_FILETABLE_ENTRY_SIZE, O2_MAXFILESTR);
 	prefix_name((char ** const) &prefixedString, adb_feature_root);

 	initInputFile(prefixedString, false); // nommap, file pointer at correct position
 	// Load the feature vector data for current track into data_buffer
 	if(audiodb_read_data(adb, infid, pp.trackID, &data_buffer, &data_buffer_size))
           error("failed to read data");
 	// Load power and calculate power and l2norm sequence sums
-	init_track_aux_data(pp.trackID, data_buffer, &sNorm, &snPtr, &sPower, &spPtr);
+	init_track_aux_data(pp.trackID, data_buffer, &dbpointers.l2norm_data, &dbpointers.l2norm, &dbpointers.power_data, &dbpointers.power);
       }
     }
     else{
       // These offsets are w.r.t. the entire database of feature vectors and auxillary variables
       trackOffset=trackOffsetTable[pp.trackID]; // num data elements offset
       trackIndexOffset=trackOffset/dbH->dim;    // 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], sPower[sPos])) &&
+    if( ( (!power_refine) || audiodb_powers_acceptable(&spec->refine, qpointers->power[qPos], dbpointers.power[sPos])) &&
 	( qPos<qpointers->nvectors-sequence_length+1 && pp.spos<trackTable[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) ){
 	// On currentTrack change, allocate and load track data
 	currentTrack=pp.trackID;

           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);
       double qn = qpointers->l2norm[qPos];
-      double sn = sNorm[sPos];
+      double sn = dbpointers.l2norm[sPos];
       switch(spec->params.distance) {
       case ADB_DISTANCE_EUCLIDEAN_NORMED:
 	dist = 2 - (2/(qn*sn))*dist;
         break;
       case ADB_DISTANCE_EUCLIDEAN:

       }
     }
     exact_evaluation_queue->pop();
   }
   // Cleanup
-  SAFE_DELETE_ARRAY(sNorm);
-  SAFE_DELETE_ARRAY(sPower);
-  SAFE_DELETE_ARRAY(meanDBdur);
+  SAFE_DELETE_ARRAY(dbpointers.l2norm_data);
+  SAFE_DELETE_ARRAY(dbpointers.power_data);
+  SAFE_DELETE_ARRAY(dbpointers.mean_duration);
 }
 
 void audioDB::query_loop(adb_query_spec_t *spec, Uns32T queryIndex) {
   
   double *query, *query_data;
-  adb_qpointers_internal_t qpointers = {0};
+  adb_qpointers_internal_t qpointers = {0}, dbpointers = {0};
 
   bool power_refine = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
 
   if( dbH->flags & O2_FLAG_LARGE_ADB )
     error("error: LARGE_ADB requires indexed query");

   if(query_from_key)
     set_up_query_from_key(spec, &query_data, &query, &qpointers, queryIndex);
   else
     set_up_query(spec, &query_data, &query, &qpointers);
 
-  unsigned int dbVectors;
-  double *sNorm, *snPtr, *sPower = 0, *spPtr = 0;
-  double *meanDBdur = 0;
-
-  if(audiodb_set_up_db(adb, spec, &sNorm, &snPtr, &sPower, &spPtr, &meanDBdur, &dbVectors)) {
+  if(audiodb_set_up_db(adb, spec, &dbpointers)) {
     error("failed to set up db");
   }
 
   VERB_LOG(1, "matching tracks...");
   

       VERB_LOG(7,"%u.%jd.%u | ", track, (intmax_t) trackIndexOffset, trackTable[track]);
       
       initialize_arrays(adb, spec, track, qpointers.nvectors, query, data_buffer, D, DD);
 
       if(spec->refine.flags & ADB_REFINE_DURATION_RATIO) {
-        VERB_LOG(3,"meanQdur=%f meanDBdur=%f\n", qpointers.mean_duration[0], meanDBdur[track]);
+        VERB_LOG(3,"meanQdur=%f meanDBdur=%f\n", qpointers.mean_duration[0], dbpointers.mean_duration[track]);
       }
 
       if((!(spec->refine.flags & ADB_REFINE_DURATION_RATIO)) || 
-         fabs(meanDBdur[track]-qpointers.mean_duration[0]) < qpointers.mean_duration[0]*spec->refine.duration_ratio) {
+         fabs(dbpointers.mean_duration[track]-qpointers.mean_duration[0]) < qpointers.mean_duration[0]*spec->refine.duration_ratio) {
         if(spec->refine.flags & ADB_REFINE_DURATION_RATIO) {
           VERB_LOG(3,"within duration tolerance.\n");
         }
 
 	// Search for minimum distance by shingles (concatenated vectors)
 	for(j = 0; j <= qpointers.nvectors - wL; j += HOP_SIZE) {
 	  for(k = 0; k <= trackTable[track] - wL; k += HOP_SIZE) {
             double thisDist = 0;
+            double qn = qpointers.l2norm[j];
+            double sn = dbpointers.l2norm[trackIndexOffset + k];
             switch(spec->params.distance) {
             case ADB_DISTANCE_EUCLIDEAN_NORMED:
-              thisDist = 2-(2/(qpointers.l2norm[j]*sNorm[trackIndexOffset+k]))*DD[j][k];
+              thisDist = 2-(2/(qn*sn))*DD[j][k];
               break;
             case ADB_DISTANCE_EUCLIDEAN:
-              thisDist = qpointers.l2norm[j]*qpointers.l2norm[j]+sNorm[trackIndexOffset+k]*sNorm[trackIndexOffset+k] - 2*DD[j][k];
+              thisDist = qn*qn + sn*sn - 2*DD[j][k];
               break;
             case ADB_DISTANCE_DOT_PRODUCT:
               thisDist = DD[j][k];
               break;
             }
 	    // Power test
-	    if ((!power_refine) || audiodb_powers_acceptable(&spec->refine, qpointers.power[j], sPower[trackIndexOffset + k])) {
+	    if ((!power_refine) || audiodb_powers_acceptable(&spec->refine, qpointers.power[j], dbpointers.power[trackIndexOffset + k])) {
               // radius test
               if((!(spec->refine.flags & ADB_REFINE_RADIUS)) || 
                  thisDist <= (spec->refine.radius+O2_DISTANCE_TOLERANCE)) {
                 adb_result_t r;
                 r.key = fileTable + track * O2_FILETABLE_ENTRY_SIZE;

     delete[] qpointers.l2norm_data;
   if(qpointers.power_data)
     delete[] qpointers.power_data;
   if(qpointers.mean_duration)
     delete[] qpointers.mean_duration;
-  if(sNorm)
-    delete[] sNorm;
-  if(sPower)
-    delete[] sPower;
+  if(dbpointers.power_data)
+    delete[] dbpointers.power_data;
+  if(dbpointers.l2norm_data)
+    delete[] dbpointers.l2norm_data;
   if(D)
     delete[] D;
   if(DD)
     delete[] DD;
-  if(meanDBdur)
-    delete[] meanDBdur;
-}
+  if(dbpointers.mean_duration)
+    delete[] dbpointers.mean_duration;
+}