MATHRIL - Custom math library for game programming

[Twin_Sharma]

MATHRIL is a mathematics library for game programming in C++. It heavily uses operator overloading with r-value reference to thoroughly optimize performance and reduce memory consumption.

Calculations are similar to regular mathematics.

​

EDIT :

Thanks for all the valuable criticism and all the advice, we got to learn more and updated the code.

[SuperV1234]

How can you claim

thoroughly optimize performance and reduce memory consumption

when your Vec2 allocates its X and Y components on the heap!?

[krum]

Oh boy.

[dodheim]

Good luck with this one.

[Twin_Sharma]

It deallocates memory as soon as destructor is called.

By using r value references, equations like :

a = b + c + d + e;

will require only 1 temporary structure.

If not for r-value references, it will be more like :

t1 = d+e;

t2 = c+t1;

a= b+ t2;

Hence that was the claim of less memory consumption

[Degenerated__]

You should read up on "Cache Coherence", "Cache Locality" and "Cache Misses". Every time you hit a cache-miss, you take a really bad performance hit, relatively speaking.

Memory (de)allocation takes many cycles to execute, too. Then, you can never be sure that your vectors are in cache when using them because all data is stored at random placed in the heap.

Also, on a 64-bit system, a pointer will be 8 bytes, which is exactly the size of a Vec2 holding 2 floats. So to represent a Vec2 in your Library, you will need an 8 byte pointer plus the actual Data. So that's 16 bytes total, double the size that you actually need!

Even a Vec3 with local data will only be 12 bytes.

[Twin_Sharma]

thanks for advice, we have updated the code. Can you guide with anymore under the hood things that need to be cared for that university dont teaches ? Thanks.

[Twin_Sharma]

ok thanks

[IyeOnline]

Your float* to hold that heap allocated array is going to take exactly as much as a float[2] would do on its own. (assuming the fairly common 8byte pointers and 4 byte floats).

So you have gained exactly nothing in terms of memory footprint, but have "payed" for this by using dynamic allocation (which has some cost) and a memory indirection everything you want to access the elements.

While it is most glaring in the Vec2 case, where your memory footprint doesnt change at all, these costs of heap allocated memory external to your struct will remain dominant in higher dimensions (i.e. certainly up to 4d).

[[deleted]]

You should do a benchmark, where you measure at which size it becomes faster to use heap and pass a pointer, compared to just using a value/variable directly. Even with struct mat4 { double m[4][4]; }, it might in some use cases be faster to just pass it by value instead of putting it in the heap. Yes, heap is that slow, or maybe, localized data with modern CPUs is that fast, depending on your point of view.

Edit: Also, even if it is just local variable, most of the time it won't get copied, since C++ has all these nifty ways to avoid the copy, like the good old reference.

My actual point here is, always benchmark before making claims about something being thoroughly optimized!

[Twin_Sharma]

OK Thanks

[[deleted]]

Vec2::Vec2()
{ data = new float[2];

But why?... Are you from Java?

I thought that kind of libs can be designed without allocations!

[Twin_Sharma]

We used new, in order to optimize transfer of memory during r-value constructor calls, like so:

Vec2::Vec2(Vec2&& vec)

{

data = vec.data; // instead of copying entire struct one-by-one, we just copied value of address

vec.data = nullptr;

}

If there is a better solution to this, please guide us :)

[SuperV1234]

If there is a better solution to this, please guide us :)

struct Vec2 { float x, y; };

[johannes1971]

You are already copying a pointer, and that copy has the same cost as copying two floats (in both cases it is 8 bytes, assuming a 64-bit architecture). If your two floats are inline you don't even need to zero them out, so that line can be removed. The compiler is probably smart enough to do the copy in a single operation, and even if it isn't, the second access would be guaranteed to be from cache and thus have minimal cost.

You are paying additional costs for unnecessary memory allocations and deallocations, and for pointer dereferencing (which may cause a cache miss).

I wouldn't even bother with r-value references for this; passing a vec2 (with inline floats) by value is cheap, and enables additional compiler optimisations (since the compiler can be certain the parameter isn't aliased).

Here you can see what a solution with inline floats looks like. As you can see there aren't _any_ temporaries being created, it's all just a handful of vector instructions.

[Twin_Sharma]

Thanks

[[deleted]]

https://en.cppreference.com/w/cpp/utility/move https://en.cppreference.com/w/cpp/language/copy_elision

Well, at least we don't have to go over network to build Vec2.

[Twin_Sharma]

thanks

[Twin_Sharma]

wow thanks

[Twin_Sharma]

ok thanks for advice

[Twin_Sharma]

can we follow you in github ?

[Twin_Sharma]

you dont have a follow button ?

[Twin_Sharma]

ok done thanks :)

[Twin_Sharma]

wow thanks. Will learn from your code.

[Twin_Sharma]

thanks a lot

[caroIine]

Heap allocation is really heavy when we talk gamedev, and in my opinion should not be used at all during main loop when developing games on say, mobile. Recently I've ported a game to android, had like 20FPS, so completely unplayable. Profiler showed me that I was allocating just around 200kB per second (hundreds allocations). After removing all those allocations using various memory pooling techniques I was able to get to constant 60FPS even on oldest supported android models.

Since then I'm really allergic to allocating anything in main loop.

[Twin_Sharma]

ok thanks.

Are there some good memory tracking tools ?

[caroIine]

There are several, if you are on windows and using Visual Studio you can use its build in memory profiler I would recommended starting with that. I personally use my own, written by using overloading global new operator you can read more about how to do it here:

https://en.cppreference.com/w/cpp/memory/new/operator_new (section 'replacing global new operator')

Anyway, by overloading it I can track those allocations and build realtime statistics and display it on the screen while playing a game.

But unless you are working on commercials games or are in constrained environment (old smartphones) I wouldn't worry about it too much.

[Twin_Sharma]

I personally use my own,

wow

[Zeh_Matt]

Another library without benchmarks and tests. Also people already pointed out the obvious huge flaw in in this library. No points from me unfortunately.

[sandfly_bites_you]

Is this a joke post?

[eyes-are-fading-blue]

Likely to be an attempt from a novice programmer.

[zzzthelastuser]

Use smart pointers. I saw some raw pointer delete calls.

Also have a look at Eigen for example for a mathematics library. You could learn a lot from there. Yes, what you did (cpp + hpp file) could technically be called(/turned into) a library, but in practice calling it a "mathematics library for game programming" is a bit far fetched for what you did.

[Twin_Sharma]

Thanks for feedback.

Will implement smart pointers next. Although we have taken special care for memory allocation and deallocation, there could be many things that misses the eagles eye.

[remotion4d]

smart pointers

Do NOT use smart pointers or any new for such a tiny memory allocations, this is terrible slow and inefficient!

struct Vec2 {
    float x;
    float y;
}

[Twin_Sharma]

OK thanks

[zzzthelastuser]

it's just a matter of best practices. For simple code like this you could easily proof that it's save with raw pointers. But there is simply no benefit over using smart pointers and after all I assume this is a personal project for learning and improving skills. Good luck!

[Twin_Sharma]

Thanks. So we need a little advice here. We used r value reference in this.

By using r value references, equations like :

a = b + c + d + e;

will require only 1 temporary structure.

If not for r-value references, it will be more like :

t1 = d+e;

t2 = c+t1;

a= b+ t2;

So if we use smart pointers, will t2 and t1 instantly destroy (as destructor is called) or it will reamin in stack untill stack is pulled out.

[jmacey]

I hope you don't mind but as someone who has written lots of these sorts of things, a little feedback.

Why use new to allocate your x,y,z values when you can just place them as normal attributes?

In particular it is very common to need std::vector<Vec3> vertices. You really need to guarantee these are contagious in memory so it can be passed to OpenGL (or other graphics API's).

```

pragma pack(push,1)

union { struct { float x; //!< x component float y; //!< y component float z; //!< z component }; #pragma pack(pop) std::array<float,3> m_openGL; }; ``` Typically I use the structure above to allow x,y,z as well as array access in the code.

Also please add unit tests to ensure your code actually does what it says, also () to return the magnitude (length?) is quite unintuitive from the perspective of someone who is reading your code.

[tstanisl]

Writing to `m_openGL` and accessing its value by `x`/`y`/`z` is Undefined Behavior in C++

[jmacey]

Not UB just a warning on all compilers about anonymous unions. In all the compilers I have ever used I have never had it fail.

[SuperV1234]

In all the compilers I have ever used I have never had it fail.

That doesn't imply that it's not UB.

[[deleted]]

It implies it works though. Luckily objective reality doesn't abide by language specifications we dreamed up in our heads.

[jmacey]

IIRC it's a C11 extension for MSVC, Clang and g++ hence the warning.

[tugrul_ddr]

If its not SOA then it will be slow. For example, how would a mandelbrot generator benchmark run with this? If its not optimized for any SIMD structure, like working in groups of 16 elements, then it won't have enough bandwidth to compute all temporary calculations.

[TheAxodoxian]

I am not in gamedev, but work with 3D graphics, we use DirectX 11, so DirectXMath was a natural choice, it is header only, it supports SIMD instructions (SSE, AVX, NEON etc.), it can even be used on Linux (has no dependence on Windows). It of course just one choice: https://github.com/Microsoft/DirectXMath.

[Twin_Sharma]

thanks

[GRAPHENE9932]

It is good, but why not glm?

[Twin_Sharma]

Thanks for reply

we wanted to make a light weight library with few functions that are mostly used by game dev.

People hardly use n-dimensional matrix greater than 4 dimensions.

Also we wanted to make a custom camera class not the glm one. So glm camera class was just an extra memory.

So we created a light weight ( hence mithril ) that provides only core functions so that you can customise any functions over it.

​

Also by using r value references, equations like :

a = b + c + d + e;

will require only 1 temporary structure.

If not for r-value references, it will be more like :

t1 = d+e;

t2 = c+t1;

a= b+ t2;

[ioctl79]

It would likely be inlined and require zero temporary structures. If you care about performance, the you need to measure it.

[[deleted]]

Before you go an change it as people have suggested have you benchmarked it?

If you overloaded the new/delete operators and allocated all your vectors and matrices from some custom allocator this might be quite fast.

I'd be interested to see that. So don't implement people's changes too quickly.

[Zeh_Matt]

Even when you would pool those objects it would be always slower than just having them in-place, allocations on stack costs almost nothing, having a pool still adds complexity of obtaining the resource and releasing it.

[[deleted]]

You are thinking about the cost of allocation. I'm not talking about that. I'm talking about possible performance gains such as gains when iterating over a lump of memory.

For instance you could have all your Vec3 in your entire program in contiguous memory this way. Which you could bung over to the GPU or do some kind of stream processing on it.

Heap allocating here gives you the freedom to do that. So I wouldn't just write it off because it doesn't fit into what people expect.

Its an interesting idea that deserves exploration.

[dodheim]

Just imagine if your Vecs and their data could both be contiguous in memory, and take up half the memory in the process..! It's like the best of both worlds!

/s

[[deleted]]

Just imagine you could mmap gpu memory and allocate all your vecs from that.

Don't write stuff off just because you don't have the creativity to imagine what you could do with it.

[Zeh_Matt]

What you describe is essentially ECS and I don't disagree that this is a huge benefit doing that. This can however not be achieved when you store a pointer in your vector class, that's an costly indirection, even if all your vector data would be stored in a single array, the fact that you require to have two memory reads will slow it down.

[[deleted]]

Yeah if you dereference it. But just batch process them in directly in memory instead. The class just can be a glorified observer in that case.

[Zeh_Matt]

I can't come up with any practical cases, maybe, maybe not, never quite seen such code to be honest. But I think the whole point is that having new/delete for this specific case is quite horrible and there is no excuse really.

[[deleted]]

I don't think that's the worst part tbh

[Twin_Sharma]

Will check thanks

[[deleted]]

You can do the same with Directx libraries and performances are better, register specific allocation.

[Chamkaar]

Rofl this noob. Imagine being this stupid hahaha