using operators and large value types

[John]

I'm sorry if this is sounding like somewhat of a noob question. I'm
loading in a large binary array of 8x8 double precision floating point
matrices, right now this is defined something like

struct Mat8x8
{
double M11;
double M12;

[Jon Skeet [C# MVP]]

John <fo*@bar.comwrote:

I'm sorry if this is sounding like somewhat of a noob question. I'm
loading in a large binary array of 8x8 double precision floating point
matrices, right now this is defined something like

struct Mat8x8
{
double M11;
double M12;
.
.
.
double M86;
double M87;
double M88;

public static Mat8x8 operator*( Mat8x8 arg1, Mat8x8 arg2 )
{
...
}

};

The first question is to ask why it's a struct at all. Why not make it
a class?

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Carl Daniel [VC++ MVP]]

"John" <fo*@bar.comwrote in message
news:TK*******************@tornado.texas.rr.com...

I'm sorry if this is sounding like somewhat of a noob question. I'm
loading in a large binary array of 8x8 double precision floating point
matrices, right now this is defined something like

struct Mat8x8
{
double M11;
double M12;
.
.
.
double M86;
double M87;
double M88;

public static Mat8x8 operator*( Mat8x8 arg1, Mat8x8 arg2 )
{
...
}

};

Of course I have all these operators defined and a bunch of other methods
that do things to these matrices. The problem is that all of these things
are getting passed around by value. Often times the CPU is spending more
time copying the memory around than it is doing the calculations.

In C++ everything was getting passed around as a const reference, but of
course we can't do this in C#.

Any thoughts on the best way to go about solving this? I'd rather not
have to rewrite my functions to take "refs" or pointers to the value
types, because as far as I can tell I wouldn't be able to use the
operators anymore.

Change your Mat8x8 from a struct to a class, then it'll be passed by
reference, not by value - I'm not sure why you'd ever want a 512 byte object
to be treated as a value type.

-cd

[John]

Jon Skeet [C# MVP] wrote:

John <fo*@bar.comwrote:

>I'm sorry if this is sounding like somewhat of a noob question. I'm
loading in a large binary array of 8x8 double precision floating point
matrices, right now this is defined something like

struct Mat8x8
{
double M11;
double M12;
.
.
.
double M86;
double M87;
double M88;

public static Mat8x8 operator*( Mat8x8 arg1, Mat8x8 arg2 )
{
...
}

};

The first question is to ask why it's a struct at all. Why not make it
a class?

I figured (and was afraid) somebody would ask this. Because then I'd
have to new millions of these objects. Keeping them as a struct and
using an array allows me to blit the memory from their source. Also the
source data sometimes is passed as a pointer to a C function.

Basically I'm getting a "buffer of 8x8 matrices" and I need to do
operations on them. Sometimes I need to create a buffer of 8x8 matrices
and pass them by pointer to some non-CLR code using interop.

It's not really feasible to use them as a class.

[John]

Carl Daniel [VC++ MVP] wrote:

"John" <fo*@bar.comwrote in message
news:TK*******************@tornado.texas.rr.com...

>I'm sorry if this is sounding like somewhat of a noob question. I'm
loading in a large binary array of 8x8 double precision floating point
matrices, right now this is defined something like

struct Mat8x8
{
double M11;
double M12;
.
.
.
double M86;
double M87;
double M88;

public static Mat8x8 operator*( Mat8x8 arg1, Mat8x8 arg2 )
{
...
}

};

Of course I have all these operators defined and a bunch of other methods
that do things to these matrices. The problem is that all of these things
are getting passed around by value. Often times the CPU is spending more
time copying the memory around than it is doing the calculations.

In C++ everything was getting passed around as a const reference, but of
course we can't do this in C#.

Any thoughts on the best way to go about solving this? I'd rather not
have to rewrite my functions to take "refs" or pointers to the value
types, because as far as I can tell I wouldn't be able to use the
operators anymore.

Change your Mat8x8 from a struct to a class, then it'll be passed by
reference, not by value - I'm not sure why you'd ever want a 512 byte object
to be treated as a value type.

-cd

As I'm sure you know the math primitives in the Microsoft.DirectX
namespace are structs. I need them to be structs for the same reason
that those are structs (matrix buffers instead of vertex buffers) only
the problem is worse because my objects are far bigger. :-(

- john

[Carl Daniel [VC++ MVP]]

"John" <fo*@bar.comwrote in message
news:l6*******************@tornado.texas.rr.com...

I figured (and was afraid) somebody would ask this. Because then I'd have
to new millions of these objects. Keeping them as a struct and using an
array allows me to blit the memory from their source. Also the source
data sometimes is passed as a pointer to a C function.

Basically I'm getting a "buffer of 8x8 matrices" and I need to do
operations on them. Sometimes I need to create a buffer of 8x8 matrices
and pass them by pointer to some non-CLR code using interop.

It's not really feasible to use them as a class.

Then I think your only option is to give up on operator overloading.

Instead of

public static Mat8x8 operator*( Mat8x8 arg1, Mat8x8 arg2 )

you'd use

public static Mat8x8 Multiply( ref Mat8x8 a1, ref Mat8x8 a2)

and you'd have to call it with explicit function call syntax, including the
ref operator:

Mat8x8 p = Mat8x8.Multiple(ref a1, ref a2)

then you'd avoid the copies.

-cd

[Jon Skeet [C# MVP]]

Carl Daniel [VC++ MVP]
<cp*****************************@mvps.org.nospamwr ote:

<snip>

Change your Mat8x8 from a struct to a class, then it'll be passed by
reference, not by value - I'm not sure why you'd ever want a 512 byte object
to be treated as a value type.

It won't be passed by reference. The reference will be passed by value.
There's a big difference.

See http://www.pobox.com/~skeet/csharp/parameters.html

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Jon Skeet [C# MVP]]

John <fo*@bar.comwrote:

The first question is to ask why it's a struct at all. Why not make it
a class?

I figured (and was afraid) somebody would ask this. Because then I'd
have to new millions of these objects. Keeping them as a struct and
using an array allows me to blit the memory from their source. Also the
source data sometimes is passed as a pointer to a C function.

Basically I'm getting a "buffer of 8x8 matrices" and I need to do
operations on them. Sometimes I need to create a buffer of 8x8 matrices
and pass them by pointer to some non-CLR code using interop.

It's not really feasible to use them as a class.

If you want to do memory-efficient calculations, you could always make
them mutable. The semantics with operators should almost certainly be
to create new instances, but there's no reason why you shouldn't have
other methods which change the values.

Note that creating millions of objects really isn't a problem for .NET.
It's a lot nicer than passing 512 byte structs around...

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Carl Daniel [VC++ MVP]]

"Jon Skeet [C# MVP]" <sk***@pobox.comwrote in message
news:MP************************@msnews.microsoft.c om...

Carl Daniel [VC++ MVP]
<cp*****************************@mvps.org.nospamwr ote:

<snip>

>Change your Mat8x8 from a struct to a class, then it'll be passed by
reference, not by value - I'm not sure why you'd ever want a 512 byte
object
to be treated as a value type.

It won't be passed by reference. The reference will be passed by value.
There's a big difference.

Whether there's a big difference depends on your expectations.
Mechanically, it's analogous to the difference in C++ between

void f(int* p) // 1

and

void f(int& p) // 2

Changing it to a ref type makes the default behavior equivalent to //1,
while leaving it a struct and adding the 'ref' keyword make the behavior
equivalent to //2.

Making it a reference type AND using the ref keyword is analogous to

void f(int*& p) //3

in C++, since you're now able to change both the reference and the value of
the referenced item.

The big difference (in changing from a value type to a ref type) is, as the
OP pointed out, the allocation of arrays and the ability to pass those
arrays to native code. An array of value type is a contiguous allocation,
while an array of reference type is a contiguous allocation of "pointers",
but the instances themselves are not guaranteed to be contiguous (nor are
they likely to even be coincidentally contiguous).

-cd

[Jon Skeet [C# MVP]]

Carl Daniel [VC++ MVP]
<cp*****************************@mvps.org.nospamwr ote:

Change your Mat8x8 from a struct to a class, then it'll be passed by
reference, not by value - I'm not sure why you'd ever want a 512 byte
object
to be treated as a value type.

It won't be passed by reference. The reference will be passed by value.
There's a big difference.

Whether there's a big difference depends on your expectations.

Yes - it depends on whether your expectation is that when someone talks
about pass by reference semantics, they really mean it in the formal
sense. I do :)

Mechanically, it's analogous to the difference in C++ between

void f(int* p) // 1

and

void f(int& p) // 2

Changing it to a ref type makes the default behavior equivalent to //1,
while leaving it a struct and adding the 'ref' keyword make the behavior
equivalent to //2.

Absolutely. And // 1 involves passing a pointer by value, not passing
anything by reference. (For evidence of this, //1 would be available in
C, and the C spec explicitly states that C always uses pass-by-value
semantics.)

Making it a reference type AND using the ref keyword is analogous to

void f(int*& p) //3

in C++, since you're now able to change both the reference and the value of
the referenced item.

Yup - passing a pointer by reference.

The big difference (in changing from a value type to a ref type) is, as the
OP pointed out, the allocation of arrays and the ability to pass those
arrays to native code. An array of value type is a contiguous allocation,
while an array of reference type is a contiguous allocation of "pointers",
but the instances themselves are not guaranteed to be contiguous (nor are
they likely to even be coincidentally contiguous).

Yup, I agree with all of that. I just disagree with your claim that
making it a reference type would give pass by reference semantics.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too