Zobrazit předchozí téma :: Zobrazit následující téma |
Autor |
Zpráva |
MD

Založen: 29. 07. 2007 Příspěvky: 437 Bydliště: Praha
|
Zaslal: 11. prosinec 2008, 09:55:37 Předmět: Dynamic branching v PS - nefunguje |
|
|
Mam zasadni problem. Potrebuju zprovoznit dynamic branching v pixel shaderu, ale nedari se to. Je to pro me opravdu velky problem, protoze tak mohu usetrit znacnou cast vykonu.
Mam shader, ktery se nazacatku podiva do textury. Kdyz neco, tak vyskoci. Jinak komplexni vypocet svetel. Shader se pousti na celou obrazovku a mist, kde je potreba pocitat svetla je malo (par obdelniku), zbytek by mel shader preskocit a tim vse urychlit. Podminka koherence splnena.
Jenze podle mereni fps se tak nedeje. Tzv dynamicke vetveni nic neurychli.
300 fps - vzdy pocitej svetla
1200 fps - vzdy vyskoc
300 fps - me "dynamicke" vetveni (zde bych ale ocekaval neco mezi 300 a 1200!)
Mam kartu GF6600 GT, pouzivam shader model 3.0, kompiluju soubor s efektem pomoci DirectX, zapnul jsem maximalni optimalizace. Podle vseho, co jsem nasel na internetu bych to mel byt schopen zprovoznit. Dokonce jsem si stanhnul nejaky banchmark, ktery meril dynamic branching a zkutecne jsem u sebe zaznamenal podstatne zrychleni, kdyz byl zapnutej.
Muj kod shaderu:
kód: |
float4 ps_global( vso_global input ) : COLOR
{
float4 color = tex2D(ts_colorB1, input.textur);
if (color.a == 0) {
return float4(0,0,0,0);
} else {
float2 gbuffCoords = tex2D(ts_gbuff, input.textur).xy;
half3 normal = half3(tex2D(ts_normal, gbuffCoords).xyz) * 2 - 1;
half4 coeffs = tex2D(ts_coeffs, gbuffCoords);
half3 colorH = half3(color.xyz);
half3 res = lerp(colorH * (half3)Ambient, colorH, coeffs.y); // ambient + emissive
half diffuse = dot(normal, ToGlobalLight);
if (diffuse > 0) {
res += CalcDiffuseSpecular(diffuse, dot(normal, HalfToCameraToLight), colorH, coeffs, GlobalLightColor);
}
res += tex2D(ts_colorB2, input.textur).rgb; // local lights
return float4(res, color.a);
}
}
|
kód: |
pass P2
{
ZEnable = FALSE;
ZWriteEnable = FALSE;
AlphaBlendEnable = TRUE;
DestBlend = DESTALPHA;
SrcBlend = INVDESTALPHA;
CullMode = NONE;
VertexShader = compile vs_3_0 vs_global();
PixelShader = compile ps_3_0 ps_global();
}
|
Tak jak tedy ten dynamic branching zapnout?? _________________ - play with objects - www.krkal.org - |
|
Návrat nahoru |
|
 |
Augi

Založen: 28. 07. 2007 Příspěvky: 782 Bydliště: Čerčany
|
Zaslal: 11. prosinec 2008, 10:07:13 Předmět: |
|
|
Zkusil bych "return float4(0,0,0,0);" nahradit instrukcí "clip" pro zahození pixelu (pokud to je pro Tebe vhodné). |
|
Návrat nahoru |
|
 |
MD

Založen: 29. 07. 2007 Příspěvky: 437 Bydliště: Praha
|
Zaslal: 11. prosinec 2008, 10:18:03 Předmět: |
|
|
Ja tam vracim, protoze jsem ten buffer chtel inicializovat. Ale i prikaz discard jsem zkousel (to je to same jako clip, ne?). Nicmene to stale neresi onu pomalost. Discard v branchi je stale stejne pomaly jako plny vypocet svetel.
Jinak tohle je modelovy priklad, kde by se mel dynamic branching imho zasadne projevit. Az budu mit scenu plnou objektu tak to zde nenastane. Jenze potrebuju to i pro jine faze a pokud to nezprovoznim, tak je muj genialni algoritmus uplne na h...  _________________ - play with objects - www.krkal.org - |
|
Návrat nahoru |
|
 |
Ondras
Založen: 12. 09. 2007 Příspěvky: 66
|
Zaslal: 11. prosinec 2008, 10:31:31 Předmět: |
|
|
nechce se mi to zkouset ale aspon nejaky rady
kdyz neco ladim a nevim cim je, tak vypnu vsechny fajnustky co jdou takze buffer si smaz bud pomoci DXSAS
"ClearSetColor=ClearColor;"
"ClearSetDepth=ClearDepth;"
"Clear=Color;"
"Clear=Depth;"
nebo z primo z kodu predtim
vypni to blendovani... Jak zapnes blending tak muze byt vsechno uplne jinak. Navic si to muzes sam blendnout v shaderu.
pak az mi to zacne fungovat tak to zacnu teprve optimalizovat a sleduju jestli neni neco jinak.
pak jeste k tomu kodu. Zkus odstranit tu else vetev.
kód: |
float4 ps_global( vso_global input ) : COLOR
{
float4 color = tex2D(ts_colorB1, input.textur);
if (color.a == 0) {
return float4(0,0,0,0);
}
//////////////tady neni else vetev //////////////////
float2 gbuffCoords = tex2D(ts_gbuff, input.textur).xy;
half3 normal = half3(tex2D(ts_normal, gbuffCoords).xyz) * 2 - 1;
half4 coeffs = tex2D(ts_coeffs, gbuffCoords);
half3 colorH = half3(color.xyz);
half3 res = lerp(colorH * (half3)Ambient, colorH, coeffs.y); // ambient + emissive
half diffuse = dot(normal, ToGlobalLight);
if (diffuse > 0) {
res += CalcDiffuseSpecular(diffuse, dot(normal, HalfToCameraToLight), colorH, coeffs, GlobalLightColor);
(
res += tex2D(ts_colorB2, input.textur).rgb; // local lights
return float4(res, color.a);
} |
|
|
Návrat nahoru |
|
 |
MD

Založen: 29. 07. 2007 Příspěvky: 437 Bydliště: Praha
|
Zaslal: 11. prosinec 2008, 10:44:18 Předmět: |
|
|
Vypnout Alpha blending me uz taky napadlo a davno Ted jsem odstranil ty else vetve a znova i alfu. Nepomohlo. Zkousim vse co pisete I kdyz kompilatoru celkem verim, ze s else si poradi spravne.
Co si ja myslim je, ze spise prolozi ty ify staticky(!!). Nevim ale proc. Jde nejak ten .fx soubor prekompilovat do assembleru, abychom se mohli podivat?
Dalsi moznost je, ze nejak spatne merim fps.. hmm ale asi fakt ne
Jo a ta podminka na zacatku je spravne. v 30% to jde do te dlouhe vetve, v 70% to vyskakuje. _________________ - play with objects - www.krkal.org - |
|
Návrat nahoru |
|
 |
Ondras
Založen: 12. 09. 2007 Příspěvky: 66
|
Zaslal: 11. prosinec 2008, 10:51:46 Předmět: |
|
|
No neco jsem googlil:
Hmm try D3DXSHADER_PREFER_FLOW_CONTROL when you call D3DXCompileShader...
If so you have to use tex2Dlod rather than tex2d
ale tezko rict, tam tomu cloveku ta prvni vec taky nepomohla.
Jo stahni si FXComposer a divej se na ten asm v nem. Das shader performance a analyze shader.
EDIT:
S tema ifama... No protoze pro ten streamovej procesor muze byt rychlejsi provest obe vetve najednou a pak pouzit jen jeden vysledek nez provadet skok (if).
co mas za kartu? |
|
Návrat nahoru |
|
 |
MD

Založen: 29. 07. 2007 Příspěvky: 437 Bydliště: Praha
|
Zaslal: 11. prosinec 2008, 11:01:23 Předmět: |
|
|
D3DXSHADER_PREFER_FLOW_CONTROL jsem uz taky pri kompilaci zkousel - nepomohlo. (btw z helpu vubec neni jasne co tenhle flag vlastne znamena )
Kartu mam GeForce 6600 GT
Zkusim ten FX composer. _________________ - play with objects - www.krkal.org - |
|
Návrat nahoru |
|
 |
Ondras
Založen: 12. 09. 2007 Příspěvky: 66
|
Zaslal: 11. prosinec 2008, 11:14:54 Předmět: |
|
|
Mas to nekde k tomu demo? zkusil bych to. |
|
Návrat nahoru |
|
 |
MD

Založen: 29. 07. 2007 Příspěvky: 437 Bydliště: Praha
|
Zaslal: 11. prosinec 2008, 11:31:39 Předmět: |
|
|
Ondras napsal: |
Mas to nekde k tomu demo? zkusil bych to. |
To by bylo pro me hodne prace, takze zatim ne. Ale diky. _________________ - play with objects - www.krkal.org - |
|
Návrat nahoru |
|
 |
nevim.nevim
Založen: 11. 12. 2008 Příspěvky: 1
|
Zaslal: 11. prosinec 2008, 15:31:52 Předmět: |
|
|
citace: |
One of the main innovations introduced with the GeForce 6800 was dynamic branching in shaders. It facilitates some shader writing and increases the efficiency of other shaders by avoiding the calculation on pixels which don?t need it. For example, why apply a very performance costly filter to soften the border of a shadow if the pixel is in the middle of a shadow? Dynamic branching helps to determine if the pixel needs it or not. Splinter Cell Chaos Theory uses this technique, whereas the Chronicles of Riddick calculates everything for every pixel. Performances drop by 10 to 15% for the first and more than 50% for the second. Of course, the algorithms aren?t identical, but it does give us an idea of what dynamic branching is capable of.
Of course, this only applies to very specific cases. In a GPU, pixels are processed by groups of 100 or even 1000. For a branching, all pixels have to take the same branch or else two branches have to be calculated for all pixels with masks to only write the result of the required branch. On paper, ATI has a clear advantage with its processing unit devoted to branching and very small threads. Let?s see if this is the case in practice with a small test that we developed allowing us to change branching granularity (the number of consecutive pixels that take the same branch). We specify the branch to take per pixel column. One column out of two has to display a complex shader and the other can skip this part of rendering. Average sized triangles in motion are displayed on the monitor. The triangle size, their position and the column size have an influence on branching efficiency. This is then closer to real situations than our previous test, which was made with two triangles in full screen. |
Doufám, že nejsem úplně mimo, ale přijde mi, že v tomhle by mohl být ten problém. Zdroj: http://www.behardware.com/articles/592-3/ati-radeon-x1800-xt-xl.html |
|
Návrat nahoru |
|
 |
MD

Založen: 29. 07. 2007 Příspěvky: 437 Bydliště: Praha
|
Zaslal: 11. prosinec 2008, 15:55:34 Předmět: |
|
|
VYRESENO!
Takze, co jsem se naucil:
1) V HLSL muzete oznacit if attributem [branch] a tim napovedet kompilatoru, ze chcete dynamicky vetvit. Kdyz to udelate, tak vam kompilator hned vyhodi warning a rekne vam proc to nejde.
2) Je to proto, ze pouzivate nejake instrukce, ktere pracuji s gradientem. To je napriklad instrukce tex2d, kde se gradient pouziva pro pristup ke spravne mipmape. Jelikoz mipmapy stejne nepotrebuju, tak tex2d mohu nahradit tex2dlod, coz uz je OK. A uz se mi to snazil naznacit Ondras a jeho anglicky mluvici kolega no napoprve mi to nedoslo
Takze jsem to prebastlil takto a fps se zdvojnasobilo:
kód: |
float4 ps_global( vso_global input ) : COLOR
{
float4 color = tex2D(ts_colorB1, input.textur);
[branch]
if (color.a == 0) {
//discard;
return float4(0,0,0,0);
} else {
float4 gbuffCoords = float4(tex2Dlod(ts_gbuff, float4(input.textur,0,0)).xy, 0,0);
half3 normal = half3(tex2Dlod(ts_normal, gbuffCoords).xyz) * 2 - 1;
half4 coeffs = tex2Dlod(ts_coeffs, gbuffCoords);
half3 colorH = half3(color.xyz);
half3 res = lerp(colorH * (half3)Ambient, colorH, coeffs.y); // ambient + emissive
half diffuse = dot(normal, ToGlobalLight);
[branch]
if (diffuse > 0) {
res += CalcDiffuseSpecular(diffuse, dot(normal, HalfToCameraToLight), colorH, coeffs, GlobalLightColor);
}
res += tex2Dlod(ts_colorB2, float4(input.textur,0,0)).rgb; // local lights
return float4(res, color.a);
}
}
|
No a to co pise nevim.nevim je samozrejme pravda. Cim novejsi a paralnejsi grafarna je, tim tam hure bude fungovat dynamic branching. To je ovsem vynahrazeno daleko vetsim vykonem  _________________ - play with objects - www.krkal.org - |
|
Návrat nahoru |
|
 |
Marek

Založen: 28. 07. 2007 Příspěvky: 1782 Bydliště: Velká Morava
|
Zaslal: 12. prosinec 2008, 02:13:38 Předmět: |
|
|
Hm zajímavý, tak ten HLSL compiler fakt není blbej. V branchi je samozřejmě nutnost používat tex2Dlod/tex2Dgrad, jinak na sousedních pixelech, kde se na prvním vyhodnotí branch na true a druhým na false, může být random mipmapa, možná dokonce nedefinovaný pixel z tex2D. Dřív to compilery povolily, dnes to vypadá, že jsou opatrnější... _________________ AMD Open Source Graphics Driver Developer |
|
Návrat nahoru |
|
 |
|