title: what(): std::bad_alloc - am I out of memory?
body: <p>My dataset: 500,000 points in 960 dimensions. The size of the file is 1.9 GB (1,922,000,000 bytes).</p>
  
  <p>The code works for smaller data sets, but for this it will crash in the same point every time. Here is a minimal example:</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include &lt;vector&gt;
  
  template&lt;typename T&gt;
  class Division_Euclidean_space {
   public:
    /**
     * The data type.
     */
    typedef T FT;
  
    /**
     * Constructor, which
     * sets 'N' and 'D' to zero.
     */
    Division_Euclidean_space()
        : N(0),
          D(0) {
  
    }
  
    /**
     * @param n - size of data
     */
    void setSize(size_t&amp; n) {
      N = n;
    }
  
    /**
     * @param n - size of data
     */
    void setSize(int n) {
      N = n;
    }
  
    /**
     * Get the number of points
     *
     * @return - the number of points
     */
    const size_t&amp; size() const {
      return N;
    }
  
    /**
     * Get the dimension of points
     *
     * @return - the dimension
     */
    const int dim() {
      return D;
    }
  
    /**
     * @param d - dimension of data
     */
    void setDim(int&amp; d) {
      D = d;
    }
  
    /**
     * \brief Inserts a new value to the collection of
     * points, held in the private vector.
     *
     * @param v - value to be inserted
     */
    void insert(FT v) {
      p.push_back(v);
    }
  
   private:
    /**
     * number of points
     */
    size_t N;
    /**
     * dimension of points
     */
    int D;
    /**
     * vector of points
     * Note that indexing is of the form: [i * D + j]
     */
    std::vector&lt;FT&gt; p;
  };
  
  typedef Division_Euclidean_space&lt;int&gt; Division_space;
  typedef Division_space::FT FT;
  
  template&lt;typename T&gt;
  void readDivisionSpacefvecs(Division_Euclidean_space&lt;T&gt;&amp; ds, int&amp; N, int&amp; D,
                              char* filename) {
    FILE* fid;
    fid = fopen(filename, "rb");
    if (!fid)
      printf("I/O error : Unable to open the file %s\n", filename);
  
    // we assign the return value of fread() to 'sz' just to suppress a warning
    size_t sz = fread(&amp;D, sizeof(D), 1, fid);
    fseek(fid, 0L, SEEK_END);
    sz = ftell(fid);
    N = sz / (1 * 4 + D * 4);
    //printf("N = %d, D = %d, |%s|\n", N, D, filename);
  
    fseek(fid, 0L, SEEK_SET);
    ds.setSize(N);
    ds.setDim(D);
    std::cout &lt;&lt; ds.dim() &lt;&lt; " " &lt;&lt; ds.size() &lt;&lt; "\n";
    int c = 0;
    float v;
    int i, j;
    for (i = 0; i &lt; N; ++i) {
      sz = fread(&amp;D, sizeof(D), 1, fid);
      //printf("%d\n", D);
      for (j = 0; j &lt; D; ++j) {
        sz = fread(&amp;v, sizeof(v), 1, fid);
        if (c &gt;= 279619)
          printf("j = %d, v = %f, read up to point %d\n", j, v, c);
        ds.insert(v);
      }
      ++c;
      printf("read up to %d\n", c);
    }
    if (c != N)
      printf("WARNING! Read less points than expected.\n");
  }
  
  int main() {
    Division_space test;
    int N, D;
    readDivisionSpacefvecs&lt;FT&gt;(test, N, D, "../../parallel/rkd_forest/Datasets/gist/gist_learn.fvecs");
  
    return 0;
  }
  </code></pre>
  
  <p>Output:</p>
  
  <pre><code>...
  j = 255, v = 0.052300, read up to point 279620
  j = 256, v = 0.052300, read up to point 279620
  terminate called after throwing an instance of 'std::bad_alloc'
    what(): std::bad_alloc
  Aborted
  </code></pre>
  
  <p>Am I out of memory? How can I know?</p>
  
  <p>Here is how much memory I have:</p>
  
  <pre><code>samaras@samaras-A15:~$ free -mt
               total       used       free     shared    buffers     cached
  Mem:          3934       2638       1295          0        179       1000
  -/+ buffers/cache:       1458       2475
  Swap:         3987          0       3987
  Total:        7922       2638       5283
  </code></pre>