[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Toon-members] Efficient (dynamic) slicing

From: E. Rosten
Subject: Re: [Toon-members] Efficient (dynamic) slicing
Date: Thu, 25 Feb 2010 20:29:21 +0000 (GMT)
User-agent: Alpine 2.00 (LSU 1167 2008-08-23)

On Wed, 24 Feb 2010, Rafael Spring wrote:

Hello gentlemen,

I'd like to learn a little bit about efficient dynamic slicing of Vectors and Matrices. Consider a situation where I hold a big Matrix in an object and want to fill that Matrix blockwise giving slices of the Matrix to an external function. Like this:

void fillSubMatrix(Matrix<>& slice) {
// write something to the sclice...

The behaviour of a matrix (slice or not) is determined by a template parameter. You probably want a function defined more like this:

template<class B>
void fillSubMatrix(Matrix<Dynamic, Dynamic, double, B>& slice)
  //Write something to the slice

This allows the function to operate efficiently on any kind of matrix. Also Matrix<>& cannot be used to represent a slice of a Matrix.

class MyMainMatrix {
MyMainMatrix() : mMatrix(500, 10) {}

void fillMatrix();

TooN::Matrix<> mMatrix;

void MyMainMatrix::fillMatrix() {
int inc = 5;    // could be any number or dynamic

for (unsigned int i = 0; i < mMatrix.num_rows(); i += inc) {
  fillSubMatrix(mMatrix.slice(i, 0, inc, mMatrix.num_cols()));

Following thread there seem to be performance penalties using dynamic slicing.

The problem depends on what you want to do with the slicing. The problem with that code is not that the slicing is dynamic, it is that the operation creates a dynamically sized temporary Vector, including data. This requires a new/delete pair and that is exceptionally slow.

The static sized example is fast because the compiler can allocate the temporary space on the stack, and probably optimizes it away anyway.

Temporary slice objects are cheap to create since they involve one pointer and 1 to 3 integer allocated on the stack.

I assume the above code would also result in a temporary object (storage allocated from the heap) being constructed at each call to fillSubMatrix().
Would the following code be any better?

I'm not sure it would compile. C++ would try to make a Matrix<> out of the slice (an allocation ans copy), but that would be a temporary and it won't let you take a non-const reference to a temporary.

void fillSubMatrix(Matrix<-1, -1, double, TooN::Internal::Slice<-1, 1> >& slice) {
// write something to the sclice

It looks like that would work. I use the template code above to avoid any reference to TooN internals, and to have generality across different kinds of slice.


(You can't go wrong with psycho-rats.)(

/d{def}def/f{/Times s selectfont}d/s{11}d/r{roll}d f 2/m{moveto}d -1
r 230 350 m 0 1 179{ 1 index show 88 rotate 4 mul 0 rmoveto}for/s 12
    d f pop 235 420 translate 0 0 moveto 1 2 scale show showpage

reply via email to

[Prev in Thread] Current Thread [Next in Thread]