Hallo,
Ik ben aan het werk aan een klein bij-projectje voor mijn grote project (een RTS game in managed code, voor de lol, niks serieus op dit moment) en ben een beetje aan het benchmarken geweest in de richting van wiskunde en matrices...
Managed DirectX bevat classes voor matrices, vectors, quaternions en al dat soort spul en gebruikt intern d3dx om dat voor elkaar te krijgen. Mijn projectje moet natuurlijk op meerdere platformen kunnen draaien, maar wel zo snel mogelijk als dat kan (dus door gebruik te maken van de snelste libraries die er zijn voor dat platform). Nu heb ik een matrix vermenigvuldiging gebenchmarkt en ik krijg daar opmerkelijke resultaten uit...
De makkelijkste manier, via de methods op het MDX matrix object
................!
Took: 0h, 0m, 1.656s. for 8000000 iterations.
Iters per ms: 4830,18867924528 - Ms per iter: 0,00020703125
De iets minder makkelijke manier, via MDX' unsafe native methods:
................!
Took: 0h, 0m, 0.750s. for 8000000 iterations.
Iters per ms: 10666,6666666667 - Ms per iter: 9,375E-05
En de .net manier, met een heel simpel matrix classje wat ik in elkaar gedraaid heb:
................!
Took: 0h, 0m, 0.750s. for 8000000 iterations.
Iters per ms: 10666,6666666667 - Ms per iter: 9,375E-05
(nee, dit is geen copy/paste fout)
Mijn vraag is nu, gezien deze resultaten, ben ik iets verkeerd aan het doen met de managed directx calls? Een heel eenvoudige implementatie in .net lijkt haast net zo snel te zijn als gebruik maken van de geoptimaliseerde d3dx calls. Ik had verwacht dat de .net code toch wel iets langzamer zou zijn...
Ik ben aan het werk aan een klein bij-projectje voor mijn grote project (een RTS game in managed code, voor de lol, niks serieus op dit moment) en ben een beetje aan het benchmarken geweest in de richting van wiskunde en matrices...
Managed DirectX bevat classes voor matrices, vectors, quaternions en al dat soort spul en gebruikt intern d3dx om dat voor elkaar te krijgen. Mijn projectje moet natuurlijk op meerdere platformen kunnen draaien, maar wel zo snel mogelijk als dat kan (dus door gebruik te maken van de snelste libraries die er zijn voor dat platform). Nu heb ik een matrix vermenigvuldiging gebenchmarkt en ik krijg daar opmerkelijke resultaten uit...
De makkelijkste manier, via de methods op het MDX matrix object
code:
1
2
3
4
5
| public bool Execute()
{
o = Matrix.Multiply(m, n);
return true;
} |
................!
Took: 0h, 0m, 1.656s. for 8000000 iterations.
Iters per ms: 4830,18867924528 - Ms per iter: 0,00020703125
De iets minder makkelijke manier, via MDX' unsafe native methods:
code:
1
2
3
4
5
6
7
8
9
10
11
| public bool Execute()
{
unsafe
{
fixed (Matrix* pm = &m) fixed (Matrix* pn = &n) fixed (Matrix* po = &o)
{
UnsafeNativeMethods.Matrix.Multiply(po, pm, pn);
}
}
return true;
} |
................!
Took: 0h, 0m, 0.750s. for 8000000 iterations.
Iters per ms: 10666,6666666667 - Ms per iter: 9,375E-05
En de .net manier, met een heel simpel matrix classje wat ik in elkaar gedraaid heb:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| public bool Execute()
{
Multiply(ref o, ref m, ref n);
return true;
}
private void Multiply(ref DNMatrix o, ref DNMatrix m, ref DNMatrix n)
{
o.m11 = m.m11 * n.m11 + m.m12 * n.m21 + m.m13 * n.m31 + m.m14 * n.m41;
o.m12 = m.m11 * n.m12 + m.m12 * n.m22 + m.m13 * n.m32 + m.m14 * n.m42;
o.m13 = m.m11 * n.m13 + m.m12 * n.m23 + m.m13 * n.m33 + m.m14 * n.m43;
o.m14 = m.m11 * n.m14 + m.m12 * n.m24 + m.m13 * n.m34 + m.m14 * n.m44;
o.m21 = m.m21 * n.m11 + m.m22 * n.m21 + m.m23 * n.m31 + m.m24 * n.m41;
o.m22 = m.m21 * n.m12 + m.m22 * n.m22 + m.m23 * n.m32 + m.m24 * n.m42;
o.m23 = m.m21 * n.m13 + m.m22 * n.m23 + m.m23 * n.m33 + m.m24 * n.m43;
o.m24 = m.m21 * n.m14 + m.m22 * n.m24 + m.m23 * n.m34 + m.m24 * n.m44;
o.m31 = m.m31 * n.m11 + m.m32 * n.m21 + m.m33 * n.m31 + m.m34 * n.m41;
o.m32 = m.m31 * n.m12 + m.m32 * n.m22 + m.m33 * n.m32 + m.m34 * n.m42;
o.m33 = m.m31 * n.m13 + m.m32 * n.m23 + m.m33 * n.m33 + m.m34 * n.m43;
o.m34 = m.m31 * n.m14 + m.m32 * n.m24 + m.m33 * n.m34 + m.m34 * n.m44;
o.m41 = m.m41 * n.m11 + m.m42 * n.m21 + m.m43 * n.m31 + m.m44 * n.m41;
o.m42 = m.m41 * n.m12 + m.m42 * n.m22 + m.m43 * n.m32 + m.m44 * n.m42;
o.m43 = m.m41 * n.m13 + m.m42 * n.m23 + m.m43 * n.m33 + m.m44 * n.m43;
o.m44 = m.m41 * n.m14 + m.m42 * n.m24 + m.m43 * n.m34 + m.m44 * n.m44;
} |
................!
Took: 0h, 0m, 0.750s. for 8000000 iterations.
Iters per ms: 10666,6666666667 - Ms per iter: 9,375E-05
(nee, dit is geen copy/paste fout)
Mijn vraag is nu, gezien deze resultaten, ben ik iets verkeerd aan het doen met de managed directx calls? Een heel eenvoudige implementatie in .net lijkt haast net zo snel te zijn als gebruik maken van de geoptimaliseerde d3dx calls. Ik had verwacht dat de .net code toch wel iets langzamer zou zijn...
:strip_icc():strip_exif()/u/6697/gerco-icon.jpg?f=community){kind=icon}
:strip_icc():strip_exif()/u/12461/crop65b195553d948.jpg?f=community)
MS geeft nogal hoog op van hun JITer/compiler als ik het me goed herinner, dus ik zou het niet geheel onwaarschijnlijk vinden als hij je truuckje doorziet.
:strip_exif()/u/11775/SoulTaker.gif?f=community)
. Het is een d3d functie, daar heb je over het algemeen geen algemene matrixfunctionaliteit voor nodig.
/u/81985/crop566b00b43645a.png?f=community)
). Ik zat er net wat mee te rommelen en int i = new int(); werkt ook in .NET 1.1, dus het zal wel een of andere vage syntax afspraak zijn. Het int type heeft geen constructor, dus new int(0) werkt niet en .NET 1.1 heeft geen generics, dus het lijkt een beetje nutteloos. De enige reden die ik ervoor kan bedenken zou inderdaad zijn om het voor alle value types consistent te houden, aangezien je voor structs wel gewoon 'constructors' kan definieren.
(Verder heeft PHP wel references en - nog veel 'erger' - globale variabelen.)