X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flibpspp%2Fsparse-xarray.c;h=5168d87922f46fb62b317b89172f4d6831f9acc8;hb=e71b8fcc7e866cb0b123b1b00070f5442903834b;hp=7480f7c266bf11c5b3f98391f3293ef6a9d66aab;hpb=70514b3f2f32d57e58b04c01c83bc5f372559824;p=pspp

diff --git a/src/libpspp/sparse-xarray.c b/src/libpspp/sparse-xarray.c
index 7480f7c266..5168d87922 100644
--- a/src/libpspp/sparse-xarray.c
+++ b/src/libpspp/sparse-xarray.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
+   Copyright (C) 2007, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -16,22 +16,22 @@
 
 #include <config.h>
 
-#include <libpspp/sparse-xarray.h>
+#include "libpspp/sparse-xarray.h"
 
 #include <limits.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include <libpspp/assertion.h>
-#include <libpspp/misc.h>
-#include <libpspp/range-set.h>
-#include <libpspp/sparse-array.h>
-#include <libpspp/temp-file.h>
+#include "libpspp/assertion.h"
+#include "libpspp/ext-array.h"
+#include "libpspp/misc.h"
+#include "libpspp/range-set.h"
+#include "libpspp/sparse-array.h"
 
-#include "md4.h"
-#include "minmax.h"
-#include "xalloc.h"
+#include "gl/md4.h"
+#include "gl/minmax.h"
+#include "gl/xalloc.h"
 
 /* A sparse array of arrays of bytes. */
 struct sparse_xarray
@@ -40,7 +40,7 @@ struct sparse_xarray
     uint8_t *default_row;               /* Defaults for unwritten rows. */
     unsigned long int max_memory_rows;  /* Max rows before dumping to disk. */
     struct sparse_array *memory;        /* Backing, if stored in memory. */
-    struct temp_file *disk;             /* Backing, if stored on disk. */
+    struct ext_array *disk;             /* Backing, if stored on disk. */
     struct range_set *disk_rows;        /* Allocated rows, if on disk. */
   };
 
@@ -103,10 +103,9 @@ sparse_xarray_clone (const struct sparse_xarray *old)
       const struct range_set_node *node;
       void *tmp = xmalloc (old->n_bytes);
 
-      new->disk = temp_file_create ();
+      new->disk = ext_array_create ();
       new->disk_rows = range_set_clone (old->disk_rows, NULL);
-      for (node = range_set_first (old->disk_rows); node != NULL;
-           node = range_set_next (old->disk_rows, node))
+      RANGE_SET_FOR_EACH (node, old->disk_rows)
         {
           unsigned long int start = range_set_node_get_start (node);
           unsigned long int end = range_set_node_get_end (node);
@@ -115,8 +114,8 @@ sparse_xarray_clone (const struct sparse_xarray *old)
           for (idx = start; idx < end; idx++)
             {
               off_t offset = (off_t) idx * old->n_bytes;
-              if (!temp_file_read (old->disk, offset, old->n_bytes, tmp)
-                  || !temp_file_write (new->disk, offset, old->n_bytes, tmp))
+              if (!ext_array_read (old->disk, offset, old->n_bytes, tmp)
+                  || !ext_array_write (new->disk, offset, old->n_bytes, tmp))
                 {
                   free (tmp);
                   sparse_xarray_destroy (new);
@@ -135,6 +134,21 @@ sparse_xarray_clone (const struct sparse_xarray *old)
   return new;
 }
 
+static void
+free_memory_rows (struct sparse_xarray *sx)
+{
+  if (sx->memory != NULL)
+    {
+      unsigned long int idx;
+      uint8_t **row;
+      for (row = sparse_array_first (sx->memory, &idx); row != NULL;
+           row = sparse_array_next (sx->memory, idx, &idx))
+        free (*row);
+      sparse_array_destroy (sx->memory);
+      sx->memory = NULL;
+    }
+}
+
 /* Destroys sparse array of rows SX. */
 void
 sparse_xarray_destroy (struct sparse_xarray *sx)
@@ -142,16 +156,8 @@ sparse_xarray_destroy (struct sparse_xarray *sx)
   if (sx != NULL)
     {
       free (sx->default_row);
-      if (sx->memory != NULL)
-        {
-          unsigned long int idx;
-          uint8_t **row;
-          for (row = sparse_array_first (sx->memory, &idx); row != NULL;
-               row = sparse_array_next (sx->memory, idx, &idx))
-            free (*row);
-          sparse_array_destroy (sx->memory);
-        }
-      temp_file_destroy (sx->disk);
+      free_memory_rows (sx);
+      ext_array_destroy (sx->disk);
       range_set_destroy (sx->disk_rows);
       free (sx);
     }
@@ -192,25 +198,24 @@ dump_sparse_xarray_to_disk (struct sparse_xarray *sx)
   assert (sx->memory != NULL);
   assert (sx->disk == NULL);
 
-  sx->disk = temp_file_create ();
+  sx->disk = ext_array_create ();
   sx->disk_rows = range_set_create ();
 
   for (row = sparse_array_first (sx->memory, &idx); row != NULL;
        row = sparse_array_next (sx->memory, idx, &idx))
     {
-      if (!temp_file_write (sx->disk, (off_t) idx * sx->n_bytes, sx->n_bytes,
+      if (!ext_array_write (sx->disk, (off_t) idx * sx->n_bytes, sx->n_bytes,
                           *row))
         {
-          temp_file_destroy (sx->disk);
+          ext_array_destroy (sx->disk);
           sx->disk = NULL;
           range_set_destroy (sx->disk_rows);
           sx->disk_rows = NULL;
           return false;
         }
-      range_set_insert (sx->disk_rows, idx, 1);
+      range_set_set1 (sx->disk_rows, idx, 1);
     }
-  sparse_array_destroy (sx->memory);
-  sx->memory = NULL;
+  free_memory_rows (sx);
   return true;
 }
 
@@ -246,7 +251,7 @@ sparse_xarray_read (const struct sparse_xarray *sx, unsigned long int row,
   else
     {
       if (range_set_contains (sx->disk_rows, row))
-        return temp_file_read (sx->disk, (off_t) row * sx->n_bytes + start,
+        return ext_array_read (sx->disk, (off_t) row * sx->n_bytes + start,
                                n, data);
     }
 
@@ -261,13 +266,13 @@ write_disk_row (struct sparse_xarray *sx, unsigned long int row,
 {
   off_t ofs = (off_t) row * sx->n_bytes;
   if (range_set_contains (sx->disk_rows, row))
-    return temp_file_write (sx->disk, ofs + start, n, data);
+    return ext_array_write (sx->disk, ofs + start, n, data);
   else
     {
-      range_set_insert (sx->disk_rows, row, 1);
-      return (temp_file_write (sx->disk, ofs, start, sx->default_row)
-              && temp_file_write (sx->disk, ofs + start, n, data)
-              && temp_file_write (sx->disk, ofs + start + n,
+      range_set_set1 (sx->disk_rows, row, 1);
+      return (ext_array_write (sx->disk, ofs, start, sx->default_row)
+              && ext_array_write (sx->disk, ofs + start, n, data)
+              && ext_array_write (sx->disk, ofs + start + n,
                                   sx->n_bytes - start - n,
                                   sx->default_row + start + n));
     }
@@ -336,8 +341,7 @@ sparse_xarray_write_columns (struct sparse_xarray *sx, size_t start,
     {
       const struct range_set_node *node;
 
-      for (node = range_set_first (sx->disk_rows); node != NULL;
-           node = range_set_next (sx->disk_rows, node))
+      RANGE_SET_FOR_EACH (node, sx->disk_rows)
         {
           unsigned long int start_row = range_set_node_get_start (node);
           unsigned long int end_row = range_set_node_get_end (node);
@@ -346,12 +350,12 @@ sparse_xarray_write_columns (struct sparse_xarray *sx, size_t start,
           for (row = start_row; row < end_row; row++)
             {
               off_t offset = (off_t) row * sx->n_bytes;
-              if (!temp_file_write (sx->disk, offset + start, n, data))
+              if (!ext_array_write (sx->disk, offset + start, n, data))
                 break;
             }
         }
 
-      if (temp_file_error (sx->disk))
+      if (ext_array_error (sx->disk))
         return false;
     }
   return true;
@@ -392,7 +396,7 @@ get_row (const struct sparse_xarray *sx, unsigned long int idx,
       uint8_t **p = sparse_array_get (sx->memory, idx);
       return *p;
     }
-  else if (temp_file_read (sx->disk, (off_t) idx * sx->n_bytes,
+  else if (ext_array_read (sx->disk, (off_t) idx * sx->n_bytes,
                            sx->n_bytes, buffer))
     return buffer;
   else
@@ -446,8 +450,7 @@ sparse_xarray_copy (const struct sparse_xarray *sx, struct sparse_xarray *dx,
           const struct range_set_node *node;
           void *tmp = xmalloc (sx->n_bytes);
 
-          for (node = range_set_first (sx->disk_rows); node != NULL;
-               node = range_set_next (sx->disk_rows, node))
+          RANGE_SET_FOR_EACH (node, sx->disk_rows)
             {
               unsigned long int start = range_set_node_get_start (node);
               unsigned long int end = range_set_node_get_end (node);
@@ -456,10 +459,10 @@ sparse_xarray_copy (const struct sparse_xarray *sx, struct sparse_xarray *dx,
               for (row = start; row < end; row++)
                 {
                   off_t offset = (off_t) row * sx->n_bytes;
-                  success = (temp_file_read (sx->disk, offset, sx->n_bytes,
+                  success = (ext_array_read (sx->disk, offset, sx->n_bytes,
                                              tmp)
                              && cb (tmp, tmp, aux)
-                             && temp_file_write (dx->disk, offset,
+                             && ext_array_write (dx->disk, offset,
                                                  dx->n_bytes, tmp));
                   if (!success)
                     break;
@@ -587,8 +590,7 @@ sparse_xarray_model_checker_hash (const struct sparse_xarray *sx,
       void *tmp = xmalloc (sx->n_bytes);
 
       md4_process_bytes ("d", 1, &ctx);
-      for (node = range_set_first (sx->disk_rows); node != NULL;
-           node = range_set_next (sx->disk_rows, node))
+      RANGE_SET_FOR_EACH (node, sx->disk_rows)
         {
           unsigned long int start = range_set_node_get_start (node);
           unsigned long int end = range_set_node_get_end (node);
@@ -597,7 +599,7 @@ sparse_xarray_model_checker_hash (const struct sparse_xarray *sx,
           for (idx = start; idx < end; idx++)
             {
               off_t offset = (off_t) idx * sx->n_bytes;
-              if (!temp_file_read (sx->disk, offset, sx->n_bytes, tmp))
+              if (!ext_array_read (sx->disk, offset, sx->n_bytes, tmp))
                 NOT_REACHED ();
               md4_process_bytes (&idx, sizeof idx, &ctx);
               md4_process_bytes (tmp, sx->n_bytes, &ctx);