Pokaż wiadomości

Ta sekcja pozwala Ci zobaczyć wszystkie wiadomości wysłane przez tego użytkownika. Zwróć uwagę, że możesz widzieć tylko wiadomości wysłane w działach do których masz aktualnie dostęp.


Wiadomości - bartekm

Strony: 1 ... 11 12 13 14 [15]
211
Warsztat.gd / Odp: Znacznik [code]
« dnia: Maj 02, 2010, 18:12:07 »
OK, zrobione. Czcionka zmieniona na:

font-family: Consolas, "Courier New", ...
font-size: 12px (wcześniej było 11px)
max-height: 32em (wcześniej było 24em)

W obydwu stylu zarówno helios (ten ciemny), jak i babylon (ten jasny).

Dzięki za zmianę, chociaż przydało by się też dla domyślnej skórki :) Rozmiar czcionki jest teraz OK. BTW da się wczytywać własne style albo modyfikować istniejące, żebym ja miał inny wygląd, a żeby nie zmieniał się innym?

Przydała by się jeszcze taka jedna mała zmiana, żeby ustawić domyślnie kolorowanie składni na C++, bo często się zdarza zapomnieć zmienić w polu edycji. Na pewno wpłynie to pozytywnie na czytelność kodu. Poza tym zdecydowana większość kodu na forum jest właśnie w C++. To tyle jeśli chodzi o uwagi :)



212
Warsztat.gd / Znacznik [code]
« dnia: Maj 02, 2010, 15:35:21 »
Mam pytanie odnośnie znacznika "code". Czy nie dało by się powiększyć czcionki kodu, bo jak dla mnie jest trochę za mała i muszę przyznać, że mam czasami przez to problem z połapaniem się w kodzie. Przydało by się też zwiększyć pole wyświetlania kodu, bo to jakie jest teraz, jest trochę za małe. Taka zmiana nie jest trudna do wprowadzenia wystarczy poszperać w pliku stylów.

213
Grafika 3D / Odp: Normal map
« dnia: Maj 01, 2010, 13:04:14 »
Jest taki program do generowania normal map od nvidii, nazywa się Melody.
http://developer.nvidia.com/object/melody_home.html

214
Szkółka / Odp: CUDA i działanie kernela
« dnia: Kwiecień 25, 2010, 15:46:46 »
Problem rozwiązany. Błędem było zadeklarowanie bloku wątków tzn.
dim3 dimBlock(Liczba.watkow.x, Liczba.watkow.y);
dim3 dimGrid(N/Liczba.watkow.x, N/Liczba.watkow.y);

Do poprawnego działania Liczba.watkow.x*Liczba.watkow.y musi być mniejsza lub równa od maksymalnej ilości wątków per blok (u mnie 512), po zmianie na:
dim3 dimBlock(16, 16);

Wszystko działa ok, bo 16*16<512. Szkoda tylko, że nie wpłynęło to na wydajność, a nawet jest gorsza niż przy jednowymiarowym bloku:(

215
Szkółka / Odp: CUDA i działanie kernela
« dnia: Kwiecień 22, 2010, 13:28:46 »
Najlepiej by było gdyby w obrębie bloku każdy wątek j zapisywał (dodawał) do innego i (wtedy nie ma tego problemu z dodawaniem do a).

Właśnie to chciałbym uzyskać, tylko nie wiem jak. Jeśli:
int i = blockIdx.x * blockDim.x + threadIdx.x;
// Jakis kod

jest to samo co:
for(i=0;i<N;i++)
{
   // Jakis kod
}
to myślałem, że dając:
int i = blockIdx.x * blockDim.x + threadIdx.x;

int j = blockIdx.y * blockDim.y + threadIdx.y;

// Jakis kod

będzie to samo co:
for(i=0;i<N;i++)
{
   for(j=0;j<N;j++)
   {
       // Jakis kod
   }
}
tak przynajmniej wynika z przykładów w dokumentacji, ale widzę, że nie ma tak lekko. Będę próbował coś zdziałać w tym kierunku, o którym pisałeś, choć nie znam na razie zasady działania shared memory.

@_OskaR
Liczba wątków jest chyba ok, jest określona przez wyrażenie
dim3 dimBlock(Liczba.watkow.x, Liczba.watkow.y);
dim3 dimGrid(N/Liczba.watkow.x, N/Liczba.watkow.y);

A potem kernel jest odpalany przez:

Oblicz <<< dimGrid, dimBlock >>> ( // Jakies zmienne );

Z pierwszym wariantem jest na pewno coś nie tak, o ile potrafię sobie poradzić z jednowymiarowym kernelem to dwuwymiarowe wogóle mi nie wychodzą. Zrobienie tablicy z wszystkimi możliwościami raczej nie wchodzi w rachubę ze względu na duży rozmiar takiej tablicy i ograniczonej pamięci karty graficznej. Dla 100 elementów może by przeszło, ale dla np. 100 000 już nie.

216
Szkółka / CUDA i działanie kernela
« dnia: Kwiecień 21, 2010, 15:11:12 »
Witam, mam taki problem, mam sobie taki kawałek kodu, jest to kernel CUDA, czyli funkcja wywoływana na GPU. Ten kod powinien obliczać przyspieszenie działające pomiędzy ciałem "i-tym" i "j-tym" ciałem. Jednak nie oblicza mi poprawnie tzn, zwraca a = 0. I moje pytanie co robię nie tak.


__global__ void ObliczPrzysp(float3 *pol, float3 *a, float *mass, int M, float GG, float pp)
{
int i = blockIdx.x * blockDim.x + threadIdx.x;

int j = blockIdx.y * blockDim.y + threadIdx.y;

float4 delta;
float Q;

if(i<M && j<M)
{
if(i!=j)
{
delta.x = pol[i].x - pol[j].x;
delta.y = pol[i].y - pol[j].y;
delta.z = pol[i].z - pol[j].z;
delta.w = sqrtf(delta.x*delta.x + delta.y*delta.y + delta.z*delta.z + pp);
Q = GG*mass[j]/(delta.w*delta.w*delta.w);
a[i].x += Q*delta.x;
a[i].y += Q*delta.y;
a[i].z += Q*delta.z;
}
}
}


Ten sam kod napisany pod jedną iterację, tzn:

__global__ void ObliczPrzysp(float3 *pol, float3 *a, float *mass, int M, float GG, float pp)
{
int i = blockIdx.x * blockDim.x + threadIdx.x;

float4 delta;
float Q;

for(j=0;j<M;j++)
{
if(i!=j)
{
delta.x = pol[i].x - pol[j].x;
delta.y = pol[i].y - pol[j].y;
delta.z = pol[i].z - pol[j].z;
delta.w = sqrtf(delta.x*delta.x + delta.y*delta.y + delta.z*delta.z + pp);
Q = GG*mass[j]/(delta.w*delta.w*delta.w);
a[i].x += Q*delta.x;
a[i].y += Q*delta.y;
a[i].z += Q*delta.z;
}
}
}


działa poprawnie, tzn. oblicza mi "a" i wszystko przebiega dobrze, ale wydajność nie jest taka jaką bym chciał, ze względu na umiejscowioną pętlę "for" wewnątrz kernela. Dla dużych M, wątek musi wykonać naprawdę dużo obliczeń, co znacznie spowalnia aplikację i zużywa grafikę tak, że nie da się normalnie pracować. Czy da się to jakoś zooptymalizować? Jak powinien wyglądać kod, żeby to działało pod "dwuwymiarowe bloki" tzn gdy:
int i = blockIdx.x * blockDim.x + threadIdx.x;

int j = blockIdx.y * blockDim.y + threadIdx.y;

217
Szkółka / Odp: SDL i wydajność
« dnia: Kwiecień 09, 2010, 16:29:35 »
Ogólnie zmierz FPS to się przekonasz czy na pewno jest on niski...

Nie jestem w tej chwili w stanie sprawdzić FPS-a. Jak ktoś chce się pofatygować do sprawdzenia jak to chodzi, to tu są spakowane wersje pod dwie rozdzielczości 320x240 i 1024x768:
http://rapidshare.com/files/373866325/Engine.rar

218
Szkółka / Odp: SDL i wydajność
« dnia: Kwiecień 09, 2010, 14:42:04 »
dodaj do pętli sdl-sleep(1);

Dodanie do pętli SDL_Delay(1) rzeczywiście obniżyło zużycie procka i tym sposobem wzrost wydajności aplikacji jednak, przy wysokich rozdzielczościach dalej jest zauważalne spowolnienie. Co ciekawe po dodaniu Delay-a do pustego okienka ze zwykłą nieskończoną pętlą i tak mam zużycie na poziomie 20-30%. Dopiero obniżenie do rozdzielczości 320x240 daje zadowalającą wydajność i zużycie na poziomie 0-3%.

219
Szkółka / Odp: SDL i wydajność
« dnia: Kwiecień 09, 2010, 13:56:44 »
Podejrzane... A nie mógłbyś zamieścić fragmentu kodu z "pętlą rysującą"? 

Mógłbym, ale zapewniam, że kod jest w porządku i nie jest skomplikowany. Zwyczajne zrzucanie powierzchni na ekran, wzorowałem się na tutorialu, więc powinno być ok. Ale i tak chyba przerzucę się na OGL+SDL, bo dodatkowy wymiar może się przydać w grach typu point&click, a w czysty SDL chyba 3D nie obsłuży. 

220
Szkółka / Odp: SDL i wydajność
« dnia: Kwiecień 09, 2010, 13:11:12 »
Cytuj
Wszystko wydaje się w nim w porządku, a jednak zarzyna mi procka. A to tylko zwykła inicjalizacja okienka. Czy coś jest z nim nie tak?
Wydaje Ci się, że to "zarzyna procka", bo to nieskończona pętla z odświeżaniem ekranu, a nie tylko inicializacja okienka.
Gdybyś dodał do tego licznik fps to przekonałbyś się, że nie ma się czym martwić...

Wystarczy spojrzeć na zużycie procka przy uruchomieniu tego kodu, żeby zobaczyć, że coś jest nie tak. W zwykłej aplikacji OGL też jest pętla nieskończona, ale tak nie zużywa procesora jak SDL. W mojej aplikacji, w której jest zwykła bitmapa 24x32 poruszana za pomocą kursora, wystarczy przełączyć na wysoką rozdzielczość np. 1680x1050 i już widać, że się tnie.

221
Szkółka / Odp: SDL i wydajność
« dnia: Kwiecień 09, 2010, 12:20:43 »
Ok w takim razie powiedzcie mi jak u was chodzi taki przykładowy kod:
#include <SDL/SDL.h>

SDL_Event zdarzenie;
SDL_Surface *ekran;
bool quit = false;

int main(int argc, char *argv[])
{
SDL_Init(SDL_INIT_EVERYTHING);

ekran = SDL_SetVideoMode(1024, 768, 32, SDL_HWSURFACE | SDL_HWACCEL);
SDL_WM_SetCaption("SDL_Window" ,NULL);

while(!quit)
{
SDL_FillRect(ekran,NULL,0);

SDL_PollEvent(&zdarzenie);

if(zdarzenie.type == SDL_QUIT)
{
quit = true;
}

SDL_Flip(ekran);
}

SDL_Quit();

return 0;
}

Wszystko wydaje się w nim w porządku, a jednak zarzyna mi procka. A to tylko zwykła inicjalizacja okienka. Czy coś jest z nim nie tak?

222
Szkółka / Odp: SDL i wydajność
« dnia: Kwiecień 09, 2010, 11:38:09 »
Dzięki za szybką odpowiedź. DrUiD próbowałem twojego sposobu, ale jest to samo. Chyba będę zmuszony przerzucić się na OGL jako render i  SDL do obsługi  I/O. Voytech dzięki za link na pewno skorzystam.

223
Szkółka / SDL i wydajność
« dnia: Kwiecień 09, 2010, 10:35:44 »
Hej, zacząłem programować sobie w SDL-u i mam problem z wydajnością. Piszę sobie silnik, na którym będę robił gry przygodowe 2D typu point&click, kto grał w serię Monkey Island wie o co chodzi. Mam taki problem, że to co napisałem koszmarnie wolno mi chodzi, tzn zarzyna mi procka mimo, że ma dwa rdzenie. Domyślam się, że wszystko chodzi na sofcie, tzn. że do rysowania zmuszany jest procek, a nie karta grafiki. Teoretycznie rozwiązało by sprawę połączenie tego z OpenGL, ale wolałbym pozostać pod samym SDL z tego względu, że pod SDL łatwo się zarządza "powierzchniami" (ang. surfaces) i łatwo można animować obiekt. W OGL trzeba się bawić w jakieś loadery tekstur i w ogóle jest to wszystko bardziej zamotane. I teraz dwa pytania:
1. Czy jeśli połączył bym SDL z OpenGL, czy dalej mógłbym korzystać z SDL-owskich powierzchni, żeby wyświetlać coś na ekranie, czy muszę to zrobić tak jak to się robi pod OpenGL?
2. Czy da się poprawić wydajność np w taki sposób, żeby rysowanie przejęła karta grafiki, ale nie trzeba było korzystać z OGL-a?

Strony: 1 ... 11 12 13 14 [15]