Mercurial > octave-nkf
changeset 9773:01f897d8a130
optimize memory manipulation by arrays & indexing
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Tue, 03 Nov 2009 11:35:59 +0100 |
| parents | 3ac8ea48279b |
| children | fbf15a0f30f0 |
| files | liboctave/Array.cc liboctave/Array.h liboctave/ChangeLog liboctave/Makefile.in liboctave/idx-vector.cc liboctave/idx-vector.h |
| diffstat | 6 files changed, 59 insertions(+), 33 deletions(-) [+] |
line wrap: on
line diff
--- a/liboctave/Array.cc Tue Nov 03 07:44:20 2009 +0100 +++ b/liboctave/Array.cc Tue Nov 03 11:35:59 2009 +0100 @@ -77,7 +77,7 @@ slice_data = rep->data; } else - std::fill (slice_data, slice_data + slice_len, val); + octave_fill (slice_len, val, slice_data); } template <class T> @@ -568,7 +568,10 @@ { octave_idx_type step = stride[0], len = dim[0]; if (step == 1) - dest = std::copy (src, src + len, dest); + { + octave_ucopy (len, src, dest); + dest += len; + } else { for (octave_idx_type i = 0, j = 0; i < len; i++, j += step) @@ -829,8 +832,8 @@ { if (lev == 0) { - T* destc = std::copy (src, src + cext[0], dest); - std::fill (destc, dest + dext[0], rfv); + octave_ucopy (cext[0], src, dest); + octave_fill (dext[0] - cext[0], rfv, dest + cext[0]); } else { @@ -838,7 +841,7 @@ for (k = 0; k < cext[lev]; k++) do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1); - std::fill (dest + k * dd, dest + dext[lev], rfv); + octave_fill (dext[lev] - k * dd, rfv, dest + k * dd); } } public: @@ -1114,7 +1117,7 @@ Array<T> tmp (Array<T> (nn), dv, 0, n); T *dest = tmp.fortran_vec (); - std::copy (data (), data () + nx, dest); + octave_ucopy (nx, data (), dest); dest[nx] = rfv; *this = tmp; @@ -1126,8 +1129,8 @@ T *dest = tmp.fortran_vec (); octave_idx_type n0 = std::min (n, nx), n1 = n - n0; - dest = std::copy (data (), data () + n0, dest); - std::fill (dest, dest + n1, rfv); + octave_ucopy (n0, data (), dest); + octave_fill (n1, rfv, dest + n0); *this = tmp; } @@ -1153,19 +1156,23 @@ octave_idx_type c0 = std::min (c, cx), c1 = c - c0; const T *src = data (); if (r == rx) - dest = std::copy (src, src + r * c0, dest); + { + octave_ucopy (r * c0, src, dest); + dest += r * c0; + } else { for (octave_idx_type k = 0; k < c0; k++) { - dest = std::copy (src, src + r0, dest); + octave_ucopy (r0, src, dest); src += rx; - std::fill (dest, dest + r1, rfv); + dest += r0; + octave_fill (r1, rfv, dest); dest += r1; } } - std::fill (dest, dest + r * c1, rfv); + octave_fill (r * c1, rfv, dest); *this = tmp; } @@ -1550,8 +1557,8 @@ Array<T> tmp (dim_vector (col_vec ? m : 1, !col_vec ? m : 1)); const T *src = data (); T *dest = tmp.fortran_vec (); - dest = std::copy (src, src + l, dest); - dest = std::copy (src + u, src + n, dest); + octave_ucopy (l, src, dest); + octave_ucopy (n - u, src + u, dest + l); *this = tmp; } else @@ -1602,8 +1609,10 @@ l *= dl; u *= dl; n *= dl; for (octave_idx_type k = 0; k < du; k++) { - dest = std::copy (src, src + l, dest); - dest = std::copy (src + u, src + n, dest); + octave_ucopy (l, src, dest); + dest += l; + octave_ucopy (n - u, src + u, dest); + dest += n - u; src += n; }
--- a/liboctave/Array.h Tue Nov 03 07:44:20 2009 +0100 +++ b/liboctave/Array.h Tue Nov 03 11:35:59 2009 +0100 @@ -38,6 +38,7 @@ #include "lo-utils.h" #include "oct-sort.h" #include "quit.h" +#include "oct-mem.h" // One dimensional array class. Handles the reference counting for // all the derived classes. @@ -61,29 +62,29 @@ int count; ArrayRep (T *d, octave_idx_type l, bool copy = false) - : data (copy ? new T [l] : d), len (l), count (1) + : data (copy ? octave_new<T> (l) : d), len (l), count (1) { if (copy) - std::copy (d, d + l, data); + octave_ucopy (l, d, data); } ArrayRep (void) : data (0), len (0), count (1) { } - explicit ArrayRep (octave_idx_type n) : data (new T [n]), len (n), count (1) { } + explicit ArrayRep (octave_idx_type n) : data (octave_new<T> (n)), len (n), count (1) { } explicit ArrayRep (octave_idx_type n, const T& val) - : data (new T [n]), len (n), count (1) + : data (octave_new<T> (n)), len (n), count (1) { - std::fill (data, data + n, val); + octave_fill (n, val, data); } ArrayRep (const ArrayRep& a) - : data (new T [a.len]), len (a.len), count (1) + : data (octave_new<T> (a.len)), len (a.len), count (1) { - std::copy (a.data, a.data + a.len, data); + octave_ucopy (a.len, a.data, data); } - ~ArrayRep (void) { delete [] data; } + ~ArrayRep (void) { octave_delete<T> (data); } octave_idx_type length (void) const { return len; } @@ -168,7 +169,7 @@ T * coerce (const U *a, octave_idx_type len) { - T *retval = new T [len]; + T *retval = octave_new<T> (len); for (octave_idx_type i = 0; i < len; i++) retval[i] = T (a[i]); @@ -733,12 +734,12 @@ { return ArrayClass::xelem (ra_idx); } }; -#endif - template <class T> std::ostream& operator << (std::ostream& os, const Array<T>& a); +#endif + /* ;;; Local Variables: *** ;;; mode: C++ ***
--- a/liboctave/ChangeLog Tue Nov 03 07:44:20 2009 +0100 +++ b/liboctave/ChangeLog Tue Nov 03 11:35:59 2009 +0100 @@ -1,3 +1,18 @@ +2009-11-03 Jaroslav Hajek <highegg@gmail.com> + + * oct-mem.h: New source. + * Makefile.in: Include it. + * Array.h (Array<T>::ArrayRep::ArrayRep (...)): Use octave_new, + octave_ucopy and octave_fill. + (Array<T>::ArrayRep::~ArrayRep): Use octave_delete. + (Array<T>::coerce): Use octave_new. + * Array.cc (Array<T>::fill, rec_resize_helper::do_resize_fill, + Array<T>::resize_fill, rec_permute_helper::do_permute, + Array<T>::delete_elements): Use octave_ucopy and octave_fill. + * idx-vector.h (index_vector::index, index_vector::assign): Use + octave_ucopy. + * idx-vector.cc (index_vector::copy_data): Ditto. + 2009-11-03 Jaroslav Hajek <highegg@gmail.com> * idx-vector.cc (idx_vector::maybe_reduce): Implement (i:k:end, :)
--- a/liboctave/Makefile.in Tue Nov 03 07:44:20 2009 +0100 +++ b/liboctave/Makefile.in Tue Nov 03 11:35:59 2009 +0100 @@ -96,7 +96,7 @@ lo-ieee.h lo-mappers.h lo-math.h lo-specfun.h lo-sysdep.h \ lo-traits.h lo-utils.h mach-info.h md5.h oct-alloc.h oct-cmplx.h \ oct-env.h oct-fftw.h oct-getopt.h oct-group.h oct-inttypes.h \ - oct-locbuf.h oct-md5.h oct-mutex.h oct-norm.h \ + oct-locbuf.h oct-md5.h oct-mem.h oct-mutex.h oct-norm.h \ oct-passwd.h oct-rand.h oct-rl-edit.h oct-rl-hist.h oct-shlib.h \ oct-sort.h oct-spparms.h oct-syscalls.h oct-sparse.h oct-time.h \ oct-uname.h pathlen.h pathsearch.h prog-args.h \
--- a/liboctave/idx-vector.cc Tue Nov 03 07:44:20 2009 +0100 +++ b/liboctave/idx-vector.cc Tue Nov 03 11:35:59 2009 +0100 @@ -636,7 +636,7 @@ { idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); const octave_idx_type *rdata = r->get_data (); - std::copy (rdata, rdata + len, data); + octave_ucopy (len, rdata, data); } break; default:
--- a/liboctave/idx-vector.h Tue Nov 03 07:44:20 2009 +0100 +++ b/liboctave/idx-vector.h Tue Nov 03 11:35:59 2009 +0100 @@ -34,6 +34,7 @@ #include "dim-vector.h" #include "oct-inttypes.h" #include "oct-alloc.h" +#include "oct-mem.h" template<class T> class Array; template<class T> class Sparse; @@ -517,7 +518,7 @@ switch (rep->idx_class ()) { case class_colon: - std::copy (src, src + len, dest); + octave_ucopy (len, src, dest); break; case class_range: { @@ -525,7 +526,7 @@ octave_idx_type start = r->get_start (), step = r->get_step (); const T *ssrc = src + start; if (step == 1) - std::copy (ssrc, ssrc + len, dest); + octave_ucopy (len, ssrc, dest); else if (step == -1) std::reverse_copy (ssrc - len + 1, ssrc + 1, dest); else if (step == 0) @@ -575,7 +576,7 @@ switch (rep->idx_class ()) { case class_colon: - std::copy (src, src + len, dest); + octave_ucopy (len, src, dest); break; case class_range: { @@ -583,7 +584,7 @@ octave_idx_type start = r->get_start (), step = r->get_step (); T *sdest = dest + start; if (step == 1) - std::copy (src, src + len, sdest); + octave_ucopy (len, src, sdest); else if (step == -1) std::reverse_copy (src, src + len, sdest - len + 1); else