USG/GPU - Historia wersji

Jginter: /* Wstęp do obliczeń równoległych na GPU */

2016-12-01T09:20:23Z

Wstęp do obliczeń równoległych na GPU

Jginter: /* Wstęp do obliczeń równoległych na GPU */

2016-12-01T09:06:53Z

Wstęp do obliczeń równoległych na GPU

Jginter: /* Wstęp do obliczeń równoległych na GPU */

2016-12-01T09:05:51Z

Wstęp do obliczeń równoległych na GPU

Jginter: /* Wstęp do obliczeń równoległych na GPU */

2016-12-01T09:00:02Z

Wstęp do obliczeń równoległych na GPU

Tsteifer: /* Zadanie */

2016-07-29T08:49:24Z

Zadanie

Tsteifer: /* Wstęp do obliczeń równoległych na GPU */

2016-07-05T09:09:49Z

Wstęp do obliczeń równoległych na GPU

Mlew o 12:31, 3 lip 2016

2016-07-03T12:31:44Z

Mlew o 12:27, 3 lip 2016

2016-07-03T12:27:01Z

Tsteifer: /* Zadanie */

2016-07-01T12:11:44Z

Zadanie

Tsteifer: /* Wstęp do obliczeń równoległych na GPU */

2016-07-01T12:06:41Z

Wstęp do obliczeń równoległych na GPU

@@ Linia 84: / Linia 84: @@
 <source lang=python>
-event = cl.enqueue_copy(queue, out, output)
+event = cl.enqueue_copy(queue, out, output_buffer)
 event.wait()
 </source>
@@ Linia 91: / Linia 91: @@
 <source lang=python>
-out_liniowy = inp[:,:,0] + inp[:,:,1]
+out_liniowy = (inp[:,:,0] + inp[:,:,1])*add
 </source>

@@ Linia 75: / Linia 75: @@
 <source lang=python>
 event = mod.Sum(queue, (np.int32(300), np.int32(200), 1), (1,1,1), input_buffer, output_buffer, add)
-# jak widać nasz kernel możemy wywołać jako metodę zmiennej mod. przyjmuje ona na wejściu potok (?) obliczeniowy, całkowite wymiary grup roboczych, wymiary ???? oraz wskaźniki do buforów)
+# jak widać nasz kernel możemy wywołać jako metodę zmiennej mod.
 event.wait()
 </source>

@@ Linia 89: / Linia 89: @@
 <source lang=python>
-out_liniowy = in[:,:,0] + in[:,:,1]
+out_liniowy = inp[:,:,0] + inp[:,:,1]
 </source>

@@ Linia 66: / Linia 66: @@
 <source lang=python>
 input_buffer = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=inp)
 output_buffer = cl.Buffer(ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=out)

@@ Linia 95: / Linia 95: @@
 <source lang=python>
-...
+import numpy as np
 </source>
 ==Profilowanie==

@@ Linia 28: / Linia 28: @@
+"
 </source>
+Kernel ten dodaje do każdej komórki tablicy wejściowej wartość zmiennej add.
 W celu wywołania kernela będziemy musieli przygotować środowisko OpenCL, skompilować kod OpenCL (za pomocą odpowiednich funkcji w Pythonie) oraz zarezerwować miejsce w pamięci i przesłać dane do bufora pamięci na GPU.
 Na początek sprawdzimy jakie procesory mamy do dyspozycji
@@ Linia 54: / Linia 54: @@
 <source lang=python>
-in = np.zeros((300,200,2))
+inp = np.zeros((300,200,2))
-in[:,:,0] = np.arange((300*200)).reshape((300,200))
+inp[:,:,0] = np.arange((300*200)).reshape((300,200))
-in[:,:,1] = np.arange((300*200)).reshape((300,200)) - 100
+inp[:,:,1] = np.arange((300*200)).reshape((300,200)) - 100
-in = in.astype(np.float32) # zmieniamy dane na pojedynczą precyzję
+inp = inp.astype(np.float32) # zmieniamy dane na pojedynczą precyzję
 out = np.zeros((300,200)).astype(np.float32)
 add = np.float32(add)
 </source>
@@ Linia 65: / Linia 66: @@
 <source lang=python>
-input = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=in)
+input_buffer = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=inp)
-output = cl.Buffer(ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=out)
+output_buffer = cl.Buffer(ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=out)
 </source>
+Ponieważ zmienna add występuje jako stała, nie musimy wykonywać dodatkowych operacji rezerwowania pamięci i możemy podać ją bezpośrednio przy wywoływaniu kernela.
-Jesteśmy już gotowi do wywołania naszego kernela:
+Jesteśmy już do tego gotowi:
 <source lang=python>
-event = mod.Sum(queue, (np.int32(300), np.int32(200), 1), (1,1,1), input, output, add)
+event = mod.Sum(queue, (np.int32(300), np.int32(200), 1), (1,1,1), input_buffer, output_buffer, add)
 # jak widać nasz kernel możemy wywołać jako metodę zmiennej mod. przyjmuje ona na wejściu potok (?) obliczeniowy, całkowite wymiary grup roboczych, wymiary ???? oraz wskaźniki do buforów)
 event.wait()

@@ Linia 39: / Linia 39: @@
 <source lang=python>
-print platform[0].get_devices()
+print(platform[0].get_devices())
 </source>
@@ Linia 47: / Linia 47: @@
 my_device = [platform[0].get_devices()[0]] # ta czesc kodu musi byc dostosowana do sprzetu na ktorym sa prowadzone cwiczenia
 ctx = cl.Context(my_gpu_device)
-queue=cl.CommandQueue(ctx, device=my_gpu_device[0])
+queue = cl.CommandQueue(ctx, device=my_gpu_device[0])
 mod = cl.Program(ctx,kernels).build()
 </source>
@@ Linia 54: / Linia 54: @@
 <source lang=python>
-in=np.zeros((300,200,2))
+in = np.zeros((300,200,2))
 in[:,:,0] = np.arange((300*200)).reshape((300,200))
 in[:,:,1] = np.arange((300*200)).reshape((300,200)) - 100
@@ Linia 104: / Linia 104: @@
 <source lang=python>
 from time import clock
-start = clock() #wskazanie zegara w danej chwili
+start = clock() # wskazanie zegara w danej chwili
 y(x)
 end = clock()
-t=end-start #zmierzony czas
+t=end-start # zmierzony czas
 </source>
@@ Linia 114: / Linia 114: @@
 <source lang=python>
-queue=cl.CommandQueue(ctx, device=my_gpu_device[0],properties=cl.command_queue_properties.PROFILING_ENABLE)
+queue=cl.CommandQueue(ctx, device=my_gpu_device[0], properties=cl.command_queue_properties.PROFILING_ENABLE)
 </source>
@@ Linia 122: / Linia 122: @@
 event = mod.Sum(queue, (np.int32(300), np.int32(200), 1), (1,1,1), input, output, add)
 event.wait()
-t=(event.profile.end-event.profile.start)*1e-9 #zmierzony czas
+t = (event.profile.end-event.profile.start)*1e-9 # zmierzony czas
 </source>
@@ Linia 130: / Linia 130: @@
 start_event=cl.enqueue_marker(queue)
 input = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=in)
-t=(event.profile.end-start_event.profile.start)*1e-9 #zmierzony czas
+t = (event.profile.end-start_event.profile.start)*1e-9 # zmierzony czas
 </source>

@@ Linia 113: / Linia 113: @@
 #* wykonanie kernela Sum;
 #* przeniesienie danych z urządzenia do hosta.
-Czy czasy te rosną liniowo z rozmiarem tablicy?
+#:Czy czasy te rosną liniowo z rozmiarem tablicy?
 # Zmierzyć (liczba powtórzeń >10000) czas trwania obliczeń funkcji np.add(x,y) dla kilku wybranych rozmiarów tablic danych wejściowych (rozmiary tożsame z rozmiarami z podpunktu pierwszego).
-Czy wielkość ta zmienia się liniowo?
+#:Czy wielkość ta zmienia się liniowo z rozmiarem tablicy?
 # Na podstawie powyższego ocenić: (dla konkretnego komputera) od jakiego rozmiaru tablicy zrównoleglenie obliczeń zaczyna być opłacalne?

@@ Linia 74: / Linia 74: @@
 ===Zadanie===
-Proszę stworzyć kernel, który będzie dostawać dwie tablice liczb zmiennoprzecinkowych, a następnie liczyć sufit (ang. ceil) z wartości bezwzględnych elementów obu tablic i zwracać największy wspólny dzielnik elementów tych tablic.
+Proszę stworzyć kernel, który będzie dostawać dwie tablice liczb zmiennoprzecinkowych, a następnie liczyć sufit (ang. ceil) z wartości bezwzględnych elementów obu tablic i zwracać największy wspólny dzielnik elementów tych tablic. Porównać działanie (wyniki) programu z poniższą liniową implementacją:
 ==Profilowanie==
@@ Linia 84: / Linia 88: @@
 y(x)
 end = clock()
-print end-start
+t=end-start #zmierzony czas
 </source>
 Oczywiście, pomiar taki jest obarczony błędem pomiarowym. Z tego względu rozsądne szacunki należy wykonywać w oparciu o dużą liczbę pomiarów. <br>
@@ Linia 95: / Linia 99: @@
 event = mod.Sum(queue, (np.int32(300), np.int32(200), 1), (1,1,1), input, output, add)
 event.wait()
-print (event.profile.end-event.profile.start)*1e-9
+t=(event.profile.end-event.profile.start)*1e-9 #zmierzony czas
 </source>
-Zwróćmy uwagę na to, że wynik dotyczy wyłącznie samych obliczeń - nie uwzględnia on czasu potrzebnego na przeniesienie danych z pamięci hosta do pamięci urządzenia i z pamięci urządzenia do hosta. Czas komunikacji między urządzeniami jest względnie długi - sprawia to, że obliczenia równoległe są opłacalne dopiero przy odpowiednio dużych danych wejściowych.
+Analogicznie zmierzyć możemy czas potrzebny na przeniesienie wyników z pamięci urządzenia do pamięci hosta.