As suggested on myprevious question, I am posting my revised code for feedback.

One thing that caught my attention is that my program actually runs slower after adding the modifications. It was previously running near 128 iterations per second on a single core machine and 382 in a 4-core machine. It now runs at 125 in the single core and 360 in the 4-core machine. I am not sure the way I was managing memory in my first version is faster or if I implemented it wrong.

Grid3d.h:

#ifndef _GRID3D_#define _GRID3D_#include <iostream>class Grid3d{private:    size_t M, N, L;    double* buffer;    size_t compute_index(size_t, size_t, size_t) const;public:    //Constructores    Grid3d(size_t,size_t,size_t);    Grid3d();    Grid3d(const Grid3d&);    ~Grid3d();    //Operadores    double& operator()(size_t, size_t, size_t);    double  operator()(size_t, size_t, size_t) const;    Grid3d& operator=(Grid3d);    //Acceso    int get_L();    int get_M();    int get_N();    double get(size_t,size_t,size_t) const;    void reset();};std::ostream & operator<< (std::ostream &,Grid3d);#endif

Grid3d.cc:

#include "Grid3d.h"#include <cmath>#include <iomanip>#include <cassert>using namespace std;//------------------------------------------------------------------// Constructores //------------------------------------------------------------------//ConstructorGrid3d::Grid3d(size_t M, size_t N, size_t L)      : M(M), N(N), L(L), buffer(new double[M * N * L]){    for (size_t l=0;l<M*N*L;l++){        buffer[l] = NAN;    }}//Constructor vacíoGrid3d::Grid3d()    :M(0), N(0), L(0){    buffer = NULL;}//Constructor copiaGrid3d::Grid3d(const Grid3d &other)    :M(other.M), N(other.N), L(other.L){    buffer = new double[M * N * L];    for (size_t l=0;l<M*N*L;l++){        buffer[l] = other.buffer[l];    }}//DestructorGrid3d::~Grid3d() { delete [] buffer; }//------------------------------------------------------------------// Operadores //------------------------------------------------------------------//Access operator ():double& Grid3d::operator()(size_t i, size_t j, size_t k){    assert(i >= 0 and i < M);    assert(j >= 0 and j < N);    assert(k >= 0 and k < L);    return buffer[compute_index(i, j, k)];}//Access operator () const:double Grid3d::operator()(size_t i, size_t j, size_t k) const{    assert(i >= 0 and i < M);    assert(j >= 0 and j < N);    assert(k >= 0 and k < L);    return buffer[compute_index(i, j, k)];}//Assignment operatorGrid3d& Grid3d::operator=(Grid3d other){    using std::swap;    swap(M, other.M);    swap(N, other.N);    swap(L, other.L);    swap(buffer, other.buffer);    return *this;}//------------------------------------------------------------------// Acceso //------------------------------------------------------------------size_t Grid3d::compute_index(size_t i, size_t j, size_t k) const{    return k * (M * N) + i * N + j;}int Grid3d::get_L(){    return L;}int Grid3d::get_M(){    return M;}int Grid3d::get_N(){    return N;}double Grid3d::get(size_t i, size_t j, size_t k) const{    assert(i >= 0 and i < M);    assert(j >= 0 and j < N);    assert(k >= 0 and k < L);    return buffer[compute_index(i, j, k)];}void Grid3d::reset(){    for (size_t l=0;l<M*N*L;l++){        buffer[l] = NAN;    }}//------------------------------------------------------------------// Others//------------------------------------------------------------------//coutstd::ostream & operator << (std::ostream & os , Grid3d g){    int M = g.get_M();    int N = g.get_N();    int L = g.get_L();    for (int k=0;k<L;k++){        cout << "k = " << k << endl;        for (int i=0;i<M;i++){            for (int j=0;j<N;j++){                cout.width(10);                os << setprecision(3) << g.get(i,j,k)<< " ";            }            os << endl;        }           os << endl;    }    return os;}

• \$\begingroup\$Are you compiling with optimization on? This is probably important, as with optimization off, compute_index will not be inlined (for example).\$\endgroup\$

  ruds

  – ruds

  2013-06-25 01:13:15 +00:00

  CommentedJun 25, 2013 at 1:13
• 2
  \$\begingroup\$As another note, using NANs may slow down your code considerably. Floating point operations with NaNs are slower than those without.\$\endgroup\$

  ruds

  – ruds

  2013-06-25 01:16:40 +00:00

  CommentedJun 25, 2013 at 1:16
• 4
  \$\begingroup\$I won't post this as an answer since it's been covered in detail on your previous post, but I'd like to again strongly urge you to use a single dimensional vector. With optimizations, it will be as fast as a raw array. It will provide much cleaner and smaller code at literally 0 cost. I consider a bare array the wrong choice here unless performance actually does be one a concern and a bare array is faster (and it wouldn't be).\$\endgroup\$

  Corbin

  – Corbin

  2013-06-25 03:38:53 +00:00

  CommentedJun 25, 2013 at 3:38
• 1
  \$\begingroup\$I would strongly recommend you to use English in your comments as well. Not only is it good practice, but it also helps in case you ever need to, say, post your code to an English-language online Q&A or code review site.\$\endgroup\$

  Lstor

  – Lstor

  2013-06-25 05:38:58 +00:00

  CommentedJun 25, 2013 at 5:38
• \$\begingroup\$@ruds I am compiling using gcc 4.7 with -O2. I initialize the grid points as NAN, then i change each point to its propper value(which is generally not 0). That way, if I forget to define the value of a grid point I notice imediatley, so i am not doing float operation with nans.\$\endgroup\$

  user1995432

  – user1995432

  2013-06-26 03:00:22 +00:00

  CommentedJun 26, 2013 at 3:00

3 Answers3

Start asking to get answers

Find the answer to your question by asking.

Explore related questions

See similar questions with these tags.