Changeset 27839 for branches/simmosaic_branches/Ohana/src/addstar/src/build_links.c

Timestamp:

May 3, 2010, 8:45:22 AM (16 years ago)

Author:

eugene

Message:

updates from trunk

Location:

branches/simmosaic_branches

Files:

• . (modified) (1 prop)
• Ohana (modified) (1 prop)
• Ohana/src/addstar/src/build_links.c (modified) (11 diffs)

branches/simmosaic_branches/Ohana/src/addstar/src/build_links.c

@@ -1 +1 @@
 # include "addstar.h"
+
+/* 
+
+There are two modes for the measure table: sorted and unsorted. 
+
+In sorted mode, all measures associated with a given average are in a single block.  The block
+is pointed to by average->measureOffset and the range is average->Nmeasure
+
+In unsorted mode, it is not possible to go directly from average to measure without scanning.
+In this case, it is necessary to use the value measure->averef to find the corresponding
+average entry.  
+
+Note that average->measureOffset and measure->averef are only valid for a given load of the
+data: they refer to the sequence number in the data blocks.
+
+next_meas is a list of the equivalent sequence of the measure block as if it were sorted.
+
+to find the sequence of measurements for a given average:
+n_0 = average->measureOffset
+n_1 = next_meas[n_0]
+n_i = next_meas[n_i-1]
+
+*/
 
 /* build the initial links assuming the table is sorted, 
    not partial, and has a correct set of average[].measureOffset,Nmeasure values */
-int *init_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
-
-  int i, j, N;
-  int *next;
+off_t *init_measure_links (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure) {
+
+  off_t i, j, N;
+  off_t *next_meas;
 
   N = 0;
 
-  ALLOCATE (next, int, Nmeasure);
+  ALLOCATE (next_meas, off_t, Nmeasure);
   for (i = 0; i < Naverage; i++, N++) {
     for (j = 0; j < average[i].Nmeasure - 1; j++, N++) {
-      next[N] = N + 1;
+      next_meas[N] = N + 1;
       if (N >= Nmeasure) {
         fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next[N] = -1;
+    next_meas[N] = -1;
     if (N >= Nmeasure) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -28 +51 @@
     }
   }
-  return (next);
-}
-
-/* build the initial links assuming the table is sorted */
-int *init_missing_links (Average *average, int Naverage, Missing *missing, int Nmissing) {
-
-  int i, j, N;
-  int *next;
-
-  N = 0;
-
-  ALLOCATE (next, int, Nmissing);
-  for (i = 0; i < Naverage; i++) {
-    for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
-      next[N] = N + 1;
-    }
-    if (average[i].Nmissing > 0) {
-      next[N] = -1;
-      if (N >= Nmissing) {
-        fprintf (stderr, "overflow in init_missing_links");
-        abort ();
-      }
-      N++;
-    }
-
-  }
-  return (next);
-}
-
-/* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
-int add_meas_link (Average *average, int *next, int Nmeasure, int NMEASURE) {
-
-  int k, m;
-
-  /* if we have trouble, check validity of next[m] : m < Nmeasure */
-  m = average[0].measureOffset;  
-
-  for (k = 0; k < average[0].Nmeasure - 1; k++)  {
-    m = next[m];
-    if (m >= NMEASURE) {
-      fprintf (stderr, "WARNING: m out of bounds (3)\n");
-    }
-  }
-
-  /* set up references */
-  next[Nmeasure] = -1;
-  if (Nmeasure >= NMEASURE) {
-    fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
-  }
-
-  if (m == -1) {
-    average[0].measureOffset = Nmeasure;
-  } else {
-    next[m] = Nmeasure;
-    if (m >= NMEASURE) {
-      fprintf (stderr, "WARNING: m out of bounds (4)\n");
-    }
-  }
-
-  return (TRUE);
-}
-
-int add_miss_link (Average *average, int *next, int Nmissing) {
-
-  int k, m;
-
-  /* there may be 0 Nmiss; this is not true for Nmeas */
-  if (average[0].Nmissing < 1) {
-    average[0].missingOffset = Nmissing;
-    next[Nmissing] = -1;
-    return (TRUE);
-  }
-
-  m = average[0].missingOffset;  
-  for (k = 0; k < average[0].Nmissing - 1; k++) m = next[m];
-  /* set up references */
-  next[Nmissing] = -1;
-  next[m] = Nmissing;
-  return (TRUE);
+  return (next_meas);
 }
 
@@ -116 +61 @@
  */ 
 
-int *build_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
-
-  int i, m, k, Nm, averef;
-  int *next;
-
-  ALLOCATE (next, int, Nmeasure);
+off_t *build_measure_links (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure) {
+
+  off_t i, m, k, Nm, averef;
+  off_t *next_meas;
+
+  ALLOCATE (next_meas, off_t, Nmeasure);
 
   /* reset the Nm, offset values for average */
@@ -132 +77 @@
     averef = measure[Nm].averef;
     m = average[averef].measureOffset;  
-    next[Nm] = -1;
+    next_meas[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -140 +85 @@
     }
 
-    for (k = 0; next[m] != -1; k++) {
-      m = next[m];
+    for (k = 0; next_meas[m] != -1; k++) {
+      m = next_meas[m];
       if (m >= Nmeasure) {
         fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -148 +93 @@
 
     average[averef].Nmeasure = k + 2;
-    next[m] = Nm;
+    next_meas[m] = Nm;
     if (m >= Nmeasure) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next);
+  return (next_meas);
+}
+
+/* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
+off_t add_meas_link (Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE) {
+
+  off_t k, m;
+
+  /* if we have trouble, check validity of next_meas[m] : m < Nmeasure */
+  m = average[0].measureOffset;  
+
+  for (k = 0; k < average[0].Nmeasure - 1; k++)  {
+    m = next_meas[m];
+    if (m >= NMEASURE) {
+      fprintf (stderr, "WARNING: m out of bounds (3)\n");
+    }
+  }
+
+  /* set up references */
+  next_meas[Nmeasure] = -1;
+  if (Nmeasure >= NMEASURE) {
+    fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
+  }
+
+  if (m == -1) {
+    average[0].measureOffset = Nmeasure;
+  } else {
+    next_meas[m] = Nmeasure;
+    if (m >= NMEASURE) {
+      fprintf (stderr, "WARNING: m out of bounds (4)\n");
+    }
+  }
+
+  return (TRUE);
 }
 
@@ -159 +137 @@
    we must always save the missing table, if it exists */
 
-Measure *sort_measure (Average *average, int Naverage, Measure *measure, int Nmeasure, int *next) {
-
-  int i, k, n, N;
+Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas) {
+
+  off_t i, k, n, N;
   Measure *tmpmeasure;
 
@@ -171 +149 @@
     average[i].measureOffset = N;
     for (k = 0; k < average[i].Nmeasure; k++, N++) {
+      if (n == -1) abort();
       tmpmeasure[N] = measure[n]; 
+      if (measure[n].averef != i) abort();
       tmpmeasure[N].averef = i;
-      n = next[n];
+      n = next_meas[n];
     }
   }
@@ -180 +160 @@
 }
 
-Missing *sort_missing (Average *average, int Naverage, Missing *missing, int Nmissing, int *next) {
-
-  int i, k, n, N;
+/* build the initial links assuming the table is sorted */
+off_t *init_missing_links (Average *average, off_t Naverage, Missing *missing, off_t Nmissing) {
+
+  off_t i, j, N;
+  off_t *next_miss;
+
+  N = 0;
+
+  ALLOCATE (next_miss, off_t, Nmissing);
+  for (i = 0; i < Naverage; i++) {
+    for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
+      next_miss[N] = N + 1;
+    }
+    if (average[i].Nmissing > 0) {
+      next_miss[N] = -1;
+      if (N >= Nmissing) {
+        fprintf (stderr, "overflow in init_missing_links");
+        abort ();
+      }
+      N++;
+    }
+
+  }
+  return (next_miss);
+}
+
+off_t add_miss_link (Average *average, off_t *next_miss, off_t Nmissing) {
+
+  off_t k, m;
+
+  /* there may be 0 Nmiss; this is not true for Nmeas */
+  if (average[0].Nmissing < 1) {
+    average[0].missingOffset = Nmissing;
+    next_miss[Nmissing] = -1;
+    return (TRUE);
+  }
+
+  m = average[0].missingOffset;  
+  for (k = 0; k < average[0].Nmissing - 1; k++) m = next_miss[m];
+  /* set up references */
+  next_miss[Nmissing] = -1;
+  next_miss[m] = Nmissing;
+  return (TRUE);
+}
+
+Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss) {
+
+  off_t i, k, n, N;
   Missing *tmpmissing;
 
@@ -193 +218 @@
     for (k = 0; k < average[i].Nmissing; k++, N++) {
       tmpmissing[N] = missing[n]; 
-      n = next[n];
+      n = next_miss[n];
     }
   }
@@ -199 +224 @@
   return (tmpmissing);
 }
+