summaryrefslogtreecommitdiff
path: root/GPU.py
blob: e0cf352869d5aec3e40f3995f33a2aefcac96b42 (plain)
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#Requirements:
#    python (sudo apt-get install python)
#    pyopencl (sudo apt-get install python-pyopencl)
#    numpy (sudo apt-get install python-numpy)
#

platform_id = 1 #Set this to -1 to choose manually, or 0 if it isn't working










import pyopencl as cl
import numpy as np

class GPU:
    def __init__(self, filename=None):
        
        self.hasSetup = False
        
        if platform_id == -1:
            self.ctx = cl.create_some_context()
        else:
            platform = cl.get_platforms()
            
            gpus = platform[platform_id]\
                   .get_devices(device_type=cl.device_type.GPU)
            self.ctx = cl.Context(devices=gpus)
            
        self.queue = cl.CommandQueue(self.ctx)

        
        if filename == None:
            return
        self.open(filename)

    def open(self, filename):
        self.clCode = open(filename).read()
        
        self.program = cl.Program(self.ctx,
                                  self.clCode).build(
                                      ['-I \
/usr/include/x86_64-linux-gnu/c++/4.9/ -I /usr/include/x86_64-linux-gnu/\
-I /usr/include/c++/4.9'
                                       ])

    def readFromString(self, s):
        self.program = cl.Program(self.ctx,
                                  s).build(
                                      ['-I \
/usr/include/x86_64-linux-gnu/c++/4.9/ -I /usr/include/x86_64-linux-gnu/ \
-I /usr/include/c++/4.9'
                                       ])
    
    def setup(self, inputs, output):
        memflags = cl.mem_flags
        
        self.inputs = inputs
        
        self.inputbuffers = [
        cl.Buffer(self.ctx,
                  memflags.READ_ONLY | memflags.COPY_HOST_PTR,
                  hostbuf = inp)
        for inp in self.inputs]
        
        self.output = np.copy(output)
        
        self.outputbuffer = cl.Buffer(self.ctx, memflags.WRITE_ONLY,
                                      self.output.nbytes)

        self.hasSetup = True

    def run(self, functionName, globalSize, *args):

        if not self.hasSetup:
            raise Exception('GPU has not setup')

        exec 'self.program.' + functionName + '''(self.queue, globalSize, None,
*(self.inputbuffers + [self.outputbuffer]))'''
        
        
        
        cl.enqueue_read_buffer(self.queue, self.outputbuffer,
                               self.output).wait()

        return self.output